Calling assembler functions from C

[Nosferax]

Let say I write an assembler routine that does some function and I want to call it from within a C program, how would I do that with VBCC or the other most common Amiga C compiler (I don't mind using SAS or other compilers).

Anyone got an example?

[thomas]

Make sure that the name of the assembler routine is declared as global symbol and that the name starts with a _. Then you can call it from the C program without the _.

for example:

_the_answer:
	move.l	#42,d0
	rts

	public	_the_answer

#include <stdio.h>

long the_answer (void);

int main (void)
{
long a = the_answer();
printf ("the answer is %ld\n",a);
}

Note that if you change any register except d0 and d1, you have to restore the previous contents before your asm routine exits.


You might compile a small C program with the -S option to get the assembler output from the compiler. Then you can see how a subroutine is defined in assembler.

For example

vc -S test.c -o test.asm

[Nosferax]

Oh! Thank you!

[alkis]

Originally Posted by thomas

Note that if you change any register except d0 and d1, you have to restore the previous contents before your asm routine exits.

Umm, aren't d0-d1/a0-a1 the 'scratch' registers?

Isn't this example a bit simplified since the_answer() doesn't take any arguments? In a normal C function call the arguments would be passed on the stack and not in CPU registers, which a typical assembler routine would prefer.

There are compiler directives you can use to make it use registers instead. In SAS/C it's something like

long __asm the_answer(__register d0 long foo);

(It's been a long time since I did this.. :-) )

[thomas]

Originally Posted by alkis

Umm, aren't d0-d1/a0-a1 the 'scratch' registers?

Maybe. But it hurts more if you miss to save a needed register than if you save a scratch register.

Originally Posted by punktniklas

Isn't this example a bit simplified since the_answer() doesn't take any arguments?

Sure, my reply wasn't meant as an overall comprehensive answer, it concentrated only on the way names are matched between Asm and C.

Here is another strongly simplified example, but this time with arguments:

_add:
	add.l	d1,d0
	rts

	public _add

#include <stdio.h>

long add (__reg("d0") long a,__reg("d1") long b);

int main (void)
{
long a = add(14,16);
printf ("14 + 16 = %ld\n",a);
}

Note that the register notation is compiler-specific. If you want to stay compiler-independent, you should keep the arguments on the stack like the compiler does it with C subroutines, too.

_add:
	move.l	4(sp),d0
	add.l	8(sp),d0
	rts

	public _add

#include <stdio.h>

long add (long a,long b);

int main (void)
{
long a = add(14,16);
printf ("14 + 16 = %ld\n",a);
}

Note that 0(sp) is the return address.

Also note that arguments are put on the stack in reverse order so that they appear in memory in the correct order. This means that 4(sp) corresponds to argument a and 8(sp) to argument b.

[arti]

How can I link vasm compiled code with gcc ?

[hitchhikr]

Afaik gcc handles objects produced with vasm (using -Fhunk in vasm command line).

[arti]

Yes!

[hitchhikr]

The advantage of working with gcc + vasm instead of gcc + as is that you can create chipmem hunk in your executable by using (in asm):

section ".data_chip",data

(i don't know if it's possible with gnu as).

[phx]

Originally Posted by hitchhikr

Afaik gcc handles objects produced with vasm (using -Fhunk in vasm command line).

Depends on the gcc-port. Some only support a.out format, in which case you have to make vasm output a.out format as well: -Faout.

Originally Posted by hitchhikr

The advantage of working with gcc + vasm instead of gcc + as is that you can create chipmem hunk in your executable by using (in asm):

section ".data_chip",data

This directive would not set the Chipmem-Flag. You have to add ",chip":

        section ".data_chip",data,chip

[hitchhikr]

I use gcc version 3.4.0.

No, data_c or data,chip won't work with gnu-ld, the linker uses the name of the section to relocate it to chipmem so it have to be ".data_chip",data (anything else won't work).

[phx]

Ok. Didn't know that. I thought that GNU-ld would be able to evaluate the memflags, when it already supports hunk-format.

[arti]

I can't compile this line in gcc (3.4.0):

long add (__reg("d0") long a,__reg("d1") long b);

add.c:3: error: syntax error before '(' token
add.c: In function `add':
add.c:3: error: syntax error before string constant
add.c:6: error: syntax error before '{' token

Tried __asm("d0") and register __d0 with no luck too.

[alkis]

Originally Posted by arti

I can't compile this line in gcc (3.4.0):

long add (__reg("d0") long a,__reg("d1") long b);

add.c:3: error: syntax error before '(' token
add.c: In function `add':
add.c:3: error: syntax error before string constant
add.c:6: error: syntax error before '{' token

Tried __asm("d0") and register __d0 with no luck too.

try

register long a __asm("d0")

[matthey]

Every compiler has its own syntax for assembler and register calling. There was an attempt years ago to make a universal syntax using macros for most of the common Amiga compilers. Vbcc was rather difficult to get working as macros don't like the characters vbcc requires for defining registers but I found a trick to get it working. It should now support GCC, vbcc, SAS/C, DICE and even the old Storm C. My contributions build on those from others. The test example is based on Thomas's example and is very simple. There is an AmigaDOS script to make the simple project using vbcc. I have not tested with other compilers so let me know if it doesn't work somewhere. Ideas for improvement are also welcome and it would be interesting to hear who came up with the original idea. See the attachment for the archive.

Edit: New version attached with GCC and vbcc tests. I believe it will only work with unofficial Amiga GCC versions like GCC 2.95.3 and 3.4.0. It was necessary to change the required syntax slightly (less readable but not too bad IMO). Needs testing and possibly fixes for other Amiga compilers. Let me know if there are problems and send me any fixes.

[arti]

Great stuff matthey.
But still no go for gcc:

Parse error before long a

long add( REG(d0) long a, REG(d1) long b );

[alkis]

You didn't tried, did you?

Ok, let's see.

m68k-amigaos-gcc --version
m68k-amigaos-gcc (GCC) 3.4.0
Copyright (C) 2004 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

cat foo.c
long add (register long a __asm("d0"), register long b __asm("d1"));
m68k-amigaos-gcc -c foo.c

No errors.

[matthey]

Originally Posted by arti

Great stuff matthey.
But still no go for gcc:

Parse error before long a

long add( REG(d0) long a, REG(d1) long b );

I can verify the problem with GCC 3.4.0. I have done some more research and testing. The line that works in the unofficial (GeekGadgets) GCC looks like it would be the following.

long add( register long a __asm("d0"), register long b __asm("d1") );

I could not find a way for newer official versions of GCC to specify the registers to functions. The target ABI is used by default.

The macros I provided do not work for GCC (someone else created them). Maybe this is another reason why the macros did not become popular. I can get the macros to generate the correct text but the __asm("reg") part is before each variable which does not work. I may have to change how the macros work to allow a universal definition and then it still is unlikely to work with newer official GCC compilers .

[arti]

I've tried this order ->

register __asm("d0") long a

But this works ->

register long a __asm("d0")

On 3.4 only, but that's ok for me.