AT&T inline C++ hello world errors - c++

Question

I am trying to use Assembly in C++ (Dev-CPP) and it won't output the string as it should. after some research I have discovered that it uses the AT&T syntax. my code will not output the string it just comes up with assembly messages.
This is my code:
#include <iostream>
using namespace std;
int main()
{
asm(".section .data");
asm("hello: .string\"Hello, World!$\"\n");
asm(".section .text");
asm("movl $0x09, %ah \n");
asm("mov hello, %dx\n");
asm("int 0x21");
system("PAUSE");
return 0;
}
could I get some help please.

Answer 1

In theory, only programs compiled with DJGPP (gcc port for DOS) can legally use DOS service functions via a DOS extender IFF you run them in DOS or Windows (XP and below, generally not Vista/7/8). Also, gcc does not generate 16-bit x86 code, which is what you seem to be expecting.
Further, you should really, really learn some inline assembly (google it up).
A compilable version if your code would look like:
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
asm(".section .data");
asm("hello: .string\"Hello, World!$\"\n");
asm(".section .text");
asm("movb $0x09, %ah\n"); // movl->movb
asm("movl $hello, %edx\n"); // mov->movl,hello->$hello,dx->edx
asm("int $0x21"); // 0x21->$0x21
system("PAUSE");
return 0;
}
But it's still unlikely to be good inline assembly because:
Your code trashes the registers and doesn't tell the compiler which are trashed, and so it likely corrupts the state of the program, which can lead to a crash or hang.
You write your instructions in individual asm statements, between which the compiler can insert any kind of code and disrupt your inline assembly. You really want to put your related instructions into a single block to prevent that from happening.
Something like this would be better:
asm volatile (
".section .data\n"
"hello: .string \"Hello, World!$\"\n"
".section .text\n"
"movb $0x09, %ah\n"
"movl $hello, %edx\n"
"int $0x21\n"
);
Unfortunately, this still won't work even with DJGPP. The problem has something to do with the memory segmentation setup done by DJGPP and the DPMI host (CWSDPMI), probably virtual memory. I can't tell what exactly is wrong there, but the above code doesn't work as-is.
So, please figure out what OS you're compiling your program for and write inline assembly code appropriately for that OS, that is, using correct registers and system call mechanisms.
DOS int 21h functions won't work in native Windows and Linux apps. Period. You've got the wrong tutorial.

Answer 2

To extend on Alexey's answer (how to overcome the segmentation issues), this would compile (and possibly run on DOS):
asm volatile(
"call 0f\n"
".byte 'H','e','l','l','o','W','o','r','l','d','!',0\n"
"0: pop %0\n"
"push %ds\n"
"push %cs\n"
"pop %ds\n"
"int $0x21\n"
"pop %ds\n" : "d"(0), "a"(9) : : "memory", "cc");
The idea is to inline the string within the code but jump over it; the return address of that call is the start address of the string. Then temporarily make the data segment identical to the code segment, call the DOS INT and restore the proper data segment after that.