Examining Compiler Generated Machine Code

Examining Compiler Generated Machine Code

On this page we will explore the process of generating machine code from one or more .c files.

The preprocessor first handles any preprocessor directives (e.g., #include).
The compiler then generates assembly code targeted for the ATmega32 microcontroller.
The linker produces the actual machine code to be downloaded to the microcontroller.
In addition, we can generate an .lss file (equivalent to the .lst file generated with the Atmel assembler).

Trivial C Program

The following C program, wk1.c, does nothing:

int main()
{
}

Even so, it produces the following .lss file:

wk1.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         000000a2  00000000  00000000  00000054  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .stab         00000378  00000000  00000000  000000f8  2**2
                  CONTENTS, READONLY, DEBUGGING
  2 .stabstr      0000005f  00000000  00000000  00000470  2**0
                  CONTENTS, READONLY, DEBUGGING
  3 .debug_aranges 00000020  00000000  00000000  000004cf  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 0000001b  00000000  00000000  000004ef  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   0000008a  00000000  00000000  0000050a  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 00000034  00000000  00000000  00000594  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   00000055  00000000  00000000  000005c8  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000020  00000000  00000000  00000620  2**2
                  CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 2a 00 	jmp	0x54	; 0x54 <__ctors_end>
   4:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
   8:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
   c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  10:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  14:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  18:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  1c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  20:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  24:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  28:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  2c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  30:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  34:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  38:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  3c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  40:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  44:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  48:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  4c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  50:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d8 e0       	ldi	r29, 0x08	; 8
  5c:	de bf       	out	0x3e, r29	; 62
  5e:	cd bf       	out	0x3d, r28	; 61

00000060 <__do_copy_data>:
  60:	10 e0       	ldi	r17, 0x00	; 0
  62:	a0 e6       	ldi	r26, 0x60	; 96
  64:	b0 e0       	ldi	r27, 0x00	; 0
  66:	e2 ea       	ldi	r30, 0xA2	; 162
  68:	f0 e0       	ldi	r31, 0x00	; 0
  6a:	02 c0       	rjmp	.+4      	; 0x70 <.do_copy_data_start>

0000006c <.do_copy_data_loop>:
  6c:	05 90       	lpm	r0, Z+
  6e:	0d 92       	st	X+, r0

00000070 <.do_copy_data_start>:
  70:	a0 36       	cpi	r26, 0x60	; 96
  72:	b1 07       	cpc	r27, r17
  74:	d9 f7       	brne	.-10     	; 0x6c <.do_copy_data_loop>

00000076 <__do_clear_bss>:
  76:	10 e0       	ldi	r17, 0x00	; 0
  78:	a0 e6       	ldi	r26, 0x60	; 96
  7a:	b0 e0       	ldi	r27, 0x00	; 0
  7c:	01 c0       	rjmp	.+2      	; 0x80 <.do_clear_bss_start>

0000007e <.do_clear_bss_loop>:
  7e:	1d 92       	st	X+, r1

00000080 <.do_clear_bss_start>:
  80:	a0 36       	cpi	r26, 0x60	; 96
  82:	b1 07       	cpc	r27, r17
  84:	e1 f7       	brne	.-8      	; 0x7e <.do_clear_bss_loop>
  86:	0e 94 49 00 	call	0x92	; 0x92 <main>
  8a:	0c 94 50 00 	jmp	0xa0	; 0xa0 <_exit>

0000008e <__bad_interrupt>:
  8e:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

00000092 <main>:
  92:	cf 93       	push	r28
  94:	df 93       	push	r29
  96:	cd b7       	in	r28, 0x3d	; 61
  98:	de b7       	in	r29, 0x3e	; 62
  9a:	df 91       	pop	r29
  9c:	cf 91       	pop	r28
  9e:	08 95       	ret

000000a0 <_exit>:
  a0:	ff cf       	rjmp	.-2      	; 0xa0 <_exit>

It is important to note that the addresses shown in the .lss file are 2 times the values found in the .lst files.
This results in a mismatch between the values found in the .lss file and the disassembler file. (The disassembler file can be accessed from the view menu in AVR Studio when running the debugger.)

Vectors

The compiler initializes all of the interrupt jump vectors.
For our program we only make use of the reset jump vector.
- The compiler jumps to ctors_end when the microcontroller is powered on.
The remaining jump vectors all contain jumps to bad_interrupt
- The bad_interrupt code just jumps back to the reset vector.
- Therefore, if any interrupt is unintentionally triggered, the program starts over.

ctors_end

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63  SREG
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d8 e0       	ldi	r29, 0x08	; 8
  5c:	de bf       	out	0x3e, r29	; 62  SPH
  5e:	cd bf       	out	0x3d, r28	; 61  SPL

Clears the status register and initializes the stack pointer.
See p. 299 of the ATmega32 Datasheet for the addresses for the i/o registers.

do_copy_data

Initializes X and Z registers for copying data from program memory into data memory.

00000060 <__do_copy_data>:
  60:	10 e0       	ldi	r17, 0x00	; 0
  62:	a0 e6       	ldi	r26, 0x60	; 96
  64:	b0 e0       	ldi	r27, 0x00	; 0
  66:	e2 ea       	ldi	r30, 0xA2	; 162
  68:	f0 e0       	ldi	r31, 0x00	; 0
  6a:	02 c0       	rjmp	.+4      	; 0x70 <.do_copy_data_start>

X points to the beginning of data memory.
Z points to the beginning of the data currently stored in program memory.
We'll revisit the do_copy_data_whatever when we actually have data to be copied.

do_clear_bss

The .bss section is used to store uninitialized global or static variables.
The do_clear_bss_whatever sections are used to clear out the data values where these global/static variables will be stored.
We'll revisit the do_clear_bss_whatever when we actually have data to be copied.

Empty main and Beyond

00000092 <main>:
  92:	cf 93       	push	r28
  94:	df 93       	push	r29
  96:	cd b7       	in	r28, 0x3d	; 61
  98:	de b7       	in	r29, 0x3e	; 62
  9a:	df 91       	pop	r29
  9c:	cf 91       	pop	r28
  9e:	08 95       	ret

000000a0 <_exit>:
  a0:	ff cf       	rjmp	.-2      	; 0xa0 <_exit>

main automatically reads the stack pointer into the Y register.
Since main uses the Y register, R28 and R29 get pushed onto the stack at the beginning and popped of the stack at the end.
Upon returning (back to 0x8a) we JMP to _exit which just loops forever.

Non-Trivial C Program

#include <avr/io.h>
 
int y[4];
 
int main()
{
  char word[] = "funness";
  int x[3];
  int i = 1;
  PORTB = x[i];
  for(i=0; i<3; ++i)
  {
    x[i] = PINB;
  }
  for(i=0; i<3; ++i)
  {
    PORTB = x[3-i];
  }
  return 0;
}

Below are parts of the listing file generated with no compiler optimization.

The compiler has picked the following locations to store variable data:
- word – stored in initialized data memory.
- y – stored in uninitialized data memory for global/static variables (bss section).
- x – stored on the stack.
- i – stored on the stack.

Data Copy

00000060 <__do_copy_data>:
  60:	10 e0       	ldi	r17, 0x00	; 0
  62:	a0 e6       	ldi	r26, 0x60	; 96
  64:	b0 e0       	ldi	r27, 0x00	; 0
  66:	ee ea       	ldi	r30, 0xAE	; 174
  68:	f1 e0       	ldi	r31, 0x01	; 1
  6a:	02 c0       	rjmp	.+4      	; 0x70 <.do_copy_data_start>

0000006c <.do_copy_data_loop>:
  6c:	05 90       	lpm	r0, Z+
  6e:	0d 92       	st	X+, r0

00000070 <.do_copy_data_start>:
  70:	a8 36       	cpi	r26, 0x68	; 104
  72:	b1 07       	cpc	r27, r17
  74:	d9 f7       	brne	.-10     	; 0x6c <.do_copy_data_loop>

A total of eight bytes are copied from program memory to data memory (for word).
These eight bytes are the seven characters in funness and the null terminator.
The do_copy_data_loop copies a value from program memory into R0 and then into data memory.
The do_copy_data_start determines if the X pointer is pointing to the last data memory location reserved for storing some program variables.
The compiler will store some other program variables on the stack (which you'll see in a minute… if you stay awake).

Clearing Data Area for Uninitialized Global/Static Variables

All global/static variables are stored in data memory since they need to be available for the life of the program.
Uninitialized global/static variables are cleared on initialization.
In this program y is an uninitialized global variable requiring ten bytes (since each int is 16-bits wide).

00000076 <__do_clear_bss>:
  76:	10 e0       	ldi	r17, 0x00	; 0
  78:	a8 e6       	ldi	r26, 0x68	; 104
  7a:	b0 e0       	ldi	r27, 0x00	; 0
  7c:	01 c0       	rjmp	.+2      	; 0x80 <.do_clear_bss_start>

0000007e <.do_clear_bss_loop>:
  7e:	1d 92       	st	X+, r1

00000080 <.do_clear_bss_start>:
  80:	a0 37       	cpi	r26, 0x72	; 114
  82:	b1 07       	cpc	r27, r17
  84:	e1 f7       	brne	.-8      	; 0x7e <.do_clear_bss_loop>
  86:	0e 94 49 00 	call	0x92	; 0x92 <main>
  8a:	0c 94 d6 00 	jmp	0x1ac	; 0x1ac <_exit>

Here we just cycle through the ten bytes of data memory writing zero to each location.
Note: By compiler convention, R1 always has the value of zero.
Once the uninitialized global/static memory has been cleared, main is called (line 86).
If main returns, the controller get sent to a tight loop that cycles forever.

Main

The main function is much more exciting now. Here are few things to keep in mind when view this code:

Non-static local variables are stored either in a dedicated register or on the stack.
The Y register is used as a local stack pointer for the function.
Interrupts are disabled when the stack pointer (addresses 0x3e and 0x3d) is being read.

00000092 <main>:
  92:	cf 93       	push	r28
  94:	df 93       	push	r29
  96:	cd b7       	in	r28, 0x3d	; 61
  98:	de b7       	in	r29, 0x3e	; 62
  9a:	65 97       	sbiw	r28, 0x15	; 21
  9c:	0f b6       	in	r0, 0x3f	; 63
  9e:	f8 94       	cli
  a0:	de bf       	out	0x3e, r29	; 62
  a2:	0f be       	out	0x3f, r0	; 63
  a4:	cd bf       	out	0x3d, r28	; 61
  a6:	ae 01       	movw	r20, r28
  a8:	4d 5f       	subi	r20, 0xFD	; 253
  aa:	5f 4f       	sbci	r21, 0xFF	; 255
  ac:	5a 8b       	std	Y+18, r21	; 0x12
  ae:	49 8b       	std	Y+17, r20	; 0x11
  b0:	80 e6       	ldi	r24, 0x60	; 96
  b2:	90 e0       	ldi	r25, 0x00	; 0
  b4:	9c 8b       	std	Y+20, r25	; 0x14
  b6:	8b 8b       	std	Y+19, r24	; 0x13
  b8:	98 e0       	ldi	r25, 0x08	; 8
  ba:	9d 8b       	std	Y+21, r25	; 0x15
  bc:	eb 89       	ldd	r30, Y+19	; 0x13
  be:	fc 89       	ldd	r31, Y+20	; 0x14
  c0:	00 80       	ld	r0, Z
  c2:	4b 89       	ldd	r20, Y+19	; 0x13
  c4:	5c 89       	ldd	r21, Y+20	; 0x14
  c6:	4f 5f       	subi	r20, 0xFF	; 255
  c8:	5f 4f       	sbci	r21, 0xFF	; 255
  ca:	5c 8b       	std	Y+20, r21	; 0x14
  cc:	4b 8b       	std	Y+19, r20	; 0x13
  ce:	e9 89       	ldd	r30, Y+17	; 0x11
  d0:	fa 89       	ldd	r31, Y+18	; 0x12
  d2:	00 82       	st	Z, r0
  d4:	49 89       	ldd	r20, Y+17	; 0x11
  d6:	5a 89       	ldd	r21, Y+18	; 0x12
  d8:	4f 5f       	subi	r20, 0xFF	; 255
  da:	5f 4f       	sbci	r21, 0xFF	; 255
  dc:	5a 8b       	std	Y+18, r21	; 0x12
  de:	49 8b       	std	Y+17, r20	; 0x11
  e0:	5d 89       	ldd	r21, Y+21	; 0x15
  e2:	51 50       	subi	r21, 0x01	; 1
  e4:	5d 8b       	std	Y+21, r21	; 0x15
  e6:	8d 89       	ldd	r24, Y+21	; 0x15
  e8:	88 23       	and	r24, r24
  ea:	41 f7       	brne	.-48     	; 0xbc <main+0x2a>
  ec:	81 e0       	ldi	r24, 0x01	; 1
  ee:	90 e0       	ldi	r25, 0x00	; 0
  f0:	9a 83       	std	Y+2, r25	; 0x02
  f2:	89 83       	std	Y+1, r24	; 0x01
  f4:	a8 e3       	ldi	r26, 0x38	; 56
  f6:	b0 e0       	ldi	r27, 0x00	; 0
  f8:	89 81       	ldd	r24, Y+1	; 0x01
  fa:	9a 81       	ldd	r25, Y+2	; 0x02
  fc:	9c 01       	movw	r18, r24
  fe:	22 0f       	add	r18, r18
 100:	33 1f       	adc	r19, r19
 102:	ce 01       	movw	r24, r28
 104:	01 96       	adiw	r24, 0x01	; 1
 106:	82 0f       	add	r24, r18
 108:	93 1f       	adc	r25, r19
 10a:	fc 01       	movw	r30, r24
 10c:	3a 96       	adiw	r30, 0x0a	; 10
 10e:	80 81       	ld	r24, Z
 110:	91 81       	ldd	r25, Z+1	; 0x01
 112:	8c 93       	st	X, r24
 114:	1a 82       	std	Y+2, r1	; 0x02
 116:	19 82       	std	Y+1, r1	; 0x01
 118:	16 c0       	rjmp	.+44     	; 0x146 <main+0xb4>
 11a:	29 81       	ldd	r18, Y+1	; 0x01
 11c:	3a 81       	ldd	r19, Y+2	; 0x02
 11e:	e6 e3       	ldi	r30, 0x36	; 54
 120:	f0 e0       	ldi	r31, 0x00	; 0
 122:	80 81       	ld	r24, Z
 124:	48 2f       	mov	r20, r24
 126:	50 e0       	ldi	r21, 0x00	; 0
 128:	22 0f       	add	r18, r18
 12a:	33 1f       	adc	r19, r19
 12c:	ce 01       	movw	r24, r28
 12e:	01 96       	adiw	r24, 0x01	; 1
 130:	82 0f       	add	r24, r18
 132:	93 1f       	adc	r25, r19
 134:	fc 01       	movw	r30, r24
 136:	3a 96       	adiw	r30, 0x0a	; 10
 138:	51 83       	std	Z+1, r21	; 0x01
 13a:	40 83       	st	Z, r20
 13c:	89 81       	ldd	r24, Y+1	; 0x01
 13e:	9a 81       	ldd	r25, Y+2	; 0x02
 140:	01 96       	adiw	r24, 0x01	; 1
 142:	9a 83       	std	Y+2, r25	; 0x02
 144:	89 83       	std	Y+1, r24	; 0x01
 146:	89 81       	ldd	r24, Y+1	; 0x01
 148:	9a 81       	ldd	r25, Y+2	; 0x02
 14a:	83 30       	cpi	r24, 0x03	; 3
 14c:	91 05       	cpc	r25, r1
 14e:	2c f3       	brlt	.-54     	; 0x11a <main+0x88>
 150:	1a 82       	std	Y+2, r1	; 0x02
 152:	19 82       	std	Y+1, r1	; 0x01
 154:	1b c0       	rjmp	.+54     	; 0x18c <main+0xfa>
 156:	a8 e3       	ldi	r26, 0x38	; 56
 158:	b0 e0       	ldi	r27, 0x00	; 0
 15a:	23 e0       	ldi	r18, 0x03	; 3
 15c:	30 e0       	ldi	r19, 0x00	; 0
 15e:	89 81       	ldd	r24, Y+1	; 0x01
 160:	9a 81       	ldd	r25, Y+2	; 0x02
 162:	f9 01       	movw	r30, r18
 164:	e8 1b       	sub	r30, r24
 166:	f9 0b       	sbc	r31, r25
 168:	cf 01       	movw	r24, r30
 16a:	9c 01       	movw	r18, r24
 16c:	22 0f       	add	r18, r18
 16e:	33 1f       	adc	r19, r19
 170:	ce 01       	movw	r24, r28
 172:	01 96       	adiw	r24, 0x01	; 1
 174:	82 0f       	add	r24, r18
 176:	93 1f       	adc	r25, r19
 178:	fc 01       	movw	r30, r24
 17a:	3a 96       	adiw	r30, 0x0a	; 10
 17c:	80 81       	ld	r24, Z
 17e:	91 81       	ldd	r25, Z+1	; 0x01
 180:	8c 93       	st	X, r24
 182:	89 81       	ldd	r24, Y+1	; 0x01
 184:	9a 81       	ldd	r25, Y+2	; 0x02
 186:	01 96       	adiw	r24, 0x01	; 1
 188:	9a 83       	std	Y+2, r25	; 0x02
 18a:	89 83       	std	Y+1, r24	; 0x01
 18c:	89 81       	ldd	r24, Y+1	; 0x01
 18e:	9a 81       	ldd	r25, Y+2	; 0x02
 190:	83 30       	cpi	r24, 0x03	; 3
 192:	91 05       	cpc	r25, r1
 194:	04 f3       	brlt	.-64     	; 0x156 <main+0xc4>
 196:	80 e0       	ldi	r24, 0x00	; 0
 198:	90 e0       	ldi	r25, 0x00	; 0
 19a:	65 96       	adiw	r28, 0x15	; 21
 19c:	0f b6       	in	r0, 0x3f	; 63
 19e:	f8 94       	cli
 1a0:	de bf       	out	0x3e, r29	; 62
 1a2:	0f be       	out	0x3f, r0	; 63
 1a4:	cd bf       	out	0x3d, r28	; 61
 1a6:	df 91       	pop	r29
 1a8:	cf 91       	pop	r28
 1aa:	08 95       	ret

Exercise for Students

Recompile the same program with the highest level of optimization (-0s) and see how things change. Is this what you would expect?