Move deopt_id and related helpers/definitions from Isolate to Thread

runtime/vm/intrinsifier.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 // Class for intrinsifying functions.
 
 #include "vm/assembler.h"
 #include "vm/intrinsifier.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/symbols.h"
@@ skipping 115 matching lines @@
 }
 
 
 bool Intrinsifier::GraphIntrinsify(const ParsedFunction& parsed_function,
                                    FlowGraphCompiler* compiler) {
   ZoneGrowableArray<const ICData*>* ic_data_array =
       new ZoneGrowableArray<const ICData*>();
   FlowGraphBuilder builder(parsed_function,
                            *ic_data_array,
                            NULL,  // NULL = not inlining.
-                           Isolate::kNoDeoptId);  // No OSR id.
+                           Thread::kNoDeoptId);  // No OSR id.
 
   intptr_t block_id = builder.AllocateBlockId();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(block_id,
                            CatchClauseNode::kInvalidTryIndex);
   GraphEntryInstr* graph_entry = new GraphEntryInstr(
-      parsed_function, normal_entry, Isolate::kNoDeoptId);  // No OSR id.
+      parsed_function, normal_entry, Thread::kNoDeoptId);  // No OSR id.
   FlowGraph* graph = new FlowGraph(parsed_function, graph_entry, block_id);
   const Function& function = parsed_function.function();
   switch (function.recognized_kind()) {
 #define EMIT_CASE(class_name, function_name, enum_name, fp)                    \
     case MethodRecognizer::k##enum_name:                                       \
       if (!Build_##enum_name(graph)) return false;                             \
       break;
 
     GRAPH_INTRINSICS_LIST(EMIT_CASE);
     default:
@@ skipping 113 matching lines @@
     return flow_graph_->function().token_pos();
   }
 
   Definition* AddNullDefinition() {
     return AddDefinition(
         new ConstantInstr(Object::ZoneHandle(Object::null())));
   }
 
   Definition* AddUnboxInstr(Representation rep, Value* value) {
     Definition* unboxed_value = AddDefinition(
-        UnboxInstr::Create(rep, value, Isolate::kNoDeoptId));
+        UnboxInstr::Create(rep, value, Thread::kNoDeoptId));
     // Manually adjust reaching type because there is no type propagation
     // when building intrinsics.
     unboxed_value->AsUnbox()->value()->SetReachingType(ZoneCompileType::Wrap(
         CompileType::FromCid(CidForRepresentation(rep))));
     return unboxed_value;
   }
 
  private:
   FlowGraph* flow_graph_;
   BlockEntryInstr* entry_;
   Instruction* current_;
 };
 
 
 static void PrepareIndexedOp(BlockBuilder* builder,
                              Definition* array,
                              Definition* index,
                              intptr_t length_offset) {
   intptr_t token_pos = builder->TokenPos();
   builder->AddInstruction(
       new CheckSmiInstr(new Value(index),
-                        Isolate::kNoDeoptId,
+                        Thread::kNoDeoptId,
                         token_pos));
 
   Definition* length = builder->AddDefinition(
       new LoadFieldInstr(new Value(array),
                          length_offset,
                          Type::ZoneHandle(Type::SmiType()),
                          Scanner::kNoSourcePos));
   builder->AddInstruction(
       new CheckArrayBoundInstr(new Value(length),
                                new Value(index),
-                               Isolate::kNoDeoptId));
+                               Thread::kNoDeoptId));
 }
 
 
 bool Intrinsifier::Build_ObjectArrayGetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* array = builder.AddParameter(2);
 
   PrepareIndexedOp(&builder, array, index, Array::length_offset());
 
   Definition* result = builder.AddDefinition(
       new LoadIndexedInstr(new Value(array),
                            new Value(index),
                            Instance::ElementSizeFor(kArrayCid),  // index scale
                            kArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_ImmutableArrayGetIndexed(FlowGraph* flow_graph) {
   return Build_ObjectArrayGetIndexed(flow_graph);
 }
 
 
 bool Intrinsifier::Build_Uint8ArrayGetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* array = builder.AddParameter(2);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   Definition* result = builder.AddDefinition(
       new LoadIndexedInstr(new Value(array),
                            new Value(index),
                            1,  // index scale
                            kTypedDataUint8ArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_ExternalUint8ArrayGetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* array = builder.AddParameter(2);
 
   PrepareIndexedOp(&builder, array, index, ExternalTypedData::length_offset());
 
   Definition* elements = builder.AddDefinition(
       new LoadUntaggedInstr(new Value(array),
                             ExternalTypedData::data_offset()));
   Definition* result = builder.AddDefinition(
       new LoadIndexedInstr(new Value(elements),
                            new Value(index),
                            1,  // index scale
                            kExternalTypedDataUint8ArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_Uint8ArraySetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* value = builder.AddParameter(1);
   Definition* index = builder.AddParameter(2);
   Definition* array = builder.AddParameter(3);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   builder.AddInstruction(
       new CheckSmiInstr(new Value(value),
-                        Isolate::kNoDeoptId,
+                        Thread::kNoDeoptId,
                         builder.TokenPos()));
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(value),
                             kNoStoreBarrier,
                             1,  // index scale
                             kTypedDataUint8ArrayCid,
-                            Isolate::kNoDeoptId,
+                            Thread::kNoDeoptId,
                             builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_ExternalUint8ArraySetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* value = builder.AddParameter(1);
   Definition* index = builder.AddParameter(2);
   Definition* array = builder.AddParameter(3);
 
   PrepareIndexedOp(&builder, array, index, ExternalTypedData::length_offset());
 
   builder.AddInstruction(
       new CheckSmiInstr(new Value(value),
-                        Isolate::kNoDeoptId,
+                        Thread::kNoDeoptId,
                         builder.TokenPos()));
   Definition* elements = builder.AddDefinition(
       new LoadUntaggedInstr(new Value(array),
                             ExternalTypedData::data_offset()));
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(elements),
                             new Value(index),
                             new Value(value),
                             kNoStoreBarrier,
                             1,  // index scale
                             kExternalTypedDataUint8ArrayCid,
-                            Isolate::kNoDeoptId,
+                            Thread::kNoDeoptId,
                             builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_Uint32ArraySetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* value = builder.AddParameter(1);
   Definition* index = builder.AddParameter(2);
   Definition* array = builder.AddParameter(3);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   Definition* unboxed_value =
       builder.AddUnboxInstr(kUnboxedUint32, new Value(value));
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(unboxed_value),
                             kNoStoreBarrier,
                             4,  // index scale
                             kTypedDataUint32ArrayCid,
-                            Isolate::kNoDeoptId,
+                            Thread::kNoDeoptId,
                             builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_Uint32ArrayGetIndexed(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* array = builder.AddParameter(2);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   Definition* unboxed_value = builder.AddDefinition(
       new LoadIndexedInstr(new Value(array),
                            new Value(index),
                            4,  // index scale
                            kTypedDataUint32ArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedUint32, new Value(unboxed_value)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_Float64ArraySetIndexed(FlowGraph* flow_graph) {
   if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
 
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* value = builder.AddParameter(1);
   Definition* index = builder.AddParameter(2);
   Definition* array = builder.AddParameter(3);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   const ICData& value_check = ICData::ZoneHandle(ICData::New(
       flow_graph->function(),
       String::Handle(flow_graph->function().name()),
       Object::empty_array(),  // Dummy args. descr.
-      Isolate::kNoDeoptId,
+      Thread::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kDoubleCid, flow_graph->function());
   builder.AddInstruction(
       new CheckClassInstr(new Value(value),
-                          Isolate::kNoDeoptId,
+                          Thread::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
   Definition* double_value =
       builder.AddUnboxInstr(kUnboxedDouble, new Value(value));
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(double_value),
                             kNoStoreBarrier,
                             8,  // index scale
                             kTypedDataFloat64ArrayCid,
-                            Isolate::kNoDeoptId,
+                            Thread::kNoDeoptId,
                             builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_Float64ArrayGetIndexed(FlowGraph* flow_graph) {
   if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
 
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* array = builder.AddParameter(2);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   Definition* unboxed_value = builder.AddDefinition(
       new LoadIndexedInstr(new Value(array),
                            new Value(index),
                            8,  // index scale
                            kTypedDataFloat64ArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedDouble, new Value(unboxed_value)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 static bool BuildBinaryFloat32x4Op(FlowGraph* flow_graph, Token::Kind kind) {
   if (!FlowGraphCompiler::SupportsUnboxedSimd128()) return false;
 
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* right = builder.AddParameter(1);
   Definition* left = builder.AddParameter(2);
 
   const ICData& value_check = ICData::ZoneHandle(ICData::New(
       flow_graph->function(),
       String::Handle(flow_graph->function().name()),
       Object::empty_array(),  // Dummy args. descr.
-      Isolate::kNoDeoptId,
+      Thread::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kFloat32x4Cid, flow_graph->function());
   // Check argument. Receiver (left) is known to be a Float32x4.
   builder.AddInstruction(
       new CheckClassInstr(new Value(right),
-                          Isolate::kNoDeoptId,
+                          Thread::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
   Definition* left_simd =
       builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(left));
 
   Definition* right_simd =
       builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(right));
 
   Definition* unboxed_result = builder.AddDefinition(
       new BinaryFloat32x4OpInstr(kind,
                                  new Value(left_simd),
                                  new Value(right_simd),
-                                 Isolate::kNoDeoptId));
+                                 Thread::kNoDeoptId));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedFloat32x4, new Value(unboxed_result)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_Float32x4Mul(FlowGraph* flow_graph) {
   return BuildBinaryFloat32x4Op(flow_graph, Token::kMUL);
 }
@@ skipping 18 matching lines @@
 
   Definition* receiver = builder.AddParameter(1);
 
   Definition* unboxed_receiver =
       builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(receiver));
 
   Definition* unboxed_result = builder.AddDefinition(
       new Simd32x4ShuffleInstr(kind,
                                new Value(unboxed_receiver),
                                0,
-                               Isolate::kNoDeoptId));
+                               Thread::kNoDeoptId));
 
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedDouble, new Value(unboxed_result)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_Float32x4ShuffleX(FlowGraph* flow_graph) {
   return BuildFloat32x4Shuffle(flow_graph,
@@ skipping 97 matching lines @@
   Definition* backing_store = builder.AddDefinition(
       new LoadFieldInstr(new Value(growable_array),
                          GrowableObjectArray::data_offset(),
                          Type::ZoneHandle(),
                          builder.TokenPos()));
   Definition* result = builder.AddDefinition(
       new LoadIndexedInstr(new Value(backing_store),
                            new Value(index),
                            Instance::ElementSizeFor(kArrayCid),  // index scale
                            kArrayCid,
-                           Isolate::kNoDeoptId,
+                           Thread::kNoDeoptId,
                            builder.TokenPos()));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
 bool Intrinsifier::Build_GrowableArraySetIndexed(FlowGraph* flow_graph) {
   if (Isolate::Current()->flags().type_checks()) {
     return false;
   }
@@ skipping 15 matching lines @@
                          Type::ZoneHandle(),
                          builder.TokenPos()));
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(backing_store),
                             new Value(index),
                             new Value(value),
                             kEmitStoreBarrier,
                             Instance::ElementSizeFor(kArrayCid),  // index scale
                             kArrayCid,
-                            Isolate::kNoDeoptId,
+                            Thread::kNoDeoptId,
                             builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_GrowableArraySetData(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* data = builder.AddParameter(1);
   Definition* growable_array = builder.AddParameter(2);
 
   const ICData& value_check = ICData::ZoneHandle(ICData::New(
       flow_graph->function(),
       String::Handle(flow_graph->function().name()),
       Object::empty_array(),  // Dummy args. descr.
-      Isolate::kNoDeoptId,
+      Thread::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kArrayCid, flow_graph->function());
   builder.AddInstruction(
       new CheckClassInstr(new Value(data),
-                          Isolate::kNoDeoptId,
+                          Thread::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
 
   builder.AddInstruction(
       new StoreInstanceFieldInstr(GrowableObjectArray::data_offset(),
                                   new Value(growable_array),
                                   new Value(data),
                                   kEmitStoreBarrier,
                                   builder.TokenPos()));
   // Return null.
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 
 bool Intrinsifier::Build_GrowableArraySetLength(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* length = builder.AddParameter(1);
   Definition* growable_array = builder.AddParameter(2);
 
   builder.AddInstruction(
       new CheckSmiInstr(new Value(length),
-                        Isolate::kNoDeoptId,
+                        Thread::kNoDeoptId,
                         builder.TokenPos()));
   builder.AddInstruction(
       new StoreInstanceFieldInstr(GrowableObjectArray::length_offset(),
                                   new Value(growable_array),
                                   new Value(length),
                                   kNoStoreBarrier,
                                   builder.TokenPos()));
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 }  // namespace dart