|
//
// 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 System;
using System.Threading;
using Mono.Collections.Generic;
namespace Mono.Cecil.Cil {
public sealed class MethodBody {
readonly internal 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 Collection<ExceptionHandler> (), null);
return exceptions;
}
}
public bool HasVariables {
get { return !variables.IsNullOrEmpty (); }
}
public Collection<VariableDefinition> Variables {
get {
if (variables == null)
Interlocked.CompareExchange (ref variables, new VariableDefinitionCollection (this.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;
}
}
static ParameterDefinition CreateThisParameter (MethodDefinition method)
{
var parameter_type = method.DeclaringType as TypeReference;
if (parameter_type.HasGenericParameters) {
var instance = new GenericInstanceType (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 ParameterDefinition (parameter_type, method);
}
public MethodBody (MethodDefinition method)
{
this.method = method;
}
public ILProcessor GetILProcessor ()
{
return new ILProcessor (this);
}
}
sealed class VariableDefinitionCollection : Collection<VariableDefinition> {
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;
}
void UpdateVariableIndices (int startIndex, int offset, VariableDefinition variableToRemove = null)
{
for (int i = startIndex; i < size; i++)
items [i].index = i + offset;
var debug_info = method == null ? null : method.debug_info;
if (debug_info == null || debug_info.Scope == null)
return;
foreach (var scope in debug_info.GetScopes ()) {
if (!scope.HasVariables)
continue;
var variables = scope.Variables;
int variableDebugInfoIndexToRemove = -1;
for (int i = 0; i < variables.Count; i++) {
var 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 VariableIndex (variable.Index + offset);
}
}
if (variableDebugInfoIndexToRemove >= 0)
variables.RemoveAt (variableDebugInfoIndexToRemove);
}
}
}
class InstructionCollection : Collection<Instruction> {
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;
var previous = items [index - 1];
previous.next = item;
item.previous = previous;
}
protected override void OnInsert (Instruction item, int index)
{
int startOffset = 0;
if (size != 0) {
var current = items [index];
if (current == null) {
var last = items [index - 1];
last.next = item;
item.previous = last;
return;
}
startOffset = current.Offset;
var previous = current.previous;
if (previous != null) {
previous.next = item;
item.previous = previous;
}
current.previous = item;
item.next = current;
}
UpdateDebugInformation (null, null);
}
protected override void OnSet (Instruction item, int index)
{
var current = items [index];
item.previous = current.previous;
item.next = current.next;
current.previous = null;
current.next = null;
UpdateDebugInformation (item, current);
}
protected override void OnRemove (Instruction item, int index)
{
var previous = item.previous;
if (previous != null)
previous.next = item.next;
var next = item.next;
if (next != null)
next.previous = item.previous;
RemoveSequencePoint (item);
UpdateDebugInformation (item, next ?? previous);
item.previous = null;
item.next = null;
}
void RemoveSequencePoint (Instruction instruction)
{
var debug_info = method.debug_info;
if (debug_info == null || !debug_info.HasSequencePoints)
return;
var 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;
}
}
}
void UpdateDebugInformation (Instruction removedInstruction, Instruction existingInstruction)
{
// Various bits of debug information store instruction offsets (as "pointers" to the IL)
// 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).
// Depending on where the InstructionOffset comes from (loaded from PE/PDB or constructed) it can be in either state.
// 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).
// Manipulating unresolved InstructionOffsets is pretty hard (since we can't rely on correct offsets of instructions).
// On the other hand resolved InstructionOffsets 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 expensive as it will walk the entire method body to convert offsets to instruction pointers
// Within the same debug info, IL offsets are typically 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 (as it checks that they're resolved)
// - If there was an edit which adds some unresolved, the cost is proportional (the code will only resolve those)
// - Then update as necessary by manipulaitng instruction references alone
InstructionOffsetResolver resolver = new InstructionOffsetResolver (items, removedInstruction, existingInstruction);
if (method.debug_info != null)
UpdateLocalScope (method.debug_info.Scope, ref resolver);
var custom_debug_infos = method.custom_infos ?? method.debug_info?.custom_infos;
if (custom_debug_infos != null) {
foreach (var custom_debug_info in custom_debug_infos) {
switch (custom_debug_info) {
case StateMachineScopeDebugInformation state_machine_scope:
UpdateStateMachineScope (state_machine_scope, ref resolver);
break;
case AsyncMethodBodyDebugInformation async_method_body:
UpdateAsyncMethodBody (async_method_body, ref resolver);
break;
default:
// No need to update the other debug info as they don't store instruction references
break;
}
}
}
}
void UpdateLocalScope (ScopeDebugInformation scope, ref InstructionOffsetResolver resolver)
{
if (scope == null)
return;
scope.Start = resolver.Resolve (scope.Start);
if (scope.HasScopes) {
foreach (var subScope in scope.Scopes)
UpdateLocalScope (subScope, ref resolver);
}
scope.End = resolver.Resolve (scope.End);
}
void UpdateStateMachineScope (StateMachineScopeDebugInformation debugInfo, ref InstructionOffsetResolver resolver)
{
resolver.Restart ();
foreach (var scope in debugInfo.Scopes) {
scope.Start = resolver.Resolve (scope.Start);
scope.End = resolver.Resolve (scope.End);
}
}
void UpdateAsyncMethodBody (AsyncMethodBodyDebugInformation debugInfo, ref InstructionOffsetResolver resolver)
{
if (!debugInfo.CatchHandler.IsResolved) {
resolver.Restart ();
debugInfo.CatchHandler = resolver.Resolve (debugInfo.CatchHandler);
}
resolver.Restart ();
for (int i = 0; i < debugInfo.Yields.Count; i++) {
debugInfo.Yields [i] = resolver.Resolve (debugInfo.Yields [i]);
}
resolver.Restart ();
for (int i = 0; i < debugInfo.Resumes.Count; i++) {
debugInfo.Resumes [i] = resolver.Resolve (debugInfo.Resumes [i]);
}
}
struct InstructionOffsetResolver {
readonly Instruction [] items;
readonly Instruction removed_instruction;
readonly Instruction existing_instruction;
int cache_offset;
int cache_index;
Instruction cache_instruction;
public int LastOffset { get => cache_offset; }
public InstructionOffsetResolver (Instruction[] instructions, Instruction removedInstruction, Instruction existingInstruction)
{
items = instructions;
removed_instruction = removedInstruction;
existing_instruction = existingInstruction;
cache_offset = 0;
cache_index = 0;
cache_instruction = items [0];
}
public void Restart ()
{
cache_offset = 0;
cache_index = 0;
cache_instruction = items [0];
}
public InstructionOffset Resolve (InstructionOffset inputOffset)
{
var result = ResolveInstructionOffset (inputOffset);
if (!result.IsEndOfMethod && result.ResolvedInstruction == removed_instruction)
result = new InstructionOffset (existing_instruction);
return result;
}
InstructionOffset ResolveInstructionOffset (InstructionOffset inputOffset)
{
if (inputOffset.IsResolved)
return inputOffset;
int offset = inputOffset.Offset;
if (cache_offset == offset)
return new InstructionOffset (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++) {
// The array can be larger than the actual size, in which case its padded with nulls at the end
// so when we reach null, treat it as an end of the IL.
if (items [i] == null)
return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
if (size == offset)
return new InstructionOffset (items [i]);
if (size > offset)
return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
size += items [i].GetSize ();
}
// Offset is larger than the size of the body - so it points after the end
return new InstructionOffset ();
} 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;
var item = items [i];
// Allow for trailing null values in the case of
// instructions.Size < instructions.Capacity
if (item == null)
return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
cache_instruction = item;
if (cache_offset == offset)
return new InstructionOffset (cache_instruction);
if (cache_offset > offset)
return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
size += item.GetSize ();
}
return new InstructionOffset ();
}
}
}
}
} |