cannot execute binary file

[Tilo B. (Firma: Qimonda) (tilodd)]

Hallo GCC-Gemeinde,

ich steh ein bischen auf dem Schlauch! Seit einer Woche bin ich stolzer 
Besitzer eines Olimex SAM9-L9260 mit ARM9 Prozessor. Linux läuft super 
auch über SSH und sonst ist alles richtg gut.

Nun wollte ich mal mit dem arm-elf-gcc das obligatorische HelloWorld 
übersetzen und per SCP rüberschieben geht alles wunderbar. Ohne 
besondere Kommandozeilenoptionen, also mit

arm-elf-gcc -mcpu=arm9 -o hello.o hello.c

bekomm ich erst mal eine riesen Datei (180k). Bischen arg groß für ein 
HelloWorld Test. Wenn ich das rüber aufs Board kopiere dann die rechte 
setze und es mir ./hello.o oder sh hello.o starten will, dann kommt nur 
Illegal instruction?

Gut also mal ins Makefile vom yagarto Test-Beispiel geschaut und noch 
ein paar Kommandozeilenoptionen dazugeschrieben

arm-elf-gcc -mcpu=arm9 -Oo -gdwarf-2 -mthumb-interwork -fomit-frame-pointer 
-Wall -Wstrict-prototypes -verbose-asm -MD -MP -I . -I ./inc -o hello.o hello.c

dann wird die hollo.o zwar nur noch rund 1.8k groß. Sieht schon mal gut 
aus. Aber nach dem rüberkopieren bekomm ich dann:

cannot execute binary file

Habt ihr ne Ahnung, was ich da falsch mache?

Gruß Tilo

[K. J. (Gast)]

Rechte zum ausfüren gesetzt ?

[Tilo B. (Firma: Qimonda) (tilodd)]

Hallo K.J.

ja zur Sicherheit hab ich die Datei gleich mit

chmod 777 hello.o

freigegeben.

Gruß Tilo

[Rufus Τ. F. (rufus)]

Das ist keine ausführbare Datei, sondern nur eine Objektdatei, d.h. das, 
was man dem Linker vorwirft, damit der die Runtimeumgebung (Startupcode, 
benötigte Libraries etc.) dazupackt.

Dem gcc wird man auch noch mitteilen müssen, daß er die Objektdatei dem 
Linker vorwirft.

[Tilo B. (Firma: Qimonda) (tilodd)]

Hmm das stimmt, mit dem Linker, das hab ich jetzt auch mitbekommen. 
Allerdings sollte dann doch der arm-elf-gcc compiler wenn ich alle 
optionen weglasse also nur mit

arm-elf-gcc -mcpu=arm9 hello.c

doch den ganzen build pfad durchlaufen, also

Preprocessing --> Compiling --> Assembling --> Linking

und dann automatisch eine elf Datei schmeißen. Tut er aber nicht, 
sondern eine a.out. und dies ist offensichtlich ein binary-File und kein 
executable.

eh ich steh total auf'm schlauch!

gruß

[Malte _. (malte)]

Probier doch mal die a.out auszuführen. Das ist der Standardname wenn 
man keinen angibt. Üblicherweise sind executables binär kodiert ;-)

[Tilo B. (Firma: Qimonda) (tilodd)]

@Malte:

na ja die Idee kam mir ja als aller erstes und so dachte ich auch sollte 
das funktionieren. Allerdings meckert der ARM9 dann mit eben dieser 
Fehlermeldung aus dem Topic-Namen.

./hello.o: cannot execute binary file

