C as Implemented in

Assembly Language

1
Overview

 We program in C for convenience

 There are no MCUs which execute C, only machine code
 So we compile the C to assembly code, a human-readable representation of machine
code
 We need to know what the assembly code implementing the C looks like
 To use the processor efficiently
 To analyze the code with precision
 To find performance and other problems
 An overview of what C gets compiled to
 C start-up module, subroutines calls, stacks, data classes and layout, pointers, control flow, etc.

2
Compiler Stages
 Parser
 reads in C code,
 checks for syntax errors,
 forms intermediate code (tree representation)
 High-Level Optimizer
 Modifies intermediate code (processor-independent)
 Code Generator
 Creates assembly code step-by-step from each node of the intermediate code
 Allocates variable uses to registers
 Low-Level Optimizer
 Modifies assembly code (parts are processor-specific)
 Assembler
 Creates object code (machine code)
 Linker/Loader
 Creates executable image from object file

3
Examining Assembly Code before Debugger

 Compiler can generate assembly code listing for reference

 Select in project options

4
Examining Disassembled Program in Debugger

5
A Word on Code Optimizations

 Compiler and rest of tool-chain try to optimize code:

 Simplifying operations
 Removing “dead” code
 Using registers

 These optimizations often get in way of understanding what the code does
 Fundamental trade-off: Fast or comprehensible code?
 Compiler optimization levels: Level 0 to Level 3

 Code examples here may use “volatile” data type modifier to reduce compiler
optimizations and improve readability

6
 USING REGISTERS

7
Register Use Conventions

 Make it easier to create modular, isolated and integrated code

 Scratch registers are not expected to be preserved upon returning from a called
subroutine
 r0-r3

 Preserved (“variable”) registers are expected to have their original values upon
returning from a called subroutine
 r4-r8, r10-r11

8
Core Register Use
Register Synonym Special Role in the procedure call standard
r15 PC The Program Counter.
r14 LR The Link Register.
r13 SP The Stack Pointer.
r12 IP The Intra-Procedure-call scratch register.
Must be saved, restored by
r11 v8 Variable-register 8.
callee-procedure it may modify
r10 v7 Variable-register 7. them.
Platform register. The meaning of this register is defined
r9 v6,SB,TR
by the platform standard.
r8 v5 Variable-register 5. Must be saved, restored by
r7 v4 Variable register 4. callee-procedure it may modify
r6 v3 Variable register 3. them.
Calling subroutine expects
r5 v2 Variable register 2.
these to retain their value.
r4 v1 Variable register 1.
r3 a4 Argument / scratch register 4.
Don’t need to be saved. May be
r2 a3 Argument / scratch register 3. used for arguments, results, or
r1 a2 Argument / result / scratch register 2. temporary values.
r0 a1 Argument / result / scratch register 1.

9
 MEMORY REQUIREMENTS

10
What Memory Does a Program Need?

int a, b;
 Five possible types
const char c=123;  Code
int d=31;  Read-only static data
void main(void) {
 Writable static data
int e;
◦ Initialized
char f[32];
e = d + 7; ◦ Zero-initialized
a = e + 29999; ◦ Uninitialized
strcpy(f,“Hello!”);  Heap
}  Stack
 What goes where?
 Code is obvious
 And the others?

11
What Memory Does a Program Need?

int a, b;
 Can the information change?
const char c=123;  No? Put it in read-only, nonvolatile memory
int d=31; ◦ Instructions
void main(void) { ◦ Constant strings
int e; ◦ Constant operands
char f[32]; ◦ Initialization values
e = d + 7;
 Yes? Put it in read/write memory
a = e + 29999;
strcpy(f,“Hello!”); ◦ Variables
} ◦ Intermediate computations
◦ Return address
◦ Other housekeeping data

12
What Memory Does a Program Need?

int a, b;
 How long does the data need to exist? Reuse
const char c=123; memory if possible.
int d=31;  Statically allocated
void main(void) { ◦ Exists from program start to end
int e;
◦ Each variable has its own fixed location
char f[32];
◦ Space is not reused
e = d + 7;
a = e + 29999;  Automatically allocated
strcpy(f,“Hello!”); ◦ Exists from function start to end
} ◦ Space can be reused
 Dynamically allocated
