public ILStructure(PEFile module, MethodDefinitionHandle handle, MetadataGenericContext genericContext, ILStructureType type, int startOffset, int endOffset, ExceptionRegion handler = default)
{
Debug.Assert(startOffset < endOffset);
this.Module = module;
this.MethodHandle = handle;
this.GenericContext = genericContext;
this.Type = type;
this.StartOffset = startOffset;
this.EndOffset = endOffset;
this.ExceptionHandler = handler;
}
public _ExceptionRegionInfo(Module aModule, ExceptionRegion aExceptionRegion)
{
Module = aModule;
ExceptionRegion = aExceptionRegion;
HandlerOffset = aExceptionRegion.HandlerOffset;
HandlerLength = aExceptionRegion.HandlerLength;
TryOffset = aExceptionRegion.TryOffset;
TryLength = aExceptionRegion.TryLength;
FilterOffset = aExceptionRegion.FilterOffset;
Kind = aExceptionRegion.Kind;
}
public ILImporter(ILScanner compilation, MethodDesc method, MethodIL methodIL = null)
{
if (methodIL == null)
{
methodIL = compilation.GetMethodIL(method);
}
else
{
_isFallbackBodyCompilation = true;
}
// This is e.g. an "extern" method in C# without a DllImport or InternalCall.
if (methodIL == null)
{
ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramSpecific, method);
}
_compilation = compilation;
_factory = (ILScanNodeFactory)compilation.NodeFactory;
_ilBytes = methodIL.GetILBytes();
_canonMethodIL = methodIL;
// Get the runtime determined method IL so that this works right in shared code
// and tokens in shared code resolve to runtime determined types.
MethodIL uninstantiatiedMethodIL = methodIL.GetMethodILDefinition();
if (methodIL != uninstantiatiedMethodIL)
{
MethodDesc sharedMethod = method.GetSharedRuntimeFormMethodTarget();
_methodIL = new InstantiatedMethodIL(sharedMethod, uninstantiatiedMethodIL);
}
else
{
_methodIL = methodIL;
}
_canonMethod = method;
var ilExceptionRegions = methodIL.GetExceptionRegions();
_exceptionRegions = new ExceptionRegion[ilExceptionRegions.Length];
for (int i = 0; i < ilExceptionRegions.Length; i++)
{
_exceptionRegions[i] = new ExceptionRegion()
{
ILRegion = ilExceptionRegions[i]
};
}
}
public ILImporter(LLVMBuilderRef builder, WebAssemblyCodegenCompilation compilation, LLVMModuleRef module, LLVMValueRef helperFunc, MethodDesc delegateCtor)
{
this._builder = builder;
this._compilation = compilation;
this.Module = module;
this._currentFunclet = helperFunc;
_locals = new LocalVariableDefinition[0];
if (delegateCtor == null)
{
_signature = new MethodSignature(MethodSignatureFlags.None, 0, GetWellKnownType(WellKnownType.Void),
new TypeDesc[0]);
}
else
{
_signature = delegateCtor.Signature;
_argSlots = new LLVMValueRef[_signature.Length];
int signatureIndex = 2; // past hidden param
int thisOffset = 0;
if (!_signature.IsStatic)
{
thisOffset = 1;
}
for (int i = 0; i < _signature.Length; i++)
{
if (CanStoreTypeOnStack(_signature[i]))
{
LLVMValueRef storageAddr;
LLVMValueRef argValue = helperFunc.GetParam((uint)signatureIndex);
// The caller will always pass the argument on the stack. If this function doesn't have
// EH, we can put it in an alloca for efficiency and better debugging. Otherwise,
// copy it to the shadow stack so funclets can find it
int argOffset = i + thisOffset;
string argName = $"arg{argOffset}_";
storageAddr = _builder.BuildAlloca(GetLLVMTypeForTypeDesc(_signature[i]), argName);
_argSlots[i] = storageAddr;
_builder.BuildStore(argValue, storageAddr);
signatureIndex++;
}
}
}
_thisType = GetWellKnownType(WellKnownType.Void);
_pointerSize = compilation.NodeFactory.Target.PointerSize;
_exceptionRegions = new ExceptionRegion[0];
}
public ILImporter(ILInterpreter interpreter, MethodDesc method, MethodIL methodIL)
{
_ilBytes = methodIL.GetILBytes();
_method = method;
_methodIL = methodIL;
_interpreter = interpreter;
var ilExceptionRegions = methodIL.GetExceptionRegions();
_exceptionRegions = new ExceptionRegion[methodIL.GetExceptionRegions().Length];
for (int i = 0; i < ilExceptionRegions.Length; i++)
{
_exceptionRegions[i] = new ExceptionRegion()
{
ILRegion = ilExceptionRegions[i]
};
}
}
public ILImporter(WebAssemblyCodegenCompilation compilation, MethodDesc method, MethodIL methodIL, string mangledName)
{
Module = compilation.Module;
_compilation = compilation;
_method = method;
_methodIL = methodIL;
_ilBytes = methodIL.GetILBytes();
_locals = methodIL.GetLocals();
var ilExceptionRegions = methodIL.GetExceptionRegions();
_exceptionRegions = new ExceptionRegion[ilExceptionRegions.Length];
for (int i = 0; i < ilExceptionRegions.Length; i++)
{
_exceptionRegions[i] = new ExceptionRegion()
{
ILRegion = ilExceptionRegions[i]
};
}
_llvmFunction = GetOrCreateLLVMFunction(mangledName);
_builder = LLVM.CreateBuilder();
}
public ILStructure(PEFile module, MethodDefinitionHandle handle, MetadataGenericContext genericContext, MethodBodyBlock body)
: this(module, handle, genericContext, ILStructureType.Root, 0, body.GetILReader().Length)
{
// Build the tree of exception structures:
for (int i = 0; i < body.ExceptionRegions.Length; i++)
{
ExceptionRegion eh = body.ExceptionRegions[i];
if (!body.ExceptionRegions.Take(i).Any(oldEh => oldEh.TryOffset == eh.TryOffset && oldEh.TryLength == eh.TryLength))
{
AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Try, eh.TryOffset, eh.TryOffset + eh.TryLength, eh));
}
if (eh.Kind == ExceptionRegionKind.Filter)
{
AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Filter, eh.FilterOffset, eh.HandlerOffset, eh));
}
AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Handler, eh.HandlerOffset, eh.HandlerOffset + eh.HandlerLength, eh));
}
// Very simple loop detection: look for backward branches
(var allBranches, var isAfterUnconditionalBranch) = FindAllBranches(body.GetILReader());
// We go through the branches in reverse so that we find the biggest possible loop boundary first (think loops with "continue;")
for (int i = allBranches.Count - 1; i >= 0; i--)
{
int loopEnd = allBranches[i].Source.End;
int loopStart = allBranches[i].Target;
if (loopStart < loopEnd)
{
// We found a backward branch. This is a potential loop.
// Check that is has only one entry point:
int entryPoint = -1;
// entry point is first instruction in loop if prev inst isn't an unconditional branch
if (loopStart > 0 && !isAfterUnconditionalBranch[loopStart])
{
entryPoint = allBranches[i].Target;
}
bool multipleEntryPoints = false;
foreach (var branch in allBranches)
{
if (branch.Source.Start < loopStart || branch.Source.Start >= loopEnd)
{
if (loopStart <= branch.Target && branch.Target < loopEnd)
{
// jump from outside the loop into the loop
if (entryPoint < 0)
{
entryPoint = branch.Target;
}
else if (branch.Target != entryPoint)
{
multipleEntryPoints = true;
}
}
}
}
if (!multipleEntryPoints)
{
AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Loop, loopStart, loopEnd, entryPoint));
}
}
}
SortChildren();
}
/// <summary>
/// </summary>
/// <param name="exceptionRegion">
/// </param>
/// <param name="catchType">
/// </param>
/// <param name="genericContext">
/// </param>
internal MetadataExceptionHandlingClauseAdapter(ExceptionRegion exceptionRegion, TypeSymbol catchType, IGenericContext genericContext)
: this(exceptionRegion, catchType)
{
this.GenericContext = genericContext;
}
/// <summary>
/// </summary>
/// <param name="exceptionRegion">
/// </param>
/// <param name="catchType">
/// </param>
internal MetadataExceptionHandlingClauseAdapter(ExceptionRegion exceptionRegion, TypeSymbol catchType)
{
this.exceptionRegion = exceptionRegion;
this.catchType = catchType;
this.lazyFinallyJumps = new Lazy <IList <string> >(() => new List <string>());
}
private static string AddReturnLabel(ExceptionRegion r)
{
r.ReturnLabels++;
return r.ReturnLabels.ToStringInvariant();
}
/// <summary>
/// Closes the currently open exception clause.
/// </summary>
/// <param name="exceptionRegion"> The exception region to modify. </param>
private void EndCurrentClause(ExceptionRegion exceptionRegion)
{
if (exceptionRegion.Clauses.Count == 0)
{
// End the try block.
Leave(exceptionRegion.EndLabel);
exceptionRegion.TryLength = this.offset - exceptionRegion.Start;
}
else
{
var latestClause = exceptionRegion.Clauses[exceptionRegion.Clauses.Count - 1];
switch (latestClause.Type)
{
case ExceptionClauseType.Catch:
Leave(exceptionRegion.EndLabel);
break;
case ExceptionClauseType.Finally:
EndFinally();
break;
case ExceptionClauseType.Filter:
break;
case ExceptionClauseType.Fault:
EndFault();
break;
}
latestClause.ILLength = this.offset - latestClause.ILStart;
}
}
/// <summary>
/// Begins a try-catch-finally block.
/// </summary>
public override void BeginExceptionBlock()
{
// Create a new active exception region stack, if necessary.
if (this.activeExceptionRegions == null)
this.activeExceptionRegions = new Stack<ExceptionRegion>();
// Create a new exception region.
var region = new ExceptionRegion();
region.Start = this.offset;
region.EndLabel = this.CreateLabel();
region.Clauses = new List<ExceptionClause>(3);
// Push the exception region to the stack.
this.activeExceptionRegions.Push(region);
}
internal static Tuple cil_handler_type(ExceptionRegion region, Type t) =>
new Tuple("cil_handler_type", region, t);
internal static Tuple cil_handler_filter(ExceptionRegion region, Instruction filter_start) =>
new Tuple("cil_handler_filter", region, filter_start);
internal static Tuple cil_handler(ExceptionRegion region, MethodImplementation method, int index, int kind,
Instruction region_start,
Instruction region_end,
Instruction handler_start) =>
new Tuple("cil_handler", region, method, index, kind, region_start, region_end, handler_start);
public ILImporter(Compilation compilation, CppWriter writer, MethodDesc method, MethodIL methodIL)
{
_compilation = compilation;
_nodeFactory = _compilation.NodeFactory;
_writer = writer;
_method = method;
_methodSignature = method.Signature;
_typeSystemContext = method.Context;
if (!_methodSignature.IsStatic)
_thisType = method.OwningType;
_methodIL = methodIL;
_ilBytes = _methodIL.GetILBytes();
_locals = _methodIL.GetLocals();
var ilExceptionRegions = _methodIL.GetExceptionRegions();
_exceptionRegions = new ExceptionRegion[ilExceptionRegions.Length];
for (int i = 0; i < ilExceptionRegions.Length; i++)
{
_exceptionRegions[i] = new ExceptionRegion() { ILRegion = ilExceptionRegions[i] };
}
}
private static string AddReturnLabel(ExceptionRegion r)
{
r.ReturnLabels++;
return IntToString(r.ReturnLabels);
}
public static Type GetCatchType(Module aModule, ExceptionRegion aRegion)
{
string xLocation = aModule.Assembly.Location;
var xReader = MetadataHelper.TryGetReader(xLocation);
switch (aRegion.CatchType.Kind)
{
case HandleKind.TypeReference:
return(MetadataHelper.GetTypeFromReference(xReader, aModule,
(TypeReferenceHandle)aRegion.CatchType, 0));
case HandleKind.TypeDefinition:
return(aModule.ResolveType(MetadataTokens.GetToken(aRegion.CatchType)));
case HandleKind.FieldDefinition:
break;
case HandleKind.MethodDefinition:
break;
case HandleKind.Parameter:
break;
case HandleKind.InterfaceImplementation:
break;
case HandleKind.MemberReference:
break;
case HandleKind.Constant:
break;
case HandleKind.CustomAttribute:
break;
case HandleKind.DeclarativeSecurityAttribute:
break;
case HandleKind.StandaloneSignature:
break;
case HandleKind.EventDefinition:
break;
case HandleKind.PropertyDefinition:
break;
case HandleKind.MethodImplementation:
break;
case HandleKind.ModuleReference:
break;
case HandleKind.TypeSpecification:
break;
case HandleKind.AssemblyDefinition:
break;
case HandleKind.AssemblyFile:
break;
case HandleKind.AssemblyReference:
break;
case HandleKind.ExportedType:
break;
case HandleKind.GenericParameter:
break;
case HandleKind.MethodSpecification:
break;
case HandleKind.GenericParameterConstraint:
break;
case HandleKind.MethodDebugInformation:
break;
case HandleKind.CustomDebugInformation:
break;
default:
throw new ArgumentOutOfRangeException();
}
throw new NotImplementedException();
}
static string AddReturnLabel(ExceptionRegion r)
{
r.ReturnLabels++;
return r.ReturnLabels.ToString();
}
