Assembler-Dump erstellen mit avr-gcc: Unterschied zwischen den Versionen

Version vom 8. Juni 2006, 10:48 Uhr

Aus den unterschiedlichsten Gründen kann es wünschenswert sein, den Assembler-Code zu sehen, den avr-gcc (oder gcc im Allgemeinen) aus einer C/C++-Quelle erzeugt. Die Ausgabe von gcc geschieht immer in Form von Assembler-Code als ASCII-Datei. Ohne die Angabe spezieller Optionen ist diese Datei jedoch nur temporär und wird nach Beenden der von gcc aufgerufenen Programme cc1 (Compiler), as (Assembler) und ld (Linker) wieder gelöscht.

Ein Weg, den zu einer Quelle gehörenden Assembler-Code zu erhalten ist also, diese temporäre Datei zu erhalten, was mit der gcc-Option -save-temps geschieht, oder indem man nur assembliert, was mit der Option -S geschieht.

Alternativ dazu kann man mit objcopy ein Disassemble der erzeugten Objekte erzeugen.

Ja nach dem, welchen dieser Möglichkeiten man wählt, enthält die Assembler-Ausgabe unterschiedliche Informationen, Darstellungen und Erläuterungen.

Als C-Beispiel dient eine kleine Funktion, die einem Foren-Beitrag zu selbigem Thema entstammt. Die Assembler-Dumps sind jedoch nur Snips der kleinen Funktion foo, um die es hier gehen soll. Für komplexere Funktionen oder andere gcc-Targets (etwa arm7-gcc) ist die Vorgehensweise analog. Die main-Funktion wird nur gebraucht, damit für das letzte Beispiel ein elf erzeugt werden kann, da hier gegen main gelinkt wird.

C-Quelle

unsigned char command_rc5; 
unsigned char Ir_data_tmp; 

void foo()
{
   uint8_t cmd = command_rc5 & ~(1<<7);

   if (Ir_data_tmp & (1<<5))       
      cmd |= (1<<7);
   
   command_rc5 = cmd;   
} 

int main main()
{
	return 0;
}

Compiler dumpt Assembler

kein Assemblieren

Die Arbeit von gcc endet mit Schreiben der Assembler-Ausgabe. Es wird also auch kein Object (*.o) erzeugt.

Kommando:

> avr-gcc -S -fverbose-asm ...

Ausgabe:

.global   foo
        .type   foo, @function
foo:
/* prologue: frame size=0 */
/* prologue end (size=0) */
        lds r25,command_rc5      ;  cmd, command_rc5
        andi r25,lo8(127)        ;  cmd,
        lds r24,Ir_data_tmp      ;  Ir_data_tmp, Ir_data_tmp
        sbrc r24,5       ;  Ir_data_tmp,
        ori r25,lo8(-128)        ;  cmd,
.L2:
        sts command_rc5,r25      ;  command_rc5, cmd
/* epilogue: frame size=0 */
        ret
/* epilogue end (size=1) */
/* function foo size 11 (10) */
        .size   foo, .-foo

mit Assemblieren

Wüschenswert wäre folgendes Kommando:

> avr-gcc -c -save-temps -fverbose-asm ...

Dies führt jedoch aus unerfindlichen Gründen zum Verlorengehen von Symbolen. Alternativ kann man zwei Aufrufe machen, was dummerweise etwas länger dauert und schwer in Makefile-Generatoren auszudrücken ist:

> avr-gcc -S -save-temps -fverbose-asm ...
> avr-gcc -c -g ...

Die Ausgabe ist dann wie im vorherigen Abschnitt, nur daß jetzt auch assembliert wird.

Assembler dumpt Assembler

Kommando:

> avr-gcc -Wa,-alhd=dump.s ...

Ausgabe:

  18                      .global foo
  20                    foo:
  21                    .LFB2:
  22                    .LM1:
  23                    /* prologue: frame size=0 */
  24                    /* prologue end (size=0) */
  25                    .LM2:
  26 0000 9091 0000             lds r25,command_rc5
  27 0004 9F77                  andi r25,lo8(127)
  28                    .LM3:
  29 0006 8091 0000             lds r24,Ir_data_tmp
  30 000a 85FD                  sbrc r24,5
  31                    .LM4:
  32 000c 9068                  ori r25,lo8(-128)
  33                    .L2:
  34                    .LM5:
  35 000e 9093 0000             sts command_rc5,r25
  36                    /* epilogue: frame size=0 */
  37 0012 0895                  ret
  38                    /* epilogue end (size=1) */
  39                    /* function foo size 11 (10) */

objdump erzeugt Disassemble

aus Object (nicht loakatiert)

Kommando:

> avr-objdump -d -S ...

Ausgabe:

00000000 <foo>:
uint8_t command_rc5, Ir_data_tmp; 

void foo()
{
   uint8_t cmd = command_rc5 & ~(1<<7);
   0:   90 91 00 00     lds     r25, 0x0000
   4:   9f 77           andi    r25, 0x7F       ; 127

   if (Ir_data_tmp & (1<<5))       
   6:   80 91 00 00     lds     r24, 0x0000
   a:   85 fd           sbrc    r24, 5
      cmd |= (1<<7);
   c:   90 68           ori     r25, 0x80       ; 128
   
   command_rc5 = cmd;   
   e:   90 93 00 00     sts     0x0000, r25
  12:   08 95           ret

aus elf (lokatiert)

Kommando:

> avr-objdump -h -S ...

Ausgabe:

0000005c <foo>:
uint8_t command_rc5, Ir_data_tmp; 

void foo()
{
   uint8_t cmd = command_rc5 & ~(1<<7);
  5c:   90 91 60 00     lds     r25, 0x0060
  60:   9f 77           andi    r25, 0x7F       ; 127

   if (Ir_data_tmp & (1<<5))       
  62:   80 91 61 00     lds     r24, 0x0061
  66:   85 fd           sbrc    r24, 5
      cmd |= (1<<7);
  68:   90 68           ori     r25, 0x80       ; 128
   
   command_rc5 = cmd;   
  6a:   90 93 60 00     sts     0x0060, r25
  6e:   08 95           ret

aus ihex (lokatiert)

Intel-HEX ist ein recht "dummes" Format, es speichert weder Section-Informationen noch Symbole, Debug-Informationen oder Quellbezüge. Dementsprechend muss man wissen, wo man nach was zu suchen hat im disassemblierten Spaghetti-Code. Zudem kann objdump nicht wissen, ob eine Sequqnz als Befehl oder als Datum zu interpretieren ist und hat keine Alignment-Info, was zu verwirrenden Disassembles führen kann, wenn objcopy z.B. mitten in einem 4-Byte-Befehl aufsetzt.

Da dieses Format auch nicht weiß, für welche Maschine es codiert, muss man dies wissen und angeben. Hier wurde der Code für einen ATmega8 erzeugt, welcher zur Gruppe avr4 gehört.

Kommando:

> avr-objdump -D -mavr4 ...

Ausgabe:

     file format ihex

Disassembly of section .sec1:

00000000 <.sec1>:
...
  5c:	90 91 60 00 	lds	r25, 0x0060
  60:	9f 77       	andi	r25, 0x7F	; 127
  62:	80 91 61 00 	lds	r24, 0x0061
  66:	85 fd       	sbrc	r24, 5
  68:	90 68       	ori	r25, 0x80	; 128
  6a:	90 93 60 00 	sts	0x0060, r25
  6e:	08 95       	ret
  ...

Siehe auch

• avr-gcc