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

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

       V(InnerAllocatedObject)                       \
       V(InstanceOf)                                 \
       V(InstanceOfKnownGlobal)                      \
       V(InstanceSize)                               \
       V(InstructionGap)                             \
       V(Integer32ToDouble)                          \
       V(Integer32ToSmi)                             \
-...
       V(IsObjectAndBranch)                          \
       V(IsStringAndBranch)                          \
       V(IsSmiAndBranch)                             \
       V(IsNumberAndBranch)                          \
       V(IsUndetectableAndBranch)                    \
       V(Label)                                      \
       V(LazyBailout)                                \
       V(LoadContextSlot)                            \
       V(LoadExternalArrayPointer)                   \
       V(LoadRoot)                                   \
       V(LoadFieldByIndex)                           \
       V(LoadFunctionPrototype)                      \
       V(LoadGlobalCell)                             \
-...
       V(Typeof)                                     \
       V(TypeofIsAndBranch)                          \
       V(Uint32ToDouble)                             \
       V(Uint32ToSmi)                                \
       V(UnknownOSRValue)                            \
       V(ValueOf)                                    \
       V(WrapReceiver)
-...
           : 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(); }
       virtual void SetDeferredLazyDeoptimizationEnvironment(LEnvironment* env) { }
-...
       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 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:
       explicit LIsStringAndBranch(LOperand* value, LOperand* temp) {
-...
     };
     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* date() { return inputs_[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 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:
-...
       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(); }
     };
-...
     };
     class LUint32ToSmi V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LUint32ToSmi(LOperand* value) {
         inputs_[0] = value;
+      }
       LOperand* value() { return inputs_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(Uint32ToSmi, "uint32-to-smi")
       DECLARE_HYDROGEN_ACCESSOR(Change)
     };
     class LNumberTagI V8_FINAL : public LTemplateInstruction<1, 1, 0> {
      public:
       explicit LNumberTagI(LOperand* value) {
-...
       LOperand* temp() { return temps_[0]; }
       DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")
       DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
       DECLARE_HYDROGEN_ACCESSOR(Change)
       bool truncating() { return hydrogen()->CanTruncateToInt32(); }
     };
-...
       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(); }
     };
-...
       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);
     };
-...
             next_block_(NULL),
             argument_count_(0),
             allocator_(allocator),
             position_(RelocInfo::kNoPosition),
             instruction_pending_deoptimization_environment_(NULL),
             pending_deoptimization_ast_id_(BailoutId::None()) { }
       // 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_;
-...
       HBasicBlock* next_block_;
       int argument_count_;
       LAllocator* allocator_;
       int position_;
       LInstruction* instruction_pending_deoptimization_environment_;
       BailoutId pending_deoptimization_ast_id_;

Also available in: Unified diff