Editor Fachwissen bezüglich c unter Linux

softpad

Guten Morgen liebe Programmierer,
Wer kann mir den genauen Befehl nennen, den man eingeben muss, um ein C-Programm als Assembler Quelltext angezeigt zu bekommen.
Bsp:Einfaches x-beliebiges Programm :

#include<stdio.h>

main()   {
int eingabe;
do{
printf("Bitte eine Zahl eingeben bis max 100: ");
scanf("%i",&eingabe);
} while(eingabe >100);
printf("Ihre Eingabe war %i",eingabe);
}

Das Programm mit dem Namen "do_Schleife.c". Dazu will man die Auflösung in As
Gnu-Assembler, also unter Linux angezeigt bekommen.

Wie lautet die -- genaue Syntax -- im Editor von Linux (oder Windows,
das ist ja im einzelnen unterschiedlich,) für dieses Programm mit dem Namen:
do_Schleife.c

pferdefreund

Das hat nix mit dem Editor zu tun - das ist eine Compiler-Option des gcc. Dem kann man sagen, erstelle nur den Assembler.

softpad

Danke für den Hinweis, falls noch jemand weiss wie die genaue Syntax des Befehls in C lautet oder einen link kennt, wo es erklärt ist, bin Ich dankbar. Per Google Suche hatte Ich keinen guten Treffer.

elise

manpages gcc:
http://linux.die.net/man/1/gcc

gcc -S deinedatei.c

-> "deinedatei.s"

Das ist auch kein Befehl von C sondern vom Compiler.

Teilweise kannst du das in deiner IDE einstellen (wenn du eine hast) oder du musst dir die richtige Compileroption raussuchen.
Evtl. heißt die Option auch Assemblerdatei nicht löschen.

RTFM vom Compiler.

~Das richtige Unterforum wäre übrigens "Compiler- und IDE-Forum".~
^Da brauchst du nicht nachfragen, ein Moderator wird den Thread sicher verschieben.^

softpad

Danke. ! !

1. Du hast 2 Threads mit dem selben Inhalt erstellt. einmal hier und einmal im Asm-unterforum: http://www.c-plusplus.net/forum/p2325187
das ist eigentlich nicht nötig.

2. ich hab dir dort geantwortet. da ich aber die vermutung habe, dass der thread im asm-forum gelöscht wird, poste ich meine antwort auch nochmal hier:

demokratischer sozialist schrieb:

Du hast die gleiche Frage schon im C-Unterforum gestellt...

Wenn ich das richtig verstehe, willst du einfach die Ausgabe vom as von diesem Programm?

erstmal solltest du dein programm gescheit umschreiben, so:

#include <stdio.h>
 
int main() // es heißt "int main", weil main einen int zurückgibt
{
   int eingabe=0;
   while(eingabe > 100) // das ganze do-konstrukt kannst du dir sparen.
   {
       printf("Bitte eine Zahl eingeben bis max 100: ");
       scanf("%i",&eingabe);
   }
   printf("Ihre Eingabe war %i",eingabe);
   return 0; // das ist der int, den main zurückgibt
}

darf ich fragen, welches buch du zum lernen verwendest? das sieht mir nämlich sehr nach K&R-C aus...

der as-output DEINES quellcodes aus dem eingangspost sieht folgendermaßen aus:

.file	"do_Schleife.c"
	.def	___main;	.scl	2;	.type	32;	.endef
	.section .rdata,"dr"
	.align 4
LC0:
	.ascii "Bitte eine Zahl eingeben bis max 100: \0"
LC1:
	.ascii "%i\0"
LC2:
	.ascii "Ihre Eingabe war %i\0"
	.text
	.globl	_main
	.def	_main;	.scl	2;	.type	32;	.endef
_main:
LFB6:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	andl	$-16, %esp
	subl	$32, %esp
	call	___main
