On Friday, 4 October 2013 at 22:00:36 UTC, Adam D. Ruppe wrote:
> I'm just playing at this point and I'm pretty sure these hacks won't quite work or might even be kinda useless... but one way to avoid the hassle of making the machine code yourself is to get the compiler to do it.
>
> So we'll write our function (just 32 bit here, the 64 bit didn't work and I'm not sure why, could be because of this http://stackoverflow.com/a/6313264/1457000 ) in D then copy it into the magic memory:
>
> void sayHello() {
> 	asm {
> 		naked;
> 	}
> 	static immutable hello = "hello!\n";
> 	auto sptr = hello.ptr;
> 	auto slen = hello.length;
> 	version(D_InlineAsm_X86)
> 	asm { // 32 bit
> 		mov ECX, sptr;
> 		mov EDX, slen;
> 		mov EBX, 1; // stdout
> 		mov EAX, 4; // sys_write
> 		int 0x80;
> 	}
>
> 	asm {
> 		ret;
> 	}
> }
> void sayHelloEnd(){} // I'm using this with the assumption that the two functions will be right next to each other in memory, thus sayHello's code goes from &sayHello .. &sayHelloEnd. idk if that is really true but it seems to work for me
>
> import core.sys.posix.sys.mman;
>
> void main()
> {
>        // NOTE: you did uint* before, now i'm doing ubyte* since we're really working in bytes, not ints
>         ubyte[] opcodes = (cast(ubyte*) mmap(null, 4096, PROT_EXEC | PROT_WRITE, MAP_PRIVATE | MAP_ANON, 0, 0))[0 .. 4096];
> 	assert(opcodes !is null);
> 	scope(exit)
> 		munmap(opcodes.ptr, 4096);
>
>        // copy the code from our sayHello function that dmd compiled for us into the executable memory area
> 	auto f = cast(ubyte*) &sayHello;
> 	auto fe = cast(ubyte*) &sayHelloEnd;
> 	auto len = fe - f;
> 	import std.stdio;
> 	writeln("length: ", len); // shouldn't be very large
>         opcodes[0 .. len] = f[0 .. len]; // copy it over
>         void* function() func = cast(void* function()) opcodes;
>         func(); // and run it
>
> 	writeln("ending function normally!");
>
>       // then write over it to prove we still can...
> 	opcodes[0] = 0xcc;
> 	func(); // this should trap
> }
>
>
>
>
> Perhaps you could string together a bunch of little functions written in D and inline asm to build your executable code most easily using tricks like this. Assuming it continues to work in more complex situations!

Hmm interesting... I'll have to work with it some! I get a segmentation fault with this code though :| It outputs:
length: 24
Segmentation fault (core dumped)

Thanks for the help though!

On Friday, 4 October 2013 at 22:00:36 UTC, Adam D. Ruppe wrote:
> I'm just playing at this point and I'm pretty sure these hacks won't quite work or might even be kinda useless... but one way to avoid the hassle of making the machine code yourself is to get the compiler to do it.
>
> So we'll write our function (just 32 bit here, the 64 bit didn't work and I'm not sure why, could be because of this http://stackoverflow.com/a/6313264/1457000 ) in D then copy it into the magic memory:
>
> void sayHello() {
> 	asm {
> 		naked;
> 	}
> 	static immutable hello = "hello!\n";
> 	auto sptr = hello.ptr;
> 	auto slen = hello.length;
> 	version(D_InlineAsm_X86)
> 	asm { // 32 bit
> 		mov ECX, sptr;
> 		mov EDX, slen;
> 		mov EBX, 1; // stdout
> 		mov EAX, 4; // sys_write
> 		int 0x80;
> 	}
>
> 	asm {
> 		ret;
> 	}
> }
> void sayHelloEnd(){} // I'm using this with the assumption that the two functions will be right next to each other in memory, thus sayHello's code goes from &sayHello .. &sayHelloEnd. idk if that is really true but it seems to work for me
>
> import core.sys.posix.sys.mman;
>
> void main()
> {
>        // NOTE: you did uint* before, now i'm doing ubyte* since we're really working in bytes, not ints
>         ubyte[] opcodes = (cast(ubyte*) mmap(null, 4096, PROT_EXEC | PROT_WRITE, MAP_PRIVATE | MAP_ANON, 0, 0))[0 .. 4096];
> 	assert(opcodes !is null);
> 	scope(exit)
> 		munmap(opcodes.ptr, 4096);
>
>        // copy the code from our sayHello function that dmd compiled for us into the executable memory area
> 	auto f = cast(ubyte*) &sayHello;
> 	auto fe = cast(ubyte*) &sayHelloEnd;
> 	auto len = fe - f;
> 	import std.stdio;
> 	writeln("length: ", len); // shouldn't be very large
>         opcodes[0 .. len] = f[0 .. len]; // copy it over
>         void* function() func = cast(void* function()) opcodes;
>         func(); // and run it
>
> 	writeln("ending function normally!");
>
>       // then write over it to prove we still can...
> 	opcodes[0] = 0xcc;
> 	func(); // this should trap
> }
>
>
>
>
> Perhaps you could string together a bunch of little functions written in D and inline asm to build your executable code most easily using tricks like this. Assuming it continues to work in more complex situations!

Hmm interesting... I'll have to work with it some! I get a segmentation fault with this code though :| It outputs:
length: 24
Segmentation fault (core dumped)

Thanks for the help though!