◦ Exists from explicit allocation to explicit deallocation
◦ Space can be reused

13
Program Memory Use
RAM Flash ROM

int a, b;
Zero-Initialized Data const char c=123; Constant Data
int d=31;
void main(void) {
int e;
Initialized Data InitializationData
char f[32];
e = d + 7;
a = e + 29999;
Stack strcpy(f,“Hello!”); Startup and Runtime
} Library Code

Heap Data Program .text

14
Activation Record
 Activation records are located Lower
(Free stack space)
on the stack address
Local storage <- Stack ptr
 Calling a function creates Activation record for
Return address
an activation record current function
Arguments
 Returning from a function Local storage
Activation record for
deletes the activation record caller function
Return address
Arguments
Local storage
Activation record for
 Automatic variables and caller’s caller function
Return address
housekeeping information are Arguments
Higher Activation record for Local storage
stored in a function’s activation address caller’s caller’s caller Return address
record function Arguments

 Not all fields (LS, RA, Arg) may be present for each activation record

15
Type and Class Qualifiers

 Const
 Never written by program, can be put in ROM to save RAM

 Volatile
 Can be changed outside of normal program flow: ISR, hardware register
 Compiler must be careful with optimizations

 Static
 Declared within function, retains value between function invocations
 Scope is limited to function

16
Linker Map File

 Contains extensive information on functions and variables

 Value, type, size, object

 Cross references between sections

 Memory map of image

 Sizes of image components

 Summary of memory requirements

17
C Run-Time Start-Up Module
RAM Flash ROM
 After reset, MCU must…
Zero-Initialized Data
Fill with Initialization Data
a, b zeros 31
 Initialize hardware
 Peripherals, etc. Initialized Data Constant Data
 Set up stack pointer d c: 123
Hello!

 Initialize C or C++ run-time Stack Startup and Runtime

environment e, f Library Code
 Set up heap memory
 Initialize variables Heap Data Code

18
 ACCESSING DATA IN MEMORY

19
Accessing Data
int siA;
void static_auto_local() {
int aiB;
 What does it take to get at a variable static int siC=3;
in memory? int * apD;
 Depends on location, which depends on int aiE=4, aiF=5, aiG=6;
storage type (static, automatic, dynamic) siA = 2;
aiB = siC + siA;
apD = & aiB;
(*apD)++;
apD = &siC;
(*apD) += 9;
apD = &siA;
apD = &aiE;
apD = &aiF;
apD = &aiG;
(*apD)++;
aiE+=7;
*apD = aiE + aiF;
}

20
Static Variables

 Static var can be located anywhere in 32-bit Load r0 with pointer to variable
Load r1 from [r0]
memory space, so need a 32-bit pointer Use value of variable
 Can’t fit a 32-bit pointer into a 16-bit
Label:
instruction (or a 32-bit instruction), so save 32-bit pointer to Variable
the pointer separate from instruction, but
nearby so we can access it with a short PC-
relative offset
 Load the pointer into a register (r0)
 Can now load variable’s value into a register
(r1) from memory using that pointer in r0
Variable
 Similarly can store a new value to the variable
in memory

