how to make an executable file by ourselves?

Printable View

03-12-2009
Masterx

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! !
03-12-2009
sean

You have to compile it into machine language. So you could output C code and use a C compiler (which is easier, but hacky), or you could output the binary into a file, and give it executable permissions.

There are tables available for converting from Assembly Language to binary (I myself never figured out how to put operands into binary, though), and with some fancy bitwise operators in C, you could output machine code fairly easily from that point.
03-12-2009
Mad_guy

Quote:

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.
03-12-2009
maxorator

Quote:

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.
03-12-2009
sean

Just a side comment, here: If you're going to use a 3rd party assembler, you might as well output code in the language with which you are most familiar, and just use THAT compiler.
03-12-2009
Masterx

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!
03-12-2009
sean

A makefile is really just a script for compiling your project. You still have to have gcc to compile individual files and do the linking.

If you want something cross platform, you have to output the source code and then compile it. Unless you want to write your own compiler (if you don't know the answer to that, the answer is definitely 'no'), there is no option but to use someone else's compiler.

You could of course output batch files or shell scripts, but that isn't very cross-platform either.
03-12-2009
Masterx

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

Emulation / interpretation is normally done by interpreting the commands, and then performing the action in a program. Normally interpretation is done on the fly, and must be redone completely every time. You would use another compiler (as above) only if you wanted to save the actions in a certain executable format.

The other option is JIT compiling, where something is compiled to "byte codes" (eg. .NET and Java) that are easy to interpret and execute, and then they are interpreted on the fly.
03-12-2009
brewbuck

Can we please! Not end every sentence! With an exclamation point!
03-13-2009
Snafuist

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
03-13-2009
stevesmithx

Quote:

Writing a virtual machine is fairly easy

Wow. One can hardly expect that statement from a complete beginner. ;)
03-13-2009
matsp

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
03-13-2009
CornedBee

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.
03-13-2009
Magos

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.
03-13-2009
Masterx

thank you all, great infos! many thanks! okay , ive got to read sth about the compilers and ill be reporting!
(by the way im using C++(standard you know! tobe able to make it work on on platforms)
03-13-2009
Snafuist

Quote:

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

From a theoretical viewpoint, a virtual machine is a loop with a switch statement: read the next instruction, decompose it into opcode and operands, call an appropriate function to handle the task. Nothing easier than that, even I could do that. ;-)

The hard part is optimization, i.e. make it execute faster than compiled code. This involves more advanced techniques such as on-the-fly code profiling, dynamic runtime optimization, hot paths, slim binaries, graph representation, code re-use, matching algorithms, whatever, but these are not specific to virtual machines.

Greets,
Philip
03-13-2009
CornedBee

Quote:

by the way im using C++(standard you know! tobe able to make it work on on platforms)

A doomed endeavor in the case of a compiler. But using standard C++ makes it easier to port it. Using an external code generator like GCC or LLVM is even better.
03-13-2009
Masterx

I didnt get you said! can you be more precise on the meaning! ?
03-14-2009
sean

What he means is that you can't write a compiler that's portable. Machine laguage on one platform is different than on another. Executables are different from system to system.

C++ would make it good for porting, but everything about your target code would be different from machine to machine.
03-14-2009
brewbuck

Quote:

Originally Posted by sean

What he means is that you can't write a compiler that's portable. Machine laguage on one platform is different than on another. Executables are different from system to system.

But that's exactly what gcc is -- a portable compiler. It uses pluggable modules to translate its optimized intermediate code into the target assembly instructions.

"Portability" sometimes implies having a set of platform-specific pieces. Nothing can ever be portable in a pure sense, but there's a practical meaning of the word as well.
03-14-2009
Masterx

so the only way to do this is to use gcc or LLVM as the compiler! well now how should i merge gcc to my project! and make it work!
03-15-2009
CornedBee

GCC is easy to port, but it's not perfectly portable. As you said, and as I said, that's impossible for a compiler.
As an aside, GCC's backends are not "pluggable". If you want a compiler that targets a different architecture, you need to compile a complete second copy.
That's one important difference between LLVM and GCC. LLVM can have multiple backends compiled in, and choose with an option passed to it. It might even be truly run-time pluggable, I'm not sure.
The other important difference is that merging GCC into a project is just about impossible. What you do is generate code, then call a separate GCC to process that code. With LLVM, you can really integrate it into your executable.

That said, it's not the only way. It's just the easiest. LLVM has been ported to 9 architectures (x86, x64, IA-64, MIPS, Alpha, ARM, PowerPC, Sparc, CellSPU) plus some pseudo-architectures (it can generate C, C++ or .Net bytecode) - with varying levels of completeness. GCC has been ported to some 30 architectures. Can you even imagine trying to replicate that effort in your own compiler?