I'm playing around with some asm code, and something is bothering me.
I compile this:
#include <stdio.h>
int main(int argc, char** argv){
printf("Hello World\n");
return 0;
}
with gcc file.c -S -o file.S
this generates a nice little piece of asm code:
.cstring
LC0:
.ascii "Hello World\0"
.text
.globl _main
_main:
LFB3:
pushq %rbp
LCFI0:
movq %rsp, %rbp
LCFI1:
subq $16, %rsp
LCFI2:
movl %edi, -4(%rbp)
movq %rsi, -16(%rbp)
leaq LC0(%rip), %rdi
call _puts
movl $0, %eax
leave
ret
LFE3:
.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EH_frame1:
.set L$set$0,LECIE1-LSCIE1
.long L$set$0
LSCIE1:
.long 0x0
.byte 0x1
.ascii "zR\0"
.byte 0x1
.byte 0x78
.byte 0x10
.byte 0x1
.byte 0x10
.byte 0xc
.byte 0x7
.byte 0x8
.byte 0x90
.byte 0x1
.align 3
LECIE1:
.globl _main.eh
_main.eh:
LSFDE1:
.set L$set$1,LEFDE1-LASFDE1
.long L$set$1
LASFDE1:
.long LASFDE1-EH_frame1
.quad LFB3-.
.set L$set$2,LFE3-LFB3
.quad L$set$2
.byte 0x0
.byte 0x4
.set L$set$3,LCFI0-LFB3
.long L$set$3
.byte 0xe
.byte 0x10
.byte 0x86
.byte 0x2
.byte 0x4
.set L$set$4,LCFI1-LCFI0
.long L$set$4
.byte 0xd
.byte 0x6
.align 3
LEFDE1:
.subsections_via_symbols
My next problem is really, how do I compile this output, and can I make GCC do it for me?
This question is related to
c
gcc
compiler-construction
assembly
gcc
can use an assembly file as input, and invoke the assembler as needed. There is a subtlety, though:
.s
" (lowercase 's'), then gcc
calls the assembler..S
" (uppercase 'S'), then gcc
applies the C preprocessor on the source file (i.e. it recognizes directives such as #if
and replaces macros), and then calls the assembler on the result.So, on a general basis, you want to do things like this:
gcc -S file.c -o file.s
gcc -c file.s
You can use GAS, which is gcc's backend assembler:
If you have main.s file.
you can generate object file by GCC
and also as
# gcc -c main.s
# as main.s -o main.o
check this link, it will help you learn some binutils of GCC http://www.thegeekstuff.com/2017/01/gnu-binutils-commands/
Yes, gcc can also compile assembly source code. Alternatively, you can invoke as
, which is the assembler. (gcc is just a "driver" program that uses heuristics to call C compiler, C++ compiler, assembler, linker, etc..)
You can embed the assembly code in a normal C program. Here's a good introduction. Using the appropriate syntax, you can also tell GCC you want to interact with variables declared in C. The program below instructs gcc that:
\n
int main(void)
{
int foo = 10, bar = 15;
__asm__ __volatile__("addl %%ebx,%%eax"
:"=a"(foo)
:"a"(foo), "b"(bar)
);
printf("foo+bar=%d\n", foo);
return 0;
}
nasm -f bin -o 2_hello 2_hello.asm
Source: Stackoverflow.com