Re: Executable memory

[Alan]

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!