public void DoneObjectNode()
{
EmitAlignment(_nodeFactory.Target.PointerSize);
Debug.Assert(_nodeFactory.Target.PointerSize == 4);
int countOfPointerSizedElements = _currentObjectData.Count / _nodeFactory.Target.PointerSize;
ISymbolNode symNode = _currentObjectNode as ISymbolNode;
if (symNode == null)
{
symNode = ((IHasStartSymbol)_currentObjectNode).StartSymbol;
}
string realName = GetBaseSymbolName(symNode, _nodeFactory.NameMangler, true);
var intPtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
var arrayglobal = Module.AddGlobalInAddressSpace(LLVMTypeRef.CreateArray(intPtrType, (uint)countOfPointerSizedElements), realName, 0);
arrayglobal.Linkage = LLVMLinkage.LLVMExternalLinkage;
_dataToFill.Add(new ObjectNodeDataEmission(arrayglobal, _currentObjectData.ToArray(), _currentObjectSymbolRefs));
foreach (var symbolIdInfo in _symbolDefs)
{
EmitSymbolDef(arrayglobal, symbolIdInfo.Key, symbolIdInfo.Value);
}
_currentObjectNode = null;
_currentObjectSymbolRefs = new Dictionary <int, SymbolRefData>();
_currentObjectData = new ArrayBuilder <byte>();
_symbolDefs.Clear();
}
public void OutputCodeForDelegateCtorInit(LLVMBuilderRef builder, LLVMValueRef helperFunc,
MethodDesc constructor,
LLVMValueRef fatFunction)
{
StackEntry[] argValues = new StackEntry [constructor.Signature.Length + 1]; // for delegate this
var shadowStack = helperFunc.GetParam(0);
argValues[0] = new LoadExpressionEntry(StackValueKind.ObjRef, "this", shadowStack, GetWellKnownType(WellKnownType.Object));
for (var i = 0; i < constructor.Signature.Length; i++)
{
if (i == 1)
{
argValues[i + 1] = new ExpressionEntry(StackValueKind.Int32, "arg" + (i + 1),
builder.BuildIntToPtr(fatFunction, LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), "toPtr"),
GetWellKnownType(WellKnownType.IntPtr));
}
else
{
var argRef = LoadVarAddress(i + 1, LocalVarKind.Argument, out TypeDesc type);
var ptrPtr = builder.BuildPointerCast(argRef,
LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), 0), "ptrPtr");
var loadArg = builder.BuildLoad(ptrPtr, "arg" + (i + 1));
argValues[i + 1] = new ExpressionEntry(GetStackValueKind(constructor.Signature[i]), "arg" + i + 1, loadArg,
constructor.Signature[i]);
}
}
HandleCall(constructor, constructor.Signature, constructor, argValues, null);
}
private LLVMValueRef OutputCodeForDictionaryLookup(LLVMBuilderRef builder, NodeFactory factory,
ReadyToRunGenericHelperNode node, GenericLookupResult lookup, LLVMValueRef ctx, string gepName)
{
// Find the generic dictionary slot
int dictionarySlot = factory.GenericDictionaryLayout(node.DictionaryOwner).GetSlotForEntry(lookup);
int offset = dictionarySlot * factory.Target.PointerSize;
// Load the generic dictionary cell
LLVMValueRef retGep = builder.BuildGEP(ctx, new[] { LLVMValueRef.CreateConstInt(LLVMTypeRef.Int32, (ulong)offset, false) }, "retGep");
LLVMValueRef castGep = builder.BuildBitCast(retGep, LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), 0), "ptrPtr");
LLVMValueRef retRef = builder.BuildLoad(castGep, gepName);
switch (lookup.LookupResultReferenceType(factory))
{
case GenericLookupResultReferenceType.Indirect:
var ptrPtr = builder.BuildBitCast(retRef, LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), 0), "ptrPtr");
retRef = builder.BuildLoad(ptrPtr, "indLoad");
break;
case GenericLookupResultReferenceType.ConditionalIndirect:
throw new NotImplementedException();
default:
break;
}
return(retRef);
}
private void EmitNativeMain(LLVMContextRef context)
{
LLVMValueRef shadowStackTop = Module.GetNamedGlobal("t_pShadowStackTop");
LLVMBuilderRef builder = context.CreateBuilder();
var mainSignature = LLVMTypeRef.CreateFunction(LLVMTypeRef.Int32, new LLVMTypeRef[] { LLVMTypeRef.Int32, LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0) }, false);
var mainFunc = Module.AddFunction("__managed__Main", mainSignature);
var mainEntryBlock = mainFunc.AppendBasicBlock("entry");
builder.PositionAtEnd(mainEntryBlock);
LLVMValueRef managedMain = Module.GetNamedFunction("StartupCodeMain");
if (managedMain.Handle == IntPtr.Zero)
{
throw new Exception("Main not found");
}
LLVMTypeRef reversePInvokeFrameType = LLVMTypeRef.CreateStruct(new LLVMTypeRef[] { LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0) }, false);
LLVMValueRef reversePinvokeFrame = builder.BuildAlloca(reversePInvokeFrameType, "ReversePInvokeFrame");
LLVMValueRef RhpReversePInvoke2 = Module.GetNamedFunction("RhpReversePInvoke2");
if (RhpReversePInvoke2.Handle == IntPtr.Zero)
{
RhpReversePInvoke2 = Module.AddFunction("RhpReversePInvoke2", LLVMTypeRef.CreateFunction(LLVMTypeRef.Void, new LLVMTypeRef[] { LLVMTypeRef.CreatePointer(reversePInvokeFrameType, 0) }, false));
}
builder.BuildCall(RhpReversePInvoke2, new LLVMValueRef[] { reversePinvokeFrame }, "");
var shadowStack = builder.BuildMalloc(LLVMTypeRef.CreateArray(LLVMTypeRef.Int8, 1000000), String.Empty);
var castShadowStack = builder.BuildPointerCast(shadowStack, LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), String.Empty);
builder.BuildStore(castShadowStack, shadowStackTop);
var shadowStackBottom = Module.AddGlobal(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), "t_pShadowStackBottom");
shadowStackBottom.Linkage = LLVMLinkage.LLVMExternalLinkage;
shadowStackBottom.Initializer = LLVMValueRef.CreateConstPointerNull(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0));
shadowStackBottom.ThreadLocalMode = LLVMThreadLocalMode.LLVMLocalDynamicTLSModel;
builder.BuildStore(castShadowStack, shadowStackBottom);
// Pass on main arguments
LLVMValueRef argc = mainFunc.GetParam(0);
LLVMValueRef argv = mainFunc.GetParam(1);
LLVMValueRef mainReturn = builder.BuildCall(managedMain, new LLVMValueRef[]
{
castShadowStack,
argc,
argv,
},
"returnValue");
builder.BuildRet(mainReturn);
mainFunc.Linkage = LLVMLinkage.LLVMExternalLinkage;
}
private static LLVMTypeRef CreateLlvmType(GlobalCompilationContext ctx)
{
var type = ctx.LlvmContext.CreateNamedStruct("__allocator_vtable");
Span <LLVMTypeRef> members = stackalloc LLVMTypeRef[]
{
LLVMTypeRef.CreatePointer(LLVMTypeRef.CreateFunction(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), new[] { LLVMTypeRef.Int32 }), 0),
LLVMTypeRef.CreatePointer(LLVMTypeRef.CreateFunction(LLVMTypeRef.Void, new[] { LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0) }), 0),
};
type.StructSetBody(members, false);
return(type);
}
public void MachineTest()
{
LLVM.InitializeX86TargetInfo();
LLVM.InitializeX86Target();
LLVM.InitializeX86TargetMC();
LLVMTypeRef pointerType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
LLVMTargetDataRef x86 = TargetDataFromTriple("i386-unknown-unknown");
LLVMTargetDataRef x86_64 = TargetDataFromTriple("amd64-unknown-unknown");
Assert.AreEqual(4, x86.ABISizeOfType(pointerType));
Assert.AreEqual(8, x86_64.ABISizeOfType(pointerType));
}
public LLVMValueRef ToLLVMValueRef(LLVMModuleRef module)
{
LLVMValueRef valRef = IsFunction ? module.GetNamedFunction(SymbolName) : module.GetNamedGlobal(SymbolName);
if (Offset != 0 && valRef.Handle != IntPtr.Zero)
{
var CreatePointer = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0);
var bitCast = LLVMValueRef.CreateConstBitCast(valRef, CreatePointer);
LLVMValueRef[] index = new LLVMValueRef[] { LLVMValueRef.CreateConstInt(LLVMTypeRef.Int32, Offset, false) };
valRef = LLVMValueRef.CreateConstGEP(bitCast, index);
}
return(valRef);
}
private void EmitReadyToRunHeaderCallback(LLVMContextRef context)
{
LLVMTypeRef intPtr = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
LLVMTypeRef intPtrPtr = LLVMTypeRef.CreatePointer(intPtr, 0);
var callback = Module.AddFunction("RtRHeaderWrapper", LLVMTypeRef.CreateFunction(intPtrPtr, new LLVMTypeRef[0], false));
var builder = context.CreateBuilder();
var block = callback.AppendBasicBlock("Block");
builder.PositionAtEnd(block);
LLVMValueRef rtrHeaderPtr = GetSymbolValuePointer(Module, _nodeFactory.ReadyToRunHeader, _nodeFactory.NameMangler, false);
LLVMValueRef castRtrHeaderPtr = builder.BuildPointerCast(rtrHeaderPtr, intPtrPtr, "castRtrHeaderPtr");
builder.BuildRet(castRtrHeaderPtr);
}
public void EmitSymbolDef(LLVMValueRef realSymbol, string symbolIdentifier, int offsetFromSymbolName)
{
string symbolAddressGlobalName = symbolIdentifier + "___SYMBOL";
LLVMValueRef symbolAddress;
var intType = LLVMTypeRef.Int32;
if (s_symbolValues.TryGetValue(symbolAddressGlobalName, out symbolAddress))
{
var int8PtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0);
var intPtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
var pointerToRealSymbol = LLVMValueRef.CreateConstBitCast(realSymbol, int8PtrType);
var offsetValue = LLVMValueRef.CreateConstInt(intType, (uint)offsetFromSymbolName, false);
var symbolPointerData = LLVMValueRef.CreateConstGEP(pointerToRealSymbol, new LLVMValueRef[] { offsetValue });
var symbolPointerDataAsInt32Ptr = LLVMValueRef.CreateConstBitCast(symbolPointerData, intPtrType);
symbolAddress.Initializer = symbolPointerDataAsInt32Ptr;
}
}
public static LLVMValueRef GetSymbolValuePointer(LLVMModuleRef module, ISymbolNode symbol, NameMangler nameMangler, bool objectWriterUse = false)
{
if (symbol is WebAssemblyMethodCodeNode)
{
ThrowHelper.ThrowInvalidProgramException();
}
string symbolAddressGlobalName = symbol.GetMangledName(nameMangler) + "___SYMBOL";
LLVMValueRef symbolAddress;
if (s_symbolValues.TryGetValue(symbolAddressGlobalName, out symbolAddress))
{
return(symbolAddress);
}
var intPtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
var myGlobal = module.AddGlobalInAddressSpace(intPtrType, symbolAddressGlobalName, 0);
myGlobal.IsGlobalConstant = true;
myGlobal.Linkage = LLVMLinkage.LLVMInternalLinkage;
s_symbolValues.Add(symbolAddressGlobalName, myGlobal);
return(myGlobal);
}
public void Fill(LLVMModuleRef module, NodeFactory nodeFactory)
{
List <LLVMValueRef> entries = new List <LLVMValueRef>();
int pointerSize = nodeFactory.Target.PointerSize;
int countOfPointerSizedElements = Data.Length / pointerSize;
byte[] currentObjectData = Data;
var intPtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int32, 0);
var intType = LLVMTypeRef.Int32;
var int8PtrType = LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0);
for (int i = 0; i < countOfPointerSizedElements; i++)
{
int curOffset = (i * pointerSize);
SymbolRefData symbolRef;
if (ObjectSymbolRefs.TryGetValue(curOffset, out symbolRef))
{
LLVMValueRef pointedAtValue = symbolRef.ToLLVMValueRef(module);
var ptrValue = LLVMValueRef.CreateConstBitCast(pointedAtValue, intPtrType);
entries.Add(ptrValue);
}
else
{
int value = BitConverter.ToInt32(currentObjectData, curOffset);
var nullptr = LLVMValueRef.CreateConstPointerNull(int8PtrType);
var dataVal = LLVMValueRef.CreateConstInt(intType, (uint)value, false);
var ptrValAsInt8Ptr = LLVMValueRef.CreateConstGEP(nullptr, new LLVMValueRef[] { dataVal });
var ptrValue = LLVMValueRef.CreateConstBitCast(ptrValAsInt8Ptr, intPtrType);
entries.Add(ptrValue);
}
}
var funcptrarray = LLVMValueRef.CreateConstArray(intPtrType, entries.ToArray());
Node.Initializer = funcptrarray;
}
public void AlignmentTest()
{
LLVMModuleRef m = LLVMModuleRef.CreateWithName("netscripten");
m.Target = "wasm32-unknown-unknown-wasm";
m.DataLayout = "e-m:e-p:32:32-i64:64-n32:64-S128";
LLVMExecutionEngineRef engineRef = m.CreateExecutionEngine();
LLVMTargetDataRef target = engineRef.TargetData;
LLVMTypeRef testStruct = LLVMTypeRef.CreateStruct(
new[]
{
LLVMTypeRef.Int16,
LLVMTypeRef.Int32
}, true);
Assert.AreEqual(1, target.ABIAlignmentOfType(testStruct));
Assert.AreEqual(1, target.CallFrameAlignmentOfType(testStruct));
Assert.AreEqual(8, target.PreferredAlignmentOfType(testStruct));
LLVMValueRef global = m.AddGlobal(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), "someGlobal");
Assert.AreEqual(4, target.PreferredAlignmentOfGlobal(global));
}
static void BuildFinallyFunclet(LLVMModuleRef module)
{
LlvmFinallyFunclet = module.AddFunction("LlvmFinallyFunclet", LLVMTypeRef.CreateFunction(LLVMTypeRef.Void,
new LLVMTypeRef[]
{
LLVMTypeRef.CreatePointer(LLVMTypeRef.CreateFunction(LLVMTypeRef.Void, new LLVMTypeRef[] { LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0) }, false), 0), // finallyHandler
LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), // shadow stack
}, false));
var block = LlvmFinallyFunclet.AppendBasicBlock("GenericFinally");
LLVMBuilderRef funcletBuilder = Context.CreateBuilder();
funcletBuilder.PositionAtEnd(block);
var finallyFunclet = LlvmFinallyFunclet.GetParam(0);
var castShadowStack = LlvmFinallyFunclet.GetParam(1);
List <LLVMValueRef> llvmArgs = new List <LLVMValueRef>();
llvmArgs.Add(castShadowStack);
funcletBuilder.BuildCall(finallyFunclet, llvmArgs.ToArray(), string.Empty);
funcletBuilder.BuildRetVoid();
funcletBuilder.Dispose();
}
private void GetCodeForReadyToRunGenericHelper(WebAssemblyCodegenCompilation compilation, ReadyToRunGenericHelperNode node, NodeFactory factory)
{
LLVMBuilderRef builder = compilation.Module.Context.CreateBuilder();
var args = new List <LLVMTypeRef>();
MethodDesc delegateCtor = null;
if (node.Id == ReadyToRunHelperId.DelegateCtor)
{
DelegateCreationInfo target = (DelegateCreationInfo)node.Target;
delegateCtor = target.Constructor.Method;
bool isStatic = delegateCtor.Signature.IsStatic;
int argCount = delegateCtor.Signature.Length;
if (!isStatic)
{
argCount++;
}
for (int i = 0; i < argCount; i++)
{
TypeDesc argType;
if (i == 0 && !isStatic)
{
argType = delegateCtor.OwningType;
}
else
{
argType = delegateCtor.Signature[i - (isStatic ? 0 : 1)];
}
args.Add(ILImporter.GetLLVMTypeForTypeDesc(argType));
}
}
LLVMValueRef helperFunc = Module.GetNamedFunction(node.GetMangledName(factory.NameMangler));
if (helperFunc.Handle == IntPtr.Zero)
{
throw new Exception("if the function is requested here, it should have been created earlier");
}
var helperBlock = helperFunc.AppendBasicBlock("genericHelper");
builder.PositionAtEnd(helperBlock);
var importer = new ILImporter(builder, compilation, Module, helperFunc, delegateCtor);
LLVMValueRef ctx;
string gepName;
if (node is ReadyToRunGenericLookupFromTypeNode)
{
// Locate the VTable slot that points to the dictionary
int vtableSlot = VirtualMethodSlotHelper.GetGenericDictionarySlot(factory, (TypeDesc)node.DictionaryOwner);
int pointerSize = factory.Target.PointerSize;
// Load the dictionary pointer from the VTable
int slotOffset = EETypeNode.GetVTableOffset(pointerSize) + (vtableSlot * pointerSize);
var slotGep = builder.BuildGEP(helperFunc.GetParam(1), new[] { LLVMValueRef.CreateConstInt(LLVMTypeRef.Int32, (ulong)slotOffset, false) }, "slotGep");
var slotGepPtrPtr = builder.BuildPointerCast(slotGep,
LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), 0), "slotGepPtrPtr");
ctx = builder.BuildLoad(slotGepPtrPtr, "dictGep");
gepName = "typeNodeGep";
}
else
{
ctx = helperFunc.GetParam(1);
gepName = "paramGep";
}
LLVMValueRef resVar = OutputCodeForDictionaryLookup(builder, factory, node, node.LookupSignature, ctx, gepName);
switch (node.Id)
{
case ReadyToRunHelperId.GetNonGCStaticBase:
{
MetadataType target = (MetadataType)node.Target;
if (compilation.TypeSystemContext.HasLazyStaticConstructor(target))
{
importer.OutputCodeForTriggerCctor(target, resVar);
}
}
break;
case ReadyToRunHelperId.GetGCStaticBase:
{
MetadataType target = (MetadataType)node.Target;
var ptrPtrPtr = builder.BuildBitCast(resVar, LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), 0), 0), "ptrPtrPtr");
resVar = builder.BuildLoad(builder.BuildLoad(ptrPtrPtr, "ind1"), "ind2");
if (compilation.TypeSystemContext.HasLazyStaticConstructor(target))
{
GenericLookupResult nonGcRegionLookup = factory.GenericLookup.TypeNonGCStaticBase(target);
var nonGcStaticsBase = OutputCodeForDictionaryLookup(builder, factory, node, nonGcRegionLookup, ctx, "lazyGep");
importer.OutputCodeForTriggerCctor(target, nonGcStaticsBase);
}
}
break;
case ReadyToRunHelperId.GetThreadStaticBase:
{
MetadataType target = (MetadataType)node.Target;
if (compilation.TypeSystemContext.HasLazyStaticConstructor(target))
{
GenericLookupResult nonGcRegionLookup = factory.GenericLookup.TypeNonGCStaticBase(target);
var threadStaticBase = OutputCodeForDictionaryLookup(builder, factory, node, nonGcRegionLookup, ctx, "tsGep");
importer.OutputCodeForTriggerCctor(target, threadStaticBase);
}
resVar = importer.OutputCodeForGetThreadStaticBaseForType(resVar).ValueAsType(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), builder);
}
break;
case ReadyToRunHelperId.DelegateCtor:
{
DelegateCreationInfo target = (DelegateCreationInfo)node.Target;
MethodDesc constructor = target.Constructor.Method;
var fatPtr = ILImporter.MakeFatPointer(builder, resVar, compilation);
importer.OutputCodeForDelegateCtorInit(builder, helperFunc, constructor, fatPtr);
}
break;
// These are all simple: just get the thing from the dictionary and we're done
case ReadyToRunHelperId.TypeHandle:
case ReadyToRunHelperId.MethodHandle:
case ReadyToRunHelperId.FieldHandle:
case ReadyToRunHelperId.MethodDictionary:
case ReadyToRunHelperId.MethodEntry:
case ReadyToRunHelperId.VirtualDispatchCell:
case ReadyToRunHelperId.DefaultConstructor:
break;
default:
throw new NotImplementedException();
}
if (node.Id != ReadyToRunHelperId.DelegateCtor)
{
builder.BuildRet(resVar);
}
else
{
builder.BuildRetVoid();
}
}
public GamaPointer(GamaTypeRef basetype) : base("[pointer]", LLVMTypeRef.CreatePointer(basetype.UnderlyingType, 0))
{
BaseType = basetype;
}
public GamaPointer(string name, GamaTypeRef basetype) : base(name, LLVMTypeRef.CreatePointer(basetype.UnderlyingType, 0))
{
BaseType = basetype;
}
