[interpreter]: Changes to interpreter builtins for accumulator and register file registers.

src/compiler/interpreter-assembler.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_INTERPRETER_CODEGEN_H_
 #define V8_COMPILER_INTERPRETER_CODEGEN_H_
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 // Do not include anything from src/compiler here!
 #include "src/allocation.h"
 #include "src/base/smart-pointers.h"
 #include "src/frames.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
 class Zone;
 
 namespace compiler {
 
 class CallDescriptor;
-class CommonOperatorBuilder;
 class Graph;
-class MachineOperatorBuilder;
 class Node;
 class Operator;
 class RawMachineAssembler;
 class Schedule;
 
 class InterpreterAssembler {
  public:
   InterpreterAssembler(Isolate* isolate, Zone* zone,
                        interpreter::Bytecode bytecode);
   virtual ~InterpreterAssembler();
 
   Handle<Code> GenerateCode();
 
+  // Accumulator.
+  Node* IncomingAccumulator();

[titzer, 2015/08/14 12:42:20]

The distinction between "incoming" accumulator and the "outgoing" accumulator is
somewhat confusing. E.g. it really only makes sense from the perspective of the
user of the assembler. Maybe just "GetAccumulator() and SetAccumulator()", since
the assembler is just holding the current state?

[rmcilroy, 2015/08/14 14:03:41]

Good idea. Done.

+  void StoreAccumulator(Node* value);
+
   // Constants.
   Node* Int32Constant(int value);
   Node* NumberConstant(double value);
   Node* HeapConstant(Unique<HeapObject> object);
 
-  // Returns the bytecode operand |index| for the current bytecode.
-  Node* BytecodeOperand(int index);
-
   // Loads from and stores to the interpreter register file.
-  Node* LoadRegister(int index);
-  Node* LoadRegister(Node* index);
-  Node* StoreRegister(Node* value, int index);
-  Node* StoreRegister(Node* value, Node* index);
+  Node* LoadRegister(Node* reg_index);
+  Node* StoreRegister(Node* value, Node* reg_index);
 
   // Returns from the function.
   void Return();
 
   // Dispatch to the bytecode.
   void Dispatch();
 
+  Node* BytecodeOperand(int index);
+  Node* BytecodeOperandSignExtended(int index);
+
  protected:
-  static const int kFirstRegisterOffsetFromFp =
-      -kPointerSize - StandardFrameConstants::kFixedFrameSizeFromFp;
-
-  // TODO(rmcilroy): Increase this when required.
-  static const int kMaxRegisterIndex = 255;
-
   // Close the graph.
   void End();
 
   // Protected helpers (for testing) which delegate to RawMachineAssembler.
   CallDescriptor* call_descriptor() const;
   Graph* graph();
 
  private:
+  // Returns a raw pointer to start of the register file on the stack.
+  Node* RegisterFilePointer();

[titzer, 2015/08/14 12:42:20]

Can we name this RegisterFileRawPointer() and the one below
BytecodeArrayTaggedPointer() to keep them straight?

[rmcilroy, 2015/08/14 14:03:41]

Done (also done for DispatchTablePointer below)

   // Returns a tagged pointer to the current function's BytecodeArray object.
   Node* BytecodeArrayPointer();
   // Returns the offset from the BytecodeArrayPointer of the current bytecode.
   Node* BytecodeOffset();
   // Returns a pointer to first entry in the interpreter dispatch table.
   Node* DispatchTablePointer();
-  // Returns the frame pointer for the current function.
-  Node* FramePointer();
 
-  // Returns the offset of register |index|.
-  Node* RegisterFrameOffset(int index);
+  // Returns the offset of register |index| relative to RegisterFilePointer().
   Node* RegisterFrameOffset(Node* index);
 
   // Returns BytecodeOffset() advanced by delta bytecodes. Note: this does not
   // update BytecodeOffset() itself.
   Node* Advance(int delta);
 
+  // Returns the outgoing accumulator value, which is either by
+  // SetOutgoingAccumulator or is the IncomingAccumulator.
+  Node* OutgoingAccumulator();
+
   // Sets the end node of the graph.
   void SetEndInput(Node* input);
 
   // Private helpers which delegate to RawMachineAssembler.
   Isolate* isolate();
   Schedule* schedule();
-  MachineOperatorBuilder* machine();
-  CommonOperatorBuilder* common();
 
   interpreter::Bytecode bytecode_;
   base::SmartPointer<RawMachineAssembler> raw_assembler_;
   Node* end_node_;
+  Node* outgoing_accumulator_;
   bool code_generated_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpreterAssembler);
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INTERPRETER_CODEGEN_H_