Moving any integer value into a register

ARM's method to move any (large) integer value into a register

Because the ARM instructions is fixed length (every ARM instruction is 4 bytes):

One ARM instruction does not have enough space left to encode integer values that are large

In order to move a large binary number (that requires more bits to encode), we break the binary number into 2 (equal) halves:

<------------- large binary number -----------> +-----------------------+-----------------------+ | most significant bits | least signficant bits | +-----------------------+-----------------------+

And use 2 assembler instructions:

movw that moves the least significant 16 bits of an integer value into the lower 16 bits of a register
movt that moves the most significant 16 bits of an integer value into the upper 16 bits of a register

These pair of assembler instructions must be use in this order:

movw rN, #lower16bits movt rN, #upper16bits

because the movw instruction will clear the upper 16 bits in the destination register rN.

Illustrating the effects of movw and movt instructions

Consider the following assembler code fragment:

main: movw r0, #1 // Move 0000000000000001 into the lower half of r1 movt r0, #1 // Move 0000000000000001 into the upper half of r1 // The result is: 00000000000000010000000000000001 // which represents the value 65536 (decimal)

After the execution of the movw r0, #1 instruction, the registerr0 of the ARM processor will contain:

<----------- register r0 ----------> +------------------+------------------+ | 0000000000000000 | 0000000000000001 | +------------------+------------------+

And after the execution of the (next) movt r0, #1 instruction, the registerr0 of the ARM processor will contain:

<----------- register r0 ----------> +------------------+------------------+ | 0000000000000001 | 0000000000000001 | +------------------+------------------+

When you read the value in register r0 as a 32 bit (binary) number, the value that this binary number represents is:

00000000000000010000000000000001 (binary) = 65537 (decimal)

That means:

If you need to move the (large) value 65537 (= 0000000000000001000000000000001 binary) into the register r0, you need to use the following 2 instructions:

Example Program: (Demo above code)
- Prog file: /home/cs255001/demo/asm/movw+movt.s
How to run the program:
As you can see the example, you will need to find (= compute) the upper 16 bits and the lower 16 bits values of 65537 in order to write the assembler instructions !!!
This is obviously a problem for a human programmer that is not used to calculation in binary
Do not worry, the ASM assembler has provide 2 helpful operations to assist you.

The :lower16: and :upper16: operation keywords

When you have a number #x, then:

    #:lower16:x   ≡  the lower 16 bits of the number x             

    #:upper16:x   ≡  the upper 16 bits of the number x

With the help of the :lower16: and :upper16: operation keywords, we can now move any value into a register very easily.

Let me demonstrate it with an example:

Suppose we want to move the value 123456 into the register r0
The 2's complement code for 123456 is: (use this page: click here )

From the above discussion, you know the values of these expressions:

#:lower16:123456 ≡ 1110001001000000 = the lower 16 bits of the binary number that is equal to 123456 decimal #:upper16:123456 ≡ 0000000000000001 = the upper 16 bits of the binary number that is equal to 123456 decimal

We can move the value 123456 into register r0 using the following instructions:

movw r0, #:lower16:123456 movt r0, #:upper16:123456

Example Program: (Demo above code)
- Prog file: /home/cs255001/demo/asm/2-mov/mov-large.s
How to run the program: