Introduce 'top-of-stack caching' to the toplevel code generator by...

src/fast-codegen.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 29 matching lines @@
 
 class FastCodeGenerator: public AstVisitor {
  public:
   FastCodeGenerator(MacroAssembler* masm, Handle<Script> script, bool is_eval)
       : masm_(masm),
         function_(NULL),
         script_(script),
         is_eval_(is_eval),
         nesting_stack_(NULL),
         loop_depth_(0),
+        location_(kStack),
         true_label_(NULL),
         false_label_(NULL) {
   }
 
   static Handle<Code> MakeCode(FunctionLiteral* fun,
                                Handle<Script> script,
                                bool is_eval);
 
   void Generate(FunctionLiteral* fun);
 
@@ skipping 143 matching lines @@
     virtual int Exit(int stack_depth) {
       return stack_depth + kForInStackElementCount;
     }
    private:
     // TODO(lrn): Check that this value is correct when implementing
     // for-in.
     static const int kForInStackElementCount = 5;
     DISALLOW_COPY_AND_ASSIGN(ForIn);
   };
 
+  enum Location {
+    kAccumulator,
+    kStack
+  };
 
   int SlotOffset(Slot* slot);
 
-  // Emit code to complete the evaluation of an expression based on its
-  // expression context and given its value is in a register, non-lookup
-  // slot, or a literal.
+  // Emit code to convert a pure value (in a register, slot, as a literal,
+  // or on top of the stack) into the result expected according to an
+  // expression context.
   void Apply(Expression::Context context, Register reg);
-  void Apply(Expression::Context context, Slot* slot, Register scratch);
+  void Apply(Expression::Context context, Slot* slot);
   void Apply(Expression::Context context, Literal* lit);
-
-  // Emit code to complete the evaluation of an expression based on its
-  // expression context and given its value is on top of the stack.
   void ApplyTOS(Expression::Context context);
 
-  // Emit code to discard count elements from the top of stack, then
-  // complete the evaluation of an expression based on its expression
-  // context and given its value is in a register.
+  // Emit code to discard count elements from the top of stack, then convert
+  // a pure value into the result expected according to an expression
+  // context.
   void DropAndApply(int count, Expression::Context context, Register reg);
 
+  // Emit code to convert pure control flow to a pair of labels into the
+  // result expected according to an expression context.
+  void Apply(Expression::Context context,
+             Label* materialize_true,
+             Label* materialize_false);
+
+  // Helper function to convert a pure value into a test context.  The value
+  // is expected on the stack or the accumulator, depending on the platform.
+  // See the platform-specific implementation for details.
+  void DoTest(Expression::Context context);
+
   void Move(Slot* dst, Register source, Register scratch1, Register scratch2);
   void Move(Register dst, Slot* source);
 
   // Return an operand used to read/write to a known (ie, non-LOOKUP) slot.
   // May emit code to traverse the context chain, destroying the scratch
   // register.
   MemOperand EmitSlotSearch(Slot* slot, Register scratch);
 
-  // Test the JavaScript value in source as if in a test context, compile
-  // control flow to a pair of labels.
-  void TestAndBranch(Register source, Label* true_label, Label* false_label);
+  void VisitForValue(Expression* expr, Location where) {
+    ASSERT(expr->context() == Expression::kValue);
+    Location saved_location = location_;
+    location_ = where;
+    Visit(expr);
+    location_ = saved_location;
+  }
 
   void VisitForControl(Expression* expr, Label* if_true, Label* if_false) {
     ASSERT(expr->context() == Expression::kTest ||
            expr->context() == Expression::kValueTest ||
            expr->context() == Expression::kTestValue);
     Label* saved_true = true_label_;
     Label* saved_false = false_label_;
     true_label_ = if_true;
     false_label_ = if_false;
     Visit(expr);
@@ skipping 17 matching lines @@
   // Platform-specific support for compiling assignments.
 
   // Load a value from a named property.
   // The receiver is left on the stack by the IC.
   void EmitNamedPropertyLoad(Property* expr);
 
   // Load a value from a keyed property.
   // The receiver and the key is left on the stack by the IC.
   void EmitKeyedPropertyLoad(Property* expr);
 
-  // Apply the compound assignment operator. Expects both operands on top
-  // of the stack.
-  void EmitCompoundAssignmentOp(Token::Value op, Expression::Context context);
+  // Apply the compound assignment operator. Expects the left operand on top
+  // of the stack and the right one in the accumulator.
+  void EmitBinaryOp(Token::Value op, Expression::Context context);
 
   // Complete a variable assignment.  The right-hand-side value is expected
-  // on top of the stack.
+  // in the accumulator.
   void EmitVariableAssignment(Variable* var, Expression::Context context);
 
-  // Complete a named property assignment.  The receiver and right-hand-side
-  // value are expected on top of the stack.
+  // Complete a named property assignment.  The receiver is expected on top
+  // of the stack and the right-hand-side value in the accumulator.
   void EmitNamedPropertyAssignment(Assignment* expr);
 
-  // Complete a keyed property assignment.  The reciever, key, and
-  // right-hand-side value are expected on top of the stack.
+  // Complete a keyed property assignment.  The receiver and key are
+  // expected on top of the stack and the right-hand-side value in the
+  // accumulator.
   void EmitKeyedPropertyAssignment(Assignment* expr);
 
   void SetFunctionPosition(FunctionLiteral* fun);
   void SetReturnPosition(FunctionLiteral* fun);
   void SetStatementPosition(Statement* stmt);
   void SetStatementPosition(int pos);
   void SetSourcePosition(int pos);
 
   // Non-local control flow support.
   void EnterFinallyBlock();
@@ skipping 27 matching lines @@
   void EmitLogicalOperation(BinaryOperation* expr);
 
   MacroAssembler* masm_;
   FunctionLiteral* function_;
   Handle<Script> script_;
   bool is_eval_;
   Label return_label_;
   NestedStatement* nesting_stack_;
   int loop_depth_;
 
+  Location location_;
   Label* true_label_;
   Label* false_label_;
 
   friend class NestedStatement;
 
   DISALLOW_COPY_AND_ASSIGN(FastCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FAST_CODEGEN_H_