public void Activate(ContextRef cr)
{
bool begun = false;
//this needs a begin signal to set the swap chain to the next backbuffer
if (cr.gl is BizHawk.Bizware.BizwareGL.Drivers.SlimDX.IGL_SlimDX9)
{
cr.gc.Begin();
begun = true;
}
if (cr == ActiveContext)
{
return;
}
ActiveContext = cr;
if (cr.gc != null)
{
//TODO - this is checking the current context inside to avoid an extra NOP context change. make this optional or remove it, since we're tracking it here
if (!begun)
{
cr.gc.Begin();
}
}
if (cr.gl != null)
{
if (cr.gl is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
{
((BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)cr.gl).MakeDefaultCurrent();
}
}
}
public void Activate(ContextRef cr)
{
bool begun = false;
//this needs a begin signal to set the swap chain to the next backbuffer
if (cr.GL.DispMethodEnum is EDispMethod.SlimDX9)
{
cr.Gc.Begin();
begun = true;
}
if (cr == _activeContext)
{
return;
}
_activeContext = cr;
if (cr.Gc != null)
{
//TODO - this is checking the current context inside to avoid an extra NOP context change. make this optional or remove it, since we're tracking it here
if (!begun)
{
cr.Gc.Begin();
}
}
else
{
if (cr.GL is IGL_TK tk)
{
tk.MakeDefaultCurrent();
}
}
}
public void Activate(ContextRef cr)
{
bool begun = false;
//this needs a begin signal to set the swap chain to the next backbuffer
if (cr.gl is BizHawk.Bizware.BizwareGL.Drivers.SlimDX.IGL_SlimDX9)
{
cr.gc.Begin();
begun = true;
}
if (cr == ActiveContext)
return;
ActiveContext = cr;
if (cr.gc != null)
{
//TODO - this is checking the current context inside to avoid an extra NOP context change. make this optional or remove it, since we're tracking it here
if(!begun)
cr.gc.Begin();
}
else if (cr.gl != null)
{
if(cr.gl is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
((BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)cr.gl).MakeDefaultCurrent();
}
}
public ContextRef CreateGLContext()
{
var ret = new ContextRef
{
gl = new Bizware.BizwareGL.Drivers.OpenTK.IGL_TK()
};
return ret;
}
public _IRunnable_26(_IRunnable_21 _enclosing, FixtureVariable f1, FixtureVariable
f2, ContextRef c2)
{
this._enclosing = _enclosing;
this.f1 = f1;
this.f2 = f2;
this.c2 = c2;
}
public DefaultABI(ContextRef context, TargetDataRef targetData)
{
this.context = context;
this.targetData = targetData;
var intPtrLLVM = LLVM.PointerType(LLVM.Int8TypeInContext(context), 0);
intPtrSize = (int)LLVM.ABISizeOfType(targetData, intPtrLLVM);
}
public _IRunnable_21(_IRunnable_19 _enclosing, FixtureVariable f1, FixtureVariable
f2, ContextRef c1, ContextRef c2)
{
this._enclosing = _enclosing;
this.f1 = f1;
this.f2 = f2;
this.c1 = c1;
this.c2 = c2;
}
public _IRunnable_19(FixtureContextTestCase _enclosing, FixtureVariable f1, FixtureVariable
f2, ContextRef c1, ContextRef c2)
{
this._enclosing = _enclosing;
this.f1 = f1;
this.f2 = f2;
this.c1 = c1;
this.c2 = c2;
}
//[System.Runtime.InteropServices.DllImport("opengl32.dll")]
//bool wglShareLists(IntPtr hglrc1, IntPtr hglrc2);
public ContextRef CreateGLContext(int major_version, int minor_version, bool forward_compatible)
{
var gl = new Bizware.BizwareGL.Drivers.OpenTK.IGL_TK(major_version, minor_version, forward_compatible);
var ret = new ContextRef {
gl = gl
};
return(ret);
}
public ContextRef CreateGLContext(int majorVersion, int minorVersion, bool forwardCompatible)
{
var gl = new IGL_TK(majorVersion, minorVersion, forwardCompatible);
var ret = new ContextRef {
GL = gl
};
return(ret);
}
public DefaultABI(ContextRef context, TargetDataRef targetData)
{
this.context = context;
this.targetData = targetData;
var intPtrLLVM = LLVM.PointerType(LLVM.Int8TypeInContext(context), 0);
intPtrSize = (int)LLVM.ABISizeOfType(targetData, intPtrLLVM);
}
public ContextRef CreateGLContext()
{
var ret = new ContextRef
{
gl = new Bizware.BizwareGL.Drivers.OpenTK.IGL_TK()
};
return(ret);
}
public virtual void Test()
{
var f1 = new FixtureVariable();
var f2 = new FixtureVariable();
var c1 = new ContextRef();
var c2 = new ContextRef();
new FixtureContext().Run(new _IRunnable_19(this, f1, f2, c1, c2));
AssertNoValue(f1);
AssertNoValue(f2);
c1.value.Run(new _IRunnable_41(this, f1, f2));
c2.value.Run(new _IRunnable_48(this, f1, f2));
}
public virtual void Test()
{
var f1 = new FixtureVariable();
var f2 = new FixtureVariable();
var c1 = new ContextRef();
var c2 = new ContextRef();
new FixtureContext().Run(new _IRunnable_19(this, f1, f2, c1, c2));
AssertNoValue(f1);
AssertNoValue(f2);
c1.value.Run(new _IRunnable_41(this, f1, f2));
c2.value.Run(new _IRunnable_48(this, f1, f2));
}
public void PrepareAssembly(AssemblyDefinition assembly)
{
this.assembly = assembly;
RegisterExternalTypes();
// Resolve corlib assembly
corlib = assembly.MainModule.Import(typeof(void)).Resolve().Module.Assembly;
// Prepare LLVM context, module and data layouts
context = LLVM.GetGlobalContext();
module = LLVM.ModuleCreateWithName(assembly.Name.Name);
// Prepare system types, for easier access
InitializeCommonTypes();
// TODO: Choose appropriate triple depending on target
var target = LLVM.GetTarget(runtimeModule);
LLVM.SetTarget(module, target);
// Initialize ABI
abi = new DefaultABI(context, targetData);
// Prepare LLVM builders
builder = LLVM.CreateBuilderInContext(context);
builder2 = LLVM.CreateBuilderInContext(context);
builderAlloca = LLVM.CreateBuilderInContext(context);
InitializeDebug();
if (!TestMode)
{
// Register SharpLangModule objects for each module
metadataPerModule = new Dictionary <Mono.Cecil.ModuleDefinition, ValueRef>();
var mangledModuleName = Regex.Replace(assembly.Name.Name + ".sharplangmodule", @"(\W)", "_");
var sharpLangModuleGlobal = LLVM.AddGlobal(module, sharpLangModuleType.ObjectTypeLLVM, mangledModuleName);
metadataPerModule[assembly.MainModule] = sharpLangModuleGlobal;
// Generate extern globals for SharpLangModule instances of other modules
foreach (var referencedAssembly in referencedAssemblies)
{
mangledModuleName = Regex.Replace(referencedAssembly.Name.Name + ".sharplangmodule", @"(\W)", "_");
var externalSharpLangModuleGlobal = LLVM.AddGlobal(module, sharpLangModuleType.ObjectTypeLLVM, mangledModuleName);
LLVM.SetLinkage(externalSharpLangModuleGlobal, Linkage.ExternalLinkage);
metadataPerModule[referencedAssembly.MainModule] = externalSharpLangModuleGlobal;
}
}
}
public void Activate(ContextRef cr)
{
if (cr == ActiveContext)
return;
ActiveContext = cr;
if (cr.gc != null)
{
//TODO - this is checking the current context inside to avoid an extra NOP context change. make this optional or remove it, since we're tracking it here
cr.gc.Begin();
}
if (cr.gl != null)
{
if(cr.gl is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
((BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)cr.gl).MakeDefaultCurrent();
}
}
public void PrepareAssembly(AssemblyDefinition assembly)
{
this.assembly = assembly;
RegisterExternalTypes();
// Resolve corlib assembly
corlib = assembly.MainModule.Import(typeof (void)).Resolve().Module.Assembly;
// Prepare LLVM context, module and data layouts
context = LLVM.GetGlobalContext();
module = LLVM.ModuleCreateWithName(assembly.Name.Name);
// Prepare system types, for easier access
InitializeCommonTypes();
// TODO: Choose appropriate triple depending on target
LLVM.SetTarget(module, triple);
// Initialize ABI
abi = new DefaultABI(context, targetData);
// Prepare LLVM builders
builder = LLVM.CreateBuilderInContext(context);
builder2 = LLVM.CreateBuilderInContext(context);
builderAlloca = LLVM.CreateBuilderInContext(context);
InitializeDebug();
if (!TestMode)
{
// Register SharpLangModule objects for each module
metadataPerModule = new Dictionary<Mono.Cecil.ModuleDefinition, ValueRef>();
var mangledModuleName = Regex.Replace(assembly.Name.Name + ".sharplangmodule", @"(\W)", "_");
var sharpLangModuleGlobal = LLVM.AddGlobal(module, sharpLangModuleType.ObjectTypeLLVM, mangledModuleName);
metadataPerModule[assembly.MainModule] = sharpLangModuleGlobal;
// Generate extern globals for SharpLangModule instances of other modules
foreach (var referencedAssembly in referencedAssemblies)
{
mangledModuleName = Regex.Replace(referencedAssembly.Name.Name + ".sharplangmodule", @"(\W)", "_");
var externalSharpLangModuleGlobal = LLVM.AddGlobal(module, sharpLangModuleType.ObjectTypeLLVM, mangledModuleName);
LLVM.SetLinkage(externalSharpLangModuleGlobal, Linkage.ExternalLinkage);
metadataPerModule[referencedAssembly.MainModule] = externalSharpLangModuleGlobal;
}
}
}
public void Activate(ContextRef cr)
{
if (cr == ActiveContext)
{
return;
}
ActiveContext = cr;
if (cr.gc != null)
{
//TODO - this is checking the current context inside to avoid an extra NOP context change. make this optional or remove it, since we're tracking it here
cr.gc.Begin();
}
if (cr.gl != null)
{
if (cr.gl is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
{
((BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)cr.gl).MakeDefaultCurrent();
}
}
}
private static ModuleRef LoadModule(ContextRef context, string fileName)
{
MemoryBufferRef memoryBuffer;
string message;
if (LLVM.CreateMemoryBufferWithContentsOfFile(fileName, out memoryBuffer, out message))
{
throw new InvalidOperationException(message);
}
ModuleRef runtimeModule;
if (LLVM.GetBitcodeModuleInContext(context, memoryBuffer, out runtimeModule, out message))
{
throw new InvalidOperationException(message);
}
LLVM.DisposeMemoryBuffer(memoryBuffer);
return(runtimeModule);
}
public unsafe static ValueRef MDStringInContext(ContextRef C, string Str, uint SLen) {
ValueRef ret = new ValueRef(LLVMPINVOKE.MDStringInContext(C.Value, Str, SLen));
return ret;
}
public unsafe static ContextRef ContextCreate() {
ContextRef ret = new ContextRef(LLVMPINVOKE.ContextCreate());
return ret;
}
/// <summary>
/// Compiles an IL assembly to LLVM bytecode.
/// </summary>
/// <param name="moduleName">The module name.</param>
public void Compile(string moduleName)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
// Create LLVM module and its context.
LLVM.EnablePrettyStackTrace();
mModule = LLVM.ModuleCreateWithName(moduleName);
mContext = LLVM.GetModuleContext(mModule);
// Targets.
LLVM.InitializeAllTargetInfos();
LLVM.InitializeAllTargets();
LLVM.InitializeAllTargetMCs();
LLVM.InitializeAllAsmParsers();
LLVM.InitializeAllAsmPrinters();
string triplet = (Options.Target == "default") ? LLVM.GetDefaultTargetTriple() : Options.Target;
MyString error = new MyString();
LLVM.SetTarget(mModule, triplet);
TargetRef target;
if (LLVM.GetTargetFromTriple(triplet, out target, error))
{
throw new InvalidOperationException(error.ToString());
}
// Optimizer.
mFunctionPassManager = LLVM.CreateFunctionPassManagerForModule(mModule);
mPassManager = LLVM.CreatePassManager();
LLVM.InitializeFunctionPassManager(mFunctionPassManager);
#if !DEBUG
// O0
if (Options.Optimization >= OptimizationLevel.O0)
{
// Function passes.
LLVM.AddPromoteMemoryToRegisterPass(mFunctionPassManager);
LLVM.AddConstantPropagationPass(mFunctionPassManager);
LLVM.AddReassociatePass(mFunctionPassManager);
LLVM.AddInstructionCombiningPass(mFunctionPassManager);
// Module passes.
LLVM.AddAlwaysInlinerPass(mPassManager);
LLVM.AddStripDeadPrototypesPass(mPassManager);
LLVM.AddStripSymbolsPass(mPassManager);
}
// O1
if (Options.Optimization >= OptimizationLevel.O1)
{
// Function passes.
LLVM.AddLowerExpectIntrinsicPass(mFunctionPassManager);
LLVM.AddEarlyCSEPass(mFunctionPassManager);
LLVM.AddLoopRotatePass(mFunctionPassManager);
LLVM.AddLoopUnswitchPass(mFunctionPassManager);
LLVM.AddLoopUnrollPass(mFunctionPassManager);
LLVM.AddLoopDeletionPass(mFunctionPassManager);
LLVM.AddTailCallEliminationPass(mFunctionPassManager);
LLVM.AddGVNPass(mFunctionPassManager);
LLVM.AddDeadStoreEliminationPass(mFunctionPassManager);
LLVM.AddJumpThreadingPass(mFunctionPassManager);
LLVM.AddCFGSimplificationPass(mFunctionPassManager);
LLVM.AddMemCpyOptPass(mFunctionPassManager);
// Module passes.
LLVM.AddDeadArgEliminationPass(mPassManager);
LLVM.AddAggressiveDCEPass(mFunctionPassManager);
}
// O2
if (Options.Optimization >= OptimizationLevel.O2)
{
// Function passes.
LLVM.AddLoopVectorizePass(mFunctionPassManager);
LLVM.AddSLPVectorizePass(mFunctionPassManager);
// Module passes.
LLVM.AddFunctionInliningPass(mPassManager);
LLVM.AddConstantMergePass(mPassManager);
LLVM.AddArgumentPromotionPass(mPassManager);
}
#endif
// Initialize types and runtime.
string dataLayout = LLVM.GetDataLayout(Module);
TargetData = LLVM.CreateTargetData(dataLayout);
TypeHelper.Init(TargetData, this);
RuntimeHelper.ImportFunctions(Module);
mBuiltinCompiler.Compile();
compileModules();
LLVM.RunPassManager(mPassManager, Module);
// Log time.
stopWatch.Stop();
Logger.LogDetail("Compilation time: " + stopWatch.Elapsed);
// Debug: print LLVM assembly code.
#if DEBUG
Console.WriteLine(LLVM.PrintModuleToString(mModule));
#endif
// Verify and throw exception on error.
Console.ForegroundColor = ConsoleColor.DarkGray;
if (LLVM.VerifyModule(mModule, VerifierFailureAction.ReturnStatusAction, error))
{
Logger.LogError("Compilation of module failed.");
Logger.LogInfo(error.ToString());
LLVM.DisposeTargetData(TargetData);
return;
}
else
{
Logger.LogDetail("Compilation of module succeeded.");
}
// Output assembly or object file.
if (!Options.OutputLLVMIR && !Options.OutputLLVMBitCode)
{
TargetMachineRef machine = LLVM.CreateTargetMachine(target, triplet, "generic", "", CodeGenOptLevel.CodeGenLevelDefault, RelocMode.RelocDefault, CodeModel.CodeModelDefault);
LLVM.SetModuleDataLayout(mModule, LLVM.CreateTargetDataLayout(machine));
CodeGenFileType type = (Options.OutputAssembly) ? CodeGenFileType.AssemblyFile : CodeGenFileType.ObjectFile;
if (LLVM.TargetMachineEmitToFile(machine, mModule, Options.OutputFile, type, error))
{
throw new InvalidOperationException(error.ToString());
}
}
// Output LLVM IR code to a file.
else if (Options.OutputLLVMIR)
{
if (LLVM.PrintModuleToFile(mModule, Options.OutputFile, error))
{
Logger.LogError("Writing the LLVM code to a file failed.");
Logger.LogInfo(error.ToString());
}
}
// Output LLVM bitcode.
else if (Options.OutputLLVMBitCode)
{
if (LLVM.WriteBitcodeToFile(mModule, Options.OutputFile) != 0)
{
Logger.LogError("Writing the LLVM code to a file failed.");
Logger.LogInfo(error.ToString());
}
}
// Cleanup.
LLVM.DisposeTargetData(TargetData);
}
public void ReleaseGLContext(object o)
{
ContextRef cr = (ContextRef)o;
cr.gl.Dispose();
}
public unsafe static ModuleRef ModuleCreateWithNameInContext(string ModuleID, ContextRef C) {
ModuleRef ret = new ModuleRef(LLVMPINVOKE.ModuleCreateWithNameInContext(ModuleID, C.Value));
return ret;
}
public void TestPTX()
{
LLVM.InitializeAllTargets();
LLVM.InitializeAllTargetMCs();
LLVM.InitializeAllTargetInfos();
LLVM.InitializeAllAsmPrinters();
ModuleRef mod = LLVM.ModuleCreateWithName("llvmptx");
var pt = LLVM.PointerType(LLVM.Int64Type(), 1);
TypeRef[] param_types = { pt };
TypeRef ret_type = LLVM.FunctionType(LLVM.VoidType(), param_types, false);
ValueRef sum = LLVM.AddFunction(mod, "sum", ret_type);
BasicBlockRef entry = LLVM.AppendBasicBlock(sum, "entry");
BuilderRef builder = LLVM.CreateBuilder();
LLVM.PositionBuilderAtEnd(builder, entry);
var v = LLVM.BuildLoad(builder, LLVM.GetParam(sum, 0), "");
ValueRef tmp = LLVM.BuildAdd(builder, v, LLVM.ConstInt(LLVM.Int64Type(), 1, false), "tmp");
LLVM.BuildStore(builder, tmp, LLVM.GetParam(sum, 0));
LLVM.BuildRetVoid(builder);
MyString the_error = new MyString();
LLVM.VerifyModule(mod, VerifierFailureAction.PrintMessageAction, the_error);
string triple = "nvptx64-nvidia-cuda";
TargetRef t2;
var b = LLVM.GetTargetFromTriple(triple, out t2, the_error);
string cpu = "";
string features = "";
TargetMachineRef tmr = LLVM.CreateTargetMachine(t2, triple, cpu, features,
CodeGenOptLevel.CodeGenLevelDefault,
RelocMode.RelocDefault,
CodeModel.CodeModelKernel);
ContextRef context_ref = LLVM.ContextCreate();
ValueRef kernelMd = LLVM.MDNodeInContext(context_ref, new ValueRef[3]
{
sum,
LLVM.MDStringInContext(context_ref, "kernel", 6),
LLVM.ConstInt(LLVM.Int32TypeInContext(context_ref), 1, false)
});
LLVM.AddNamedMetadataOperand(mod, "nvvm.annotations", kernelMd);
var y1 = LLVM.TargetMachineEmitToMemoryBuffer(
tmr,
mod,
Swigged.LLVM.CodeGenFileType.AssemblyFile,
the_error,
out MemoryBufferRef buffer);
string ptx = null;
try
{
ptx = LLVM.GetBufferStart(buffer);
uint length = LLVM.GetBufferSize(buffer);
// Output the PTX assembly code. We can run this using the CUDA Driver API
System.Console.WriteLine(ptx);
}
finally
{
LLVM.DisposeMemoryBuffer(buffer);
}
// RUN THE MF.
Int64[] h_C = new Int64[100];
CudaContext ctx = new CudaContext(CudaContext.GetMaxGflopsDeviceId());
CudaKernel kernel = ctx.LoadKernelPTX(Encoding.ASCII.GetBytes(ptx), "sum");
var d_C = new CudaDeviceVariable <Int64>(100);
int N = 1;
int threadsPerBlock = 256;
kernel.BlockDimensions = threadsPerBlock;
kernel.GridDimensions = (N + threadsPerBlock - 1) / threadsPerBlock;
kernel.Run(d_C.DevicePointer);
h_C = d_C;
System.Console.WriteLine("Result " + h_C[0]);
if (h_C[0] != 1)
{
throw new Exception("Failed.");
}
LLVM.DumpModule(mod);
LLVM.DisposeBuilder(builder);
}
public unsafe static TypeRef IntTypeInContext(ContextRef C, uint NumBits) {
TypeRef ret = new TypeRef(LLVMPINVOKE.IntTypeInContext(C.Value, NumBits));
return ret;
}
public unsafe static void ContextDispose(ContextRef C) {
LLVMPINVOKE.ContextDispose(C.Value);
}
public static TypeRef getIntNTy(ContextRef C, uint AS)
{
return(LLVM.IntTypeInContext(C, AS));
}
public unsafe static ValueRef ConstStructInContext(ContextRef C, ValueRef[] ConstantVals, bool Packed) {
fixed (ValueRef* swig_ptrTo_ConstantVals = ConstantVals)
{
ValueRef ret = new ValueRef(LLVMPINVOKE.ConstStructInContext(C.Value, (System.IntPtr)swig_ptrTo_ConstantVals, (uint)ConstantVals.Length, Packed));
return ret;
}
}
public unsafe static BasicBlockRef InsertBasicBlockInContext(ContextRef C, BasicBlockRef BB, string Name) {
BasicBlockRef ret = new BasicBlockRef(LLVMPINVOKE.InsertBasicBlockInContext(C.Value, BB.Value, Name));
return ret;
}
public unsafe static BasicBlockRef AppendBasicBlockInContext(ContextRef C, ValueRef Fn, string Name) {
BasicBlockRef ret = new BasicBlockRef(LLVMPINVOKE.AppendBasicBlockInContext(C.Value, Fn.Value, Name));
return ret;
}
public unsafe static ValueRef MDNodeInContext(ContextRef C, ValueRef[] Vals) {
fixed (ValueRef* swig_ptrTo_Vals = Vals)
{
ValueRef ret = new ValueRef(LLVMPINVOKE.MDNodeInContext(C.Value, (System.IntPtr)swig_ptrTo_Vals, (uint)Vals.Length));
return ret;
}
}
public unsafe static ContextRef GetGlobalContext() {
ContextRef ret = new ContextRef(LLVMPINVOKE.GetGlobalContext());
return ret;
}
public void Invalidate()
{
ActiveContext = null;
}
public unsafe static TypeRef X86MMXTypeInContext(ContextRef C) {
TypeRef ret = new TypeRef(LLVMPINVOKE.X86MMXTypeInContext(C.Value));
return ret;
}
public ModuleRef CompileAssembly(AssemblyDefinition assembly)
{
this.assembly = assembly;
corlib = assembly.MainModule.Import(typeof(void)).Resolve().Module.Assembly;
module = LLVM.ModuleCreateWithName(assembly.Name.Name);
allocObjectFunction = RuntimeInline.Runtime.define_allocObject(module);
context = LLVM.GetModuleContext(module);
builder = LLVM.CreateBuilderInContext(context);
intPtrType = LLVM.PointerType(LLVM.Int8TypeInContext(context), 0);
int32Type = LLVM.Int32TypeInContext(context);
int64Type = LLVM.Int64TypeInContext(context);
intPtrSize = 4; // Or 8?
nativeIntType = int32Type; // Or int64Type?
builderPhi = LLVM.CreateBuilderInContext(context);
intPtr = GetType(corlib.MainModule.GetType(typeof(IntPtr).FullName));
int32 = GetType(corlib.MainModule.GetType(typeof(int).FullName));
int64 = GetType(corlib.MainModule.GetType(typeof(long).FullName));
// struct IMTSlot { i8* functionPtr, i32 functionId, IMTEntry* nextEntry }
imtEntryType = LLVM.StructCreateNamed(context, "IMTEntry");
LLVM.StructSetBody(imtEntryType, new[] { intPtrType, int32Type, LLVM.PointerType(imtEntryType, 0) }, false);
// Process types
foreach (var assemblyModule in assembly.Modules)
{
var typeReferences = assemblyModule.GetTypeReferences();
foreach (var type in typeReferences)
{
CreateType(type);
}
var memberReferences = assemblyModule.GetMemberReferences();
foreach (var member in memberReferences)
{
var method = member as MethodReference;
if (member.DeclaringType.ContainsGenericParameter())
{
continue;
}
CreateType(member.DeclaringType);
if (method != null)
{
if (!method.HasGenericParameters)
{
CreateFunction(method);
}
}
}
foreach (var type in assemblyModule.Types)
{
if (!type.HasGenericParameters && type.FullName != typeof(void).FullName)
{
GetClass(type);
}
foreach (var nestedType in type.NestedTypes)
{
if (!nestedType.HasGenericParameters)
{
GetClass(nestedType);
}
}
}
}
// Process methods
foreach (var @class in classes)
{
CompileClassMethods(@class.Value);
}
// Generate code
while (methodsToCompile.Count > 0)
{
var methodToCompile = methodsToCompile.Dequeue();
CompileFunction(methodToCompile.Key, methodToCompile.Value);
}
// Emit "main" which will call the assembly entry point (if any)
Function entryPoint;
if (assembly.EntryPoint != null && functions.TryGetValue(assembly.EntryPoint, out entryPoint))
{
var mainFunctionType = LLVM.FunctionType(int32Type, new TypeRef[0], false);
var mainFunction = LLVM.AddFunction(module, "main", mainFunctionType);
LLVM.SetLinkage(mainFunction, Linkage.ExternalLinkage);
LLVM.PositionBuilderAtEnd(builder, LLVM.AppendBasicBlockInContext(context, mainFunction, string.Empty));
var parameters = (entryPoint.ParameterTypes.Length > 0)
? new[] { LLVM.ConstPointerNull(entryPoint.ParameterTypes[0].DefaultType) }
: new ValueRef[0];
LLVM.BuildCall(builder, entryPoint.GeneratedValue, parameters, string.Empty);
LLVM.BuildRet(builder, LLVM.ConstInt(int32Type, 0, false));
}
LLVM.DisposeBuilder(builder);
// Verify module
#if VERIFY_LLVM
string message;
if (LLVM.VerifyModule(module, VerifierFailureAction.PrintMessageAction, out message))
{
throw new InvalidOperationException(message);
}
#endif
return(module);
}
public unsafe static uint GetMDKindIDInContext(ContextRef C, string Name, uint SLen) {
uint ret = LLVMPINVOKE.GetMDKindIDInContext(C.Value, Name, SLen);
return ret;
}
public unsafe static TypeRef PPCFP128TypeInContext(ContextRef C) {
TypeRef ret = new TypeRef(LLVMPINVOKE.PPCFP128TypeInContext(C.Value));
return ret;
}
public unsafe static ValueRef ConstStringInContext(ContextRef C, string Str, uint Length, bool DontNullTerminate) {
ValueRef ret = new ValueRef(LLVMPINVOKE.ConstStringInContext(C.Value, Str, Length, DontNullTerminate));
return ret;
}
public unsafe static TypeRef IntPtrTypeForASInContext(ContextRef C, TargetDataRef TD, uint AS) {
TypeRef ret = new TypeRef(LLVMPINVOKE.IntPtrTypeForASInContext(C.Value, TD.Value, AS));
return ret;
}
public void RegisterMainAssembly(AssemblyDefinition assembly)
{
this.assembly = assembly;
corlib = assembly.MainModule.Import(typeof(void)).Resolve().Module.Assembly;
context = LLVM.GetGlobalContext();
module = LLVM.ModuleCreateWithName(assembly.Name.Name);
MemoryBufferRef memoryBuffer;
string message;
if (LLVM.CreateMemoryBufferWithContentsOfFile(@"..\..\..\..\src\SharpLang.Runtime\Runtime.bc", out memoryBuffer, out message))
{
throw new InvalidOperationException(message);
}
if (LLVM.GetBitcodeModuleInContext(context, memoryBuffer, out runtimeModule, out message))
{
throw new InvalidOperationException(message);
}
LLVM.DisposeMemoryBuffer(memoryBuffer);
// TODO: Choose appropriate triple depending on target
LLVM.SetTarget(module, "i686-pc-mingw32");
var dataLayout = LLVM.GetDataLayout(runtimeModule);
targetData = LLVM.CreateTargetData(dataLayout);
allocObjectFunction = ImportRuntimeFunction(module, "allocObject");
resolveInterfaceCallFunction = ImportRuntimeFunction(module, "resolveInterfaceCall");
isInstInterfaceFunction = ImportRuntimeFunction(module, "isInstInterface");
throwExceptionFunction = ImportRuntimeFunction(module, "throwException");
sharpPersonalityFunction = ImportRuntimeFunction(module, "sharpPersonality");
pinvokeLoadLibraryFunction = ImportRuntimeFunction(module, "PInvokeOpenLibrary");
pinvokeGetProcAddressFunction = ImportRuntimeFunction(module, "PInvokeGetProcAddress");
builder = LLVM.CreateBuilderInContext(context);
intPtrType = LLVM.PointerType(LLVM.Int8TypeInContext(context), 0);
int32Type = LLVM.Int32TypeInContext(context);
int64Type = LLVM.Int64TypeInContext(context);
intPtrSize = 4; // Or 8?
nativeIntType = int32Type; // Or int64Type?
builder2 = LLVM.CreateBuilderInContext(context);
debugBuilder = LLVM.DIBuilderCreate(module);
intPtr = GetType(corlib.MainModule.GetType(typeof(IntPtr).FullName));
int8 = GetType(corlib.MainModule.GetType(typeof(sbyte).FullName));
int16 = GetType(corlib.MainModule.GetType(typeof(short).FullName));
int32 = GetType(corlib.MainModule.GetType(typeof(int).FullName));
int64 = GetType(corlib.MainModule.GetType(typeof(long).FullName));
uint8 = GetType(corlib.MainModule.GetType(typeof(byte).FullName));
uint16 = GetType(corlib.MainModule.GetType(typeof(ushort).FullName));
uint32 = GetType(corlib.MainModule.GetType(typeof(uint).FullName));
uint64 = GetType(corlib.MainModule.GetType(typeof(ulong).FullName));
@bool = GetType(corlib.MainModule.GetType(typeof(bool).FullName));
@float = GetType(corlib.MainModule.GetType(typeof(float).FullName));
@double = GetType(corlib.MainModule.GetType(typeof(double).FullName));
@object = GetType(corlib.MainModule.GetType(typeof(object).FullName));
// struct IMTEntry { i32 functionId, i8* functionPtr }
imtEntryType = LLVM.StructCreateNamed(context, "IMTEntry");
LLVM.StructSetBody(imtEntryType, new[] { int32Type, intPtrType }, false);
caughtResultType = LLVM.StructCreateNamed(context, "CaughtResultType");
LLVM.StructSetBody(caughtResultType, new[] { intPtrType, int32Type }, false);
RegisterAssembly(assembly);
}
public unsafe static TypeRef StructTypeInContext(ContextRef C, TypeRef[] ElementTypes, bool Packed) {
fixed (TypeRef* swig_ptrTo_ElementTypes = ElementTypes)
{
TypeRef ret = new TypeRef(LLVMPINVOKE.StructTypeInContext(C.Value, (System.IntPtr)swig_ptrTo_ElementTypes, (uint)ElementTypes.Length, Packed));
return ret;
}
}
public void Invalidate()
{
ActiveContext = null;
}
public unsafe static TypeRef StructCreateNamed(ContextRef C, string Name) {
TypeRef ret = new TypeRef(LLVMPINVOKE.StructCreateNamed(C.Value, Name));
return ret;
}
public unsafe static bool ParseBitcodeInContext(ContextRef ContextRef, MemoryBufferRef MemBuf, out ModuleRef OutModule, out string OutMessage) {
bool ret = LLVMPINVOKE.ParseBitcodeInContext(ContextRef.Value, MemBuf.Value, out OutModule.Value, out OutMessage);
return ret;
}
public unsafe static ContextRef GetModuleContext(ModuleRef M) {
ContextRef ret = new ContextRef(LLVMPINVOKE.GetModuleContext(M.Value));
return ret;
}
public unsafe static ContextRef GetTypeContext(TypeRef Ty) {
ContextRef ret = new ContextRef(LLVMPINVOKE.GetTypeContext(Ty.Value));
return ret;
}
public unsafe static bool GetBitcodeModuleProviderInContext(ContextRef ContextRef, MemoryBufferRef MemBuf, out ModuleProviderRef OutMP, out string OutMessage) {
bool ret = LLVMPINVOKE.GetBitcodeModuleProviderInContext(ContextRef.Value, MemBuf.Value, out OutMP.Value, out OutMessage);
return ret;
}
public static TypeRef getVoidTy(ContextRef C)
{
return(LLVM.VoidTypeInContext(C));
}
public unsafe static BuilderRef CreateBuilderInContext(ContextRef C) {
BuilderRef ret = new BuilderRef(LLVMPINVOKE.CreateBuilderInContext(C.Value));
return ret;
}
