Optimize instanceof further...

src/lithium-allocator.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 464 matching lines @@
   LDoubleRegister() : LOperand() { }
   explicit LDoubleRegister(int index) : LOperand(DOUBLE_REGISTER, index) { }
 };
 
 
 // A register-allocator view of a Lithium instruction. It contains the id of
 // the output operand and a list of input operand uses.
 class InstructionSummary: public ZoneObject {
  public:
   InstructionSummary()
-      : output_operand_(NULL), input_count_(0), operands_(4), is_call_(false) {}
+      : output_operand_(NULL),
+        input_count_(0),
+        operands_(4),
+        is_call_(false),
+        is_save_doubles_(false) {}
 
   // Output operands.
   LOperand* Output() const { return output_operand_; }
   void SetOutput(LOperand* output) {
     ASSERT(output_operand_ == NULL);
     output_operand_ = output;
   }
 
   // Input operands.
   int InputCount() const { return input_count_; }
   LOperand* InputAt(int i) const {
     ASSERT(i < input_count_);
     return operands_[i];
   }
   void AddInput(LOperand* input) {
     operands_.InsertAt(input_count_, input);
     input_count_++;
   }
 
   // Temporary operands.
   int TempCount() const { return operands_.length() - input_count_; }
   LOperand* TempAt(int i) const { return operands_[i + input_count_]; }
   void AddTemp(LOperand* temp) { operands_.Add(temp); }
 
   void MarkAsCall() { is_call_ = true; }
   bool IsCall() const { return is_call_; }
 
+  void MarkAsSaveDoubles() { is_save_doubles_ = true; }
+  bool IsSaveDoubles() const { return is_save_doubles_; }
+
  private:
   LOperand* output_operand_;
   int input_count_;
   ZoneList<LOperand*> operands_;
   bool is_call_;
+  bool is_save_doubles_;
 };
 
 // Representation of the non-empty interval [start,end[.
 class UseInterval: public ZoneObject {
  public:
   UseInterval(LifetimePosition start, LifetimePosition end)
       : start_(start), end_(end), next_(NULL) {
     ASSERT(start.Value() < end.Value());
   }
 
@@ skipping 254 matching lines @@
   // Record a use of an input operand in the current instruction.
   void RecordUse(HValue* value, LUnallocated* operand);
   // Record the definition of the output operand.
   void RecordDefinition(HInstruction* instr, LUnallocated* operand);
   // Record a temporary operand.
   void RecordTemporary(LUnallocated* operand);
 
   // Marks the current instruction as a call.
   void MarkAsCall();
 
+  // Marks the current instruction as a requiring saving double registers.

[Mads Ager (chromium), 2011/01/04 17:25:58]

as a -> as

[Søren Thygesen Gjesse, 2011/01/05 09:28:00]

Done.

+  void MarkAsSaveDoubles();
+
   // Checks whether the value of a given virtual register is tagged.
   bool HasTaggedValue(int virtual_register) const;
 
   // Returns the register kind required by the given virtual register.
   RegisterKind RequiredRegisterKind(int virtual_register) const;
 
   // Begin a new instruction.
   void BeginInstruction();
 
   // Summarize the current instruction.
@@ skipping 178 matching lines @@
 
   bool has_osr_entry_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_