Objectives

Lab Practice, Part 1 - working with Edlinas

• Open the new file, type edl subPro.asm at DOS prompt
• Hit TAB key a few times until the Stack rectangle will be observed. You will need to use TAB key to move between Stack and Memory rectangles.
• We will write the program that has subprogram call. This program will simulate all steps that will be executed in C++/C program when function call will be performed.
• Type in the following simple program that reads one input integer and add 1 to the input number. The incrementation part is written in separate subprogram: incsub. The subprogram accepts one parameter, and has a return value that equals value of parameter + 1 The return value will be stored in EAX ( to keep the rule that will work with C++/C code).
  Here is an assembly code. Pay attention to my comments. You don't need to type in the comments.

          MOV ESP, 02000H ; initialize the stack
          IN EAX, [0] ;get a user input
          PUSH EAX ; push the value of the parameter into the STACK before function call
          CALL incsub
          OUT [1], EAX ; here the program will return from the subprogram,
          ;the return value was stored in EAX, so it can be outputed from EAX
          ADD ESP, 4 ;ESP returns to the initial value
        ; we need this line to clear the stack from the parameter that was pushed
        ; in C/C++ the calling function is responsible for this
          RET
  incsub:
            PUSH EBX ; this register will be used to hold the value of the parameter or/and for computations
            MOV EBX, [ESP + 8] ; move the value of the parameter into EBX
            INC EBX ; increment the value of EBX by 1
            MOV EAX, EBX ; remember! return value should be stored in EAX
            POP EBX ; EBX will get some garbage value, but it doesn't affect anything
          ;the important part is that now the ESP holds the address of the statement
          ;where the subprogram should return
          RET

• Run this program in EDLINAS with different parameter to observe the result. Observe the Stack rectangel and Memory rectange while runinng the program.

Part 2 - Working with NASM in LINUX enviroment

• Login to your LINUX account
• We will rewrite the Part I of this lab in following way: the subprogram will be written in Assembly language in file incProg.asm and the main program will be written in C/C++ in file lab9.c
• Type emacs incProg.asm & at LINUX prompt and type in the following code, adding the comments to each line:

          global incsub
  incsub:
          push ebx
          mov ebx, [esp+8]
          inc ebx
          mov eax, ebx
          pop ebx
          ret

• Save the file ( File - > Save)
• Exit from the file ( File - >Exit)
• Compile the assembly code uisng NASM assembler, type the following at LINUX prompt:
  nasm -f elf incProg.asm
• Open the file lab9.c, type emacs lab9.c &
• Type in the following C++ (for the students who would like to use C++) code:

  #inlcude < iostream >
  using namespace std;
  extern "C" int incsub ( int x );

  int main (){
  

  int x, y;
  cout << "Please enter the value fo x that will be incremented by 1 \n";
  y = incsub(x);
  cout << " the result is " << y << endl;
  return 0;
  
  }

• Type in the following C code (for the students who would like to use C language)

  #include < stdio.h >
  int incsub (int x);

  int main ( ){
  

  int x, y;
  printf("Please enter the integre \n");
  scanf("%d", & x);
  y = intsub(x);
  printf("the result is %d \n", y);
  return 0;
  
  }
• Compile and Link C++ and Assembly code, type the following: g++   lab9.c  incProg.o
• Compile and Link C and Assembly code, type in the following: gcc   lab9.c   incProg.o
• Run the resulting program by typing a.out
• Observe the result.

• Lab Assignment
• Write the Assembly language function int sign ( int parameter) in file signProg.asm that accepts one integer parameter and finds the sign of the parameter ( positive, negative or zero). Function will return 1 for the positive, 0 for the zero and -1 for the negative.
• Compile the assembly code using NASM
• Write the C/C++ code that reads one integer and calls to the function sign in order to check the sign of the input number. The program will print an aprorpiate message for each case.
• Compile, Link and Run the resulting program in Linux
• Write an Assembly language function int sum (int x, int y) that returns the sum of x and y.
• Compile the Assembly code using NSAM Assembler
• Write C/C++ code that reads two integers and calls to the function sum to calculate the sum of the input numbers.
• Compile, Link and Run the resulting code in Linux
• Write an Assembly code that swaps two numbers.
• Compile it with NASM
• Write a C/C++ code that reads 10 integers and sorts them in increasing order using Bubble Sort that uses function swap.
• Compile, Link and Run the resulting code in Linux.