L2:
	movl	$LC0, (%esp)
	call	_printf
	leal	28(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$LC1, (%esp)
	call	_scanf
	movl	28(%esp), %eax
	cmpl	$100, %eax
	jg	L2
	movl	28(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$LC2, (%esp)
	call	_printf
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
LFE6:
	.def	_printf;	.scl	2;	.type	32;	.endef
	.def	_scanf;	.scl	2;	.type	32;	.endef

du solltest generell darauf achten, do zu vermeiden. das ist auch nur eine art des spaghetti-codes.
und lern bitte kein K&R-C. besser C89 oder gleich C99.

da hab ich wohl grad nicht mitgedacht, mein quellcode hat einen kleinen fehler, so muss es richtig heißen:

#include <stdio.h>

int main() // es heißt "int main", weil main einen int zurückgibt
{
   int eingabe=101; // eingabe muss größer als 100 sein, weil sonst die ganze while-schleife übersprungen wird
   while(eingabe > 100) // das ganze do-konstrukt kannst du dir sparen.
   {
       printf("Bitte eine Zahl eingeben bis max 100: ");
       scanf("%i",&eingabe);
   }
   printf("Ihre Eingabe war %i",eingabe);
   return 0; // das ist der int, den main zurückgibt
}

Bashar

demokratischer sozialist schrieb:

du solltest generell darauf achten, do zu vermeiden. das ist auch nur eine art des spaghetti-codes.

Du solltest dazu sagen, dass das nur deine Meinung ist. Spaghetti-Code ist es mit Sicherheit nicht, eine While-Schleife ist eine ganz normale Grundform der Schleife in der strukturierten Programmierung. Zur Erinnerung: Spaghetti bezieht sich auf einen schwer entwirrbaren Kontrollfluss, und das ist bei solchen Konstrukten objektiv nicht der Fall.

edit: Ich kann deine Meinung an sich akzeptieren, ich mag do-while auch nicht, und die Macher von z.B. Python oder Matlab auch nicht.

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C (C89, C99 und C11) in das Forum Compiler- und IDE-Forum verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Bashar schrieb:

Spaghetti bezieht sich auf einen schwer entwirrbaren Kontrollfluss, und das ist bei solchen Konstrukten objektiv nicht der Fall.

edit: Ich kann deine Meinung an sich akzeptieren, ich mag do-while auch nicht, und die Macher von z.B. Python oder Matlab auch nicht.

Ja, ich meinte jetzt eher, dass das Lesen erschwert wird, weil man quellcode von oben nach unten liest, aber die anweisung (while..) erst am ende der do schleife steht.

softpad

Danke für die Hinweise und das Programm , das bringt mich schon weiter,

wonach Ich suche ist jedoch der exakte Befehl bzw. Vorgehen wie Ich --selber-- ein c-Programm in Assembler anzeigen lassen kann!

Der Hinweis von elise mit :
gcc -S deinedatei.c

hat mich schon insoweit weitergebracht als dass in Linux im Terminal in dem Verzeichnis eine Datei mit dem Namen deinedatei.s erzeugt wird.

Mit dem zweiten Teil: ->"deinedatei.s" bekomme Ich allerdings nicht den Inhalt der -entsprechenden- Datei angezeigt?

Ich muss das Terminal irgendwie dazu bringen mir den Inhalt des c-Programms, so wie es der Kollege in dem Vorhergehenden Beispiel gut dargestellt hat, anzeigen zu lassen.
??? ...

softpad

Ich verstehe nicht ganz, was du tun willst.

die gcc option "-S" erzeugt den assembler-code deines c-codes, genau das ist der code, den der gnu assembler bekommt.

der gnu assembler erzeugt eine objekt-datei (quasi eine art "prototyp" einer ausführbaren datei), und der linker "ld" erzeugt aus der objekt-datei eine ausführbare datei.

was genau willst du tun? den assemblercode hast du ja schon.

ok, vielleicht weiß ich doch, was du meinst.

ich glaube, du suchst einen disassembler, also ein programm, was den ausführbaren code in einer ausführbaren datei anzeigt.

unter linux gibts da objdump

objdump -D datei.exe

softpad

Richtig ! Allerdings kommt jetzt die Meldung:

sokonord@ubuntu:~/Arbeitsfläche/Trplc$ objdump -D Groessenvergl.s
sokonord@ubuntu:~/Arbeitsfläche/Trplc$ objdump -D Groessenvergl.exe
objdump: 'Groessenvergl.exe': No such file
sokonord@ubuntu:~/Arbeitsfläche/Trplc$ 

??...

bzw.:
sokonord@ubuntu:~/Arbeitsfläche/Trplc$ objdump -D Groessenvergl.s
sokonord@ubuntu:~/Arbeitsfläche/Trplc$

keine Ausgabe?

Zu Veranschaulichung das Vz:

sokonord@ubuntu:~/Arbeitsfläche/Trplc$ ls
a.out                    endlicherzahlenkfunc2.c~      Groessenvergl2.c~       pointerschalter3.c~
array2.c                 endlicherzahlenkfunc.c        Groessenvergl.c         pointerschalter.c~
array2.c~                endlicherzahlenkfunc.c~       Groessenvergl.c~        struct2.c
array.c                  Entscheidungsstruktur2.c      Groessenvergl.s         struct2.c~
array.c~                 Entscheidungsstruktur2.c~     kalender2.c             struct.c
do_Schleife2.c           Entscheidungsstruktur.c       kalender2.c~            struct.c~
do_Schleife.c            Entscheidungsstruktur.c~      kalender.c              test.c
do_Schleife.c~           Formelimpl Zinsen extern2.c~  kalender.c~             test.c~
endlicherzahlenk2.c      gesch_Schleife2.c             kalenderTrpl.c~         zinsberechnung2.c
endlicherzahlenk2.c~     gesch_Schleife.c              pointermechanik.c~      zinsberechnung.c
endlicherzahlenk.c       Gleichungsalgorithmus2.c      pointermechanikTrpl.c~  zinsen2.c
endlicherzahlenk.c~      Gleichungsalgorithmus.c       pointerschalter2.c~     zinsen2.c~
endlicherzahlenkfunc2.c  Groessenvergl2.c              pointerschalter3-1.c~   zinsen.c
sokonord@ubuntu:~/Arbeitsfläche/Trplc$ objdump -D Groessenvergl.s
sokonord@ubuntu:~/Arbeitsfläche/Trplc$ objdump -D Groessenvergl.exe
objdump: 'Groessenvergl.exe': No such file
sokonord@ubuntu:~/Arbeitsfläche/Trplc$

du musst natürlich zuerst das programm kompilieren.

unter ubuntu gibt es keine exe dateien.

Jochen Kalmbach

"a.out"? Gibt das einfach mal ein...

softpad

Hallo liebe Freunde der Programmiersprachen, Ich habe das Problem mit eurer Hilfe ---vorerst--- so gelöst:

gcc -S Groessenvergl.c
  objdump -D Groessenvergl.s
  as -o Groessenvergl.o Groessenvergl.s
  ld -o Groessenvergl.x Groessenvergl.o
  ./Groessenvergl.x
    cat Groessenvergl.s

Welche der Systemanweisungen vor der mit letzten mit cat... entscheidend ist muss
Ich noch durchtesten. In As habe Ich zwar kein lauffähiges Programm erhalten,
Der AS fragt nach der Funktiona scanf... aber Ich erhalte folgende Ausgabe mit
dem letzten Befehl cat nach

sokonord@ubuntu:~/Arbeitsfläche/Trplc$ cat Groessenvergl.s
	.file	"Groessenvergl.c"
	.section	.rodata
.LC0:
	.string	"x eingeben: "
.LC1:
	.string	"%i"
.LC2:
	.string	"y eingeben: "
.LC3:
	.string	"z eingeben: "
.LC4:
	.string	"Die groesste Zahl ist %i \n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	andl	$-16, %esp
	subl	$32, %esp
	movl	$.LC0, %eax
	movl	%eax, (%esp)
	call	printf
	movl	$.LC1, %eax
	leal	20(%esp), %edx
	movl	%edx, 4(%esp)
	movl	%eax, (%esp)
	call	__isoc99_scanf
	movl	$.LC2, %eax
	movl	%eax, (%esp)
	call	printf
	movl	$.LC1, %eax
	leal	24(%esp), %edx
	movl	%edx, 4(%esp)
	movl	%eax, (%esp)
	call	__isoc99_scanf
	movl	$.LC3, %eax
	movl	%eax, (%esp)
	call	printf
	movl	$.LC1, %eax
	leal	28(%esp), %edx
	movl	%edx, 4(%esp)
	movl	%eax, (%esp)
	call	__isoc99_scanf
	movl	20(%esp), %edx
	movl	24(%esp), %eax
	cmpl	%eax, %edx
	jle	.L2
	movl	28(%esp), %edx
	movl	20(%esp), %eax
	cmpl	%eax, %edx
	cmovge	%edx, %eax
	jmp	.L3
.L2:
	movl	28(%esp), %edx
	movl	24(%esp), %eax
	cmpl	%eax, %edx
	cmovge	%edx, %eax
.L3:
	movl	$.LC4, %edx
	movl	%eax, 4(%esp)
	movl	%edx, (%esp)
	call	printf
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu/Linaro 4.6.2-7ubuntu1) 4.6.2"
	.section	.note.GNU-stack,"",@progbits

Da muss man wohl bisschen dran arbeiten... Danke für die Tipps!

Hö?

Du weißt doch hoffentlich, dass du diese Schritte nicht alle selbst machen musst, oder?

gcc Groessenvergleich.c -o Groessenvergleich.x

Und schon hast du deine executable.