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);
// TODO: Choose appropriate triple depending on target
LLVM.SetTarget(module, "i686-pc-mingw32");
// Prepare system types, for easier access
InitializeCommonTypes();
// Prepare LLVM builders
builder = LLVM.CreateBuilderInContext(context);
builder2 = LLVM.CreateBuilderInContext(context);
debugBuilder = LLVM.DIBuilderCreate(module);
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 unsafe static DIDescriptor DIBuilderCreateTemplateTypeParameter(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor Ty, DIDescriptor File, uint LineNo, uint ColumnNo) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateTemplateTypeParameter(Builder.Value, Scope.Value, Name, Ty.Value, File.Value, LineNo, ColumnNo));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateEnumerationType(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNumber, ulong SizeInBits, ulong AlignInBits, DIDescriptor Elements, DIDescriptor ClassType) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateEnumerationType(Builder.Value, Scope.Value, Name, File.Value, LineNumber, SizeInBits, AlignInBits, Elements.Value, ClassType.Value));
return ret;
}
public unsafe static ValueRef DIBuilderInsertDeclareBefore(DIBuilderRef Builder, ValueRef Val, DIDescriptor VarInfo, DIDescriptor Expr, ValueRef InsertBefore) {
ValueRef ret = new ValueRef(LLVMPINVOKE.DIBuilderInsertDeclareBefore(Builder.Value, Val.Value, VarInfo.Value, Expr.Value, InsertBefore.Value));
return ret;
}
public unsafe static DIDescriptor DIBuilderGetOrCreateArray(DIBuilderRef Builder, DIDescriptor[] Ptr) {
fixed (DIDescriptor* swig_ptrTo_Ptr = Ptr)
{
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderGetOrCreateArray(Builder.Value, (System.IntPtr)swig_ptrTo_Ptr, (uint)Ptr.Length));
return ret;
}
}
public unsafe static DIDescriptor DIBuilderCreateVectorType(DIBuilderRef Builder, ulong Size, ulong AlignInBits, DIDescriptor Ty, DIDescriptor Subscripts) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateVectorType(Builder.Value, Size, AlignInBits, Ty.Value, Subscripts.Value));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateGlobalVariable(DIBuilderRef Builder, DIDescriptor Context, string Name, string LinkageName, DIDescriptor File, uint LineNo, DIDescriptor Ty, bool isLocalToUnit, ValueRef Val, DIDescriptor Decl) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateGlobalVariable(Builder.Value, Context.Value, Name, LinkageName, File.Value, LineNo, Ty.Value, isLocalToUnit, Val.Value, Decl.Value));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateLexicalBlock(DIBuilderRef Builder, DIDescriptor Scope, DIDescriptor File, uint Line, uint Col, uint Discriminator) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateLexicalBlock(Builder.Value, Scope.Value, File.Value, Line, Col, Discriminator));
return ret;
}
public unsafe static void DIBuilderFinalize(DIBuilderRef Builder) {
LLVMPINVOKE.DIBuilderFinalize(Builder.Value);
}
public unsafe static void DIBuilderDispose(DIBuilderRef Builder) {
LLVMPINVOKE.DIBuilderDispose(Builder.Value);
}
public unsafe static DIBuilderRef DIBuilderCreate(ModuleRef M) {
DIBuilderRef ret = new DIBuilderRef(LLVMPINVOKE.DIBuilderCreate(M.Value));
return ret;
}
public unsafe static ValueRef DIBuilderCreateNameSpace(DIBuilderRef Builder, ValueRef Scope, string Name, ValueRef File, uint LineNo) {
ValueRef ret = new ValueRef(LLVMPINVOKE.DIBuilderCreateNameSpace(Builder.Value, Scope.Value, Name, File.Value, LineNo));
return ret;
}
public unsafe static ValueRef DIBuilderCreateComplexVariable(DIBuilderRef Builder, uint Tag, ValueRef Scope, string Name, ValueRef File, uint LineNo, ValueRef Ty, ValueRef[] AddrOps, uint ArgNo) {
fixed (ValueRef* swig_ptrTo_AddrOps = AddrOps)
{
ValueRef ret = new ValueRef(LLVMPINVOKE.DIBuilderCreateComplexVariable(Builder.Value, Tag, Scope.Value, Name, File.Value, LineNo, Ty.Value, (System.IntPtr)swig_ptrTo_AddrOps, (uint)AddrOps.Length, ArgNo));
return ret;
}
}
public unsafe static ValueRef DIBuilderCreateTemplateTypeParameter(DIBuilderRef Builder, ValueRef Scope, string Name, ValueRef Ty, ValueRef File, uint LineNo, uint ColumnNo) {
ValueRef ret = new ValueRef(LLVMPINVOKE.DIBuilderCreateTemplateTypeParameter(Builder.Value, Scope.Value, Name, Ty.Value, File.Value, LineNo, ColumnNo));
return ret;
}
public unsafe static void DICompositeTypeSetTypeArray(DIBuilderRef Builder, out DIDescriptor CompositeType, DIDescriptor TypeArray) {
LLVMPINVOKE.DICompositeTypeSetTypeArray(Builder.Value, out CompositeType.Value, TypeArray.Value);
}
private void InitializeDebug()
{
debugBuilder = LLVM.DIBuilderCreate(module);
debugEmptyExpression = LLVM.DIBuilderCreateExpression(debugBuilder, new long[0]);
}
public unsafe static void DIBuilderCreateCompileUnit(DIBuilderRef Builder, uint Lang, string File, string Dir, string Producer, bool isOptimized, string Flags, uint RuntimeVer, string SplitName) {
LLVMPINVOKE.DIBuilderCreateCompileUnit(Builder.Value, Lang, File, Dir, Producer, isOptimized, Flags, RuntimeVer, SplitName);
}
public unsafe static DIDescriptor DIBuilderCreateExpression(DIBuilderRef Builder, long[] Addresses) {
fixed (long* swig_ptrTo_Addresses = Addresses)
{
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateExpression(Builder.Value, (System.IntPtr)swig_ptrTo_Addresses, (uint)Addresses.Length));
return ret;
}
}
public unsafe static DIDescriptor DIBuilderCreateFile(DIBuilderRef Builder, string Filename, string Directory) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateFile(Builder.Value, Filename, Directory));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateLocalVariable(DIBuilderRef Builder, uint Tag, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNo, DIDescriptor Ty, bool AlwaysPreserve, uint Flags, uint ArgNo) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateLocalVariable(Builder.Value, Tag, Scope.Value, Name, File.Value, LineNo, Ty.Value, AlwaysPreserve, Flags, ArgNo));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateSubroutineType(DIBuilderRef Builder, DIDescriptor File, DIDescriptor ParameterTypes) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateSubroutineType(Builder.Value, File.Value, ParameterTypes.Value));
return ret;
}
public unsafe static DIDescriptor DIBuilderGetOrCreateSubrange(DIBuilderRef Builder, long Lo, long Count) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderGetOrCreateSubrange(Builder.Value, Lo, Count));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateFunction(DIBuilderRef Builder, DIDescriptor Scope, string Name, string LinkageName, DIDescriptor File, uint LineNo, DIDescriptor Ty, bool isLocalToUnit, bool isDefinition, uint ScopeLine, uint Flags, bool isOptimized, ValueRef Fn, DIDescriptor TParam, DIDescriptor Decl) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateFunction(Builder.Value, Scope.Value, Name, LinkageName, File.Value, LineNo, Ty.Value, isLocalToUnit, isDefinition, ScopeLine, Flags, isOptimized, Fn.Value, TParam.Value, Decl.Value));
return ret;
}
public unsafe static ValueRef DIBuilderInsertDeclareAtEnd(DIBuilderRef Builder, ValueRef Val, DIDescriptor VarInfo, DIDescriptor Expr, BasicBlockRef InsertAtEnd) {
ValueRef ret = new ValueRef(LLVMPINVOKE.DIBuilderInsertDeclareAtEnd(Builder.Value, Val.Value, VarInfo.Value, Expr.Value, InsertAtEnd.Value));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateBasicType(DIBuilderRef Builder, string Name, ulong SizeInBits, ulong AlignInBits, uint Encoding) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateBasicType(Builder.Value, Name, SizeInBits, AlignInBits, Encoding));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateEnumerator(DIBuilderRef Builder, string Name, ulong Val) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateEnumerator(Builder.Value, Name, Val));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreatePointerType(DIBuilderRef Builder, DIDescriptor PointeeTy, ulong SizeInBits, ulong AlignInBits, string Name) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreatePointerType(Builder.Value, PointeeTy.Value, SizeInBits, AlignInBits, Name));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateUnionType(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNumber, ulong SizeInBits, ulong AlignInBits, uint Flags, DIDescriptor Elements, uint RunTimeLang, string UniqueId) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateUnionType(Builder.Value, Scope.Value, Name, File.Value, LineNumber, SizeInBits, AlignInBits, Flags, Elements.Value, RunTimeLang, UniqueId));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateForwardDecl(DIBuilderRef Builder, uint Tag, string Name, DIDescriptor Scope, DIDescriptor File, uint Line, uint RuntimeLang, ulong SizeInBits, ulong AlignInBits, string UniqueId) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateForwardDecl(Builder.Value, Tag, Name, Scope.Value, File.Value, Line, RuntimeLang, SizeInBits, AlignInBits, UniqueId));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateNameSpace(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNo) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateNameSpace(Builder.Value, Scope.Value, Name, File.Value, LineNo));
return ret;
}
public unsafe static DIDescriptor DIBuilderCreateClassType(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNumber, ulong SizeInBits, ulong AlignInBits, ulong OffsetInBits, uint Flags, DIDescriptor DerivedFrom, DIDescriptor Elements, DIDescriptor VTableHolder, DIDescriptor TemplateParms, string UniqueId) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateClassType(Builder.Value, Scope.Value, Name, File.Value, LineNumber, SizeInBits, AlignInBits, OffsetInBits, Flags, DerivedFrom.Value, Elements.Value, VTableHolder.Value, TemplateParms.Value, UniqueId));
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 DIDescriptor DIBuilderCreateMemberType(DIBuilderRef Builder, DIDescriptor Scope, string Name, DIDescriptor File, uint LineNo, ulong SizeInBits, ulong AlignInBits, ulong OffsetInBits, uint Flags, DIDescriptor Ty) {
DIDescriptor ret = new DIDescriptor(LLVMPINVOKE.DIBuilderCreateMemberType(Builder.Value, Scope.Value, Name, File.Value, LineNo, SizeInBits, AlignInBits, OffsetInBits, Flags, Ty.Value));
return ret;
}