:-(

[Malte _. (malte)]

Beim Ausführen der ./a.out kommt die Meldung mit der ./hello.o? 
Irgendwass passt da nicht.

[Tilo B. (Firma: Qimonda) (tilodd)]

ja ja, sorry hab einmal die Ausgabedatei direkt angegeben

 arm-elf-gcc -mcpu=arm9 hello.c -o hello.o

und einmal ohne

 arm-elf-gcc -mcpu=arm9 hello.c

beide entstehenden Files (a.out und hello.o) bringen die gleiche 
Fehleremeldung:

[Joerg W. (joergwolfram)]

Probier's mal aus mit:

arm-elf-gcc -mcpu=arm9 hello.c -o hello

so (ähnlich, aber ohne -mcpu) kompiliere ich unter Linux kleine 
Programme ohne makefile.

Gruß Jörg

[Jörg W. (dl8dtl) (Moderator)]

Dann wirst du dich wohl oder übel kundig machen müssen, was genau
dein Linux da als Binärformat benötigt, um es zur direkten Ausführung
zu akzeptieren.  U. U. hilft dir ja das Kommando "file" weiter, um
existierende (tatsächlich lauffähige) Binaries mit dem von dir
erzeugten zu vergleichen.

[Tilo B. (Firma: Qimonda) (tilodd)]

Hmm file war ne gute idee, allerdings wird dann komplett verrückt, denn 
es erkennt offenbar, dass es sich um eine Executable handelt.

ELF 32-bit LSB executable, ARM, version 1 (ARM), statically linked, not stripped

aber dennoch beim starten bekomm ich eine

Illegal instruction

kommt schon, einer muß es doch wissen!

[yalu (Gast)]

Gesprächiger als file ist readelf. Wende doch einmal

arm-elf-readelf -h

auf

  - das von dir selbst kompilierte Programm und

  - ein fertiges Programm aus der Linux-Installation des Zielsystems

an und vergleiche die Ausgaben.

Für die ARMs gibt es ja unterschiedliche Befehlssätze und Datenformate
(normal/thumb, little-endian/big-endian). Ohne mich mit den ARMs gut
auszukennen, vermute ich, dass nicht alle Formate vom Zielsystem
unterstützt werden.

[Stefan B. (stefan)]

Entscheide dich doch mal, welche Fehlermeldung jetzt wirklich kommt.

#1 "Illegal instruction" oder #2 "cannot execute binary file"

Bei #1 erkennt Linux ein execute binary file, d.h. einen übersetzten und 
gelinkten Quellcode. Aber der ist für den Zielprozessor nicht richtig 
übersetzt und wirft deshalb bei der Ausführung einen Fehler.

Bei #2 hast du kein execute binary file, sondern z.B. nur eine 
Objektdatei, die noch mit den Libraries zu verlinken wäre. Die 
Fehlermeldung kommt, wenn Linux sich die Datei ansieht, um sie zu 
starten. Es kann passieren, dass du nach der Korrektur von #2 bei #1 
landest.

[yalu (Gast)]

> Bei #2 hast du kein execute binary file, sondern z.B. nur eine
> Objektdatei, die noch mit den Libraries zu verlinken wäre.

Oder ein Executable, das für ein anderes Zielsystem kompiliert und
gelinkt wurde.

[Tilo B. (Firma: Qimonda) (tilodd)]

Also erst mal vielen Dank für die Unterstützung. Der beschränken wir uns 
mal auf Fehler #1. So und der Tipp mit arm-elf-readelf -h war gut. Aber 
nun seht selbst. aus hallo.c -->

ELF Header:
  Magic:   7f 45 4c 46 01 01 01 61 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            ARM
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           ARM
  Version:                           0x1
  Entry point address:               0x8100
  Start of program headers:          52 (bytes into file)
  Start of section headers:          261348 (bytes into file)
  Flags:                             0x2, has entry point, GNU EABI
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         1
  Size of section headers:           40 (bytes)
  Number of section headers:         24
  Section header string table index: 21

und aus einem file vom AT91SAM9260 (Board von olimex im übrigen)

ELF Header:
  Magic:   7f 45 4c 46 01 01 01 61 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            ARM
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           ARM
  Version:                           0x1
  Entry point address:               0x9b28
  Start of program headers:          52 (bytes into file)
  Start of section headers:          56080 (bytes into file)
  Flags:                             0x2, has entry point, GNU EABI
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         6
  Size of section headers:           40 (bytes)
  Number of section headers:         24
  Section header string table index: 23

So richtig seh ich da keine unterschiede. :-(

[luhser (Gast)]

Gabs da nicht nen unterschied zwischen den einzelnen Compilervarianten, 
einer für Linuxbinaries [gcc-arm-linux oder so] und der andere für 
standaloneanwendungen? Schliesslich wird ja anders gelinkt (oder so ;) )

[Tilo B. (Firma: Qimonda) (tilodd)]

Ahh, richtig, also schnell das Manual vom Board zur Hand, da war doch 
irgendwas:

$ PATH=$PATH:/usr/local/arm/4.1.1-920t/bin
$ cat > hello.c
#include <stdio.h>
int main(void)
{
unsigned int i;
printf("\r\nProba proba ");
for (i=0; i<10; i++)
printf("\r\n%d", i);
return 0;
}
^D
$ arm-linux-gcc -o hello hello.c
$ cp hello ~/htdocs/
----- On the board -----
~ # wget http://192.168.0.xx/hello
~ # chmod 777 hello
~ # ./hello
Proba proba
01
....

wer lesen kann ist klar im Vortei! Eine Frage bleibt dann aber noch, 
gibt es den arm-linux-gcc auf für Windows (also ohne aufwendige cygwin 
installation)? Ist hat in der Firma etwas schwierig ein linux mal 
schnell installieren zu lassen. Bürokratie usw. Na ja.

Gruß und danke

[Martin T. (mthomas) (Moderator)]

>...arm-elf-gcc...
Ist das eine "bare metal"-Toolchain (target arm-elf)?. Ausgabe von 
arm-elf-gcc -v? Schon mit einem Cross-Compiler für target arm-linux 
ausprobiert?

[Martin T. (mthomas) (Moderator)]

Hoppla, zu lahm gewesen.

Cross-Compiler für arm-linux Targets und Win32-Hosts: 
http://www.codesourcery.com/gnu_toolchains/arm/portal/release570
Nie selbst ausprobiert. Nutze für eigene Experimente in dem Bereich eine 
virtuelle Maschine (vmware Server), darin Debian, damit buildroot.

[Tilo B. (Firma: Qimonda) (tilodd)]

Danke Thomas, werds mal ausprobieren, wenns nicht funzt kann ich immer 
noch auf ne Linux Distribution zurückgreifen.

Im Übrigen: arm-elf-gcc ist der cross-compiler von yatargo, allerdings 
nur für die hardware-nahe-kompilierung. Ich erinnere mich an die ersten 
versuche damit, d.h. mittels JTAG auf die Hardware geladen und debugt 
hat wunderbar funktioniert.

Für stand-alone Anwendungen auf dem embedded-Linux ist aber 
höchstwahrscheilich der arm-linux-gcc zu verwenden. wenigstens noch was 
gelernt heute :-D

Gruß an alle und ich hoffe so könnte es nun funktionieren.