[Interpreter] Basic flow control.

src/interpreter/bytecode-array-builder.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_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_
 #define V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_
 
 #include <vector>
 
 #include "src/ast.h"
 #include "src/identity-map.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/zone.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
 
 namespace interpreter {
 
+class BytecodeLabel;
 class Register;
 
 class BytecodeArrayBuilder {
  public:
   BytecodeArrayBuilder(Isolate* isolate, Zone* zone);
   Handle<BytecodeArray> ToBytecodeArray();
 
   // Set number of parameters expected by function.
   void set_parameter_count(int number_of_params);
   int parameter_count() const;
 
   // Set number of locals required for bytecode array.
   void set_locals_count(int number_of_locals);
   int locals_count() const;
 
   // Returns true if the bytecode has an explicit return at the end.
   bool HasExplicitReturn();
 
   Register Parameter(int parameter_index);
 
   // 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();
   BytecodeArrayBuilder& LoadTrue();
   BytecodeArrayBuilder& LoadFalse();
 
   // Register-accumulator transfers.
   BytecodeArrayBuilder& LoadAccumulatorWithRegister(Register reg);
   BytecodeArrayBuilder& StoreAccumulatorInRegister(Register reg);
 
@@ skipping 11 matching lines @@
                                            int feedback_slot,
                                            LanguageMode language_mode);
 
   // Call a JS function. The JSFunction or Callable to be called should be in
   // |callable|, the receiver should be in |receiver| and all subsequent
   // arguments should be in registers <receiver + 1> to
   // <receiver + 1 + arg_count>.
   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);
+  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);
 
-  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);
+  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;
 
   size_t GetConstantPoolEntry(Handle<Object> object);
 
   int BorrowTemporaryRegister();
   void ReturnTemporaryRegister(int reg_index);
 
   Isolate* isolate_;
   ZoneVector<uint8_t> bytecodes_;
   bool bytecode_generated_;
 
   IdentityMap<size_t> constants_map_;
   ZoneVector<Handle<Object>> constants_;
+  ZoneSet<BytecodeLabel*> forward_labels_;
+  ZoneSet<BytecodeLabel*> bound_labels_;
 
   int parameter_count_;
   int local_register_count_;
   int temporary_register_count_;
   int temporary_register_next_;
 
   friend class TemporaryRegisterScope;
   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 {
  public:
   explicit TemporaryRegisterScope(BytecodeArrayBuilder* builder);
   ~TemporaryRegisterScope();
   Register NewRegister();
 
  private:
   void* operator new(size_t size);
   void operator delete(void* p);
 
   BytecodeArrayBuilder* builder_;
   int count_;
   int last_register_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TemporaryRegisterScope);
 };
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_