Thread: Assembly

Originally Posted by samGwilliam

Here's another question along the same lines: Why do some keywords have a normal version and a version with two underscores preceding (asm/__asm, for example)?

in my vc++ _asm is for one liners. __asm{} is for blocks

Code:

#include <stdio.h>


int main()
{

	int x = 65;
	int *y = &x;
	char format[] = "%i";
	

	printf("X equals: ");   
	_asm mov eax, y;       //move the address of x into eax
							//could have been placed in next block
							//just using it as an example
	__asm
	{
	
                  push format;        //push format string onto stack
                  push eax;			//now eax (the address of x)
		call printf;        //call C's printf
                  pop eax;            //clean up the stack
	}

	_asm pop eax;           //clean up the stack 
							//also could have been place inside __asm{}
	return 0;
}

edit: this is probably not good or safe code. i've only dabbled in the realm of asm w/ c/c++

That underscore business is to avoid breaking existing code.

For example, the type bool hasn't always been around, so it used to be that people conjured up their own way of storing boolean values. When C99 included a boolean type, it was named _Bool so as not to conflict with the various definitions of boolean types that existing programs used.

...........none the less, my above 'program' won't compile if i mix up _asm and __asm

Then don't mix them up

Originally Posted by Bubba

Which is why I don't like MASM. It's too political, I'd rather use NASM where nothing is assumed.



Yes, there is a way to tell MSVC to keep it's grubby hands off of your assembly code - but you cannot guarantee that you are optimized to the max while doing it. For instance if MSVC was using a register prior to your code and then you use the same register....you have a problem.

Here is how the compiler deals with it. Since you have no idea what registers the code is actually using because, for the most part, all you see is C/C++ code. So when the compiler sees that you want to use a register that it is already using, it pushes the value of that register onto the stack. When you are done with it, or when it deems you are done with it, it pops it off the stack and resumes what it was doing.

In DJGPP and AT&T syntax there is a way to specify which registers get 'fragged' so the compiler can better use registers prior to and after your code.

But with modern processor speeds, I doubt register problems will amount to much.

And I might add that Fordy pointed something very important out to me not long ago about inline assembly. If you are going to need to access the stack, do it from your assembly code. Don't attempt to use temporaries and then load those in your code. It looks nicer, but it is significantly slower. I'm sure with some searching you could probably find this thread on the board in a search for 'Bilinear interpolation.'

But if you use something like MSVC's "naked" qualifier for a function definition (as I did here http://cboard.cprogramming.com/showthread.php?t=43552) then you forego that problem, as the C++ code sees it as another CALL instruction for which it doesnt need to "de-optimize". IA32 defines rules for dealing with registers over a CALL, and the compiler should'nt differentiate between a CALL to a function written in C or C++, or a call using "naked".

With such a method, you end up achieveing exactly what you do with linking in an object file from an assembler, and with far less hassle. The only downside is that MSVC is a little more strict with the MASM syntax than the assembler, so if you like using lots of macros or some of the more esoteric features, then you are better off linking object files.