MSIL compiler

// Part 1 of 3

using System;

using System.Collections.Generic;

using System.Text;

namespace MsilCompiler

{

class Compiler

{

static void Main(string[] args)

{

// Initialize Phoenix.

Initialize(args);

// Create a new PE module unit.

Phx.PEModuleUnit peModuleUnit = Phx.PEModuleUnit.Open("foo.dll");

peModuleUnit.OutputImagePath = "foo2.exe";

peModuleUnit.LoadEncodedIRUnitList();

peModuleUnit.PreAssignTypeTokens();

// Create a reference to System.Object.

Phx.Symbols.AssemblySymbol mscorlibSymbol =

LookupAssembly(peModuleUnit, "mscorlib");

Phx.Name objTypeName =

Phx.Name.New(lifetime, "System.Object");

Phx.Symbols.MsilTypeSymbol objTypeSymbol =

Phx.Symbols.MsilTypeSymbol.New(peModuleUnit.SymbolTable, objTypeName, 0);

Phx.Types.AggregateType objType =

Phx.Types.AggregateType.NewDynamicSize(typeTable, objTypeSymbol);

objType.IsPrimary = true;

objTypeSymbol.Visibility = Phx.Symbols.Visibility.ClrTokenReference;

// Now, attach the class type to the mscorlib assembly reference.

mscorlibSymbol.InsertInLexicalScope(objTypeSymbol, objTypeName);

// Create a class that extends System.Object

Phx.Name classTypeName =

Phx.Name.New(Phx.GlobalData.GlobalLifetime, "SampleClass");

Phx.Symbols.MsilTypeSymbol classTypeSym =

Phx.Symbols.MsilTypeSymbol.New(peModuleUnit.SymbolTable, classTypeName, 0);

Phx.Types.AggregateType classType =

Phx.Types.AggregateType.NewDynamicSize(peModuleUnit.TypeTable,

classTypeSym);

classType.Access = Phx.Symbols.Access.Public;

classType.IsDefinition = true;

Phx.Types.BaseTypeLink baseLink =

Phx.Types.BaseTypeLink.New(objType, false);

classType.AppendBaseTypeLink(baseLink);

classType.IsPrimary = true;

classType.IsSelfDescribing = true;

// Now, insert the class type into the assembly scope.

Phx.AssemblyUnit assemblyUnit = peModuleUnit.AssemblyUnit;

Phx.Symbols.AssemblySymbol assemblySymbol = assemblyUnit.AssemblySymbol;

assemblySymbol.InsertInLexicalScope(classTypeSym, classTypeName);

// Create a method void Main(string[] args)

Phx.Types.Type arrayOfStringType =

Phx.Types.ManagedArrayType.New(typeTable, typeTable.ObjectPointerSystemStringType, null);

Phx.Types.FunctionType mainMethodType =

typeTable.GetFunctionType(Phx.Types.CallingConventionKind.ClrCall,

typeTable.VoidType, arrayOfStringType, null, null, null);

Phx.Name mainMethodName =

Phx.Name.New(Phx.GlobalData.GlobalLifetime, "Main");

Phx.Symbols.FunctionSymbol mainMethodSymbol =

Phx.Symbols.FunctionSymbol.New(peModuleUnit.SymbolTable, 0, mainMethodName,

mainMethodType, Phx.Symbols.Visibility.GlobalDefinition);

Phx.Name argsName = Phx.Name.New(lifetime, "args");

Phx.Symbols.FunctionArgument functionArgument = Phx.Symbols.FunctionArgument.New(mainMethodSymbol, argsName, 0);

mainMethodSymbol.AppendFunctionArgument(functionArgument);

// Add it as a method of the traceType.

classType.AddMethod(mainMethodSymbol);

classTypeSym.InsertInLexicalScope(mainMethodSymbol, mainMethodName);

// Allocate it inthe .text section.

Phx.Name textName =

Phx.Name.New(lifetime, ".text");

Phx.Symbols.SectionSymbol textSymbol =

peModuleUnit.SymbolTable.LookupByName(textName).AsSectionSymbol;

mainMethodSymbol.AllocationBaseSectionSymbol = textSymbol;

mainMethodSymbol.Access = Phx.Symbols.Access.Public;

mainMethodSymbol.MethodSpecifier = Phx.Symbols.MethodSpecifier.Static;

// End of Part 1 of 3

// Part 3 of 3

static void Initialize(string[] args)

{

// Create and register architecture and runtime.

Phx.Targets.Architectures.Architecture msilArchitecture = Phx.Targets.Architectures.Msil.Architecture.New();

Phx.Targets.Runtimes.Runtime msilRuntime = Phx.Targets.Runtimes.Vccrt.Win.Msil.Runtime.New(msilArchitecture);

Phx.GlobalData.RegisterTargetArchitecture(msilArchitecture);

Phx.GlobalData.RegisterTargetRuntime(msilRuntime);

Phx.Targets.Architectures.Architecture x86Architecture = Phx.Targets.Architectures.X86.Architecture.New();

Phx.Targets.Runtimes.Runtime x86Runtime = Phx.Targets.Runtimes.Vccrt.Win32.X86.Runtime.New(x86Architecture);

Phx.GlobalData.RegisterTargetArchitecture(x86Architecture);

Phx.GlobalData.RegisterTargetRuntime(x86Runtime);

// Initialize the infrastructure.

Phx.Initialize.BeginInitialization();

// Initialize controls set by command line, register plugins,

// etc. Read control values first from the PHX environment variable,

// then the command line, then from the _PHX_ environment variable.

Phx.Initialize.EndInitialization("PHX|*|_PHX_|", args);

// Enable some controls. We want to see the names of types, types

// in our IR dumps, linenumbers in our IR dumps, and linenumbers

// in our object file.

Phx.Controls.Parser.ParseArgumentString(null,

"-dumptypesym -dump:types -dump:linenumbers -lineleveldebug");

// Cache pointer to the main type table.

typeTable = Phx.GlobalData.TypeTable;

// Create a lifetime.

lifetime =

Phx.Lifetime.New(Phx.LifetimeKind.Module, null);

}

static Phx.Symbols.AssemblySymbol LookupAssembly(Phx.ModuleUnit moduleUnit, string assemblyNameString)

{

Phx.Name assemblyName =

Phx.Name.New(lifetime, assemblyNameString);

Phx.Symbols.Table symbolTable = moduleUnit.SymbolTable;

Phx.Symbols.NameMap nameMap = symbolTable.NameMap;

// If the module was not compiled with debug, the module sym

// table may not have a name map.

if (nameMap == null)

{

nameMap = Phx.Symbols.NameMap.New(symbolTable, 64);

symbolTable.AddMap(nameMap);

}

Phx.Symbols.Symbol sym = nameMap.Lookup(assemblyName);

// Note that there might be a number of symbols with

// identical names, so search through until we have an

// assembly reference.

while (sym != null)

{

if (sym.IsAssemblySymbol)

{

return sym.AsAssemblySymbol;

}

sym = nameMap.LookupNext(sym);

}

return null;

}

static Phx.Types.Table typeTable;

static Phx.Lifetime lifetime;

}

}