/deps/v8/src/mips/lithium-mips.h - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/mips/lithium-mips.h

       V(InnerAllocatedObject)                       \
       V(InstanceOf)                                 \
       V(InstanceOfKnownGlobal)                      \
       V(InstanceSize)                               \
       V(InstructionGap)                             \
       V(Integer32ToDouble)                          \
       V(Integer32ToSmi)                             \
-...
       V(IsConstructCallAndBranch)                   \
       V(IsObjectAndBranch)                          \
       V(IsStringAndBranch)                          \
       V(IsNumberAndBranch)                          \
       V(IsSmiAndBranch)                             \
       V(IsUndetectableAndBranch)                    \
       V(Label)                                      \
       V(LazyBailout)                                \
       V(LoadContextSlot)                            \
       V(LoadExternalArrayPointer)                   \
       V(LoadRoot)                                   \
       V(LoadFieldByIndex)                           \
       V(LoadFunctionPrototype)                      \
       V(LoadGlobalCell)                             \
-...
           : environment_(NULL),
             hydrogen_value_(NULL),
             bit_field_(IsCallBits::encode(false)) {
         set_position(RelocInfo::kNoPosition);
+      }
       virtual ~LInstruction() {}
-...
       LPointerMap* pointer_map() const { return pointer_map_.get(); }
       bool HasPointerMap() const { return pointer_map_.is_set(); }
       // The 31 bits PositionBits is used to store the int position value. And the
       // position value may be RelocInfo::kNoPosition (-1). The accessor always
       // +1/-1 so that the encoded value of position in bit_field_ is always >= 0
       // and can fit into the 31 bits PositionBits.
       void set_position(int pos) {
         bit_field_ = PositionBits::update(bit_field_, pos + 1);
+      }
       int position() { return PositionBits::decode(bit_field_) - 1; }
       void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
       HValue* hydrogen_value() const { return hydrogen_value_; }
-...
       // Interface to the register allocator and iterators.
       bool ClobbersTemps() const { return IsCall(); }
       bool ClobbersRegisters() const { return IsCall(); }
       bool ClobbersDoubleRegisters() const { return IsCall(); }
       virtual bool ClobbersDoubleRegisters() const { return IsCall(); }
       // Interface to the register allocator and iterators.
       bool IsMarkedAsCall() const { return IsCall(); }
-...
       virtual LOperand* TempAt(int i) = 0;
       class IsCallBits: public BitField<bool, 0, 1> {};
       class PositionBits: public BitField<int, 1, 31> {};
       LEnvironment* environment_;
       SetOncePointer<LPointerMap> pointer_map_;
-...
     class LGoto V8_FINAL : public LTemplateInstruction<0, 0, 0> {
      public:
       explicit LGoto(int block_id) : block_id_(block_id) { }
       explicit LGoto(HBasicBlock* block) : block_(block) { }
       virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE;
       DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
       virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
       virtual bool IsControl() const V8_OVERRIDE { return true; }
       int block_id() const { return block_id_; }
       int block_id() const { return block_->block_id(); }
      private:
       int block_id_;
       HBasicBlock* block_;
     };
