Added an Isolate* field to NoTrackDoubleFieldsForSerializerScope, PlatformFeatureScope and BinaryOp…

src/ic.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 725 matching lines @@
 
 
 // Mode to overwrite BinaryExpression values.
 enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
 
 // Type Recording BinaryOpIC, that records the types of the inputs and outputs.
 class BinaryOpIC: public IC {
  public:
   class State V8_FINAL BASE_EMBEDDED {
    public:
-    explicit State(ExtraICState extra_ic_state);
+    explicit State(Isolate* isolate, ExtraICState extra_ic_state);

[Michael Starzinger, 2014/04/25 08:03:30]

nit: No longer needs to be "explicit" here.

[Sven Panne, 2014/04/25 08:27:09]

Done.

 
-    State(Token::Value op, OverwriteMode mode)
+    State(Isolate* isolate, Token::Value op, OverwriteMode mode)
         : op_(op), mode_(mode), left_kind_(NONE), right_kind_(NONE),
-          result_kind_(NONE) {
+          result_kind_(NONE), isolate_(isolate) {
       ASSERT_LE(FIRST_TOKEN, op);
       ASSERT_LE(op, LAST_TOKEN);
     }
 
     InlineCacheState GetICState() const {
       if (Max(left_kind_, right_kind_) == NONE) {
         return ::v8::internal::UNINITIALIZED;
       }
       if (Max(left_kind_, right_kind_) == GENERIC) {
         return ::v8::internal::MEGAMORPHIC;
@@ skipping 56 matching lines @@
       return KindToType(right_kind_, zone);
     }
     Type* GetResultType(Zone* zone) const;
 
     void Print(StringStream* stream) const;
 
     void Update(Handle<Object> left,
                 Handle<Object> right,
                 Handle<Object> result);
 
+    Isolate* isolate() const { return isolate_; }
+
    private:
     enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
 
     Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
     static const char* KindToString(Kind kind);
     static Type* KindToType(Kind kind, Zone* zone);
     static bool KindMaybeSmi(Kind kind) {
       return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
     }
@@ skipping 10 matching lines @@
     class HasFixedRightArgField:   public BitField<bool, 13, 1> {};
     class FixedRightArgValueField: public BitField<int,  14, 4> {};
     class RightKindField:          public BitField<Kind, 14, 3> {};
 
     Token::Value op_;
     OverwriteMode mode_;
     Kind left_kind_;
     Kind right_kind_;
     Kind result_kind_;
     Maybe<int> fixed_right_arg_;
+    Isolate* isolate_;
   };
 
   explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) { }
 
   static Builtins::JavaScript TokenToJSBuiltin(Token::Value op);
 
   MaybeHandle<Object> Transition(Handle<AllocationSite> allocation_site,
                                  Handle<Object> left,
                                  Handle<Object> right) V8_WARN_UNUSED_RESULT;
 };
@@ skipping 109 matching lines @@
 DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite);
 DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss);
 DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IC_H_