---

The c = a + b statement

---

• Introduction
  • We have learned all the necessary ARM assembler instructions and directives to write assignment statements that uses only simple variables (i.e.: no arrays and linked lists)

    So we will now write the following very simple program in ARM assembler:

    int a = 4; // a,b,c are all int typed variables int b = 5; int c; main( ) { c = a + b; }

  ---

  ---

  ---

  ---

• Defining the variables
  • This webpage has presented the necessary knowledge on how to define permanent variables in the program: click here

    Read that page if you don't follow what I will do next.

    ---

  • The int typed variables a, b, c are defined in the .data section using the following directives:

    .data a: .4byte 4 // a contains the value 4 b: .4byte 5 // b contains the value 5 c: .skip 4 // c is not initialized (will contain 0)

  ---

  ---

  ---

  ---

• Writing the statement in the program
  • The statement:

    c = a + b;

    is writting in the .text section of the assembler program.

    The meaning of the statement c = a + b is:

    1. Compute the value in the expression in the RHS of the assignment 2. Store the result value in memory at the address of the variable given in the LHS

    In the assignment c = a + b, we must do these actions:

    Get the int value in the variable a (into some register) Get the int value in the variable b (into another register) Add the values Then store the result in memory reserved for the variable c (you must use the memory address marked by the label c)

    From what you have learned in ARM assembler programming, the following ARM instructions will perform the stated tasks above:

    // Move a into r1 movw r0, #:lower16:a // Moves the address of memory movt r0, #:upper16:a // variable a into register r0 ldr r1,[r0] // Move int value from var into r1 // Move b into r2 movw r0, #:lower16:b // Moves the address of memory movt r0, #:upper16:b // variable b into register r0 ldr r2,[r0] // Move int value from var into r2 // Add them up add r2, r1, r2 // r2 = a + b // Move sum in r2 to c movw r0, #:lower16:c // Moves the address of memory movt r0, #:upper16:c // variable c into register r0 str r2,[r0]

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: /home/cs255001/demo/asm/2-mov/abc-1.s

      /* -------------------------------------------------- Define required labels for EGTAPI -------------------------------------------------- */ .global main, Stop, CodeEnd .global DataStart, DataEnd .global a, b, c /* -------------------------------------------------- Begin of the program instructions -------------------------------------------------- */ .text main: // Move a into r1 movw r0, #:lower16:a // Moves the address of memory movt r0, #:upper16:a // variable a into register r0 ldr r1,[r0] // Move int value from var into r1 // Move b into r2 movw r0, #:lower16:b // Moves the address of memory movt r0, #:upper16:b // variable b into register r0 ldr r2,[r0] // Move int value from var into r2 // Add them up add r2, r1, r2 // r2 = a + b // Move sum in r2 to c movw r0, #:lower16:c // Moves the address of memory movt r0, #:upper16:c // variable c into register r0 str r2,[r0] // Move sum in r2 to var c Stop: CodeEnd: nop /* -------------------------------------------------- Begin of the permanent program variables -------------------------------------------------- */ .data DataStart: a: .4byte 4 // int a contains the value 4 b: .4byte 5 // int b contains the value 5 c: .skip 4 // int c is not initialized (will contain 0) DataEnd: .end

    How to run the program:

    To compile:   as255 abc-1 To run: use EGTAPI

  ---

  ---

  ---

  ---

• Using different data types
  • You just saw an assembler program that uses int data type.

    When you write assembler programs, it is very important that:

    You access the memory variables using the correct load and store instructions

    ---

  • From the load instruction page and the store instruction page , you need to use:

    Data type Load instruction Store instruction ------------- ------------------ ------------------- int ldr str short ldrsh strh byte ldrsb strb

    If you use a wrong instruction for a given data type, your program may not work correctly (because incorrect data may be copied between the CPU and the memory)

    I will do 2 examples with mixed data type operations.

  ---

  ---

  ---

  ---

• Mixed data type operation example 1
  • We will write the following high level program in ARM assembler:

    byte a = 4; // 3 different data types short b = 5; int c = 256; main( ) { c = a + b; }

    We need to align some variables because of alignment requirements (see: click here)

    .data a: .byte 4 // a contains the value 4 in 8 bits .align 1 b: .2byte 5 // b contains the value 5 in 16 bits .align 2 c: .4byte 256 // c contains the value 256 in 32 bits

    The assembler program must use the correct load and store instructions for each variable.

    Here are the changes (highlight in red):

    main: // Move a into r1 movw r0, #:lower16:a // Moves the address of memory movt r0, #:upper16:a // variable a into register r0 ldrsb r1,[r0] // Move byte value from var into r1 // ldrsb also sign-extend to int for computation !! // Move b into r2 movw r0, #:lower16:b // Moves the address of memory movt r0, #:upper16:b // variable b into register r0 ldrsh r2,[r0] // Move short value from var into r2 // ldrsh also sign-extend to int for computation !! // Add them up add r2, r1, r2 // r2 = a + b // Move sum in r2 to c movw r0, #:lower16:c // Moves the address of memory movt r0, #:upper16:c // variable c into register r0 str r2,[r0] // Move sum in r2 to int var c

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: /home/cs255001/demo/asm/2-mov/abc-2.s

    How to run the program:

    To compile:   as255 abc-2 To run: EGTAPI

  ---

  ---

  ---

  ---

• Mixed data type operation example 2 (overflow !)
  • We will write the following high level program in ARM assembler:

    byte a = 4; // 3 different data types short b = 5; int c = 256; main( ) { a = b + c; // a is a byte typed variable !!! }

    Because the variable types have not changed, we can use the same .data segment (I won't repeat it here).

    The statement has changed.

    Now we must get the values from b and c, add them up and store the sum in the variable a.

    When you write the assembler code, we need to make sure we use the correct load/store instruction for each data type.

    The assembler program is as follows:

    main: // Move short b into r1 movw r0, #:lower16:b // Moves the address of memory movt r0, #:upper16:b // variable b into register r0 ldrsh r1,[r0] // Move short value from var into r1 // ldrsb also sign-extend to int !! // Move c into r2 movw r0, #:lower16:c // Moves the address of memory movt r0, #:upper16:c // variable c into register r0 ldr r2,[r0] // Move int value from var into r2 // Add them up add r2, r1, r2 // r2 = b + c // Move sum in r2 to a movw r0, #:lower16:a // Moves the address of memory movt r0, #:upper16:a // variable a into register r0 strb r2,[r0] // Move sum in r2 to byte var c

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: /home/cs255001/demo/asm/2-mov/abc-3.s

    How to run the program:

    To compile:   as255 abc-3              To run: EGTAPI

    ---

    ---

    Can you explan why a = 5 after the execution ???

    Answer: overflow

    Try c = 100 - you will see that there is no overflow and the program is correct

    ---

    ---

  • Note:

    Notice that in assembler programming, there is no casting operation !!! You have performed the casting operating when you move 16 bits from the 32 bits register to a memory variable !!! (You did not use all the bits in the register !!!)