private void ReadAsyncMethodBody(AsyncMethodBodyDebugInformation async_method) { if (async_method.catch_handler.Offset > -1) { async_method.catch_handler = new InstructionOffset(GetInstruction(async_method.catch_handler.Offset)); } InstructionOffset instructionOffset; if (!async_method.yields.IsNullOrEmpty()) { for (int i = 0; i < async_method.yields.Count; i++) { Collection <InstructionOffset> yields = async_method.yields; int index = i; instructionOffset = async_method.yields[i]; yields[index] = new InstructionOffset(GetInstruction(instructionOffset.Offset)); } } if (!async_method.resumes.IsNullOrEmpty()) { for (int j = 0; j < async_method.resumes.Count; j++) { Collection <InstructionOffset> resumes = async_method.resumes; int index2 = j; instructionOffset = async_method.resumes[j]; resumes[index2] = new InstructionOffset(GetInstruction(instructionOffset.Offset)); } } }
public SequencePoint(Instruction instruction, Document document) { if (document == null) throw new ArgumentNullException ("document"); this.offset = new InstructionOffset (instruction); this.document = document; }
internal SequencePoint(int offset, Document document) { if (document == null) throw new ArgumentNullException ("document"); this.offset = new InstructionOffset (offset); this.document = document; }
public SequencePoint(Instruction instruction, Document document) { if (document == null) { throw new ArgumentNullException("document"); } offset = new InstructionOffset(instruction); this.document = document; }
internal SequencePoint(int offset, Document document) { if (document == null) { throw new ArgumentNullException("document"); } this.offset = new InstructionOffset(offset); this.document = document; }
public ScopeDebugInformation(Instruction start, Instruction end) : this() { if (start == null) { throw new ArgumentNullException("start"); } this.start = new InstructionOffset(start); if (end != null) { this.end = new InstructionOffset(end); } }
private void ReadScope(ScopeDebugInformation scope) { InstructionOffset instructionOffset = scope.Start; Instruction instruction = GetInstruction(instructionOffset.Offset); if (instruction != null) { scope.Start = new InstructionOffset(instruction); } instructionOffset = scope.End; Instruction instruction2 = GetInstruction(instructionOffset.Offset); InstructionOffset end; if (instruction2 == null) { instructionOffset = default(InstructionOffset); end = instructionOffset; } else { end = new InstructionOffset(instruction2); } scope.End = end; if (!scope.variables.IsNullOrEmpty()) { for (int i = 0; i < scope.variables.Count; i++) { VariableDebugInformation variableDebugInformation = scope.variables[i]; VariableDefinition variable = GetVariable(variableDebugInformation.Index); if (variable != null) { variableDebugInformation.index = new VariableIndex(variable); } } } if (!scope.scopes.IsNullOrEmpty()) { ReadScopes(scope.scopes); } }
InstructionOffset ResolveInstructionOffset(InstructionOffset inputOffset, ref InstructionOffsetCache cache) { 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()); } }
public StateMachineScope(Instruction start, Instruction end) { this.start = new InstructionOffset(start); this.end = end != null ? new InstructionOffset(end) : new InstructionOffset(); }
internal StateMachineScope(int start, int end) { this.start = new InstructionOffset(start); this.end = new InstructionOffset(end); }
public AsyncMethodBodyDebugInformation() : base(KindIdentifier) { this.catch_handler = new InstructionOffset(-1); }
internal AsyncMethodBodyDebugInformation(int catchHandler) : base(KindIdentifier) { this.catch_handler = new InstructionOffset(catchHandler); }
public StateMachineScopeDebugInformation(Instruction start, Instruction end) : base(KindIdentifier) { this.start = new InstructionOffset(start); this.end = end != null ? new InstructionOffset(end) : new InstructionOffset(); }
internal StateMachineScopeDebugInformation(int start, int end) : base(KindIdentifier) { this.start = new InstructionOffset(start); this.end = new InstructionOffset(end); }
internal StateMachineScopeDebugInformation(int start, int end) : base(KindIdentifier) { this.start = new InstructionOffset (start); this.end = new InstructionOffset (end); }
public StateMachineScopeDebugInformation(Instruction start, Instruction end) : base(KindIdentifier) { this.start = new InstructionOffset (start); this.end = new InstructionOffset (end); }
public ScopeDebugInformation(Instruction start, Instruction end) : this() { if (start == null) throw new ArgumentNullException ("start"); this.start = new InstructionOffset (start); if (end != null) this.end = new InstructionOffset (end); }
internal AsyncMethodBodyDebugInformation(int catchHandler) : base(KindIdentifier) { this.catch_handler = new InstructionOffset (catchHandler); }
InstructionOffset ResolveInstructionOffset(InstructionOffset inputOffset, ref InstructionOffsetCache cache) { 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++) { if (size == offset) { return(new InstructionOffset(items [i])); } if (size > offset) { return(new InstructionOffset(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; cache.Instruction = items [i]; if (cache.Offset == offset) { return(new InstructionOffset(cache.Instruction)); } if (cache.Offset > offset) { return(new InstructionOffset(items [i - 1])); } size += items [i].GetSize(); } return(new InstructionOffset()); } }
public AsyncMethodBodyDebugInformation(Instruction catchHandler) : base(KindIdentifier) { catch_handler = new InstructionOffset(catchHandler); }