private void StartImportingBasicBlock(BasicBlock basicBlock)
{
// Import all associated EH regions
foreach (ExceptionRegion ehRegion in _exceptionRegions)
{
ILExceptionRegion region = ehRegion.ILRegion;
if (region.TryOffset == basicBlock.StartOffset)
{
MarkBasicBlock(_basicBlocks[region.HandlerOffset]);
if (region.Kind == ILExceptionRegionKind.Filter)
{
MarkBasicBlock(_basicBlocks[region.FilterOffset]);
}
// Once https://github.com/dotnet/corert/issues/3460 is done, this should be deleted.
// Throwing InvalidProgram is not great, but we want to do *something* if this happens
// because doing nothing means problems at runtime. This is not worth piping a
// a new exception with a fancy message for.
if (region.Kind == ILExceptionRegionKind.Catch)
{
TypeDesc catchType = (TypeDesc)_methodIL.GetObject(region.ClassToken);
if (catchType.IsRuntimeDeterminedSubtype)
{
ThrowHelper.ThrowInvalidProgramException();
}
}
}
}
_currentInstructionOffset = -1;
_previousInstructionOffset = -1;
}
private void StartImportingBasicBlock(BasicBlock basicBlock)
{
// Import all associated EH regions
foreach (ExceptionRegion ehRegion in _exceptionRegions)
{
ILExceptionRegion region = ehRegion.ILRegion;
if (region.TryOffset == basicBlock.StartOffset)
{
MarkBasicBlock(_basicBlocks[region.HandlerOffset]);
if (region.Kind == ILExceptionRegionKind.Filter)
{
MarkBasicBlock(_basicBlocks[region.FilterOffset]);
}
}
}
_currentInstructionOffset = -1;
_previousInstructionOffset = -1;
}
public override ILExceptionRegion[] GetExceptionRegions()
{
if (_ilExceptionRegions != null)
{
return(_ilExceptionRegions);
}
ImmutableArray <ExceptionRegion> exceptionRegions = _methodBody.ExceptionRegions;
ILExceptionRegion[] ilExceptionRegions;
int length = exceptionRegions.Length;
if (length == 0)
{
ilExceptionRegions = Array.Empty <ILExceptionRegion>();
}
else
{
ilExceptionRegions = new ILExceptionRegion[length];
for (int i = 0; i < length; i++)
{
var exceptionRegion = exceptionRegions[i];
ilExceptionRegions[i] = new ILExceptionRegion(
(ILExceptionRegionKind)exceptionRegion.Kind, // assumes that ILExceptionRegionKind and ExceptionRegionKind enums are in sync
exceptionRegion.TryOffset,
exceptionRegion.TryLength,
exceptionRegion.HandlerOffset,
exceptionRegion.HandlerLength,
MetadataTokens.GetToken(exceptionRegion.CatchType),
exceptionRegion.FilterOffset);
}
}
Interlocked.CompareExchange(ref _ilExceptionRegions, ilExceptionRegions, null);
return(_ilExceptionRegions);
}
public override ILExceptionRegion[] GetExceptionRegions()
{
if (_ilExceptionRegions != null)
return _ilExceptionRegions;
ImmutableArray<ExceptionRegion> exceptionRegions = _methodBody.ExceptionRegions;
ILExceptionRegion[] ilExceptionRegions;
int length = exceptionRegions.Length;
if (length == 0)
{
ilExceptionRegions = Array.Empty<ILExceptionRegion>();
}
else
{
ilExceptionRegions = new ILExceptionRegion[length];
for (int i = 0; i < length; i++)
{
var exceptionRegion = exceptionRegions[i];
ilExceptionRegions[i] = new ILExceptionRegion(
(ILExceptionRegionKind)exceptionRegion.Kind, // assumes that ILExceptionRegionKind and ExceptionRegionKind enums are in sync
exceptionRegion.TryOffset,
exceptionRegion.TryLength,
exceptionRegion.HandlerOffset,
exceptionRegion.HandlerLength,
MetadataTokens.GetToken(exceptionRegion.CatchType),
exceptionRegion.FilterOffset);
}
}
return (_ilExceptionRegions = ilExceptionRegions);
}
public bool Initialize(MutableModule mutableModule, EcmaMethodIL wrappedMethod)
{
bool failedToReplaceToken = false;
try
{
Debug.Assert(mutableModule.ModuleThatIsCurrentlyTheSourceOfNewReferences == null);
mutableModule.ModuleThatIsCurrentlyTheSourceOfNewReferences = ((EcmaMethod)wrappedMethod.OwningMethod).Module;
var owningMethodHandle = mutableModule.TryGetEntityHandle(wrappedMethod.OwningMethod);
if (!owningMethodHandle.HasValue)
{
return(false);
}
_mutableModule = mutableModule;
_maxStack = wrappedMethod.MaxStack;
_isInitLocals = wrappedMethod.IsInitLocals;
_owningMethod = wrappedMethod.OwningMethod;
_exceptionRegions = (ILExceptionRegion[])wrappedMethod.GetExceptionRegions().Clone();
_ilBytes = (byte[])wrappedMethod.GetILBytes().Clone();
_locals = (LocalVariableDefinition[])wrappedMethod.GetLocals();
for (int i = 0; i < _exceptionRegions.Length; i++)
{
var region = _exceptionRegions[i];
if (region.Kind == ILExceptionRegionKind.Catch)
{
var newHandle = _mutableModule.TryGetHandle((TypeSystemEntity)wrappedMethod.GetObject(region.ClassToken));
if (!newHandle.HasValue)
{
return(false);
}
_exceptionRegions[i] = new ILExceptionRegion(region.Kind, region.TryOffset, region.TryLength, region.HandlerOffset, region.HandlerLength, newHandle.Value, newHandle.Value);
}
}
ILTokenReplacer.Replace(_ilBytes, GetMutableModuleToken);
#if DEBUG
Debug.Assert(ReadyToRunStandaloneMethodMetadata.Compute((EcmaMethod)_owningMethod) != null);
#endif // DEBUG
}
finally
{
mutableModule.ModuleThatIsCurrentlyTheSourceOfNewReferences = null;
}
return(!failedToReplaceToken);
int GetMutableModuleToken(int token)
{
object result = wrappedMethod.GetObject(token);
int? newToken;
if (result is string str)
{
newToken = mutableModule.TryGetStringHandle(str);
}
else
{
newToken = mutableModule.TryGetHandle((TypeSystemEntity)result);
}
if (!newToken.HasValue)
{
// Toekn replacement has failed. Do not attempt to use this IL.
failedToReplaceToken = true;
return(1);
}
return(newToken.Value);
}
}