-...
     };
     class LCallStub V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LCallStub V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LCallStub(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")
       DECLARE_HYDROGEN_ACCESSOR(CallStub)
-...
     };
     class LMulI V8_FINAL : public LTemplateInstruction<1, 2, 1> {
     class LMulI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       LMulI(LOperand* left, LOperand* right, LOperand* temp) {
       LMulI(LOperand* left, LOperand* right) {
         inputs_[0] = left;
         inputs_[1] = right;
         temps_[0] = temp;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* temp() { return temps_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")
       DECLARE_HYDROGEN_ACCESSOR(Mul)
-...
     };
     class LMathAbs V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LMathAbs V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LMathAbs(LOperand* value) {
       LMathAbs(LOperand* context, LOperand* value) {
         inputs_[1] = context;
         inputs_[0] = value;
+      }
       LOperand* context() { return inputs_[1]; }
       LOperand* value() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs")
-...
     };
     class LIsNumberAndBranch V8_FINAL : public LControlInstruction<1, 0> {
      public:
       explicit LIsNumberAndBranch(LOperand* value) {
         inputs_[0] = value;
+      }
       LOperand* value() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(IsNumberAndBranch, "is-number-and-branch")
       DECLARE_HYDROGEN_ACCESSOR(IsNumberAndBranch)
     };
     class LIsStringAndBranch V8_FINAL : public LControlInstruction<1, 1> {
      public:
       LIsStringAndBranch(LOperand* value, LOperand* temp) {
-...
     };
     class LStringCompareAndBranch V8_FINAL : public LControlInstruction<2, 0> {
     class LStringCompareAndBranch V8_FINAL : public LControlInstruction<3, 0> {
      public:
       LStringCompareAndBranch(LOperand* left, LOperand* right) {
         inputs_[0] = left;
         inputs_[1] = right;
       LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
         inputs_[0] = context;
         inputs_[1] = left;
         inputs_[2] = right;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* left() { return inputs_[1]; }
       LOperand* right() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch,
                                    "string-compare-and-branch")
-...
     };
     class LCmpT V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LCmpT V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LCmpT(LOperand* left, LOperand* right) {
         inputs_[0] = left;
         inputs_[1] = right;
       LCmpT(LOperand* context, LOperand* left, LOperand* right) {
         inputs_[0] = context;
         inputs_[1] = left;
         inputs_[2] = right;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* left() { return inputs_[1]; }
       LOperand* right() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")
       DECLARE_HYDROGEN_ACCESSOR(CompareGeneric)
-...
     };
     class LInstanceOf V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LInstanceOf V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LInstanceOf(LOperand* left, LOperand* right) {
         inputs_[0] = left;
         inputs_[1] = right;
       LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
         inputs_[0] = context;
         inputs_[1] = left;
         inputs_[2] = right;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* left() { return inputs_[1]; }
       LOperand* right() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")
     };
     class LInstanceOfKnownGlobal V8_FINAL : public LTemplateInstruction<1, 1, 1> {
     class LInstanceOfKnownGlobal V8_FINAL : public LTemplateInstruction<1, 2, 1> {
      public:
       LInstanceOfKnownGlobal(LOperand* value, LOperand* temp) {
         inputs_[0] = value;
       LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
         inputs_[0] = context;
         inputs_[1] = value;
         temps_[0] = temp;
+      }
       LOperand* value() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* value() { return inputs_[1]; }
       LOperand* temp() { return temps_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal,
-...
     };
     class LInstanceSize V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LInstanceSize(LOperand* object) {
         inputs_[0] = object;
+      }
       LOperand* object() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(InstanceSize, "instance-size")
       DECLARE_HYDROGEN_ACCESSOR(InstanceSize)
     };
     class LBoundsCheck V8_FINAL : public LTemplateInstruction<0, 2, 0> {
      public:
       LBoundsCheck(LOperand* index, LOperand* length) {
-...
       DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")
       DECLARE_HYDROGEN_ACCESSOR(CompareMap)
       Handle<Map> map() const { return hydrogen()->map(); }
       Handle<Map> map() const { return hydrogen()->map().handle(); }
     };
-...
       LOperand* temp() { return temps_[0]; }
       Smi* index() const { return index_; }
       DECLARE_CONCRETE_INSTRUCTION(ValueOf, "date-field")
       DECLARE_HYDROGEN_ACCESSOR(ValueOf)
       DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field")
       DECLARE_HYDROGEN_ACCESSOR(DateField)
      private:
       Smi* index_;
-...
     };
     class LThrow V8_FINAL : public LTemplateInstruction<0, 1, 0> {
     class LThrow V8_FINAL : public LTemplateInstruction<0, 2, 0> {
      public:
       explicit LThrow(LOperand* value) {
         inputs_[0] = value;
       LThrow(LOperand* context, LOperand* value) {
         inputs_[0] = context;
         inputs_[1] = value;
+      }
       LOperand* value() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* value() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
     };
-...
     };
     class LArithmeticT V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LArithmeticT V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LArithmeticT(Token::Value op, LOperand* left, LOperand* right)
       LArithmeticT(Token::Value op,
                    LOperand* context,
                    LOperand* left,
                    LOperand* right)
           : op_(op) {
         inputs_[0] = left;
         inputs_[1] = right;
         inputs_[0] = context;
         inputs_[1] = left;
         inputs_[2] = right;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* left() { return inputs_[1]; }
       LOperand* right() { return inputs_[2]; }
       Token::Value op() const { return op_; }
       virtual Opcode opcode() const V8_FINAL  { return LInstruction::kArithmeticT; }
-...
     };
     class LReturn V8_FINAL : public LTemplateInstruction<0, 2, 0> {
     class LReturn V8_FINAL : public LTemplateInstruction<0, 3, 0> {
      public:
       explicit LReturn(LOperand* value, LOperand* parameter_count) {
       LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
         inputs_[0] = value;
         inputs_[1] = parameter_count;
         inputs_[1] = context;
         inputs_[2] = parameter_count;
+      }
       LOperand* value() { return inputs_[0]; }
-...
         ASSERT(has_constant_parameter_count());
         return LConstantOperand::cast(parameter_count());
+      }
       LOperand* parameter_count() { return inputs_[1]; }
       LOperand* parameter_count() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(Return, "return")
     };
-...
     };
     class LLoadNamedGeneric V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LLoadNamedGeneric V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LLoadNamedGeneric(LOperand* object) {
         inputs_[0] = object;
       LLoadNamedGeneric(LOperand* context, LOperand* object) {
         inputs_[0] = context;
         inputs_[1] = object;
+      }
       LOperand* object() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* object() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic")
       DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric)
-...
     };
     class LLoadRoot V8_FINAL : public LTemplateInstruction<1, 0, 0> {
      public:
       DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
       DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
       Heap::RootListIndex index() const { return hydrogen()->index(); }
     };
     class LLoadExternalArrayPointer V8_FINAL
         : public LTemplateInstruction<1, 1, 0> {
      public:
-...
     };
     class LLoadKeyedGeneric V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LLoadKeyedGeneric V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LLoadKeyedGeneric(LOperand* object, LOperand* key) {
         inputs_[0] = object;
         inputs_[1] = key;
       LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key) {
         inputs_[0] = context;
         inputs_[1] = object;
         inputs_[2] = key;
+      }
       LOperand* object() { return inputs_[0]; }
       LOperand* key() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* object() { return inputs_[1]; }
       LOperand* key() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic")
     };
-...
     };
     class LLoadGlobalGeneric V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LLoadGlobalGeneric V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LLoadGlobalGeneric(LOperand* global_object) {
         inputs_[0] = global_object;
       LLoadGlobalGeneric(LOperand* context, LOperand* global_object) {
         inputs_[0] = context;
         inputs_[1] = global_object;
+      }
       LOperand* global_object() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* global_object() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic")
       DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric)
-...
     };
     class LStoreGlobalGeneric V8_FINAL : public LTemplateInstruction<0, 2, 0> {
     class LStoreGlobalGeneric V8_FINAL : public LTemplateInstruction<0, 3, 0> {
      public:
       explicit LStoreGlobalGeneric(LOperand* global_object,
                                    LOperand* value) {
         inputs_[0] = global_object;
         inputs_[1] = value;
       LStoreGlobalGeneric(LOperand* context,
                           LOperand* global_object,
                           LOperand* value) {
         inputs_[0] = context;
         inputs_[1] = global_object;
         inputs_[2] = value;
+      }
       LOperand* global_object() { return inputs_[0]; }
       LOperand* value() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* global_object() { return inputs_[1]; }
       LOperand* value() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(StoreGlobalGeneric, "store-global-generic")
       DECLARE_HYDROGEN_ACCESSOR(StoreGlobalGeneric)
-...
     };
     class LDeclareGlobals V8_FINAL : public LTemplateInstruction<0, 0, 0> {
     class LDeclareGlobals V8_FINAL : public LTemplateInstruction<0, 1, 0> {
      public:
       explicit LDeclareGlobals(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals")
       DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals)
     };
-...
     };
     class LInvokeFunction V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LInvokeFunction V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LInvokeFunction(LOperand* function) {
         inputs_[0] = function;
       LInvokeFunction(LOperand* context, LOperand* function) {
         inputs_[0] = context;
         inputs_[1] = function;
+      }
       LOperand* function() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* function() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
       DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
-...
     };
     class LCallKeyed V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LCallKeyed V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LCallKeyed(LOperand* key) {
         inputs_[0] = key;
       LCallKeyed(LOperand* context, LOperand* key) {
         inputs_[0] = context;
         inputs_[1] = key;
+      }
       LOperand* key() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* key() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(CallKeyed, "call-keyed")
       DECLARE_HYDROGEN_ACCESSOR(CallKeyed)
-...
     class LCallNamed V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LCallNamed V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LCallNamed(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(CallNamed, "call-named")
       DECLARE_HYDROGEN_ACCESSOR(CallNamed)
-...
     };
     class LCallFunction V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LCallFunction V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LCallFunction(LOperand* function) {
         inputs_[0] = function;
       LCallFunction(LOperand* context, LOperand* function) {
         inputs_[0] = context;
         inputs_[1] = function;
+      }
       LOperand* function() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* function() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
       DECLARE_HYDROGEN_ACCESSOR(CallFunction)
-...
     };
     class LCallGlobal V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LCallGlobal V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LCallGlobal(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(CallGlobal, "call-global")
       DECLARE_HYDROGEN_ACCESSOR(CallGlobal)
-...
     };
     class LCallNew V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LCallNew V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LCallNew(LOperand* constructor) {
         inputs_[0] = constructor;
       LCallNew(LOperand* context, LOperand* constructor) {
         inputs_[0] = context;
         inputs_[1] = constructor;
+      }
       LOperand* constructor() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* constructor() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
       DECLARE_HYDROGEN_ACCESSOR(CallNew)
-...
     };
     class LCallNewArray V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LCallNewArray V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LCallNewArray(LOperand* constructor) {
         inputs_[0] = constructor;
       LCallNewArray(LOperand* context, LOperand* constructor) {
         inputs_[0] = context;
         inputs_[1] = constructor;
+      }
       LOperand* constructor() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* constructor() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
       DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
-...
     };
     class LCallRuntime V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LCallRuntime V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LCallRuntime(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
       DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
       virtual bool ClobbersDoubleRegisters() const V8_OVERRIDE {
         return save_doubles() == kDontSaveFPRegs;
+      }
       const Runtime::Function* function() const { return hydrogen()->function(); }
       int arity() const { return hydrogen()->argument_count(); }
       SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); }
     };
-...
       LOperand* temp2() { return temps_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")
       DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
       DECLARE_HYDROGEN_ACCESSOR(Change)
       bool truncating() { return hydrogen()->CanTruncateToInt32(); }
     };
-...
     };
     class LStoreNamedGeneric V8_FINAL : public LTemplateInstruction<0, 2, 0> {
     class LStoreNamedGeneric V8_FINAL : public LTemplateInstruction<0, 3, 0> {
      public:
       LStoreNamedGeneric(LOperand* object, LOperand* value) {
         inputs_[0] = object;
         inputs_[1] = value;
       LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
         inputs_[0] = context;
         inputs_[1] = object;
         inputs_[2] = value;
+      }
       LOperand* object() { return inputs_[0]; }
       LOperand* value() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* object() { return inputs_[1]; }
       LOperand* value() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
       DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
-...
     };
     class LStoreKeyedGeneric V8_FINAL : public LTemplateInstruction<0, 3, 0> {
     class LStoreKeyedGeneric V8_FINAL : public LTemplateInstruction<0, 4, 0> {
      public:
       LStoreKeyedGeneric(LOperand* obj, LOperand* key, LOperand* value) {
         inputs_[0] = obj;
         inputs_[1] = key;
         inputs_[2] = value;
       LStoreKeyedGeneric(LOperand* context,
                          LOperand* obj,
                          LOperand* key,
                          LOperand* value) {
         inputs_[0] = context;
         inputs_[1] = obj;
         inputs_[2] = key;
         inputs_[3] = value;
+      }
       LOperand* object() { return inputs_[0]; }
       LOperand* key() { return inputs_[1]; }
       LOperand* value() { return inputs_[2]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* object() { return inputs_[1]; }
       LOperand* key() { return inputs_[2]; }
       LOperand* value() { return inputs_[3]; }
       DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
       DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
-...
     };
     class LTransitionElementsKind V8_FINAL : public LTemplateInstruction<0, 1, 1> {
     class LTransitionElementsKind V8_FINAL : public LTemplateInstruction<0, 2, 1> {
      public:
       LTransitionElementsKind(LOperand* object,
                               LOperand* context,
                               LOperand* new_map_temp) {
         inputs_[0] = object;
         inputs_[1] = context;
         temps_[0] = new_map_temp;
+      }
       LOperand* context() { return inputs_[1]; }
       LOperand* object() { return inputs_[0]; }
       LOperand* new_map_temp() { return temps_[0]; }
-...
       virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
       Handle<Map> original_map() { return hydrogen()->original_map(); }
       Handle<Map> transitioned_map() { return hydrogen()->transitioned_map(); }
       Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
       Handle<Map> transitioned_map() {
         return hydrogen()->transitioned_map().handle();
+      }
       ElementsKind from_kind() { return hydrogen()->from_kind(); }
       ElementsKind to_kind() { return hydrogen()->to_kind(); }
     };
-...
     };
     class LStringAdd V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LStringAdd V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LStringAdd(LOperand* left, LOperand* right) {
         inputs_[0] = left;
         inputs_[1] = right;
       LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
         inputs_[0] = context;
         inputs_[1] = left;
         inputs_[2] = right;
+      }
       LOperand* left() { return inputs_[0]; }
       LOperand* right() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* left() { return inputs_[1]; }
       LOperand* right() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
       DECLARE_HYDROGEN_ACCESSOR(StringAdd)
-...
     class LStringCharCodeAt V8_FINAL : public LTemplateInstruction<1, 2, 0> {
     class LStringCharCodeAt V8_FINAL : public LTemplateInstruction<1, 3, 0> {
      public:
       LStringCharCodeAt(LOperand* string, LOperand* index) {
         inputs_[0] = string;
         inputs_[1] = index;
       LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
         inputs_[0] = context;
         inputs_[1] = string;
         inputs_[2] = index;
+      }
       LOperand* string() { return inputs_[0]; }
       LOperand* index() { return inputs_[1]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* string() { return inputs_[1]; }
       LOperand* index() { return inputs_[2]; }
       DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at")
       DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt)
     };
     class LStringCharFromCode V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LStringCharFromCode V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LStringCharFromCode(LOperand* char_code) {
         inputs_[0] = char_code;
       explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
         inputs_[0] = context;
         inputs_[1] = char_code;
+      }
       LOperand* char_code() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* char_code() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code")
       DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode)
-...
     class LAllocate V8_FINAL : public LTemplateInstruction<1, 2, 2> {
      public:
       LAllocate(LOperand* size, LOperand* temp1, LOperand* temp2) {
       LAllocate(LOperand* context,
                 LOperand* size,
                 LOperand* temp1,
                 LOperand* temp2) {
         inputs_[0] = context;
         inputs_[1] = size;
         temps_[0] = temp1;
         temps_[1] = temp2;
+      }
       LOperand* context() { return inputs_[0]; }
       LOperand* size() { return inputs_[1]; }
       LOperand* temp1() { return temps_[0]; }
       LOperand* temp2() { return temps_[1]; }
-...
     };
     class LRegExpLiteral V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LRegExpLiteral V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LRegExpLiteral(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal")
       DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral)
     };
     class LFunctionLiteral V8_FINAL : public LTemplateInstruction<1, 0, 0> {
     class LFunctionLiteral V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LFunctionLiteral(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal")
       DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral)
     };
-...
     };
     class LTypeof V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LTypeof V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LTypeof(LOperand* value) {
         inputs_[0] = value;
       LTypeof(LOperand* context, LOperand* value) {
         inputs_[0] = context;
         inputs_[1] = value;
+      }
       LOperand* value() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* value() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
     };
-...
     };
     class LStackCheck V8_FINAL : public LTemplateInstruction<0, 0, 0> {
     class LStackCheck V8_FINAL : public LTemplateInstruction<0, 1, 0> {
      public:
       explicit LStackCheck(LOperand* context) {
         inputs_[0] = context;
+      }
       LOperand* context() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")
       DECLARE_HYDROGEN_ACCESSOR(StackCheck)
-...
     };
     class LForInPrepareMap V8_FINAL : public LTemplateInstruction<1, 1, 0> {
     class LForInPrepareMap V8_FINAL : public LTemplateInstruction<1, 2, 0> {
      public:
       explicit LForInPrepareMap(LOperand* object) {
         inputs_[0] = object;
       LForInPrepareMap(LOperand* context, LOperand* object) {
         inputs_[0] = context;
         inputs_[1] = object;
+      }
       LOperand* object() { return inputs_[0]; }
       LOperand* context() { return inputs_[0]; }
       LOperand* object() { return inputs_[1]; }
       DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map")
     };
-...
       LPlatformChunk(CompilationInfo* info, HGraph* graph)
           : LChunk(info, graph) { }
       int GetNextSpillIndex(bool is_double);
       LOperand* GetNextSpillSlot(bool is_double);
       int GetNextSpillIndex(RegisterKind kind);
       LOperand* GetNextSpillSlot(RegisterKind kind);
     };
-...
       // Build the sequence for the graph.
       LPlatformChunk* Build();
       LInstruction* CheckElideControlInstruction(HControlInstruction* instr);
       // Declare methods that deal with the individual node types.
     #define DECLARE_DO(type) LInstruction* Do##type(H##type* node);
       HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
-...
       LInstruction* DoArithmeticD(Token::Value op,
                                   HArithmeticBinaryOperation* instr);
       LInstruction* DoArithmeticT(Token::Value op,
                                   HArithmeticBinaryOperation* instr);
                                   HBinaryOperation* instr);
       LPlatformChunk* chunk_;
       CompilationInfo* info_;

Also available in: Unified diff