Embedded System
Lecture 4: Introduction to ARM Assembly
Language Programming
Introduction to GNU ARM Tool
Chain
Prog1.s
.section .text
.global _start
_start:
MOV r0, #0x11 @ load initial value
MOV r1, r0, LSL #1 @ shift 1 bit left
MOV r2, r1, LSL #1 @ shift 1 bit left
loop:
B loop @ wait for result
.end
Assemble & Link
$ arm-elf-as --gstabs -mcpu=arm7tdmi
prog1.s -o prog.o
$ arm-elf-ld prog1.o -o prog1.elf
$ arm-elf-insight prog1.elf
$ arm-elf-objdump -D prog1.elf
$ arm-elf-objdump -S prog1.elf
$ arm-elf-objdump -t prog1.elf
$ arm-elf-objdump -t prog1.o
Structure of Assembly Language
Program
General form of source lines in your assembly file is
{label} {instruction|directive|pseudo-instruction} {;comment}
For GNU ARM Assembly Prog
Label: instruction/directive/psedo-instruction @comment

All the sections within a source line (or statement) are optional.

Label is a name that represents an address in memory.

Labels must start at the beginning of the line

Labels do not start with a digit. However it can contain any alphabet, digits, and few
special characters ( _ ,  . and  $ ).

Instruction/directive/pseudo-instruction must be preceded by a white space, either a tab
or any number of white spaces.

Comments are preceded by ;, @. C style commenting /* .. */ is also allowed

Constants

Decimal eg. 123

Hexadecimal eg. 0X3F

n_xxx (n is the base and xxx is the number)

Character constants: 'A' '\n'

String constants:  Hello World\n

Housekeeping rules

Mnemonics can be written either in all small letters or in all capital
letters. While ADD or add is valid, Add is not valid.

Split up long lines using backslash (\) character. There must not
be any other characters following the backlash, such as space or
tab.
Assembler Directives

Directives are instructions to assembler to do something itself.

All assembler directives start with a period ('.').

.byte expression
Insert (8-bit) byte value of the expression into the object file.
.byte 64, ©A© ;insert byte 0x40,0x41
.byte 0x42 ;insert byte 0x42
.byte 0b1000011,0104 ;insert bytes 0x43,0x44

.data: Switch the destination of following statements into the
data section of the final executable.

All executable programs have at least two sections called .text
.text
and .data
.data

.end marks the end of source code file; everything after this
.end
directive is ignored by the assembler.

.global symbol
.global symbol
specify that the symbol is to be made globally visible to all modules
(source code files) that are part of the executable, and visible to the GNU
linker. The symbol _start, which is required by the GNU Linker to
_start
specify the first instruction to be executed in a program, must always be
a global one.

.text
.text
Switch the destination of the following statements into the text
section of the final executable. This is the section where assembly
instructions should be placed.

.section name [, ªflagsº [,@type]] (for ELF targets)
.section name [, ªflagsº [,@type]]
It instructs the assembler to create a new code or data section. Sections
are independent, named, indivisible chunk of code or data that are
manipulated by the linker.

.equ symbol, expression
.equ symbol, expression
This directive sets the value of symbol to expression.

.align abs_expr1 abs_expr2 abs_expr3
.align abs_expr1 abs_expr2 abs_expr3

Pad the location counter to a particular storage boundary.

abs_expr1: alignment required
abs_expr2: fill value to be stored in the padding bytes.
abs_expr3: max number of bytes to be skipped by this alignment
directive

All arguments are optional. If all arguments are missing .align inserts
zero to 3 bytes of 0x00 so that the next location will be on a 4-byte
(word) boundary.
.byte 0x55 ; inserts the byte 0x55
.align; inserts three alignment bytes: 0x00 0x00
0x00
.word 0xAA55EE11 ; inserts the bytes 0x11 0xEE 0x55
0xAA (LSB order)

.space size, fill
.space size, fill
reserves a block of memory of size bytes each of value fill.
Macros

Macro definition allow a programmer to build definitions of functions or
operations once, and then call this operation by name throughout the
code, saving some writing time.

Macros can be a part of conditional assembly, wherein parts of the
source file may or may not be compiled based on certain variables.

Macro definitions are substituted at assembly time, replacing the
macro call with the actual assembly code.

Syntax:
.macro {$cond} {$par1{,$par2}...}
.... code
.endm
.macro AddMul vara, varb, varc
.macro AddMul vara, varb, varc
ADD \vara, \varb, \varc @add two terms
ADD \vara, \vara, #6 @add 6 to the sum
MOV \vara, \vara, LSL #3 @multiply by 8
.endm
.endm
_start:
MOV r0, #10
MOV r1, #20
MOV r2, #30
AddMul r0, r1, r2
AddMul r0, r1, r2
loop:
b loop @wait here
.end
ARM Instruction Set

Data Processing Instructions

Branch Instructions (Flow Control)

Status Register transfer instructions (Logic/Bit
bashing)

Load and Store instructions (Memory Access)

Co-processor instructions (System Control)

Exception generating instructions (Priviledged)
Data Processing Instructions

Manipulate data within registers.

Move instructions, arithmetic instructions,
logical instructions, comparison instructions and
multiply instructions.

Most data processing instructions can process
one of their operands using the barrel shifter.

If you use the S suffix on a data processing
instruction, then it updates the flags in the cpsr.
cpsr
Move Instructions

It copies N into a destination
register.

N could be register or an immediate
value.
Barrel Shifter

Data processing instructions are
processed within the ALU.

The 32-bit binary pattern in one of
the source registers can be shifted
left or right before it enters the ALU.

Some data processing instructions
do not use barrel shift. For example:
MUL, CLZ (count leading zeros),
QADD (signed saturated 32-bit add)
instructions.

Pre-processing or shift occurs within
the cycle time of the instruction.

MOV r7, r5, LSL #2
Arithmetic Instructions

Implement addition and subtraction of 32-bit signed and unsigned
values.

e.g. : SUB r0, r1, r2

A wide range of second operand shift is available for arithmetic and
logical instructions.

ADD r0, r1, r1, LSL #1 ; let r0 = 3 * r1
Logical Instructions
r1 = 0b1111
r0 = 0x00000000
r0 = 0x00000000
r1 = 0x02040608
r1 = 0x02040608
r2 = 0b0101
r2 = 0x10305070
r2 = 0x10305070
BIC r0, r1, r2
ORR r0, r1, r2
ORR r0, r1, r2
r0 = 0b1010
r0 = 0x12345678
r0 = 0x12345678
0
Comparison Instructions

Used to compare or test a register with 32-bit value.

It updates the cpsr flag bits according to the result, but do not
affect other registers.

After the bits have been set, the information can then be used
to change program flow by using conditional execution.
Multiply Instructions

Long multiply instructions (SMLAL, SMULL,
UMLAL, and UMULL) produce 64-bit result.
The result is placed in two 32-bit registers
labelled RdLo and RdHi.
Branch Instructions

A branch instruction is used to change the flow
of execution or is used to call a sub-routine.

This type of instruction allows programs to have
subroutines, if-then-else structures and loops.

The branch labels are placed at the beginning
of the line and are used to mark an address
that can be used later by the assembler to
calculate the branch offset.
Examples
Summary

Introduction to GNU ARM Tool Chain

Assembler Directives

Macros

Data Processing Instructions

Data Movement between registers

Arithmetic & Logical Operations

Multiply

Barrel Shifter