[Add] FishNet
This commit is contained in:
@@ -0,0 +1,441 @@
|
||||
//
|
||||
// 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();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user