简单的x86-64 C ++内联汇编“ Hello World”示例

Question

I am trying to find a very basic C++ inline x86-64 assembly example, similar to this:

a Simple "Hello World" Inline Assembly language Program in C/C++

char msg[] = "Hello, world";

asm {
    mov ax,4       // (I/O Func.)
    mov bx,1       // (Output func)  
    lds cx, msg   // (address of the string)
    mov dx,6       //  (lenght of the string)
    int 0x21       // system call
}

which would work with the Intel Compiler. Could someone please help with this?

EDIT Regarding OS I have the ICC on Windows and Linux- lets say Linux!

Answer 1

The code you have posted is 16-bit code. 64-bit Windows (or any version of Linux) doesn't support 16-bit code. [And it's a bit buggy, since it sets the length to 6, when the actual length of the string is 12...]

You could possibly figure out how to do the same thing in Windows code, but I fail to see the point of learning how to make system calls in Windows from assembler. Write some code that does something that you can actually apply in real life, such as counting the number of characters in a string.

Of course, you will need to use either Intel or GCC compilers, since the Microsoft compiler doesn't allow inline assembler in 64-bit mode.

Here's a little sample of inline assembler using the "read timestamp counter" instruction, which will work with the gcc compiler (and by compatibility should work with the Intel compiler too).

static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}

Answer 2

AT&T vs. Intel assembly format.

at&t noprefix                   intel
mov eax, -4(ebp,edx,4)          mov DWORD PTR[-4 +ebp +edx *4], eax
mov eax, -4(ebp)                mov DWORD PTR[-4 +ebp], eax
mov edx, (ecx)                  mov DWORD PTR[ecx], edx
lea (   ,eax,4), eax            lea eax, DWORD PTR[8 + eax*4]
lea (eax,eax,2), eax            lea eax, DWORD PTR[eax*2+eax]

Or this.

asm(".intel_syntax noprefix");
asm("mov eax, ebx");

asm(".att_syntax prefix");
asm("mov %ebx, %eax");

AT&T syntax.

int main(int argc, char *argv[])
{
int x=1, f=2, fa=3;
asm("int $0x3");
asm("mov 4%0,%%eax"::"m"(x));
asm("movss 4%0,%%xmm1"::"m"(f));
asm("fld 4%0"::"m"(fa));
return 0;
}

Note that one difference is the use of '%' and the direction of assignment to a register.

Some more discussion here and here . Much of that has to do with debugging.