Example-code

Call C++-functions and use C++-variables from inside NASM

- Function names in gcc :

int test(){ code... }
This function gets a "v" (void) nameextension for the linker ld.
Funktions get _Z and the number of signes used for the name befor the name.
In NASM you have to use in this case the function-name (Lable) _Z4testv.

int hello (int new, char t) { code... }
For each variable is the type code added to the name.

`char'	`c'
`unsigned char'	`C'
`short'	`s'
`unsigned short'	`S'
`int'	`i'
`unsigned int'	`I'
`long'	`l'
`unsigned long'	`L'
`long long'	`q'
`unsigned long'	`Q'
`float'	`f'
`double'	`d'
`void'	`v'
`id'	`@'
`Class'	`#'
`SEL'	`:'
`char*'	`*'
unknown type	`?'
bit-fields	`b' followed by the starting position of the bit-field, the type of the bit-field and the size of the bit-field (the bit-fields encoding was changed from the NeXT's compiler encoding)

*Copied from the GCC-docs 'Type encoding'.

In this case the function-name for use in NASM is '_Z5helloic'.

- Variable-names in gcc :

int myvar=0;	//global variable
int main(){
...
int x=0;	//lokal variable of main. There is no access to !
return 0;
}

And like this you can call a function written in gcc :

Any c++ program :

test.cpp :

-compil it with: g++ -c test.cpp -o test_cpp.o

------------------------

int myvar=2;	//global variable, however it isn't set to 2 in my test program.
char myextravar;	//global variable
int sqr(){	//global function - sqr(void) -> _Z3sqrv
myvar = myvar*myvar;	//myvarª
return myvar;	//If you have such a line eax holds the value.
}
void normal(){	//-> _Z6normalv
myvar = myvar+3;	//Here myvar is hanged at the global position
}

------------------------

Your NASM program :

test.nasm :

-compil it with: nasm -f elf test.nasm

------------------------
section .data

EXTERN myvar	;this makes myvar from the c++ programm useable for you
EXTERN _Z3sqrv	;this makes the function int sqr(void) from the c++ programm useable for you
EXTERN _Z6normalv	;this makes the function void normal(void) from the c++ programm useable for you

section .text
global _start

%include "collection.inc"

_start:

	mov	ecx,20
a:
	call	_Z3sqrv	;call the global c++ function sqr()
	call	output	;a standard output procedure (syscall) eax = output
	call	_Z6normalv	;call the global c++ function normal()
	mov	eax,[myvar]	;or you can get the c++ variabel into eax like this too
	call	output	;a standard output procedure (syscall)
	loop	a	;jmp to a if ecx > 0
ende:
	mov	eax,1	;system call number (sys_exit)
	int	$80	;call kernel (EXIT)

------------------------

linking both object-files together

Now the bigest and easiest part :
That is done with : ld -s -o test test.o test_cpp.o
test.o is your NASM-object-file and should stand befor the c++-file test_cpp.o.
Now you have an executeable called 'test'.

Some Tips

Avoid to return something in c++ programs because of stack overflow or stack mistakes errors. It's also faster to use the variable direktly, so you don't have to push and pop it. Mov reg,[mem] is as fast as pop, and sometimes faster.
If you use the c++ command return, the value is then in eax for all integer values (char, schort, int, longint). In all other cases the offset is hold in eax
Avoid float values at all if you are realy intrested in a precise results. The CPU internal math processor doesn't have a fault correction yet and woudn't get one because of speedless, the 64 bit AMD (and if Intel get one) and Motorola processors also not.

I know something !