Added a Isolate* parameter to Serializer::enabled().

src/ia32/lithium-ia32.h

 // Copyright 2012 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 243 matching lines @@
   HValue* hydrogen_value() const { return hydrogen_value_; }
 
   virtual void SetDeferredLazyDeoptimizationEnvironment(LEnvironment* env) { }
 
   void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); }
   bool IsCall() const { return IsCallBits::decode(bit_field_); }
 
   // Interface to the register allocator and iterators.
   bool ClobbersTemps() const { return IsCall(); }
   bool ClobbersRegisters() const { return IsCall(); }
-  virtual bool ClobbersDoubleRegisters() const {
+  virtual bool ClobbersDoubleRegisters(Isolate* isolate) const V8_OVERRIDE {
     return IsCall() ||
            // We only have rudimentary X87Stack tracking, thus in general
            // cannot handle phi-nodes.
-           (!CpuFeatures::IsSafeForSnapshot(SSE2) && IsControl());
+        (!CpuFeatures::IsSafeForSnapshot(isolate, SSE2) && IsControl());
   }
 
   virtual bool HasResult() const = 0;
   virtual LOperand* result() const = 0;
 
   bool HasDoubleRegisterResult();
   bool HasDoubleRegisterInput();
   bool IsDoubleInput(X87Register reg, LCodeGen* cgen);
 
   LOperand* FirstInput() { return InputAt(0); }
@@ skipping 114 matching lines @@
   virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE {
     return !IsRedundant();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap")
 };
 
 
 class LClobberDoubles V8_FINAL : public LTemplateInstruction<0, 0, 0> {
  public:
-  LClobberDoubles() { ASSERT(!CpuFeatures::IsSafeForSnapshot(SSE2)); }
+  explicit LClobberDoubles(Isolate* isolate) {
+    ASSERT(!CpuFeatures::IsSafeForSnapshot(isolate, SSE2));
+  }
 
-  virtual bool ClobbersDoubleRegisters() const { return true; }
+  virtual bool ClobbersDoubleRegisters(Isolate* isolate) const V8_OVERRIDE {
+    return true;
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(ClobberDoubles, "clobber-d")
 };
 
 
 class LGoto V8_FINAL : public LTemplateInstruction<0, 0, 0> {
  public:
   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_->block_id(); }
-  virtual bool ClobbersDoubleRegisters() const { return false; }
+  virtual bool ClobbersDoubleRegisters(Isolate* isolate) const V8_OVERRIDE {
+    return false;
+  }
 
   bool jumps_to_join() const { return block_->predecessors()->length() > 1; }
 
  private:
   HBasicBlock* block_;
 };
 
 
 class LLazyBailout V8_FINAL : public LTemplateInstruction<0, 0, 0> {
  public:
@@ skipping 1572 matching lines @@
  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 {
+  virtual bool ClobbersDoubleRegisters(Isolate* isolate) 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 LInteger32ToDouble V8_FINAL : public LTemplateInstruction<1, 1, 0> {
@@ skipping 716 matching lines @@
       : LChunkBuilderBase(graph->zone()),
         chunk_(NULL),
         info_(info),
         graph_(graph),
         status_(UNUSED),
         current_instruction_(NULL),
         current_block_(NULL),
         next_block_(NULL),
         allocator_(allocator) { }
 
+  Isolate* isolate() const { return graph_->isolate(); }
+
   // 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)
 #undef DECLARE_DO
 
@@ skipping 141 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_LITHIUM_IA32_H_