Thread: how to make an executable file by ourselves?

hello all, im curious to know how i can make my own executable files! i mean i made a simple simulator ! with my own made language! pretty simple! sth like this

Code:

RED 1 
WRI 1
HLT

and yet a simpler version

Code:

1010  //read Memory location 10
1210 //write To Memory Location 10
9000 //Halt the program execution

well the program now works only inside the simulator(actually you run the simulator and then you write your program in my new language! and then you press 1 e.g and simulator interpret the codes and will do the calculations!
now im seeking a way to make an executable file when the user tries to run the emulated code on simulator! so that, after that the user gets an executable program! and wont need the simulator anymore to run the new language codes! !

There are tables available for converting from Assembly Language to binary

Dealing with executable file formats is a pain though, especially when you deal with it directly in your compiler.

I would suggest just emitting a .s file filled with assembly code and passing that to something like GCC or GNU as to get a binary. It'll deal with all the linking and whatnot for you so you don't have to, but of course, this requires that GCC/etc. is installed.

Originally Posted by Mad_guy

Dealing with executable file formats is a pain though, especially when you deal with it directly in your compiler.

I would suggest just emitting a .s file filled with assembly code and passing that to something like GCC or GNU as to get a binary. It'll deal with all the linking and whatnot for you so you don't have to, but of course, this requires that GCC/etc. is installed.

There's a wide variety of assemblers, no need to use GCC.

thanks guys , but im a bit confused! how am i supposed to convert sth like

Code:

while ( cpu is running )
{
              switch ( Opcode )
              {
                             case RED:
                             {
                                      int number;  
                                      cout<<"Enter a number";
                                      cin>>number;
                              }
                            ~~~~
                }
}

into machine language!! please note that i want sth corss platform ( C++) , so that on each platform that the original simulator is compiled and run the platform specific executable gets produced!

talking about gcc and stuff! do i have to inject gcc compilers into my simple simulator! in order to be able to make executables ? so what are makefiles! though? ive heard they are for making executable files out there!

tanx sean / are those recompilation stuff that we face in emulation , done with the same approach?

Can we please! Not end every sentence! With an exclamation point!

The C compiler translates C code to assembler code. The assembler translates assembler code to object code. The linker translates object code to executables. The CPU translates executables to actions.

So you have several choices:
- translate from your language to C
- translate from your language to assembler
- translate from your language to object code
- translate from your language to executables

These choices are sorted by portability.


For a completely different approach, there are virtual machines and/or interpreters: a virtual machine is a program that translates bytecode/object code to actions, an interpreter is a program that translates your language to actions directly.

Writing a virtual machine is fairly easy (but you will have to write a program that translates your language to bytecode), writing interpreters is clumsy.


I'd recommend writing a compiler that translates your language to assembler code, or writing a virtual machine.

Greets,
Philip

Writing a virtual machine is fairly easy

Wow. One can hardly expect that statement from a complete beginner.

Since it is YOUR simulator, you can arrang your executable file in whatever way you like. The simplest form would be a simple hex file:

Code:

1000: 00 AA 83 12 18
2000: 12 34 56 78

Where the first hex number is the address you want data loaded at, the second set is the bytes to be loaded at that address.
In this example, five bytes are loaded at 0x1000, and then another 4 bytes as address 2000.

"Real" executable formats are of generally more complex because they have to solve many more problems (such as the address to load the file may vary depending on circumstances, or there are DLL's and other external references to cover).

--
Mats

Here's another option: target LLVM. LLVM can be used as a toolset, or as libraries, so you can easily combine LLVM parts with your own code to create a complete compiler, or even a JITting VM.

If you use .NET you can use Microsoft.CSharp, System.CodeDom.Compiler and System.Reflection to compile C# (or VB) code on the fly. You enter code in the form of a string and get an assembly back which you can either execute immediately or save to a file.

In your case you could write a compiler taking your own language and constructs C# code from it, then compile it using the above system.

Read http://www.ziggyware.com/readarticle.php?article_id=98 for more info.