[Interpreter] Basic flow control.

src/interpreter/bytecode-array-builder.h

Index: src/interpreter/bytecode-array-builder.h
diff --git a/src/interpreter/bytecode-array-builder.h b/src/interpreter/bytecode-array-builder.h
index f7a8dddebd3f77d78cc90ce58264ad3736b3be4e..e224d2975cb47589875842e4b9c32329fe29550e 100644
--- a/src/interpreter/bytecode-array-builder.h
+++ b/src/interpreter/bytecode-array-builder.h
@@ -20,6 +20,7 @@ class Isolate;
 
 namespace interpreter {
 
+class BytecodeLabel;
 class Register;
 
 class BytecodeArrayBuilder {
@@ -43,6 +44,8 @@ class BytecodeArrayBuilder {
   // Constant loads to accumulator.
   BytecodeArrayBuilder& LoadLiteral(v8::internal::Smi* value);
   BytecodeArrayBuilder& LoadLiteral(Handle<Object> object);
+  BytecodeArrayBuilder& LoadLiteral(int value);

[rmcilroy, 2015/09/18 10:42:23]

I would prefer not to add this since it's not clear if it will end up being a
smi or a heapnumber. It looks like it is only for tests - could you just do
LoadLiteral(Smi::FromInt(v)) in the tests where you need this?

[oth, 2015/09/23 10:46:55]

Done. The intent was to enable writing slightly cleaner tests. Ditto the
Add/Subtract/Multiple/Divide/Modulo change (which is also dropped).

+  BytecodeArrayBuilder& LoadLiteral(double value);
   BytecodeArrayBuilder& LoadUndefined();
   BytecodeArrayBuilder& LoadNull();
   BytecodeArrayBuilder& LoadTheHole();
@@ -74,21 +77,50 @@ class BytecodeArrayBuilder {
   BytecodeArrayBuilder& Call(Register callable, Register receiver,
                              size_t arg_count);
 
-  // Operators.
+  // Operators (register == lhs, accumulator = rhs).
   BytecodeArrayBuilder& BinaryOperation(Token::Value binop, Register reg);
+  BytecodeArrayBuilder& Add(Register reg);
+  BytecodeArrayBuilder& Subtract(Register reg);
+  BytecodeArrayBuilder& Multiply(Register reg);
+  BytecodeArrayBuilder& Divide(Register reg);
+  BytecodeArrayBuilder& Modulo(Register reg);
+
+  // Tests.
+  BytecodeArrayBuilder& CompareOperation(Token::Value op, Register reg);
 
   // Flow Control.
+  BytecodeArrayBuilder& Bind(BytecodeLabel* label);
+  BytecodeArrayBuilder& Jump(BytecodeLabel* label);
+  BytecodeArrayBuilder& JumpIfTrue(BytecodeLabel* label);
+  BytecodeArrayBuilder& JumpIfFalse(BytecodeLabel* label);
   BytecodeArrayBuilder& Return();
 
  private:
   static Bytecode BytecodeForBinaryOperation(Token::Value op);
-  static bool FitsInByteOperand(int value);
-  static bool FitsInByteOperand(size_t value);
-
-  void Output(Bytecode bytecode, uint8_t r0, uint8_t r1, uint8_t r2);
-  void Output(Bytecode bytecode, uint8_t r0, uint8_t r1);
-  void Output(Bytecode bytecode, uint8_t r0);
+  static Bytecode BytecodeForCompareOperation(Token::Value op);
+  static bool FitsInIdxOperand(int value);
+  static bool FitsInIdxOperand(size_t value);
+  static bool FitsInImm8Operand(int value);
+  static bool IsJumpWithSmi8Operand(Bytecode jump_bytecode);
+  static Bytecode GetJumpWithConstantOperand(Bytecode jump_with_smi8_operand);
+
+  ZoneVector<uint8_t>* bytecodes() { return &bytecodes_; }
+  const ZoneVector<uint8_t>* bytecodes() const { return &bytecodes_; }
+  Isolate* isolate() const { return isolate_; }
+
+  template <size_t N>
+  void RawOutputAt(ZoneVector<uint8_t>::iterator pos, uint8_t(&bytes)[N]);
+  void Output(const ZoneVector<uint8_t>::iterator& pos, Bytecode bytecode,
+              uint8_t operand);
+  void Output(Bytecode bytecode, uint8_t operand0, uint8_t operand1,
+              uint8_t operand2);
+  void Output(Bytecode bytecode, uint8_t operand0, uint8_t operand1);
+  void Output(Bytecode bytecode, uint8_t operand0);
   void Output(Bytecode bytecode);
+  void OutputJump(Bytecode jump_bytecode,
+                  const ZoneVector<uint8_t>::iterator& jump_location,
+                  const ZoneVector<uint8_t>::iterator& jump_target);
+  BytecodeArrayBuilder& Jump(Bytecode jump_bytecode, BytecodeLabel* label);
 
   bool OperandIsValid(Bytecode bytecode, int operand_index,
                       uint8_t operand_value) const;
@@ -104,6 +136,8 @@ class BytecodeArrayBuilder {
 
   IdentityMap<size_t> constants_map_;
   ZoneVector<Handle<Object>> constants_;
+  ZoneSet<BytecodeLabel*> forward_labels_;
+  ZoneSet<BytecodeLabel*> bound_labels_;
 
   int parameter_count_;
   int local_register_count_;
@@ -114,6 +148,31 @@ class BytecodeArrayBuilder {
   DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArrayBuilder);
 };
 
+
+// A label representing a branch target in a bytecode array. When a
+// label is bound, it represents a known position in the bytecode
+// array. For labels that are forward references there can be at most
+// one reference whilst it is unbound.
+class BytecodeLabel {
+ public:
+  static const size_t kUnbound = 0;
+  BytecodeLabel() : offset_(kUnbound) {}
+
+ private:
+  // For forward references |offset_| is the offset of the branch that
+  // refers to this label. For bound references it is the offset of
+  // the label itself in the bytecode array.
+  size_t offset_;
+
+  INLINE(void bind_to(size_t offset)) { offset_ = offset; }
+  INLINE(size_t offset() const) { return offset_; }
+
+  friend class BytecodeArrayBuilder;
+
+  DISALLOW_COPY_AND_ASSIGN(BytecodeLabel);
+};
+
+
 // A stack-allocated class than allows the instantiator to allocate
 // temporary registers that are cleaned up when scope is closed.
 class TemporaryRegisterScope {