private Result RewriteIndexAssignment(BinaryExpression node, Stack stack) { var index = (IndexExpression)node.Left; var cr = new ChildRewriter(this, stack, 2 + index.ArgumentCount); cr.Add(index.Object); cr.AddArguments(index); cr.Add(node.Right); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefInstance(index.Object); } if (cr.Rewrite) { node = new AssignBinaryExpression ( new IndexExpression ( cr[0], // Object index.Indexer, cr[1, -2] // arguments ), cr[-1] // value ); } return(cr.Finish(node)); }
internal override Expression AsExpression(Expression target) { RequireNoValueProperty(); RequireNotRefInstance(target); MemberExpression member = Expression.MakeMemberAccess(target, _binding.Member); ParameterExpression memberTemp = _spiller.MakeTemp(member.Type); Expression[] block = new Expression[_inits.Count + 2]; block[0] = Expression.Assign(memberTemp, member); for (int i = 0; i < _inits.Count; i++) { ChildRewriter cr = _childRewriters[i]; Result add = cr.Finish(Expression.Call(memberTemp, _inits[i].AddMethod, cr[0, -1])); block[i + 1] = add.Node; } // We need to copy back value types if (memberTemp.Type.GetTypeInfo().IsValueType) { block[_inits.Count + 1] = Expression.Block( typeof(void), Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp) ); } else { block[_inits.Count + 1] = Utils.Empty(); } return(MakeBlock(block)); }
private Result RewriteBinaryExpression(Expression expr, Stack stack) { var node = (BinaryExpression)expr; var cr = new ChildRewriter(this, stack, 3); // Left expression executes on the stack as left by parent cr.Add(node.Left); // Right expression always has non-empty stack (left is on it) cr.Add(node.Right); // conversion is a lambda, stack state will be ignored cr.Add(node.Conversion); if (cr.Action == RewriteAction.SpillStack) { RequireNoRefArgs(node.Method); } return(cr.Finish ( cr.Rewrite ? BinaryExpression.Create ( node.NodeType, cr[0], cr[1], node.Type, node.Method, (LambdaExpression)cr[2] ) : expr )); }
private Result RewriteIndexExpression(Expression expr, Stack stack) { var node = (IndexExpression)expr; var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1); // For instance methods, the instance executes on the // stack as is, but stays on the stack, making it non-empty. cr.Add(node.Object); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefInstance(node.Object); } if (cr.Rewrite) { expr = new IndexExpression ( cr[0], node.Indexer, cr[1, -1] ); } return(cr.Finish(expr)); }
private Result RewriteNewArrayExpression(Expression expr, Stack stack) { var node = (NewArrayExpression)expr; if (node.NodeType == ExpressionType.NewArrayInit) { // In a case of array construction with element initialization // the element expressions are never emitted on an empty stack because // the array reference and the index are on the stack. stack = Stack.NonEmpty; } else { // In a case of NewArrayBounds we make no modifications to the stack // before emitting bounds expressions. } var cr = new ChildRewriter(this, stack, node.Expressions.Count); cr.Add(node.Expressions); if (cr.Rewrite) { expr = NewArrayExpression.Make(node.NodeType, node.Type, new TrueReadOnlyCollection <Expression>(cr[0, -1])); } return(cr.Finish(expr)); }
internal override MemberBinding AsBinding() { switch (_action) { case RewriteAction.None: return(_binding); case RewriteAction.Copy: ElementInit[] newInits = new ElementInit[_inits.Count]; for (int i = 0; i < _inits.Count; i++) { ChildRewriter cr = _childRewriters[i]; if (cr.Action == RewriteAction.None) { newInits[i] = _inits[i]; } else { newInits[i] = Expression.ElementInit(_inits[i].AddMethod, cr[0, -1]); } } return(Expression.ListBind(_binding.Member, new TrueReadOnlyCollection <ElementInit>(newInits))); } throw ContractUtils.Unreachable; }
private Result RewriteMethodCallExpression(Expression expr, Stack stack) { MethodCallExpression node = (MethodCallExpression)expr; var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1); // For instance methods, the instance executes on the // stack as is, but stays on the stack, making it non-empty. cr.Add(node.Object); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefInstance(node.Object); cr.MarkRefArgs(node.Method, startIndex: 1); } if (cr.Rewrite) { if (node.Object != null) { expr = new InstanceMethodCallExpressionN(node.Method, cr[0], cr[1, -1]); } else { expr = new MethodCallExpressionN(node.Method, cr[1, -1]); } } return(cr.Finish(expr)); }
//RewriteIndexExpression private Result RewriteIndexExpression(Expression expr, Stack stack) { IndexExpression node = (IndexExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); // For instance methods, the instance executes on the // stack as is, but stays on the stack, making it non-empty. cr.Add(node.Object); cr.Add(node.Arguments); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNotRefInstance(node.Object); #else MarkRefInstance(cr, node.Object); #endif } if (cr.Rewrite) { expr = CreateIndexExpression( cr[0], node.Indexer, cr[1, -1] ); } return(cr.Finish(expr)); }
internal override MemberBinding AsBinding() { switch (Action) { case RewriteAction.None: return(Binding); case RewriteAction.Copy: int count = _initializers.Count; ElementInit[] newInitializer = new ElementInit[count]; for (int i = 0; i < count; i++) { ChildRewriter cr = _childRewriters[i]; if (cr.Action == RewriteAction.None) { newInitializer[i] = _initializers[i]; } else { newInitializer[i] = new ElementInit(_initializers[i].AddMethod, cr[0, -1]); } } return(new MemberListBinding(Binding.Member, new TrueReadOnlyCollection <ElementInit>(newInitializer))); } throw ContractUtils.Unreachable; }
private Result RewriteMemberAssignment(BinaryExpression node, Stack stack) { var lvalue = (MemberExpression)node.Left; var cr = new ChildRewriter(this, stack, 2); // If there's an instance, it executes on the stack in current state // and rest is executed on non-empty stack. // Otherwise the stack is left unchanged. cr.Add(lvalue.Expression); cr.Add(node.Right); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefInstance(lvalue.Expression); } if (cr.Rewrite) { return(cr.Finish ( new AssignBinaryExpression ( MemberExpression.Make(cr[0], lvalue.Member), cr[1] ) )); } return(new Result(RewriteAction.None, node)); }
internal override Expression AsExpression(Expression target) { if (target.Type.IsValueType && _binding.Member is System.Reflection.PropertyInfo) { throw Error.CannotAutoInitializeValueTypeElementThroughProperty(_binding.Member); } RequireNotRefInstance(target); MemberExpression member = Expression.MakeMemberAccess(target, _binding.Member); ParameterExpression memberTemp = _spiller.MakeTemp(member.Type); Expression[] block = new Expression[_inits.Count + 2]; block[0] = Expression.Assign(memberTemp, member); for (int i = 0; i < _inits.Count; i++) { ChildRewriter cr = _childRewriters[i]; Result add = cr.Finish(Expression.Call(memberTemp, _inits[i].AddMethod, cr[0, -1])); block[i + 1] = add.Node; } // We need to copy back value types if (memberTemp.Type.IsValueType) { block[_inits.Count + 1] = Expression.Block( typeof(void), Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp) ); } else { block[_inits.Count + 1] = Expression.Empty(); } return(MakeBlock(block)); }
internal override Expression AsExpression(Expression target) { RequireNoValueProperty(); Expression member = MemberExpression.Make(target, _binding.Member); Expression memberTemp = _spiller.MakeTemp(member.Type); int count = _inits.Count; Expression[] block = new Expression[count + 2]; block[0] = new AssignBinaryExpression(memberTemp, member); for (int i = 0; i < count; i++) { ChildRewriter cr = _childRewriters[i]; Result add = cr.Finish(new InstanceMethodCallExpressionN(_inits[i].AddMethod, memberTemp, cr[0, -1] !)); block[i + 1] = add.Node; } // We need to copy back value types if (memberTemp.Type.IsValueType) { block[count + 1] = Expression.Block( typeof(void), new AssignBinaryExpression(MemberExpression.Make(target, _binding.Member), memberTemp) ); } else { block[count + 1] = Utils.Empty; } return(MakeBlock(block)); }
// MethodCallExpression private Result RewriteMethodCallExpression(Expression expr, Stack stack) { MethodCallExpression node = (MethodCallExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); // For instance methods, the instance executes on the // stack as is, but stays on the stack, making it non-empty. cr.Add(node.Object); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNotRefInstance(node.Object); RequireNoRefArgs(node.Method); #else MarkRefInstance(cr, node.Object); MarkRefArgs(cr, node.Method, 1); #endif } return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr)); }
private Result RewriteMemberExpression(Expression expr, Stack stack) { MemberExpression node = (MemberExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, 1); cr.Add(node.Expression); if (cr.Rewrite) { if (cr.Action == RewriteAction.SpillStack && node.Member is PropertyInfo) { // Only need to validate propreties because reading a field // is always side-effect free. #if LINQ RequireNotRefInstance(node.Expression); #else MarkRefInstance(cr, node.Expression); #endif } expr = MemberExpressionStubs.Make(cr[0], node.Member); } return(cr.Finish(expr)); }
private Result RewriteIndexAssignment(BinaryExpression node, Stack stack) { IndexExpression index = (IndexExpression)node.Left; ChildRewriter cr = new ChildRewriter(this, stack, 2 + index.Arguments.Count); cr.Add(index.Object); cr.Add(index.Arguments); cr.Add(node.Right); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNotRefInstance(index.Object); #else MarkRefInstance(cr, index.Object); #endif } if (cr.Rewrite) { node = CreateAssignBinaryExpression( CreateIndexExpression( cr[0], // Object index.Indexer, cr[1, -2] // arguments ), cr[-1] // value ); } return(cr.Finish(node)); }
private static void MarkRefInstance(ChildRewriter cr, Expression instance) { // Primitive value types are okay because they are all readonly, // but we can't rely on this for non-primitive types. For those // we have to spill the by ref local. if (instance != null && instance.Type.GetTypeInfo().IsValueType&& instance.Type.GetTypeCode() == TypeCode.Object) { cr.MarkByRef(0); } }
// NewExpression private Result RewriteNewExpression(Expression expr, Stack stack) { NewExpression node = (NewExpression)expr; // The first expression starts on a stack as provided by parent, // rest are definitely non-emtpy (which ChildRewriter guarantees) ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count); cr.Add(node.Arguments); return(cr.Finish(cr.Rewrite ? new NewExpression(node.Constructor, cr[0, -1], node.Members) : expr)); }
// InvocationExpression private Result RewriteInvocationExpression(Expression expr, Stack stack) { InvocationExpression node = (InvocationExpression)expr; ChildRewriter cr; #if LINQ // NB: Our compiler doesn't inline; this could still happen at a later stage in the LINQ compiler after lowering async lambdas to sync ones. // See if the lambda will be inlined LambdaExpression lambda = node.LambdaOperand(); if (lambda != null) { // Arguments execute on current stack cr = new ChildRewriter(this, stack, node.Arguments.Count); cr.Add(node.Arguments); if (cr.Action == RewriteAction.SpillStack) { RequireNoRefArgs(ExpressionStubs.GetInvokeMethod(node.Expression)); } // Lambda body also executes on current stack var spiller = new StackSpiller(stack); lambda = lambda.Accept(spiller); if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None) { node = node.Rewrite(lambda, cr[0, -1]); } Result result = cr.Finish(node); return(new Result(result.Action | spiller._lambdaRewrite, result.Node)); } #endif cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); // first argument starts on stack as provided cr.Add(node.Expression); // rest of arguments have non-empty stack (delegate instance on the stack) cr.Add(node.Arguments); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNoRefArgs(ExpressionStubs.GetInvokeMethod(node.Expression)); #else MarkRefArgs(cr, ExpressionStubs.GetInvokeMethod(node.Expression), 1); #endif } return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr)); }
// MethodCallExpression // TODO: ref parameters!!! private Result RewriteMethodCallExpression(Expression expr, Stack stack) { MethodCallExpression node = (MethodCallExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); // For instance methods, the instance executes on the // stack as is, but stays on the stack, making it non-empty. cr.Add(node.Object); cr.Add(node.Arguments); return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr)); }
// InvocationExpression private Result RewriteInvocationExpression(Expression expr, Stack stack) { InvocationExpression node = (InvocationExpression)expr; // first argument starts on stack as provided ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); cr.Add(node.Expression); // rest of arguments have non-empty stack (delegate instance on the stack) cr.Add(node.Arguments); return(cr.Finish(cr.Rewrite ? new InvocationExpression(cr[0], cr[1, -1], node.Type) : expr)); }
private Result RewriteAwaitExpression(Expression expr, Stack stack) { var node = (AwaitCSharpExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, 1); cr.Add(node.Operand); // NB: We always spill the stack for await, so unconditionally rewrite. var res = cr.Finish(node.Rewrite(cr[0], node.Info)); return(new Result(RewriteAction.SpillStack, res.Node)); }
private Result RewriteDynamicExpression(Expression expr, Stack stack) { var node = (IDynamicExpression)expr; // CallSite is on the stack ChildRewriter cr = new ChildRewriter(this, Stack.NonEmpty, node.ArgumentCount); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { RequireNoRefArgs(node.DelegateType.GetMethod("Invoke")); } return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0, -1]) : expr)); }
private Result RewriteAwaitExpression(Expression expr, Stack stack) { var node = (AwaitCSharpExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, 1); cr.Add(node.Operand); // NB: We always spill the stack for await, so unconditionally rewrite. var res = cr.Finish(node.Rewrite(cr[0])); return new Result(RewriteAction.SpillStack, res.Node); }
private static void MarkRefArgs(ChildRewriter cr, MethodBase method, int firstIndex) { if (method != null) { var parameters = method.GetParametersCached(); for (int i = 0, j = firstIndex; i < parameters.Length; i++, j++) { var parameter = parameters[i]; if (parameter.ParameterType.IsByRef) { cr.MarkByRef(j); } } } }
private Result RewriteDynamicExpression(Expression expr, Stack stack) { var node = (DynamicExpression)expr; // CallSite is on the stack IArgumentProvider argNode = (IArgumentProvider)node; int argCount = argNode.ArgumentCount; ChildRewriter cr = new ChildRewriter(this, Stack.NonEmpty, argCount); for (int i = 0; i < argCount; i++) { cr.Add(argNode.GetArgument(i)); } return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0, -1]) : expr)); }
private Result RewriteInvocationExpression(Expression expr, Stack stack) { var node = (InvocationExpression)expr; ChildRewriter cr; // See if the lambda will be inlined. LambdaExpression lambda = node.LambdaOperand; if (lambda != null) { // Arguments execute on current stack. cr = new ChildRewriter(this, stack, node.ArgumentCount); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 0); } // Lambda body also executes on current stack. var spiller = new StackSpiller(stack); lambda = lambda.Accept(spiller); if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None) { node = new InvocationExpressionN(lambda, cr[0, -1], node.Type); } Result result = cr.Finish(node); return(new Result(result.Action | spiller._lambdaRewrite, result.Node)); } cr = new ChildRewriter(this, stack, node.ArgumentCount + 1); // First argument starts on stack as provided. cr.Add(node.Expression); // Rest of arguments have non-empty stack (the delegate instance is on the stack). cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 1); } return(cr.Finish(cr.Rewrite ? new InvocationExpressionN(cr[0], cr[1, -1], node.Type) : expr)); }
// InvocationExpression private Result RewriteInvocationExpression(Expression expr, Stack stack) { InvocationExpression node = (InvocationExpression)expr; ChildRewriter cr; // See if the lambda will be inlined LambdaExpression lambda = node.LambdaOperand; if (lambda != null) { // Arguments execute on current stack cr = new ChildRewriter(this, stack, node.Arguments.Count); cr.Add(node.Arguments); if (cr.Action == RewriteAction.SpillStack) { RequireNoRefArgs(Expression.GetInvokeMethod(node.Expression)); } // Lambda body also executes on current stack var spiller = new StackSpiller(stack); lambda = lambda.Accept(spiller); if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None) { node = node.Rewrite(lambda, cr[0, -1]); } Result result = cr.Finish(node); return(new Result(result.Action | spiller._lambdaRewrite, result.Node)); } cr = new ChildRewriter(this, stack, node.Arguments.Count + 1); // first argument starts on stack as provided cr.Add(node.Expression); // rest of arguments have non-empty stack (delegate instance on the stack) cr.Add(node.Arguments); if (cr.Action == RewriteAction.SpillStack) { RequireNoRefArgs(Expression.GetInvokeMethod(node.Expression)); } return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr)); }
internal ListBindingRewriter(MemberListBinding memberBinding, StackSpiller stackSpiller, Stack stack) : base(memberBinding, stackSpiller) { _inits = memberBinding.Initializers; _childRewriters = new ChildRewriter[_inits.Count]; for (var i = 0; i < _inits.Count; i++) { var init = _inits[i]; var cr = new ChildRewriter(stackSpiller, stack, init.Arguments.Count); cr.Add(init.Arguments); RewriteAction |= cr.Action; _childRewriters[i] = cr; } }
internal ListBindingRewriter(MemberListBinding binding, StackSpiller spiller, Stack stack) : base(binding, spiller) { _inits = binding.Initializers; _childRewriters = new ChildRewriter[_inits.Count]; for (int i = 0; i < _inits.Count; i++) { ElementInit init = _inits[i]; ChildRewriter cr = new ChildRewriter(spiller, stack, init.Arguments.Count); cr.Add(init.Arguments); _action |= cr.Action; _childRewriters[i] = cr; } }
private Result RewriteNewExpression(Expression expr, Stack stack) { var node = (NewExpression)expr; // The first expression starts on a stack as provided by parent, // rest are definitely non-empty (which ChildRewriter guarantees). var cr = new ChildRewriter(this, stack, node.ArgumentCount); cr.AddArguments(node); if (cr.Action == RewriteAction.SpillStack) { cr.MarkRefArgs(node.Constructor, startIndex: 0); } return(cr.Finish(cr.Rewrite ? new NewExpression(node.Constructor, cr[0, -1], node.Members) : expr)); }
internal ListBindingRewriter(MemberListBinding binding, StackSpiller spiller, Stack stack) : base(binding, spiller) { _initializers = binding.Initializers; var count = _initializers.Count; _childRewriters = new ChildRewriter[count]; for (var i = 0; i < count; i++) { var init = _initializers[i]; var cr = new ChildRewriter(spiller, stack, init.Arguments.Count); cr.Add(init.Arguments); Action |= cr.Action; _childRewriters[i] = cr; } }