32

Is it possible to generate assembly language functions from C functions using GCC, so that they can be invoked from an assembly language program? I know that gcc compiles C to machine code (which can easily be disassembled into assembly language), and I already know that it's possible to inline assembly language functions in C, but I haven't yet found a way to invoke C functions from assembly language programs, which is basically the inverse of this.

Here, I'm attempting to inline a C function in an x86 assembly program. If inlining isn't possible, then is there some other way to invoke a C function from an assembly language program?

.686p
.model flat,stdcall
.stack 2048

.data

.code
start:

invoke  ExitProcess, 0

printSomething PROC ;now I'm attempting to inline a C function here
    void printSomething(thingToPrint){
        printf("This is a C function that I want to invoke from an assembly language program.");
        printf("There must be some way to do this - is it possible somehow?");
    }
printSomething ENDP

end start
Community
  • 1
  • 1
Anderson Green
  • 30,230
  • 67
  • 195
  • 328
  • I don't remember all the details but you just need to compile to object files and link them together. You just need to know what calling conventions are used when invoking the function. – Jeff Mercado Apr 27 '13 at 18:44
  • 1
    You could add the assembly code showing what you have tried, and tell how it fails to compile or how it behaves wrong. It would be much easier for an answer to point out what's the problem with it. – hyde Apr 27 '13 at 18:47
  • 3
    You can learn how to do this by writing a C function that calls the function you want to call, compiling it to assembly language (`-S`), and studying the results. I would also point you at the "psABI", but I can't find a copy anymore. – zwol Apr 27 '13 at 18:59
  • 2
    Of course you can do this. Just follow the rules of your compiler's ABI. – David Heffernan Apr 27 '13 at 19:10

2 Answers2

39

I'm going from memory here, so I may be off slightly on a detail or two. However, it should I hope be enough to get you going in the right direction.

You're going to need to tell the GCC assembler that your routine printSomething() is not defined in your assembly file. In 'C' you would use the extern keyword. For assembly you will need to use .globl.

.globl printSomething

If you are using a different assembler than GCC's, the keyword may be different.

The next big question is 'how do I pass the arguments'? This very much depends upon your processor AND OS. Since the title of your question indicates x86, I am going to assume that you are using either the 16-bit or 32-bit modes and the standard x86 ABI (as opposed to x86-64 which is also differs between Windows and Linux). The C parameters are passed to the called routine by pushing them onto the stack. They are pushed onto the stack from right to left.

Thus,

printSomething (arg1, arg2, arg3, arg4);

translates to ...

pushl arg4
pushl arg3
pushl arg2
pushl arg1
call  printSomething
addl  $0x10, %esp

You may be asking yourself, what is this 

addl $0x10, %esp

? We passed (aka pushed) four 32-bit arguments to the routine (onto the stack). Although the routine knows to expect those arguments, it is NOT responsible for popping them off the stack. The caller is responsible for that. So, after we return from the routine, we adjust the stack pointer to discard the four 32-bit arguments we previously pushed onto the stack.

In the above example, I am assuming that we are operating in 32-bit mode. If it were 16-bit mode, it would be ...

pushw arg4
pushw arg3
pushw arg2
pushw arg1
call  printSomething
addw  $0x8, %sp

I realize that in your example, printSomething() only takes one (1) argument and in my example I used four (4). Just adjust my example as is needed.

For the final steps, you will need to compile both your C and assembly files into object files, link the object files and then execute.

I hope this helps.

Sparky
  • 13,505
  • 4
  • 26
  • 27
  • Now I wonder if it's possible to actually generate x86 assembly procedures from C functions using GCC. Would it be possible to convert every function in a C program to the equivalent assembly language function, using GCC, or some other C compiler? – Anderson Green May 09 '13 at 23:24
  • 2
    @AndersonGreen - You can always try using the -S option. "gcc -S file.c" will convert "file.c" into assembly (naming it file.s). Alternatively, if you already have your executable, you can use "objdump -d exe_file > exe_file.asm" to disassemble "exe_file" and dump the result into "exe_file.asm". – Sparky May 10 '13 at 02:06
  • @Sparky In x86 procedure convention, every function has `leave` or equivalent instructions before it returns to caller. I think the `addl $0x10, %esp` in your example is redundant. – StrikeW Aug 22 '15 at 06:35
  • @StrikeW - The "addl $0x10, %esp" in the examples is used for cleaning up the parameters that were pushed on the stack. In C, the caller is typically responsible for cleaning up the parameters on the stack. The "leave" instruction (or equivalent) in the called C function is for cleaning up any stack space used by the called function. If, the called function is responsible for cleaning up the parameters passed to it on the stack, it would be using the "RET n" instruction (where n is the number of bytes to pop from the stack). – Sparky Aug 24 '15 at 15:07
  • Doesn't `C` compile extern methods preceded with `_`? So the call should be `call _printSomething` ... ??? – IAbstract Aug 22 '16 at 18:39
2

For x86_64, note that you have to be careful with some extra things:

Ciro Santilli OurBigBook.com
  • 347,512
  • 102
  • 1,199
  • 985