calling assembly function from c

x86-64 Linux example

There is already an answer here which shows how to call a void func(void), but here is an x86-64 Linux example that accepts parameters and has a return value, which was what was asked in the question. (The question and some other answers are using 32-bit code, which has a different calling convention).

To start off, let's simplify the assembly function:

# Need to make it global so it can be accessed in another file with extern .globl integrate # Cannot hurt to define it as a function type, sometimes useful for dynamic linking, see comments in: https://stackoverflow.com/questions/65837016/how-to-call-a-function-in-an-external-assembly-file#comment116408928_65837016 .type integrate, @function integrate: # int integrate(int from /*EDI*/, int to /*ESI*/) # INPUT: # the first parameter `from` is contained in %edi, the int-sized low half of %rdi # the second parameter `to` is contained in %esi # OUTPUT: # return is passed in %eax; # you can leave garbage in the high half of RAX if convenient lea 123(%rdi, %rsi), %ecx # from + to + 123 just for example # (main work of function done) mov %ecx, %eax # it seems your return value is in %ecx # but we need it in %eax for the return value to C # or just use EAX instead of ECX in the first place to avoid this instruction ret 

This is using the System V calling convention, where the function return value is passed back in rax and the parameters that the function receives are passed in rdi, rsi, rdx, rcx, r8, r9, then the stack in reverse order. (What are the calling conventions for UNIX & Linux system calls (and user-space functions) on i386 and x86-64). For example:

long add_four_nums(int first, long second, short third, unsigned fourth); 

The function declared with this prototype would receive first in %edi, second in %rsi, third in %dx, and fourth in %ecx. It would return its result in %rax.

Now that we have the assembly written (though the function is mainly a stub to show how to accept arguments and return a value), you can use that function in your C file like you currently have:

#include <stdio.h> extern int integrate(int from,int to); int main() { printf("%d\n", integrate(1,10)); } 

It can be compiled and linked with gcc, then run, as:

$ gcc -o combined -Wall main.c integrate.s && ./combined 

I see the following problems with the code:

• calling convention mandates you must preserve the value of edi
• cmp %edi,1024 is using 1024 as address and will probably fault. You want cmp $1024,%edi for comparing with an immediate number
• you are reloading eax and ecx from the arguments each iteration so the calculation you perform has no effect
• you don't seem to put any sensible return value into eax (it will return the value of from that was passed in)

The first two points apply even if "what assembly code is doing is not important".

Not sure if you have solved this or not, but here is how I have done this.

When compiling make sure to add both files: $gcc main.c print_msg.s -o main

To run the assembler file on its own: $as print_msg.s -o print_msg.o followed by $ld print_msg.o -e print -o print_msg. Note that this is not required if you only want to run it from your C file.

The assembler file: print_msg.s

# A program to be called from a C program # Declaring data that doesn't change .section .data string: .ascii "Hello from assembler\n" length: .quad . - string # The actual code .section .text .global print .type print, @function #<-Important print: mov $0x1,%rax # Move 1(write) into rax mov $0x1,%rdi # Move 1(fd stdOut) into rdi. mov $string,%rsi # Move the _location_ of the string into rsi mov length,%rdx # Move the _length_ of the string into rdx syscall # Call the kernel mov %rax,%rdi # Move the number of bytes written to rdi mov $0x3c,%rax # Move 60(sys_exit) into rax syscall # Call the kernel 

then the C file: main.c

extern void print(void); int main(void) { print(); return 0; } 

warning: return type of ‘main’ is not ‘int’

means that the return type of ‘main’ is not ‘int’... Change it to int, then:

int main() { } 

Also, to solve the linker error, invoke GCC as

gcc -o myprog main.c integrate.s 

and that should work.

First change:

/* void main() */ int main(void) 

main cannot be void and has to return an integer (via the error). In order for C to see your integrate function, you have to specify its function signature in a header file or in the C file and after that you can do:

as -o integrate.o integrate.s 

Then, do:

gcc -Wall -c c_program.c 

Finally, do:

gcc c_program.o integrate.o -o integrate 

Then try:

./integrate 

or

sudo chmod u+x ./integrate && ./integrate 

NOTE: the header file should look something like:

/* integrate.h */ #ifndef INTEGRATE #define INTEGRATE return_type integrate(ARGS, ...); /*if any ARGS are passed*/ #endif 

and put #include "integrate.h" at the top of your C file.