I'm writing a compiler, and I want it to compile to a native executable (just Linux, for now). I don't want it to be Assembly, it needs to be PURE machine code. Can anyone point me in the right direction?
EDIT: I want to produce x86 Linux machine code.
The assembler is not used at runtime. It is used at compile time to generate native code, which is what is typically distributed in software packages. Once you have that executable, the assembler is no longer necessary. Also, the assembling stage is typically called automatically by the compiler, as one of its stages, so the programmer isn't explicitly aware of it.
Therefore, if you want to generate native code, and don't want to tie into one of the excellent existing toolchains like llvm, the first thing you would want to do is write an assembler, whether that's a separate executable or simply a module in your compiler. It's too difficult to go straight from high-level code to machine code. In fact, compilers typically have several stages.
You want your compiler to generate machine code directly. But program files are not just machine code — there is an executable file format, within which there is relocatable machine code & initialized data. For linux, there is a file format that covers both program files and object files: https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
Typically, the compiler (and/or assembler), linker, and operating system loader form a pipeline that cooperates to reconstitute a program into memory for execution by the processor in the context of an operating system process. By the time the program runs, the location of all symbols is known and any references to symbols are converted from nominal references to numeric address references.
Each stage may be missing numeric address information, captured instead symbolically. Use of external symbols and otherwise unknown addresses requires relocation at various stages in that pipeline.
Beyond raw machine code & data, these file formats are capable of containing metadata about the program such as symbol imports & exports, relocations required, debugger-required information, etc..
See also https://en.wikipedia.org/wiki/Comparison_of_executable_file_formats
Otherwise you might be interested in JIT technology, where machine code is generated directly into memory for immediate execution, and thus there is no output file.
Nothing stops you from writing machine code. Every good assembly manual should show the instruction encoding. Your compiler just has to write those instructions instead of writing assembly code.
Don't forget that your executable file is not just machine code, it also has ELF headers saying which things go where in memory.
Most compilers find it more convenient to write assembly code, but yours doesn't have to.
