- Remove Isolate::Flags structure and store flags directly in isolate.

runtime/vm/flow_graph_builder.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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 975 matching lines @@
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   Isolate* isolate = Isolate::Current();
-  if (isolate->flags().type_checks() || isolate->flags().asserts()) {
+  if (isolate->type_checks() || isolate->asserts()) {
     value = Bind(new(Z) AssertBooleanInstr(condition_token_pos(), value));
   }
   Value* constant_true = Bind(new(Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new(Z) StrictCompareInstr(condition_token_pos(),
                                 Token::kEQ_STRICT,
                                 value,
                                 constant_true,
                                 false);  // No number check.
   BranchInstr* branch = new(Z) BranchInstr(comp);
@@ skipping 14 matching lines @@
              (comp->left()->BindsToConstantNull() ||
               comp->right()->BindsToConstantNull())) {
     branch = new(Z) BranchInstr(new(Z) StrictCompareInstr(
         comp->token_pos(),
         (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
         comp->left(),
         comp->right(),
         false));  // No number check.
   } else {
     branch = new(Z) BranchInstr(comp);
-    branch->set_is_checked(Isolate::Current()->flags().type_checks());
+    branch->set_is_checked(Isolate::Current()->type_checks());
   }
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
-  ASSERT(!Isolate::Current()->flags().type_checks());
+  ASSERT(!Isolate::Current()->type_checks());
   Value* constant_true = Bind(new(Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new(Z) StrictCompareInstr(condition_token_pos(),
                              Token::kNE_STRICT,
                              neg->value(),
                              constant_true,
                              false);  // No number check.
   BranchInstr* branch = new(Z) BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
   ComparisonInstr* comp = definition->AsComparison();
   if (comp != NULL) {
     MergeBranchWithComparison(comp);
     return;
   }
-  if (!Isolate::Current()->flags().type_checks()) {
+  if (!Isolate::Current()->type_checks()) {
     BooleanNegateInstr* neg = definition->AsBooleanNegate();
     if (neg != NULL) {
       MergeBranchWithNegate(neg);
       return;
     }
   }
   ReturnValue(Bind(definition));
 }
 
 
@@ skipping 72 matching lines @@
       EffectGraphVisitor for_effect(owner());
       node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
       Append(for_effect);
       if (!is_open()) {
         return;
       }
     }
     return_value = Bind(BuildLoadLocal(*temp, node->token_pos()));
   }
 
-  if (Isolate::Current()->flags().type_checks()) {
+  if (Isolate::Current()->type_checks()) {
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsGenerativeConstructor()) {
@@ skipping 180 matching lines @@
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
     EffectGraphVisitor empty(owner());
     Isolate* isolate = Isolate::Current();
-    if (isolate->flags().type_checks() || isolate->flags().asserts()) {
+    if (isolate->type_checks() || isolate->asserts()) {
       ValueGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       Value* right_value = for_right.value();
       for_right.Do(new(Z) AssertBooleanInstr(node->right()->token_pos(),
                                              right_value));
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
       } else {
         Join(for_left, empty, for_right);
       }
@@ skipping 46 matching lines @@
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
 
     TestGraphVisitor for_test(owner(), node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     Isolate* isolate = Isolate::Current();
-    if (isolate->flags().type_checks() || isolate->flags().asserts()) {
+    if (isolate->type_checks() || isolate->asserts()) {
       right_value =
           for_right.Bind(new(Z) AssertBooleanInstr(node->right()->token_pos(),
                                                    right_value));
     }
     Value* constant_true = for_right.Bind(new(Z) ConstantInstr(Bool::True()));
     Value* compare =
         for_right.Bind(new(Z) StrictCompareInstr(node->token_pos(),
                                                  Token::kEQ_STRICT,
                                                  right_value,
                                                  constant_true,
@@ skipping 358 matching lines @@
     Definition* result = new(Z) InstanceCallInstr(
         node->token_pos(),
         Symbols::EqualOperator(),
         Token::kEQ,  // Result is negated later for kNE.
         arguments,
         Object::null_array(),
         kNumArgsChecked,
         owner()->ic_data_array());
     if (node->kind() == Token::kNE) {
       Isolate* isolate = Isolate::Current();
-      if (isolate->flags().type_checks() || isolate->flags().asserts()) {
+      if (isolate->type_checks() || isolate->asserts()) {
         Value* value = Bind(result);
         result = new(Z) AssertBooleanInstr(node->token_pos(), value);
       }
       Value* value = Bind(result);
       result = new(Z) BooleanNegateInstr(value);
     }
     ReturnDefinition(result);
     return;
   }
 
@@ skipping 26 matching lines @@
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     Isolate* isolate = Isolate::Current();
-    if (isolate->flags().type_checks() || isolate->flags().asserts()) {
+    if (isolate->type_checks() || isolate->asserts()) {
       value =
           Bind(new(Z) AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new(Z) BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
@@ skipping 1774 matching lines @@
         node->token_pos().IsDebugPause()) {
       AddInstruction(new(Z) DebugStepCheckInstr(
           node->token_pos(), RawPcDescriptors::kRuntimeCall));
     }
   }
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
-  if (Isolate::Current()->flags().type_checks()) {
+  if (Isolate::Current()->type_checks()) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
   Definition* store = BuildStoreLocal(node->local(),
                                       store_value,
                                       node->token_pos());
   ReturnDefinition(store);
 }
@@ skipping 23 matching lines @@
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   const TokenPosition token_pos = node->token_pos();
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
-  if (Isolate::Current()->flags().type_checks()) {
+  if (Isolate::Current()->type_checks()) {
     const AbstractType& type =
         AbstractType::ZoneHandle(Z, node->field().type());
     const String& dst_name = String::ZoneHandle(Z, node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
 
   if (FLAG_use_field_guards) {
@@ skipping 409 matching lines @@
       CheckStackOverflowInstr* check =
           new(Z) CheckStackOverflowInstr(node->token_pos(), 0);
       // If we are inlining don't actually attach the stack check. We must still
       // create the stack check in order to allocate a deopt id.
       if (!owner()->IsInlining()) {
         AddInstruction(check);
       }
     }
   }
 
-  if (Isolate::Current()->flags().type_checks() && is_top_level_sequence) {
+  if (Isolate::Current()->type_checks() && is_top_level_sequence) {
     const int num_params = function.NumParameters();
     int pos = 0;
     if (function.IsFactory() ||
         function.IsDynamicFunction() ||
         function.IsGenerativeConstructor()) {
       // Skip type checking of type arguments for factory functions.
       // Skip type checking of receiver for instance functions and constructors.
       pos = 1;
     }
     while (pos < num_params) {
@@ skipping 519 matching lines @@
                    Script::Handle(function.script()),
                    function.token_pos(),
                    Report::AtLocation,
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart