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

Version vom 13. Februar 2007, 10:58 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, an den zu einer C-Quelle gehörenden Assembler-Code zu kommen ist also, diese temporäre Datei zu erhalten. Dazu gibt man die gcc-Option -save-temps an oder man lässt gcc lediglich assemblieren, 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. Während die Assembler-Ausgabe von gcc direkt als Eingabe für den GNU-Assembler verwendet werden kann, sind die Disassembles und Assembler-Dumps des Assemblers für diesen Zweck nicht verwendbar.

Zum besseren Verständnis der folgenden Abschnitte ist es hilfreich, den Ablauf der Codegenerierung bei gcc zu kennen.

C-Quelle

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.

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:

> gcc -S -fverbose-asm ...

Ausgabe (hier für avr-gcc):

.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

Um die temporäre Assembler-Datei auch zu erhalten wenn Assembliert wird, dient folgender Aufruf, der auch die Ausgabe des Precompilers (*.i) erhält:

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

Alternativ kann man das Erzeugen des Objects in zwei Schritte aufteilen: Compileren *.c → *.s) und Assemblieren (*.s → *.o). Insgesamt hat man dann also das gleiche Resultat wie bei -c.

> gcc -S foo.c -fverbose-asm ...
> gcc -c foo.s ...

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

Bei diesem Ansatz ist es günstig, ohne Debug-Informationen zu übersetzen, da ansonsten die Assembler-Ausgabe unleserlicher und deutlich größer wird.

Assembler dumpt Assembler

Kommando: Dier Option -Wa,... bewirkt, daß die nachfolgenden Zeichen mit an die Assembler-Kommandozeile übergeben werden. Der Assembler wird also zusätzlich mit der Option -alhd=dump.s gestartet, was das Schreiben der Ausgabe bewirkt.

> 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)

Damit die Quellschnippsel im Dump angezeigt werden muss das Object mit Debug-Informationen erzeugt worden sein, und die Quelle muss noch vorhanden sein.

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