21
Static Variables AREA ||.text||, CODE, READONLY, ALIGN=2
;;;20 siA = 2;
00000e 2102 MOVS r1,#2 ; r1 = 2
000010 4a37 LDR r2,|L1.240| ; r2 = &siA
 Key 000012 6011 STR r1,[r2,#0] ; *r2 = r1
 variable’s value
 variable’s address ;;;21 aiB = siC + siA;
000014 4937 LDR r1,|L1.244| ; r1 = &siC
 address of copy of variable’s
000016 6809 LDR r1,[r1,#0] ; r1 = *r1
address 000018 6812 LDR r2,[r2,#0] ; r2 = *r2
 Addresses of siA and siC are 00001a 1889 ADDS r1,r1,r2 ; r1 = r1 + r2
...
stored as literals to be loaded
into pointers |L1.240|
 Variables siC and siA are located DCD ||siA||
|L1.244|
in .data section with initial values DCD ||siC||
AREA ||.data||, DATA, ALIGN=2
||siC||
DCD 0x00000003
||siA||
DCD 0x00000000
22
Automatic Variables Stored on Stack
int main(void) {
 Automatic variables are stored in a function’s auto vars;
a();
activation record (unless optimized and promoted }
to register)
void a(void) {
 Activation records are located on the stack auto vars;
 Calling a function creates an activation record, b();
allocating space on stack }

 Returning from a function deletes void b(void) {

the activation record, freeing up space on stack auto vars;
c();
 Variables in C are implicitly automatic, there is no }
need to specify the keyword
void c(void) {
auto vars;
…
}
23
Addressing Automatic Variables

 Program must allocate space on stack for variables

Address Contents
 Stack addressing uses an offset from the stack pointer: SP
[sp, #offset] SP+0x4
SP+0x8
SP+0xC
 Items on the stack are word aligned SP+0x10
SP+0x14
 In instructions, one byte used for offset, which is multiplied SP+0x18
by four SP+0x1C
 Possible offsets: 0, 4, 8, …, 1020 SP+0x20
 Maximum range addressable this way is 1024 bytes

24
Automatic Variables
Address Contents
SP aiG ;;;14 void static_auto_local( void ) {
SP+4 aiF 000000 b50f PUSH {r0-r3,lr}
SP+8 aiE ;;;15 int aiB;
SP+0xC aiB ;;;16 static int siC=3;
SP+0x10 r0 ;;;17 int * apD;
SP+0x14 r1 ;;;18 int aiE=4, aiF=5, aiG=6;
SP+0x18 r2 000002 2104 MOVS r1,#4
SP+0x1C r3 000004 9102 STR r1,[sp,#8]
SP+0x20 lr
000006 2105 MOVS r1,#5
000008 9101 STR r1,[sp,#4]
 Initialize aiE 00000a 2106 MOVS r1,#6
 Initialize aiF 00000c 9100 STR r1,[sp,#0]
…
 Initialize aiG ;;;21 aiB = siC + siA;
…
00001c 9103 STR r1,[sp,#0xc]
 Store value for aiB
25
 USING POINTERS

26
Using Pointers to Automatics

 C Pointer: a variable which holds the

;;;22 apD = & aiB;
data’s address 00001e a803 ADD r0,sp,#0xc
;;;23 (*apD)++;
000020 6801 LDR r1,[r0,#0]
 aiB is on stack at SP+0xc
000022 1c49 ADDS r1,r1,#1
 Compute r0 with variable’s address 000024 6001 STR r1,[r0,#0]
from stack pointer and offset (0xc)
 Load r1 with variable’s value from
memory
 Operate on r1, save back to variable’s
address

27
Using Pointers to Statics
;;;24 apD = &siC;
 Load r0 with variable’s address from 000026 4833 LDR r0,|L1.244|
address of copy of variable’s address ;;;25 (*apD) += 9;
000028 6801 LDR r1,[r0,#0]
00002a 3109 ADDS r1,r1,#9
 Load r1 with variable’s value from 00002c 6001 STR r1,[r0,#0]
memory |L1.244|
DCD ||siC||
AREA ||.data||, DATA, ALIGN=2
 Operate on r1, save back to variable’s ||siC||
address DCD 0x00000003

28
 ARRAY ACCESS

29
Array Access
uint8 buff2[3];
 What does it take to get at an uint16 buff3[5][7];
array element in memory?
 Depends on how many dimensions uint32 arrays(uint8 n, uint8 j) {
 Depends on element size and row volatile uint32 i;
width i = buff2[0] + buff2[n];
i += buff3[n][j];
 Depends on location, which
return i;
depends on storage type (static,
}
automatic, dynamic)

30
Accessing 1-D Array Elements
Address Contents
 Need to calculate element address: sum of… buff2 buff2[0]
 array start address
buff2 + 1 buff2[1]
 offset: index * element size
buff2 + 2 buff2[2]
 buff2 is array of unsigned characters

 Move n (argument) from r0 into r2 00009e 4602 MOV r2,r0

;;;76 i = buff2[0] + buff2[n];
 Load r3 with pointer to buff2
0000a0 4b1b LDR r3,|L1.272|
 Load (byte) r3 with first element of buff2 0000a2 781b LDRB r3,[r3,#0] ; buff2
 Load r4 with pointer to buff2 0000a4 4c1a LDR r4,|L1.272|
 Load (byte) r4 with element at address buff2+r2 0000a6 5ca4 LDRB r4,[r4,r2]
 r2 holds argument n 0000a8 1918 ADDS r0,r3,r4
 Add r3 and r4 to form sum |L1.272|
DCD buff2

31
Accessing 2-D Array Elements
uint16 buff3[5][7]
Address Contents  var[rows][columns]
buff3 buff3[0][0]
 Sizes
buff3+1
 Element: 2 bytes
buff3+2 buff3[0][1]
buff3+3  Row: 7*2 bytes = 14 bytes (0xe)
(etc.)  Offset based on row index and column
buff3+10 buff3[0][5] index
buff3+11  column offset = column index *
buff3+12 buff3[0][6] element size
buff3+13
 row offset = row index * row size
buff3+14 buff3[1][0]
buff3+15
buff3+16 buff3[1][1]
buff3+17
(etc.)
buff3+68 buff3[4][6]
buff3+69

32
Code to Access 2-D Array

Instruction r0 r1 r2 r3 r4 Description
;;; i += buff3[n][j]; i j n - -
MOVS r3,#0xe - - - 0xe - Load row size
MULS r3,r2,r3 - - n n*0xe - Multiply by row number
LDR r4,|L1.276| - - - - &buff3 Load address of buff3
ADDS r3,r3,r4 - - - &buff3+n*0xe - Add buff3 address to row
offset
LSLS r4,r1,#1 - j - - j<<1 Multiply column number by 2
(buff3 is uint16 array)
LDRH r3,[r3,r4] - - - *(uint16)(&buff3+n*0xe+j<<1) j<<1 Load halfword r3 with
= buff3[n][j] element at r3+r4 (buff3 +
row offset + col offset)
ADDS r0,r3,r0 i+buff3[n][j] - - buff3[n][j] Add r3 to r0 (i)

33
 CALLING FUNCTIONS

34
AAPCS Core Register Use
Register Synonym Special Role in the procedure call standard
r15 PC The Program Counter.
r14 LR The Link Register.
r13 SP The Stack Pointer.
r12 IP The Intra-Procedure-call scratch register.
r11 v8 Variable-register 8.
r10 v7 Variable-register 7.
Platform register. The meaning of this register is defined
r9 v6,SB,TR
by the platform standard.
r8 v5 Variable-register 5.
r7 v4 Variable register 4.
r6 v3 Variable register 3.
r5 v2 Variable register 2.
r4 v1 Variable register 1.
r3 a4 Argument / scratch register 4.
r2 a3 Argument / scratch register 3.
r1 a2 Argument / result / scratch register 2.
r0 a1 Argument / result / scratch register 1.

35
Function Arguments and Return Values

 First, pass the arguments

 How to pass them?
◦ Much faster to use registers than stack
◦ But quantity of registers is limited
 Basic rules
◦ Process arguments in order they appear in source code
◦ Round size up to be a multiple of 4 bytes
◦ Copy arguments into core registers (r0-r3), aligning doubles to even registers
◦ Copy remaining arguments onto stack, aligning doubles to even addresses
 Second, call the function
 Usually as subroutine with branch link (bl) or branch link and exchange instruction (blx)

36
Return Values

 Callee passes Return Value in register(s)

or stack Return value size Registers used for passing
Fundamental Composite Data
Data Type Type

 Registers 1-4 bytes r0 r0

8 bytes r0-r1 stack
16 bytes r0-r3 stack
 Stack Indeterminate size n/a stack

 Caller function allocates space for return

value, then passes pointer to space as an
argument to callee
 Callee stores result at location indicated by
pointer

37
Call Example
int fun2(int arg2_1, int arg2_2) { fun2 PROC
int i; ;;;85 int fun2(int arg2_1, int
arg2_2 += fun3(arg2_1, 4, 5, 6); arg2_2) {
… ...
} 0000e0 2306 MOVS r3,#6
0000e2 2205 MOVS r2,#5
 Argument 4 into r3 0000e4 2104 MOVS r1,#4
 Argument 3 into r2 0000e6 4630 MOV r0,r6

 Argument 2 into r1
 Argument 0 into r0 0000e8 f7fffffe BL fun3
 Call fun3 with BL instruction
0000ec 1904 ADDS r4,r0,r4
 Result was returned in r0, so add to
r4 (arg2_2 += result)

38
 Call and Return Example
fun3 PROC
int fun3(int arg3_1, int arg3_2, ;;;81 int fun3(int arg3_1, int arg3_2,
int arg3_3, int arg3_4) { int arg3_3, int arg3_4) {
return arg3_1*arg3_2*
arg3_3*arg3_4; 0000ba b510 PUSH {r4,lr}
}

 Save r4 and Link Register on stack 0000c0 4348 MULS r0,r1,r0

0000c2 4350 MULS r0,r2,r0
 r0 = arg3_1*arg3_2 0000c4 4358 MULS r0,r3,r0
 r0 *= arg3_3
 r0 *= arg3_4 0000c6 bd10 POP {r4,pc}

 Restore r4 and return from

subroutine
 Return value is in r0

39
 CONTROL FLOW

40
Control Flow: Conditionals and Loops

 How does the compiler implement for (i = 0; i < 10; i++){

conditionals and loops? x += i;
}
if (x){ switch (x) {
y++; case 1: while (x<10) {
} else { y += 3; x = x + 1;
y--; break; }
} case 31:
y -= 5; do {
break; x += 2;
default: } while (x < 20);
y--;
break;
}

41
Control Flow: If/Else
;;;39 if (x){
000056 2900 CMP r1,#0
000058 d001 BEQ |L1.94|

T F ;;;40 y++;
00005a 1c52 ADDS r2,r2,#1
Condition 00005c e000 B |L1.96|

|L1.94|
;;;41 } else {
action_if action_else ;;;42 y--;
00005e 1e52 SUBS r2,r2,#1

|L1.96|
;;;43 }

42
Control Flow: Switch 000066 d104 BNE |L1.114|
000068 e001 B |L1.110|
Evaluate |L1.106|
;;;46 case 1:
;;;47 y += 3;
T 00006a 1cd2 ADDS r2,r2,#3
= const1? action1 ;;;48 break;
00006c e003 B |L1.118|
F |L1.110|
T ;;;49 case 31:
= const2? action2 ;;;50 y -= 5;
00006e 1f52 SUBS r2,r2,#5
F ;;;51 break;
000070 e001 B |L1.118|
action3 |L1.114|
;;;52 default:
;;;53 y--;
000072 1e52 SUBS r2,r2,#1
;;;54 break;
;;;45 switch (x) { 000074 bf00 NOP
000060 2901 CMP r1,#1 |L1.118|
000062 d002 BEQ |L1.106| 000076 bf00 NOP
000064 291f CMP r1,#0x1f ;;;55 }

43
Iteration: While

;;;57 while (x<10) {

000078 e000 B |L1.124|
|L1.122|
loop_body ;;;58 x = x + 1;
00007a 1c49 ADDS r1,r1,#1
|L1.124|
00007c 290a CMP r1,#0xa
T ;57
Condition
00007e d3fc BCC |L1.122|
;;;59 }
F

44
Iteration: For
;;;61 for (i = 0; i < 10; i++){
init_expression 000080 2300 MOVS r3,#0
000082 e001 B |L1.136|

|L1.132|
loop_body ;;;62 x += i;
000084 18c9 ADDS r1,r1,r3
000086 1c5b ADDS r3,r3,#1
cond_expression ;61

|L1.136|
000088 2b0a CMP r3,#0xa
T ;61
Condition
00008a d3fb BCC |L1.132|
;;;63 }
F
45
Iteration: Do/While

;;;65 do {
00008c bf00 NOP
loop_body
|L1.142|
;;;66 x += 2;
T 00008e 1c89 ADDS r1,r1,#2
Condition ;;;67 } while (x < 20);
000090 2914 CMP r1,#0x14
000092 d3fc BCC |L1.142|
F

46