private Emit(CallingConventions callConvention, Type returnType, Type[] parameterTypes, bool allowUnverifiable, bool doVerify, bool strictBranchVerification) { CallingConventions = callConvention; AllowsUnverifiableCIL = allowUnverifiable; IsVerifying = doVerify; UsesStrictBranchVerification = strictBranchVerification; ReturnType = TypeOnStack.Get(returnType); ParameterTypes = parameterTypes; IL = new BufferedILGenerator <DelegateType>(); Trackers = new LinqList <VerifiableTracker>(); AllLocals = new LinqList <Local>(); UnusedLocals = new LinqHashSet <Local>(); UnusedLabels = new LinqHashSet <Label>(); UnmarkedLabels = new LinqHashSet <Label>(); Branches = new LinqList <SigilTuple <OpCode, Label, int> >(); Marks = new LinqDictionary <Label, int>(); Returns = new LinqList <int>(); Throws = new LinqList <int>(); BranchPatches = new LinqDictionary <int, SigilTuple <Label, UpdateOpCodeDelegate, OpCode> >(); CurrentExceptionBlock = new Stack <ExceptionBlock>(); TryBlocks = new LinqDictionary <ExceptionBlock, SigilTuple <int, int> >(); CatchBlocks = new LinqDictionary <CatchBlock, SigilTuple <int, int> >(); FinallyBlocks = new LinqDictionary <FinallyBlock, SigilTuple <int, int> >(); ReadonlyPatches = new LinqList <SigilTuple <int, TypeOnStack> >(); Shorthand = new EmitShorthand <DelegateType>(this); FreedLocals = new LinqList <Local>(); CurrentLocals = new LinqDictionary <string, Local>(); Locals = new LocalLookup(CurrentLocals); CurrentLabels = new LinqDictionary <string, Label>(); Labels = new LabelLookup(CurrentLabels); ElidableCasts = new LinqList <int>(); TypesProducedAtIndex = new LinqDictionary <int, LinqList <TypeOnStack> >(); var start = DefineLabel("__start"); CurrentVerifiers = IsVerifying ? new RollingVerifier(start, UsesStrictBranchVerification) : new RollingVerifierWithoutVerification(start); MarkLabel(start); }
public RollingVerifier(Label beginAt, bool strictBranchVerification) { UsesStrictBranchVerification = strictBranchVerification; RestoreOnMark = new LinqDictionary<Label, LinqList<VerifiableTracker>>(); RestoreStacksOnMark = new LinqDictionary<Label, LinqList<LinqStack<LinqList<TypeOnStack>>>>(); VerifyFromLabel = new LinqDictionary<Label, LinqList<VerifiableTracker>>(); StacksAtLabels = new LinqDictionary<Label, SigilTuple<bool, LinqStack<LinqList<TypeOnStack>>>>(); ExpectedStacksAtLabels = new LinqDictionary<Label, LinqList<SigilTuple<bool, LinqStack<LinqList<TypeOnStack>>>>>(); MustBeEmptyWhenBranchedTo = new LinqHashSet<Label>(); EmptyCurrentScope(); Add(new VerifiableTracker(beginAt), new LinqStack<LinqList<TypeOnStack>>()); }
private void ValidateDelegateType(Type delegateType) { var baseTypes = new LinqHashSet <Type>(); baseTypes.Add(delegateType); var bType = TypeHelpers.GetBaseType(delegateType); while (bType != null) { baseTypes.Add(bType); bType = TypeHelpers.GetBaseType(bType); } if (!baseTypes.Contains(typeof(Delegate))) { throw new ArgumentException("delegateType must be a delegate, found " + delegateType.FullName); } var invoke = delegateType.GetMethod("Invoke"); var returnType = invoke.ReturnType; if (returnType != ReturnType) { throw new ArgumentException("Expected delegateType to return " + ReturnType + ", found " + returnType); } var parameterTypes = invoke.GetParameters(); if (parameterTypes.Length != ParameterTypes.Length) { throw new ArgumentException("Expected delegateType to take " + ParameterTypes.Length + " parameters, found " + parameterTypes.Length); } for (var i = 0; i < parameterTypes.Length; i++) { var actualType = parameterTypes[i].ParameterType; var expectedType = ParameterTypes[i]; if (actualType != expectedType) { throw new ArgumentException("Expected delegateType's parameter at index " + i + " to be a " + expectedType + ", found " + actualType); } } }
private static void ValidateNewParameters <CheckDelegateType>() { var delType = typeof(CheckDelegateType); var baseTypes = new LinqHashSet <Type>(); baseTypes.Add(delType); var bType = delType.BaseType; while (bType != null) { baseTypes.Add(bType); bType = bType.BaseType; } if (!baseTypes.Contains(typeof(Delegate))) { throw new ArgumentException("DelegateType must be a delegate, found " + delType.FullName); } }
private static void ValidateNewParameters <CheckDelegateType>() { var delType = typeof(CheckDelegateType); var baseTypes = new LinqHashSet <Type>(); baseTypes.Add(delType); #if NETSTANDARD var bType = delType.GetTypeInfo().BaseType; #else var bType = delType.BaseType; #endif while (bType != null) { baseTypes.Add(bType); bType = TypeHelpers.GetBaseType(bType); } if (!baseTypes.Contains(typeof(Delegate))) { throw new ArgumentException("DelegateType must be a delegate, found " + delType.FullName); } }
private static void UpdateStack(LinqStack<LinqList<TypeOnStack>> stack, InstructionAndTransitions wrapped, bool isBaseless) { var legal = wrapped.Transitions; var instr = wrapped.Instruction; var legalSize = 0; legal.Each( t => { legalSize += t.PushedToStack.Length; if (t.Before != null) t.Before(stack, isBaseless); } ); if (legal.Any(l => LinqAlternative.Any(l.PoppedFromStack, u => u == TypeOnStack.Get<PopAllType>()))) { if (instr.HasValue) { for (var i = 0; i < stack.Count; i++) { var ix = stack.Count - i - 1; stack.ElementAt(i).Each(y => y.Mark(wrapped, ix)); } } stack.Clear(); } else { var toPop = legal.First().PoppedCount; for (var j = 0; j < toPop && stack.Count > 0; j++) { var popped = stack.Pop(); if (instr.HasValue) { var ix = toPop - j - 1; popped.Each(y => y.Mark(wrapped, ix)); } } } var toPush = new LinqList<TypeOnStack>(legalSize); var pushed = new LinqHashSet<TypeOnStack>(); for(var i = 0; i < legal.Count; i++) { foreach (var p in legal[i].PushedToStack) { if (pushed.Contains(p)) continue; toPush.Add(p); pushed.Add(p); } } if (toPush.Count > 0) { stack.Push(toPush); } }