public TryHandler(ExceptionHandlingClause clause) { if (clause.Flags == ExceptionHandlingClauseOptions.Finally) { Type = NodeType.TryFinally; } else { Type = NodeType.TryCatch; } TryStartIp = clause.TryOffset; TryEndIp = clause.TryOffset + clause.TryLength; HandlerStartIp = clause.HandlerOffset; HandlerEndIp = clause.HandlerOffset + clause.HandlerLength; if (HandlerStartIp == 0) { HandlerStartIp = -1; } if (HandlerEndIp == 0) { HandlerEndIp = -1; } }
public ProjectingExceptionHandlingClause(ExceptionHandlingClause clause, Projector projector) : base(clause) { Debug.Assert(null != projector); _projector = projector; }
public _ExceptionRegionInfo(ExceptionHandlingClause aExceptionClause) { try { ExceptionClause = aExceptionClause; HandlerOffset = aExceptionClause.HandlerOffset; HandlerLength = aExceptionClause.HandlerLength; TryOffset = aExceptionClause.TryOffset; TryLength = aExceptionClause.TryLength; if (aExceptionClause.Flags == ExceptionHandlingClauseOptions.Clause) { Kind = ExceptionRegionKind.Catch; CatchType = aExceptionClause.CatchType; } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Fault)) { Kind = ExceptionRegionKind.Fault; } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Filter)) { Kind = ExceptionRegionKind.Filter; FilterOffset = aExceptionClause.FilterOffset; } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Finally)) { Kind = ExceptionRegionKind.Finally; } } catch { // ignored } }
public _ExceptionRegionInfo(ExceptionHandlingClause aExceptionClause) { try { ExceptionClause = aExceptionClause; HandlerOffset = aExceptionClause.HandlerOffset; HandlerLength = aExceptionClause.HandlerLength; TryOffset = aExceptionClause.TryOffset; TryLength = aExceptionClause.TryLength; if (aExceptionClause.Flags == ExceptionHandlingClauseOptions.Clause) { Kind = ExceptionRegionKind.Catch; CatchType = aExceptionClause.CatchType; } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Fault)) { Kind = ExceptionRegionKind.Fault; } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Filter)) { Kind = ExceptionRegionKind.Filter; FilterOffset = aExceptionClause.FilterOffset; CatchType = typeof(System.Exception); //TODO: Confirm that this is correct. } else if (aExceptionClause.Flags.HasFlag(ExceptionHandlingClauseOptions.Finally)) { Kind = ExceptionRegionKind.Finally; } } catch { // ignored } }
public ProjectingExceptionHandlingClause(ExceptionHandlingClause clause, Projector projector) : base(clause) { Contract.Requires(null != projector); _projector = projector; }
public ILOpCode(ILCode aCode, int aPosition, int aNextPosition, ExceptionHandlingClause aEhc) { Code = aCode; Position = aPosition; NextPosition = aNextPosition; Ehc = aEhc; }
private static Type GetCatchType(ExceptionHandlingClause clause) { try { return(clause.CatchType); } catch { return(null); } }
public override ExceptionHandlingClause ProjectExceptionHandlingClause(ExceptionHandlingClause value) { if (value == null) { return(null); } Debug.Assert(NeedsProjection(value)); return(new ProjectingExceptionHandlingClause(value, this)); }
private static int GetFilterOffset(ExceptionHandlingClause clause) { try { return(clause.FilterOffset); } catch { return(-1); } }
public bool IsCatchBlockBegin(int ilOffset, out ExceptionHandlingClause exceptionHandlingClause) { exceptionHandlingClause = null; int handlingClauseIndex; if (NonIlOffsets.IsCatchBlockBegin(ilOffset, out handlingClauseIndex)) { exceptionHandlingClause = _exceptionHandlingClauses[handlingClauseIndex]; return(true); } return(false); }
private bool IsTryBlockEnd(int ilOffset, out ExceptionHandlingClause exceptionHandlingClause) { exceptionHandlingClause = null; int handlingClauseIndex; if (NonIlOffsets.IsTryBlockEnd(ilOffset, out handlingClauseIndex)) { exceptionHandlingClause = _exceptionHandlingClauses[handlingClauseIndex]; return(true); } return(false); }
public ExceptionHandlingClauseData Build(ExceptionHandlingClause c) { return(new ExceptionHandlingClauseData { Flags = c.Flags, CatchType = c.Flags == ExceptionHandlingClauseOptions.Clause ? typeInfoDataConverter.Build(c.CatchType) : null, TryOffset = c.TryOffset, TryLength = c.TryLength, HandlerOffset = c.HandlerOffset, HandlerLength = c.HandlerLength }); }
public TryHandler(ExceptionHandlingClause clause) { TryStartIp = clause.TryOffset; TryEndIp = clause.TryOffset + clause.TryLength; HandlerStartIp = clause.HandlerOffset; HandlerEndIp = clause.HandlerOffset + clause.HandlerLength; if (HandlerStartIp == 0) { HandlerStartIp = -1; } if (HandlerEndIp == 0) { HandlerEndIp = -1; } }
internal OpCodeType(ILCode aCode, int aPosition, int aNextPosition, ExceptionHandlingClause aEhc) { ILCode = aCode; Position = aPosition; NextPosition = aNextPosition; Handler = aEhc; NeedHandler = (aEhc != null) && ((aEhc.HandlerOffset == Position) || (((aEhc.Flags & ExceptionHandlingClauseOptions.Filter) != 0) && aEhc.FilterOffset == Position)) && (aEhc.Flags == ExceptionHandlingClauseOptions.Clause); HandlerRef = ".Error"; HandlerPosition = -1; if (aEhc != null && aEhc.HandlerOffset > Position) { HandlerPosition = aEhc.HandlerOffset; HandlerRef = Helper.GetLabel(aEhc.HandlerOffset); } }
public static ExceptionHandler ToDNLib(this ExceptionHandlingClause clause, ModuleDef module, IList <Instruction> instructions) { ExceptionHandlerType type = clause.Flags.ToDNLib(); ExceptionHandler result = new ExceptionHandler(type); if (clause.CatchType != null) { result.CatchType = module.ToSig(clause.CatchType.ToSignature()).ToTypeDefOrRef(); } if (type.HasFlag(ExceptionHandlerType.Filter)) { result.FilterStart = instructions.AtOffset(clause.FilterOffset); } result.HandlerStart = instructions.AtOffset(clause.HandlerOffset); result.HandlerEnd = instructions.AtOffset(clause.HandlerOffset + clause.HandlerLength); result.TryStart = instructions.AtOffset(clause.TryOffset); result.TryEnd = instructions.AtOffset(clause.TryOffset + clause.TryLength); return(result); }
public OpField(Code aOpCode, int aPos, int aNextPos, FieldInfo aValue, ExceptionHandlingClause aCurrentExceptionHandler) : base(aOpCode, aPos, aNextPos, aCurrentExceptionHandler) { Value = aValue; }
internal OpMethod(ILCode aCode, int aPosition, int aNextPosition, MethodBase aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; MethodUID = aValue.GetHashCode(); CallingConvention = CallingConvention.StdCall; var attrib = Value.GetCustomAttribute <DllImportAttribute>(); if (attrib != null) { CallingConvention = attrib.CallingConvention; } }
public OpNone(ILCode aCode, int aPosition, int aNextPosition, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { }
public OpSingle(ILCode aCode, int aPosition, int aNextPosition, float aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; }
internal unsafe static uint CallFilter (InternalSystem.Exception exception, ExceptionHandlingClause handler, void* callerBP) { Diagnostics.Error ("Unimplemented - ExceptionHandling.CallFilter"); return 0; }
public OpString(ILCode aCode, int aPosition, int aNextPosition, string aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; }
public OpNone(Code aOpCode, int aPos, int aNextPos, ExceptionHandlingClause aCurrentExceptionHandler) : base(aOpCode, aPos, aNextPos, aCurrentExceptionHandler) { }
public abstract ExceptionHandlingClause ProjectExceptionHandlingClause(ExceptionHandlingClause value);
internal OpToken(ILCode aCode, int aPosition, int aNextPosition, int aValue, Module aModule, Type[] aTypeGenericArgs, Type[] aMethodGenericArgs, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; if (IsField) { ValueField = aModule.ResolveField(Value, aTypeGenericArgs, aMethodGenericArgs); } if (IsType) { ValueType = aModule.ResolveType(Value, aTypeGenericArgs, aMethodGenericArgs); } }
public static void TestMethodBody1() { using (MetadataLoadContext lc = new MetadataLoadContext(new CoreMetadataAssemblyResolver(), "mscorlib")) { Assembly coreAssembly = lc.LoadFromStream(TestUtils.CreateStreamForCoreAssembly()); Assembly a = lc.LoadFromByteArray(TestData.s_AssemblyWithMethodBodyImage); Type nonsense = a.GetType("Nonsense`1", throwOnError: true); Type theT = nonsense.GetTypeInfo().GenericTypeParameters[0]; MethodInfo m = nonsense.GetMethod("Foo"); Type theM = m.GetGenericArguments()[0]; MethodBody mb = m.GetMethodBody(); byte[] il = mb.GetILAsByteArray(); Assert.Equal <byte>(TestData.s_AssemblyWithMethodBodyILBytes, il); Assert.Equal(4, mb.MaxStackSize); Assert.True(mb.InitLocals); Assert.Equal(0x11000001, mb.LocalSignatureMetadataToken); IList <LocalVariableInfo> lvis = mb.LocalVariables; Assert.Equal(10, lvis.Count); Assert.Equal(0, lvis[0].LocalIndex); Assert.False(lvis[0].IsPinned); Assert.Equal(coreAssembly.GetType("System.Single", throwOnError: true), lvis[0].LocalType); Assert.Equal(1, lvis[1].LocalIndex); Assert.False(lvis[1].IsPinned); Assert.Equal(coreAssembly.GetType("System.Double", throwOnError: true), lvis[1].LocalType); Assert.Equal(2, lvis[2].LocalIndex); Assert.False(lvis[2].IsPinned); Assert.Equal(theT, lvis[2].LocalType); Assert.Equal(3, lvis[3].LocalIndex); Assert.False(lvis[3].IsPinned); Assert.Equal(theT.MakeArrayType(), lvis[3].LocalType); Assert.Equal(4, lvis[4].LocalIndex); Assert.False(lvis[4].IsPinned); Assert.Equal(coreAssembly.GetType("System.Collections.Generic.IList`1", throwOnError: true).MakeGenericType(theM), lvis[4].LocalType); Assert.Equal(5, lvis[5].LocalIndex); Assert.False(lvis[5].IsPinned); Assert.Equal(coreAssembly.GetType("System.String", throwOnError: true), lvis[5].LocalType); Assert.Equal(6, lvis[6].LocalIndex); Assert.False(lvis[6].IsPinned); Assert.Equal(coreAssembly.GetType("System.Int32", throwOnError: true).MakeArrayType(), lvis[6].LocalType); Assert.Equal(7, lvis[7].LocalIndex); Assert.True(lvis[7].IsPinned); Assert.Equal(coreAssembly.GetType("System.Int32", throwOnError: true).MakeByRefType(), lvis[7].LocalType); Assert.Equal(8, lvis[8].LocalIndex); Assert.False(lvis[8].IsPinned); Assert.Equal(coreAssembly.GetType("System.Int32", throwOnError: true).MakeArrayType(), lvis[8].LocalType); Assert.Equal(9, lvis[9].LocalIndex); Assert.False(lvis[9].IsPinned); Assert.Equal(coreAssembly.GetType("System.Boolean", throwOnError: true), lvis[9].LocalType); IList <ExceptionHandlingClause> ehcs = mb.ExceptionHandlingClauses; Assert.Equal(2, ehcs.Count); ExceptionHandlingClause ehc = ehcs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Finally, ehc.Flags); Assert.Equal(97, ehc.TryOffset); Assert.Equal(41, ehc.TryLength); Assert.Equal(138, ehc.HandlerOffset); Assert.Equal(5, ehc.HandlerLength); ehc = ehcs[1]; Assert.Equal(ExceptionHandlingClauseOptions.Filter, ehc.Flags); Assert.Equal(88, ehc.TryOffset); Assert.Equal(58, ehc.TryLength); Assert.Equal(172, ehc.HandlerOffset); Assert.Equal(16, ehc.HandlerLength); Assert.Equal(146, ehc.FilterOffset); } }
private static void PrintExceptionHandlingClauses (ExceptionHandlingClause exceptionHandlingClause) { Debug.COM1.Write ("\t\tType: "); Debug.COM1.WriteNumber ((int) exceptionHandlingClause.ExceptionType, true); Debug.COM1.WriteLine (); if (exceptionHandlingClause.ExceptionType == ExceptionHandlerType.Catch) { Testcase.Test (exceptionHandlingClause.TypeInfo != null, "Runtime", "exceptionHandlingClause.TypeInfo != null"); if (exceptionHandlingClause.TypeInfo != null) { Debug.COM1.Write ("\t\tCatch Type: "); Debug.COM1.WriteLine (exceptionHandlingClause.TypeInfo.Name); } } }
/// <summary> /// Calls the handler. /// </summary> /// <param name="exception">The exception.</param> /// <param name="getNewHandler">if set to <c>true</c> [get new handler].</param> /// <param name="handler">The handler.</param> /// <param name="i">The i.</param> /// <param name="clauseIndex">Index of the clause.</param> /// <param name="callerBP">The caller BP.</param> /// <returns></returns> private unsafe static bool CallHandler (InternalSystem.Exception exception, bool getNewHandler, ExceptionHandlingClause handler, int i, int clauseIndex, void* callerBP) { if (handler != null) { #if DEBUG_EXCEPTION_HANDLING Debug.COM1.Write ("Calling the found handler from Frame: #"); Debug.COM1.WriteNumber ((int) (i - exception.IgnoreStackFramesCount), false); Debug.COM1.Write ("/Clause: #"); Debug.COM1.WriteNumber ((int) clauseIndex, false); Debug.COM1.WriteLine (); #endif exception.CallingStack [i].IgnoreMethodBoundaryClause [clauseIndex] = true; if (handler.ExceptionType == ExceptionHandlerType.Finally || handler.ExceptionType == ExceptionHandlerType.Fault) { ExceptionHandling.CallFinallyFault (exception, handler, callerBP); } else if (handler.ExceptionType == ExceptionHandlerType.Filter) { // If it is a filter and it fails look for the next Exception Handler if (ExceptionHandling.CallFilter (exception, handler, callerBP) == 0) getNewHandler = true; else ExceptionHandling.CallHandler (exception, handler, callerBP); } else if (handler.ExceptionType == ExceptionHandlerType.Catch) ExceptionHandling.CallHandler (exception, handler, callerBP); } return getNewHandler; }
internal unsafe static void CallFinallyFault (InternalSystem.Exception exception, ExceptionHandlingClause handler, void* callerBP) { Diagnostics.Error ("Unimplemented - ExceptionHandling.CallFinallyFault"); }
internal OpField(ILCode aCode, int aPosition, int aNextPosition, FieldInfo aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; }
internal OpBranch(ILCode aCode, int aPosition, int aNextPosition, int aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; }
//public static Dictionary<MethodBase, uint> MethodUIDs = new Dictionary<MethodBase, uint>(); public OpMethod(ILCode aCode, int aPosition, int aNextPosition, MethodBase aValue, ExceptionHandlingClause aEhc) : base(aCode, aPosition, aNextPosition, aEhc) { Value = aValue; MethodUID = 0; if (aValue.IsAbstract) { MethodUID = (uint)aValue.GetHashCode(); /* * if (MethodUIDs.ContainsKey(aValue)) * { * MethodUID = MethodUIDs[aValue]; * } * else * { * MethodUID = Counter++; * MethodUIDs.Add(aValue, MethodUID); * }*/ } }
public OpType(Code aOpCode, int aPos, int aNextPos, Type aValue, ExceptionHandlingClause aCurrentExceptionHandler) : base(aOpCode, aPos, aNextPos, aCurrentExceptionHandler) { Value = aValue; }
public DelegatingExceptionHandlingClause(ExceptionHandlingClause clause) { Contract.Requires(clause != null); _clause = clause; }
public static void TestEHClauses() { using (MetadataLoadContext lc = new MetadataLoadContext(new CoreMetadataAssemblyResolver(), "mscorlib")) { Assembly coreAssembly = lc.LoadFromStream(TestUtils.CreateStreamForCoreAssembly()); Assembly a = lc.LoadFromByteArray(TestData.s_AssemblyWithEhClausesImage); Type gt = a.GetType("G`1", throwOnError: true); Type et = a.GetType("MyException`2", throwOnError: true); Type gtP0 = gt.GetGenericTypeParameters()[0]; Type etP0 = et.GetGenericTypeParameters()[0]; Type etP1 = et.GetGenericTypeParameters()[1]; { MethodInfo m = gt.GetMethod("Catch"); Type theM = m.GetGenericArguments()[0]; MethodBody body = m.GetMethodBody(); IList <ExceptionHandlingClause> ehs = body.ExceptionHandlingClauses; Assert.Equal(1, ehs.Count); ExceptionHandlingClause eh = ehs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Clause, eh.Flags); Assert.Equal(1, eh.TryOffset); Assert.Equal(15, eh.TryLength); Assert.Equal(16, eh.HandlerOffset); Assert.Equal(16, eh.HandlerLength); Assert.Throws <InvalidOperationException>(() => eh.FilterOffset); Assert.Equal(et.MakeGenericType(gtP0, theM), eh.CatchType); } { Type sysInt32 = coreAssembly.GetType("System.Int32", throwOnError: true); Type sysSingle = coreAssembly.GetType("System.Single", throwOnError: true); MethodInfo m = gt.MakeGenericType(sysInt32).GetMethod("Catch").MakeGenericMethod(sysSingle); MethodBody body = m.GetMethodBody(); IList <ExceptionHandlingClause> ehs = body.ExceptionHandlingClauses; Assert.Equal(1, ehs.Count); ExceptionHandlingClause eh = ehs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Clause, eh.Flags); Assert.Equal(1, eh.TryOffset); Assert.Equal(15, eh.TryLength); Assert.Equal(16, eh.HandlerOffset); Assert.Equal(16, eh.HandlerLength); Assert.Throws <InvalidOperationException>(() => eh.FilterOffset); Assert.Equal(et.MakeGenericType(sysInt32, sysSingle), eh.CatchType); } { MethodInfo m = gt.GetMethod("Finally"); MethodBody body = m.GetMethodBody(); IList <ExceptionHandlingClause> ehs = body.ExceptionHandlingClauses; Assert.Equal(1, ehs.Count); ExceptionHandlingClause eh = ehs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Finally, eh.Flags); Assert.Equal(1, eh.TryOffset); Assert.Equal(15, eh.TryLength); Assert.Equal(16, eh.HandlerOffset); Assert.Equal(14, eh.HandlerLength); Assert.Throws <InvalidOperationException>(() => eh.FilterOffset); Assert.Throws <InvalidOperationException>(() => eh.CatchType); } { MethodInfo m = gt.GetMethod("Fault"); MethodBody body = m.GetMethodBody(); IList <ExceptionHandlingClause> ehs = body.ExceptionHandlingClauses; Assert.Equal(1, ehs.Count); ExceptionHandlingClause eh = ehs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Fault, eh.Flags); Assert.Equal(1, eh.TryOffset); Assert.Equal(15, eh.TryLength); Assert.Equal(16, eh.HandlerOffset); Assert.Equal(14, eh.HandlerLength); Assert.Throws <InvalidOperationException>(() => eh.FilterOffset); Assert.Throws <InvalidOperationException>(() => eh.CatchType); } { MethodInfo m = gt.GetMethod("Filter"); MethodBody body = m.GetMethodBody(); IList <ExceptionHandlingClause> ehs = body.ExceptionHandlingClauses; Assert.Equal(1, ehs.Count); ExceptionHandlingClause eh = ehs[0]; Assert.Equal(ExceptionHandlingClauseOptions.Filter, eh.Flags); Assert.Equal(1, eh.TryOffset); Assert.Equal(15, eh.TryLength); Assert.Equal(40, eh.HandlerOffset); Assert.Equal(16, eh.HandlerLength); Assert.Equal(16, eh.FilterOffset); Assert.Throws <InvalidOperationException>(() => eh.CatchType); } } }
/// <summary> /// Reads the method header from the instruction stream. /// </summary> /// <param name="reader">The reader used to decode the instruction stream.</param> /// <returns></returns> private MethodHeader ReadMethodHeader(EndianAwareBinaryReader reader) { MethodHeader header = new MethodHeader(); // Read first byte header.Flags = (MethodFlags)reader.ReadByte(); // Check least significant 2 bits switch (header.Flags & MethodFlags.HeaderMask) { case MethodFlags.TinyFormat: header.CodeSize = ((uint)(header.Flags & MethodFlags.TinyCodeSizeMask) >> 2); header.Flags &= MethodFlags.HeaderMask; break; case MethodFlags.FatFormat: // Read second byte of flags header.Flags = (MethodFlags)(reader.ReadByte() << 8 | (byte)header.Flags); if (MethodFlags.ValidHeader != (header.Flags & MethodFlags.HeaderSizeMask)) throw new InvalidDataException(@"Invalid method header."); header.MaxStack = reader.ReadUInt16(); header.CodeSize = reader.ReadUInt32(); header.LocalsSignature = new Token(reader.ReadUInt32()); // ReadStandAloneSigRow break; default: throw new InvalidDataException(@"Invalid method header while trying to decode " + this.methodCompiler.Method.FullName + ". (Flags = " + header.Flags.ToString("X") + ", Rva = " + this.methodCompiler.Method.Rva + ")"); } // Are there sections following the code? if (MethodFlags.MoreSections != (header.Flags & MethodFlags.MoreSections)) return header; // Yes, seek to them and process those sections long codepos = reader.BaseStream.Position; // Seek to the end of the code... long dataSectPos = codepos + header.CodeSize; if (0 != (dataSectPos & 3)) dataSectPos += (4 - (dataSectPos % 4)); reader.BaseStream.Position = dataSectPos; // Read all headers, so the IL decoder knows how to handle these... byte flags; do { flags = reader.ReadByte(); bool isFat = (0x40 == (flags & 0x40)); int length; int blocks; if (isFat) { byte a = reader.ReadByte(); byte b = reader.ReadByte(); byte c = reader.ReadByte(); length = (c << 24) | (b << 16) | a; blocks = (length - 4) / 24; } else { length = reader.ReadByte(); blocks = (length - 4) / 12; /* Read & skip the padding. */ reader.ReadInt16(); } Debug.Assert(0x01 == (flags & 0x3F), @"Unsupported method data section."); // Read the clause for (int i = 0; i < blocks; i++) { ExceptionHandlingClause clause = new ExceptionHandlingClause(); clause.Read(reader, isFat); methodCompiler.ExceptionClauseHeader.AddClause(clause); } } while (0x80 == (flags & 0x80)); reader.BaseStream.Position = codepos; return header; }
/// <summary> /// Traces the specified label. /// </summary> /// <param name="label">The label.</param> private void Trace(int label, ExceptionHandlingClause clause) { outgoingStack = new Stack<Operand>[basicBlocks.Count]; scheduledMoves = new Stack<Operand>[basicBlocks.Count]; processed = new BitArray(basicBlocks.Count); processed.SetAll(false); enqueued = new BitArray(basicBlocks.Count); enqueued.SetAll(false); var firstBlock = FindBlock(label); processed.Set(firstBlock.Sequence, true); workList.Enqueue(new WorkItem(firstBlock, new Stack<Operand>())); while (workList.Count > 0) { AssignOperands(workList.Dequeue()); } }