441 lines
16 KiB
C#
441 lines
16 KiB
C#
//
|
|
// Author:
|
|
// Jb Evain (jbevain@gmail.com)
|
|
//
|
|
// Copyright (c) 2008 - 2015 Jb Evain
|
|
// Copyright (c) 2008 - 2011 Novell, Inc.
|
|
//
|
|
// Licensed under the MIT/X11 license.
|
|
//
|
|
|
|
using MonoFN.Collections.Generic;
|
|
using System;
|
|
using System.Threading;
|
|
|
|
namespace MonoFN.Cecil.Cil
|
|
{
|
|
public sealed class MethodBody
|
|
{
|
|
internal readonly MethodDefinition method;
|
|
internal ParameterDefinition this_parameter;
|
|
internal int max_stack_size;
|
|
internal int code_size;
|
|
internal bool init_locals;
|
|
internal MetadataToken local_var_token;
|
|
internal Collection<Instruction> instructions;
|
|
internal Collection<ExceptionHandler> exceptions;
|
|
internal Collection<VariableDefinition> variables;
|
|
public MethodDefinition Method
|
|
{
|
|
get { return method; }
|
|
}
|
|
public int MaxStackSize
|
|
{
|
|
get { return max_stack_size; }
|
|
set { max_stack_size = value; }
|
|
}
|
|
public int CodeSize
|
|
{
|
|
get { return code_size; }
|
|
}
|
|
public bool InitLocals
|
|
{
|
|
get { return init_locals; }
|
|
set { init_locals = value; }
|
|
}
|
|
public MetadataToken LocalVarToken
|
|
{
|
|
get { return local_var_token; }
|
|
set { local_var_token = value; }
|
|
}
|
|
public Collection<Instruction> Instructions
|
|
{
|
|
get
|
|
{
|
|
if (instructions == null)
|
|
Interlocked.CompareExchange(ref instructions, new InstructionCollection(method), null);
|
|
|
|
return instructions;
|
|
}
|
|
}
|
|
public bool HasExceptionHandlers
|
|
{
|
|
get { return !exceptions.IsNullOrEmpty(); }
|
|
}
|
|
public Collection<ExceptionHandler> ExceptionHandlers
|
|
{
|
|
get
|
|
{
|
|
if (exceptions == null)
|
|
Interlocked.CompareExchange(ref exceptions, new(), null);
|
|
|
|
return exceptions;
|
|
}
|
|
}
|
|
public bool HasVariables
|
|
{
|
|
get { return !variables.IsNullOrEmpty(); }
|
|
}
|
|
public Collection<VariableDefinition> Variables
|
|
{
|
|
get
|
|
{
|
|
if (variables == null)
|
|
Interlocked.CompareExchange(ref variables, new VariableDefinitionCollection(method), null);
|
|
|
|
return variables;
|
|
}
|
|
}
|
|
public ParameterDefinition ThisParameter
|
|
{
|
|
get
|
|
{
|
|
if (method == null || method.DeclaringType == null)
|
|
throw new NotSupportedException();
|
|
|
|
if (!method.HasThis)
|
|
return null;
|
|
|
|
if (this_parameter == null)
|
|
Interlocked.CompareExchange(ref this_parameter, CreateThisParameter(method), null);
|
|
|
|
return this_parameter;
|
|
}
|
|
}
|
|
|
|
private static ParameterDefinition CreateThisParameter(MethodDefinition method)
|
|
{
|
|
TypeReference parameter_type = method.DeclaringType as TypeReference;
|
|
|
|
if (parameter_type.HasGenericParameters)
|
|
{
|
|
GenericInstanceType instance = new(parameter_type, parameter_type.GenericParameters.Count);
|
|
for (int i = 0; i < parameter_type.GenericParameters.Count; i++)
|
|
instance.GenericArguments.Add(parameter_type.GenericParameters[i]);
|
|
|
|
parameter_type = instance;
|
|
}
|
|
|
|
if (parameter_type.IsValueType || parameter_type.IsPrimitive)
|
|
parameter_type = new ByReferenceType(parameter_type);
|
|
|
|
return new(parameter_type, method);
|
|
}
|
|
|
|
public MethodBody(MethodDefinition method)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
public ILProcessor GetILProcessor()
|
|
{
|
|
return new(this);
|
|
}
|
|
}
|
|
|
|
internal sealed class VariableDefinitionCollection : Collection<VariableDefinition>
|
|
{
|
|
private readonly MethodDefinition method;
|
|
|
|
internal VariableDefinitionCollection(MethodDefinition method)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
internal VariableDefinitionCollection(MethodDefinition method, int capacity) : base(capacity)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
protected override void OnAdd(VariableDefinition item, int index)
|
|
{
|
|
item.index = index;
|
|
}
|
|
|
|
protected override void OnInsert(VariableDefinition item, int index)
|
|
{
|
|
item.index = index;
|
|
UpdateVariableIndices(index, 1);
|
|
}
|
|
|
|
protected override void OnSet(VariableDefinition item, int index)
|
|
{
|
|
item.index = index;
|
|
}
|
|
|
|
protected override void OnRemove(VariableDefinition item, int index)
|
|
{
|
|
UpdateVariableIndices(index + 1, -1, item);
|
|
item.index = -1;
|
|
}
|
|
|
|
private void UpdateVariableIndices(int startIndex, int offset, VariableDefinition variableToRemove = null)
|
|
{
|
|
for (int i = startIndex; i < size; i++)
|
|
items[i].index = i + offset;
|
|
|
|
MethodDebugInformation debug_info = method == null ? null : method.debug_info;
|
|
if (debug_info == null || debug_info.Scope == null)
|
|
return;
|
|
|
|
foreach (ScopeDebugInformation scope in debug_info.GetScopes())
|
|
{
|
|
if (!scope.HasVariables)
|
|
continue;
|
|
|
|
Collection<VariableDebugInformation> variables = scope.Variables;
|
|
int variableDebugInfoIndexToRemove = -1;
|
|
for (int i = 0; i < variables.Count; i++)
|
|
{
|
|
VariableDebugInformation variable = variables[i];
|
|
|
|
// If a variable is being removed detect if it has debug info counterpart, if so remove that as well.
|
|
// Note that the debug info can be either resolved (has direct reference to the VariableDefinition)
|
|
// or unresolved (has only the number index of the variable) - this needs to handle both cases.
|
|
if (variableToRemove != null && ((variable.index.IsResolved && variable.index.ResolvedVariable == variableToRemove) || (!variable.index.IsResolved && variable.Index == variableToRemove.Index)))
|
|
{
|
|
variableDebugInfoIndexToRemove = i;
|
|
continue;
|
|
}
|
|
|
|
// For unresolved debug info updates indeces to keep them pointing to the same variable.
|
|
if (!variable.index.IsResolved && variable.Index >= startIndex)
|
|
{
|
|
variable.index = new(variable.Index + offset);
|
|
}
|
|
}
|
|
|
|
if (variableDebugInfoIndexToRemove >= 0)
|
|
variables.RemoveAt(variableDebugInfoIndexToRemove);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class InstructionCollection : Collection<Instruction>
|
|
{
|
|
private readonly MethodDefinition method;
|
|
|
|
internal InstructionCollection(MethodDefinition method)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
internal InstructionCollection(MethodDefinition method, int capacity) : base(capacity)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
protected override void OnAdd(Instruction item, int index)
|
|
{
|
|
if (index == 0)
|
|
return;
|
|
|
|
Instruction previous = items[index - 1];
|
|
previous.next = item;
|
|
item.previous = previous;
|
|
}
|
|
|
|
protected override void OnInsert(Instruction item, int index)
|
|
{
|
|
int startOffset = 0;
|
|
if (size != 0)
|
|
{
|
|
Instruction current = items[index];
|
|
if (current == null)
|
|
{
|
|
Instruction last = items[index - 1];
|
|
last.next = item;
|
|
item.previous = last;
|
|
return;
|
|
}
|
|
|
|
startOffset = current.Offset;
|
|
|
|
Instruction previous = current.previous;
|
|
if (previous != null)
|
|
{
|
|
previous.next = item;
|
|
item.previous = previous;
|
|
}
|
|
|
|
current.previous = item;
|
|
item.next = current;
|
|
}
|
|
|
|
UpdateLocalScopes(null, null);
|
|
}
|
|
|
|
protected override void OnSet(Instruction item, int index)
|
|
{
|
|
Instruction current = items[index];
|
|
|
|
item.previous = current.previous;
|
|
item.next = current.next;
|
|
|
|
current.previous = null;
|
|
current.next = null;
|
|
|
|
UpdateLocalScopes(item, current);
|
|
}
|
|
|
|
protected override void OnRemove(Instruction item, int index)
|
|
{
|
|
Instruction previous = item.previous;
|
|
if (previous != null)
|
|
previous.next = item.next;
|
|
|
|
Instruction next = item.next;
|
|
if (next != null)
|
|
next.previous = item.previous;
|
|
|
|
RemoveSequencePoint(item);
|
|
UpdateLocalScopes(item, next ?? previous);
|
|
|
|
item.previous = null;
|
|
item.next = null;
|
|
}
|
|
|
|
private void RemoveSequencePoint(Instruction instruction)
|
|
{
|
|
MethodDebugInformation debug_info = method.debug_info;
|
|
if (debug_info == null || !debug_info.HasSequencePoints)
|
|
return;
|
|
|
|
Collection<SequencePoint> sequence_points = debug_info.sequence_points;
|
|
for (int i = 0; i < sequence_points.Count; i++)
|
|
{
|
|
if (sequence_points[i].Offset == instruction.offset)
|
|
{
|
|
sequence_points.RemoveAt(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateLocalScopes(Instruction removedInstruction, Instruction existingInstruction)
|
|
{
|
|
MethodDebugInformation debug_info = method.debug_info;
|
|
if (debug_info == null)
|
|
return;
|
|
|
|
// Local scopes store start/end pair of "instruction offsets". Instruction offset can be either resolved, in which case it
|
|
// has a reference to Instruction, or unresolved in which case it stores numerical offset (instruction offset in the body).
|
|
// Typically local scopes loaded from PE/PDB files will be resolved, but it's not a requirement.
|
|
// Each instruction has its own offset, which is populated on load, but never updated (this would be pretty expensive to do).
|
|
// Instructions created during the editting will typically have offset 0 (so incorrect).
|
|
// Local scopes created during editing will also likely be resolved (so no numerical offsets).
|
|
// So while local scopes which are unresolved are relatively rare if they appear, manipulating them based
|
|
// on the offsets allone is pretty hard (since we can't rely on correct offsets of instructions).
|
|
// On the other hand resolved local scopes are easy to maintain, since they point to instructions and thus inserting
|
|
// instructions is basically a no-op and removing instructions is as easy as changing the pointer.
|
|
// For this reason the algorithm here is:
|
|
// - First make sure that all instruction offsets are resolved - if not - resolve them
|
|
// - First time this will be relatively expensinve as it will walk the entire method body to convert offsets to instruction pointers
|
|
// Almost all local scopes are stored in the "right" order (sequentially per start offsets), so the code uses a simple one-item
|
|
// cache instruction<->offset to avoid walking instructions multiple times (that would only happen for scopes which are out of order).
|
|
// - Subsequent calls should be cheap as it will only walk all local scopes without doing anything
|
|
// - If there was an edit on local scope which makes some of them unresolved, the cost is proportional
|
|
// - Then update as necessary by manipulaitng instruction references alone
|
|
|
|
InstructionOffsetCache cache = new()
|
|
{
|
|
Offset = 0,
|
|
Index = 0,
|
|
Instruction = items[0]
|
|
};
|
|
|
|
UpdateLocalScope(debug_info.Scope, removedInstruction, existingInstruction, ref cache);
|
|
}
|
|
|
|
private void UpdateLocalScope(ScopeDebugInformation scope, Instruction removedInstruction, Instruction existingInstruction, ref InstructionOffsetCache cache)
|
|
{
|
|
if (scope == null)
|
|
return;
|
|
|
|
if (!scope.Start.IsResolved)
|
|
scope.Start = ResolveInstructionOffset(scope.Start, ref cache);
|
|
|
|
if (!scope.Start.IsEndOfMethod && scope.Start.ResolvedInstruction == removedInstruction)
|
|
scope.Start = new(existingInstruction);
|
|
|
|
if (scope.HasScopes)
|
|
{
|
|
foreach (ScopeDebugInformation subScope in scope.Scopes)
|
|
UpdateLocalScope(subScope, removedInstruction, existingInstruction, ref cache);
|
|
}
|
|
|
|
if (!scope.End.IsResolved)
|
|
scope.End = ResolveInstructionOffset(scope.End, ref cache);
|
|
|
|
if (!scope.End.IsEndOfMethod && scope.End.ResolvedInstruction == removedInstruction)
|
|
scope.End = new(existingInstruction);
|
|
}
|
|
|
|
private struct InstructionOffsetCache
|
|
{
|
|
public int Offset;
|
|
public int Index;
|
|
public Instruction Instruction;
|
|
}
|
|
|
|
private InstructionOffset ResolveInstructionOffset(InstructionOffset inputOffset, ref InstructionOffsetCache cache)
|
|
{
|
|
if (inputOffset.IsResolved)
|
|
return inputOffset;
|
|
|
|
int offset = inputOffset.Offset;
|
|
|
|
if (cache.Offset == offset)
|
|
return new(cache.Instruction);
|
|
|
|
if (cache.Offset > offset)
|
|
{
|
|
// This should be rare - we're resolving offset pointing to a place before the current cache position
|
|
// resolve by walking the instructions from start and don't cache the result.
|
|
int size = 0;
|
|
for (int i = 0; i < items.Length; i++)
|
|
{
|
|
if (size == offset)
|
|
return new(items[i]);
|
|
|
|
if (size > offset)
|
|
return new(items[i - 1]);
|
|
|
|
size += items[i].GetSize();
|
|
}
|
|
|
|
// Offset is larger than the size of the body - so it points after the end
|
|
return new();
|
|
}
|
|
else
|
|
{
|
|
// The offset points after the current cache position - so continue counting and update the cache
|
|
int size = cache.Offset;
|
|
for (int i = cache.Index; i < items.Length; i++)
|
|
{
|
|
cache.Index = i;
|
|
cache.Offset = size;
|
|
|
|
Instruction item = items[i];
|
|
|
|
// Allow for trailing null values in the case of
|
|
// instructions.Size < instructions.Capacity
|
|
if (item == null)
|
|
break;
|
|
|
|
cache.Instruction = item;
|
|
|
|
if (cache.Offset == offset)
|
|
return new(cache.Instruction);
|
|
|
|
if (cache.Offset > offset)
|
|
return new(items[i - 1]);
|
|
|
|
size += item.GetSize();
|
|
}
|
|
|
|
return new();
|
|
}
|
|
}
|
|
}
|
|
} |