private void ValidateTryCatchFinallyBlocks() { foreach (var kv in TryBlocks.AsEnumerable()) { if (kv.Value.Item2 == -1) { throw new SigilVerificationException( "Unended ExceptionBlock " + kv.Key, IL.Instructions(AllLocals) ); } } foreach (var kv in CatchBlocks.AsEnumerable()) { if (kv.Value.Item2 == -1) { throw new Exception("Invalid State, all ExceptionBlocks are ended but CatchBlock " + kv.Key + " isn't ended"); } } foreach (var kv in FinallyBlocks.AsEnumerable()) { if (kv.Value.Item2 == -1) { throw new Exception("Invalid State, all ExceptionBlocks are ended but FinallyBlock " + kv.Key + " isn't ended"); } } }
/// <summary> /// Transfers control to another method. /// /// The parameters and calling convention of method must match the current one's. /// /// The stack must be empty to jump. /// /// Like the branching instructions, Jump cannot leave exception blocks. /// </summary> public Emit <DelegateType> Jump(MethodInfo method) { if (method == null) { throw new ArgumentNullException("method"); } if (method.CallingConvention != CallingConventions) { throw new ArgumentException("Jump expected a calling convention of " + CallingConventions + ", found " + method.CallingConvention); } var paras = method.GetParameters(); if (paras.Length != ParameterTypes.Length) { throw new ArgumentException("Jump expected a method with " + ParameterTypes.Length + " parameters, found " + paras.Length); } if (!AllowsUnverifiableCIL) { FailUnverifiable("Jump"); } if (CatchBlocks.Any(t => t.Value.Item2 == -1)) { throw new InvalidOperationException("Jump cannot transfer control from a catch block"); } if (FinallyBlocks.Any(t => t.Value.Item2 == -1)) { throw new InvalidOperationException("Jump cannot transfer control from a finally block"); } if (TryBlocks.Any(t => t.Value.Item2 == -1)) { throw new InvalidOperationException("Jump cannot transfer control from an exception block"); } UpdateState(Wrap(new[] { new StackTransition(0) }, "Jump")); for (var i = 0; i < paras.Length; i++) { var shouldBe = paras[i].ParameterType; var actuallyIs = ParameterTypes[i]; if (!shouldBe.IsAssignableFrom(actuallyIs)) { throw new SigilVerificationException("Jump expected the #" + i + " parameter to be assignable from " + actuallyIs + ", but found " + shouldBe, IL.Instructions(AllLocals)); } } UpdateState(OpCodes.Jmp, method, TypeHelpers.EmptyTypes, Wrap(StackTransition.None(), "Jump")); return(this); }
/// <summary> /// <para>Leave an exception or catch block, branching to the given label.</para> /// <para>This instruction empties the stack.</para> /// </summary> public Emit <DelegateType> Leave(Label label) { if (label == null) { throw new ArgumentNullException("label"); } if (((IOwned)label).Owner != this) { if (((IOwned)label).Owner is DisassembledOperations <DelegateType> ) { return(Leave(label.Name)); } FailOwnership(label); } if (!TryBlocks.Any(t => t.Value.Item2 == -1) && !CatchBlocks.Any(c => c.Value.Item2 == -1)) { throw new InvalidOperationException("Leave can only be used within an exception or catch block"); } // Note that Leave *always* nuked the stack; nothing survies exiting an exception block UpdateOpCodeDelegate update; UpdateState(OpCodes.Leave, label, Wrap(new[] { new StackTransition(new [] { typeof(PopAllType) }, TypeHelpers.EmptyTypes) }, "Leave"), out update); Branches.Add(SigilTuple.Create(OpCodes.Leave, label, IL.Index)); BranchPatches[IL.Index] = SigilTuple.Create(label, update, OpCodes.Leave); MustMark = true; var valid = CurrentVerifiers.UnconditionalBranch(label); if (!valid.Success) { throw new SigilVerificationException("Leave", valid, IL.Instructions(AllLocals)); } return(this); }
private void ValidateTryCatchFinallyBranches() { foreach (var branch in Branches.AsEnumerable()) { var instr = BranchPatches[branch.Item3]; var toLabel = branch.Item2; var fromIndex = branch.Item3; var toIndex = Marks[toLabel]; var fromTryBlocks = TryBlocks.Where(t => fromIndex >= t.Value.Item1 && fromIndex <= t.Value.Item2).ToList(); var fromCatchBlocks = CatchBlocks.Where(c => fromIndex >= c.Value.Item1 && fromIndex <= c.Value.Item2).ToList(); var fromFinallyBlocks = FinallyBlocks.Where(f => fromIndex >= f.Value.Item1 && fromIndex <= f.Value.Item2).ToList(); var toTryBlocks = TryBlocks.Where(t => toIndex >= t.Value.Item1 && toIndex <= t.Value.Item2).ToList(); var toCatchBlocks = CatchBlocks.Where(c => toIndex >= c.Value.Item1 && toIndex <= c.Value.Item2).ToList(); var toFinallyBlocks = FinallyBlocks.Where(f => toIndex >= f.Value.Item1 && toIndex <= f.Value.Item2).ToList(); var fromTryBlock = fromTryBlocks.OrderByDescending(t => t.Value.Item1).Select(t => t.Key).FirstOrDefault(); var fromCatchBlock = fromCatchBlocks.OrderByDescending(c => c.Value.Item1).Select(c => c.Key).FirstOrDefault(); var fromFinallyBlock = fromFinallyBlocks.OrderByDescending(f => f.Value.Item1).Select(f => f.Key).FirstOrDefault(); var toTryBlock = toTryBlocks.OrderByDescending(t => t.Value.Item1).Select(t => t.Key).FirstOrDefault(); var toCatchBlock = toCatchBlocks.OrderByDescending(c => c.Value.Item1).Select(c => c.Key).FirstOrDefault(); var toFinallyBlock = toFinallyBlocks.OrderByDescending(f => f.Value.Item1).Select(f => f.Key).FirstOrDefault(); // Nothing funky going on, carry on if (fromTryBlock == null && fromCatchBlock == null && fromFinallyBlock == null && toTryBlock == null && toCatchBlock == null && toFinallyBlock == null) { continue; } if (fromCatchBlock != null && toCatchBlock != fromCatchBlock) { if (instr.Item3 != OpCodes.Leave) { throw new SigilVerificationException( "Cannot branch from inside " + fromCatchBlock + " to outside, exit the ExceptionBlock first", IL.Instructions(AllLocals) ); } } if (fromFinallyBlock != null && toFinallyBlock != fromFinallyBlock) { throw new SigilVerificationException( "Cannot branch from inside " + fromFinallyBlock + " to outside, exit the ExceptionBlock first", IL.Instructions(AllLocals) ); } if (toFinallyBlock != null && fromFinallyBlock != toFinallyBlock) { throw new SigilVerificationException( "Cannot branch into a FinallyBlock", IL.Instructions(AllLocals) ); } if (fromTryBlock != null && toTryBlock != fromTryBlock) { if (instr.Item3 != OpCodes.Leave) { throw new SigilVerificationException( "Cannot branch from inside " + fromTryBlock + " to outside, exit the ExceptionBlock first", IL.Instructions(AllLocals) ); } } } }