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

src/ic.cc

 // 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 2040 matching lines @@
   }
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       Runtime::SetObjectProperty(
           isolate, object, key, value, NONE, strict_mode));
   return *result;
 }
 
 
-BinaryOpIC::State::State(ExtraICState extra_ic_state) {
+BinaryOpIC::State::State(Isolate* isolate, ExtraICState extra_ic_state)
+    : isolate_(isolate) {
   // We don't deserialize the SSE2 Field, since this is only used to be able
   // to include SSE2 as well as non-SSE2 versions in the snapshot. For code
   // generation we always want it to reflect the current state.
   op_ = static_cast<Token::Value>(
       FIRST_TOKEN + OpField::decode(extra_ic_state));
   mode_ = OverwriteModeField::decode(extra_ic_state);
   fixed_right_arg_ = Maybe<int>(
       HasFixedRightArgField::decode(extra_ic_state),
       1 << FixedRightArgValueField::decode(extra_ic_state));
   left_kind_ = LeftKindField::decode(extra_ic_state);
@@ skipping 30 matching lines @@
 
 // static
 void BinaryOpIC::State::GenerateAheadOfTime(
     Isolate* isolate, void (*Generate)(Isolate*, const State&)) {
   // TODO(olivf) We should investigate why adding stubs to the snapshot is so
   // expensive at runtime. When solved we should be able to add most binops to
   // the snapshot instead of hand-picking them.
   // Generated list of commonly used stubs
 #define GENERATE(op, left_kind, right_kind, result_kind, mode)  \
   do {                                                          \
-    State state(op, mode);                                      \
+    State state(isolate, op, mode);                             \
     state.left_kind_ = left_kind;                               \
     state.fixed_right_arg_.has_value = false;                   \
     state.right_kind_ = right_kind;                             \
     state.result_kind_ = result_kind;                           \
     Generate(isolate, state);                                   \
   } while (false)
   GENERATE(Token::ADD, INT32, INT32, INT32, NO_OVERWRITE);
   GENERATE(Token::ADD, INT32, INT32, INT32, OVERWRITE_LEFT);
   GENERATE(Token::ADD, INT32, INT32, NUMBER, NO_OVERWRITE);
   GENERATE(Token::ADD, INT32, INT32, NUMBER, OVERWRITE_LEFT);
@@ skipping 174 matching lines @@
   GENERATE(Token::SUB, SMI, INT32, INT32, NO_OVERWRITE);
   GENERATE(Token::SUB, SMI, NUMBER, NUMBER, NO_OVERWRITE);
   GENERATE(Token::SUB, SMI, NUMBER, NUMBER, OVERWRITE_LEFT);
   GENERATE(Token::SUB, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT);
   GENERATE(Token::SUB, SMI, SMI, SMI, NO_OVERWRITE);
   GENERATE(Token::SUB, SMI, SMI, SMI, OVERWRITE_LEFT);
   GENERATE(Token::SUB, SMI, SMI, SMI, OVERWRITE_RIGHT);
 #undef GENERATE
 #define GENERATE(op, left_kind, fixed_right_arg_value, result_kind, mode) \
   do {                                                                    \
-    State state(op, mode);                                                \
+    State state(isolate, op, mode);                                       \
     state.left_kind_ = left_kind;                                         \
     state.fixed_right_arg_.has_value = true;                              \
     state.fixed_right_arg_.value = fixed_right_arg_value;                 \
     state.right_kind_ = SMI;                                              \
     state.result_kind_ = result_kind;                                     \
     Generate(isolate, state);                                             \
   } while (false)
   GENERATE(Token::MOD, SMI, 2, SMI, NO_OVERWRITE);
   GENERATE(Token::MOD, SMI, 4, SMI, NO_OVERWRITE);
   GENERATE(Token::MOD, SMI, 4, SMI, OVERWRITE_LEFT);
@@ skipping 157 matching lines @@
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 MaybeHandle<Object> BinaryOpIC::Transition(
     Handle<AllocationSite> allocation_site,
     Handle<Object> left,
     Handle<Object> right) {
-  State state(target()->extra_ic_state());
+  State state(isolate(), target()->extra_ic_state());
 
   // Compute the actual result using the builtin for the binary operation.
   Object* builtin = isolate()->js_builtins_object()->javascript_builtin(
       TokenToJSBuiltin(state.op()));
   Handle<JSFunction> function = handle(JSFunction::cast(builtin), isolate());
   Handle<Object> result;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate(),
       result,
       Execution::Call(isolate(), function, left, 1, &right),
       Object);
 
   // Execution::Call can execute arbitrary JavaScript, hence potentially
   // update the state of this very IC, so we must update the stored state.
   UpdateTarget();
   // Compute the new state.
-  State old_state(target()->extra_ic_state());
+  State old_state(isolate(), target()->extra_ic_state());
   state.Update(left, right, result);
 
   // Check if we have a string operation here.
   Handle<Code> target;
   if (!allocation_site.is_null() || state.ShouldCreateAllocationMementos()) {
     // Setup the allocation site on-demand.
     if (allocation_site.is_null()) {
       allocation_site = isolate()->factory()->NewAllocationSite();
     }
 
@@ skipping 435 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal