Thread: how to make an executable file by ourselves?

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)

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

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.

I didnt get you said! can you be more precise on the meaning! ?

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.

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!

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?