Writing a Compiler for .net - IL or Bytecode?

Question

I'm currently diving into the inner workings of .net, which means IL. As an exercise, I want to build a brainf..k compiler for .net (yes, they already exist, but as said it's for learning purposes).

For the moment I'm just writing some text files that contain .il and compile them with ilasm, which works. But I wonder if I could/should go one level deeper and write bytecode directly?

My "concern" is the Windows PE Stuff when compiling an EXE - instead of ilasm I would need some sort of Bytecode linker that would take my MSIL/CIL bytecode and generate the PE Stuff for it?

Or do compilers "only" compile their language to IL and execute ilasm? Is there a managed version of it that I can call/embed from my compiler?

Answer 1

Why not simply use the Reflection.Emit api to produce a in-memory assembly with the compiled code and then save it to disk? Should be a lot easier than writing out .IL files.

Links:

• Using Reflection.Emit
• ILGenerator.Emit Method

If you want to go down this road, if you ask more specific questions here on SO you'll get plenty of example of how to define a dynamic assembly and save it to disk.

Here's an example:

using System; using System.Reflection.Emit; using System.Reflection;  namespace SO2598958 {     class Program     {         static void Main()         {             AssemblyBuilder asm = AppDomain.CurrentDomain.DefineDynamicAssembly(                 new AssemblyName("TestOutput"),                 AssemblyBuilderAccess.RunAndSave);              ModuleBuilder mod = asm.DefineDynamicModule("TestOutput.exe",                 "TestOutput.exe");             TypeBuilder type = mod.DefineType("Program", TypeAttributes.Class);              MethodBuilder main = type.DefineMethod("Main",                 MethodAttributes.Public | MethodAttributes.Static);             ILGenerator il = main.GetILGenerator();             il.Emit(OpCodes.Ldstr, "Hello world!");             il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine",                 BindingFlags.Public | BindingFlags.Static,                 null, new Type[] { typeof(String) }, null));             il.Emit(OpCodes.Ret);              type.CreateType();             asm.SetEntryPoint(main);             asm.Save("TestOutput.exe");         }     } } 

You can download the test solution file from here. Direct link to zip file with solution here.

If you first compile and run this program, it'll produce a new exe file on disk, called TestOutput, which you can then execute in order to have "Hello World!" printed on the console.

Answer 2

System.Reflection.Emit provides facilities to create IL code in a statically-typed way without having to generate and compile text files with IL.