Thread: Run machine-code in a non-executable

I want to load actual proccesor-specific machine code (as in
IBM-compatible, not as in 486 10 MHz only) and run it.

I plan to follow this order of actions:
1) malloc() memory and load the entire file into it,
2) set a pointer to a class to point to the first bit of file (may
change to header info @ begining of file)
3) do a pointer->function() type of operation to call code.

The file format currently stands at:

Code:

something function(int target, int *data){
                          switch (target){
                              case 1: called_function_1( data );
                              case 2: called_function_2( data );
                              ...
                          }
                          return ( value );
    };

    void called_function_1( int *data ){
               ...
    };

    void called_function_2( int *data ){
               ...
    };

This isn't really code, just something to carry the concept across,
all variables except for target and data in the first function would
be in memory the file code itself malloc()'ed. target and data
would be at locations at the end of the file in the file set aside
for that purpose.

This is intended to be used to incorporate plug-and-play type
functionality in a format that I understand, and in a format that I
choose (in case I need to change the format of the file later to
add a header or some-such thing). Unfortunatly, I don't know if
this will work, or even if I will need to have the program modify
the plug-in according to it's memory location.

May seem a bit of a doozy, but I really want to know the
answer (I figure it should be useful for a mechanism to port
programs from one OS to another on the same platform also).

Thanks.

Sorry about some of the funkiness of my wording, I
had intended to click preview, guess what I did
instead.

the Code Segment and the Data Segment are seperated. your program and stack are allocated by the operating system and run through before being unallocated and returned to the system.

unfortunately, the code segment is read-only. this means that running a program like you want to would require some sort of emulator to read in the commands and execute them.

There's probably some work-around that can be used, does anyone know how poly-morphic programs do it? They mentioned it in the FAQ or tutorials area but I never saw a link to the info. If I had some OS or poly-morphic code experience I could probably do this in my sleep.

there's this "feature" (read: bug) in windows that allows programs to do this. it was done for the purpose of debugging, but it has been exploited to do other things, cheats in games among them. you can probably find more information on google. try searching for how to make programs like this.

you might be able to overlap the code segment with the data segment, but i think this results in an segmentation fault. on older, pre i386 machines, it might work.

some old 8086's had a bug which allowed programs to change the code stack pointer at will. this is probably worthless for your applications, though.


try researching into debugging. gdb is open source and probably has source code which allows you to do this.

Thanks. That last suggestion, especially, could do more than I was hoping, and the dlopen tip sounds like exactly what I had in mind. I'll have to look up those bugs, too, might be useful.