clang-format runtime/vm

runtime/vm/flow_graph_type_propagator.cc

 // Copyright (c) 2013, 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_type_propagator.h"
 
 #include "vm/cha.h"
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 #include "vm/regexp_assembler.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, trace_type_propagation, false,
+DEFINE_FLAG(bool,
+            trace_type_propagation,
+            false,
             "Trace flow graph type propagation");
 
 DECLARE_FLAG(bool, propagate_types);
 
 
 void FlowGraphTypePropagator::Propagate(FlowGraph* flow_graph) {
 #ifndef PRODUCT
   Thread* thread = flow_graph->thread();
   TimelineStream* compiler_timeline = Timeline::GetCompilerStream();
-  TimelineDurationScope tds2(thread,
-                             compiler_timeline,
+  TimelineDurationScope tds2(thread, compiler_timeline,
                              "FlowGraphTypePropagator");
 #endif  // !PRODUCT
   FlowGraphTypePropagator propagator(flow_graph);
   propagator.Propagate();
 }
 
 
 FlowGraphTypePropagator::FlowGraphTypePropagator(FlowGraph* flow_graph)
     : FlowGraphVisitor(flow_graph->reverse_postorder()),
       flow_graph_(flow_graph),
-      visited_blocks_(new(flow_graph->zone()) BitVector(
-          flow_graph->zone(), flow_graph->reverse_postorder().length())),
+      visited_blocks_(new (flow_graph->zone())
+                          BitVector(flow_graph->zone(),
+                                    flow_graph->reverse_postorder().length())),
       types_(flow_graph->current_ssa_temp_index()),
-      in_worklist_(new(flow_graph->zone()) BitVector(
-          flow_graph->zone(), flow_graph->current_ssa_temp_index())),
+      in_worklist_(new (flow_graph->zone())
+                       BitVector(flow_graph->zone(),
+                                 flow_graph->current_ssa_temp_index())),
       asserts_(NULL),
       collected_asserts_(NULL) {
   for (intptr_t i = 0; i < flow_graph->current_ssa_temp_index(); i++) {
     types_.Add(NULL);
   }
 
   if (Isolate::Current()->type_checks()) {
     asserts_ = new ZoneGrowableArray<AssertAssignableInstr*>(
         flow_graph->current_ssa_temp_index());
     for (intptr_t i = 0; i < flow_graph->current_ssa_temp_index(); i++) {
@@ skipping 21 matching lines @@
   for (intptr_t i = 0; i < worklist_.length(); i++) {
     ASSERT(worklist_[i]->IsPhi());
     *worklist_[i]->Type() = CompileType::None();
   }
 
   // Iterate until a fixed point is reached, updating the types of
   // definitions.
   while (!worklist_.is_empty()) {
     Definition* def = RemoveLastFromWorklist();
     if (FLAG_support_il_printer && FLAG_trace_type_propagation) {
-      THR_Print("recomputing type of v%" Pd ": %s\n",
-                def->ssa_temp_index(),
+      THR_Print("recomputing type of v%" Pd ": %s\n", def->ssa_temp_index(),
                 def->Type()->ToCString());
     }
     if (def->RecomputeType()) {
       if (FLAG_support_il_printer && FLAG_trace_type_propagation) {
         THR_Print("  ... new type %s\n", def->Type()->ToCString());
       }
-      for (Value::Iterator it(def->input_use_list());
-           !it.Done();
+      for (Value::Iterator it(def->input_use_list()); !it.Done();
            it.Advance()) {
         Instruction* instr = it.Current()->instruction();
 
         Definition* use_defn = instr->AsDefinition();
         if (use_defn != NULL) {
           AddToWorklist(use_defn);
         }
 
         // If the value flow into a branch recompute type constrained by the
         // branch (if any). This ensures that correct non-nullable type will
@@ skipping 108 matching lines @@
 }
 
 
 void FlowGraphTypePropagator::VisitValue(Value* value) {
   CompileType* type = TypeOf(value->definition());
   value->SetReachingType(type);
 
   if (FLAG_support_il_printer && FLAG_trace_type_propagation) {
     THR_Print("reaching type to %s for v%" Pd " is %s\n",
               value->instruction()->ToCString(),
-              value->definition()->ssa_temp_index(),
-              type->ToCString());
+              value->definition()->ssa_temp_index(), type->ToCString());
   }
 }
 
 
 void FlowGraphTypePropagator::VisitJoinEntry(JoinEntryInstr* join) {
   for (PhiIterator it(join); !it.Done(); it.Advance()) {
     worklist_.Add(it.Current());
   }
 }
 
@@ skipping 24 matching lines @@
 
 
 void FlowGraphTypePropagator::VisitCheckClassId(CheckClassIdInstr* check) {
   // Can't propagate the type/cid because it may cause illegal code motion and
   // we don't track dependencies in all places via redefinitions.
 }
 
 
 void FlowGraphTypePropagator::VisitInstanceCall(InstanceCallInstr* instr) {
   if (instr->has_unique_selector()) {
-    SetCid(instr->ArgumentAt(0),
-           instr->ic_data()->GetReceiverClassIdAt(0));
+    SetCid(instr->ArgumentAt(0), instr->ic_data()->GetReceiverClassIdAt(0));
   }
 }
 
 
 void FlowGraphTypePropagator::VisitPolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* instr) {
   if (instr->instance_call()->has_unique_selector()) {
-    SetCid(instr->ArgumentAt(0),
-           instr->ic_data().GetReceiverClassIdAt(0));
+    SetCid(instr->ArgumentAt(0), instr->ic_data().GetReceiverClassIdAt(0));
   }
 }
 
 
 void FlowGraphTypePropagator::VisitGuardFieldClass(
     GuardFieldClassInstr* guard) {
   const intptr_t cid = guard->field().guarded_cid();
-  if ((cid == kIllegalCid) ||
-      (cid == kDynamicCid) ||
+  if ((cid == kIllegalCid) || (cid == kDynamicCid) ||
       Field::IsExternalizableCid(cid)) {
     return;
   }
 
   Definition* def = guard->value()->definition();
   CompileType* current = TypeOf(def);
-  if (current->IsNone() ||
-      (current->ToCid() != cid) ||
+  if (current->IsNone() || (current->ToCid() != cid) ||
       (current->is_nullable() && !guard->field().is_nullable())) {
     const bool is_nullable =
         guard->field().is_nullable() && current->is_nullable();
     SetTypeOf(def, ZoneCompileType::Wrap(CompileType(is_nullable, cid, NULL)));
   }
 }
 
 
 void FlowGraphTypePropagator::VisitAssertAssignable(
     AssertAssignableInstr* instr) {
@@ skipping 65 matching lines @@
   AssertAssignableInstr* assert = (*asserts_)[defn->ssa_temp_index()];
   if ((assert == NULL) || (assert == kStrengthenedAssertMarker)) {
     return;
   }
   ASSERT(assert->env() != NULL);
 
   Instruction* check_clone = NULL;
   if (check->IsCheckSmi()) {
     check_clone =
         new CheckSmiInstr(assert->value()->Copy(zone()),
-                          assert->env()->deopt_id(),
-                          check->token_pos());
+                          assert->env()->deopt_id(), check->token_pos());
     check_clone->AsCheckSmi()->set_licm_hoisted(
         check->AsCheckSmi()->licm_hoisted());
   } else {
     ASSERT(check->IsCheckClass());
-    check_clone =
-        new CheckClassInstr(assert->value()->Copy(zone()),
-                            assert->env()->deopt_id(),
-                            check->AsCheckClass()->unary_checks(),
-                            check->token_pos());
+    check_clone = new CheckClassInstr(
+        assert->value()->Copy(zone()), assert->env()->deopt_id(),
+        check->AsCheckClass()->unary_checks(), check->token_pos());
     check_clone->AsCheckClass()->set_licm_hoisted(
         check->AsCheckClass()->licm_hoisted());
   }
   ASSERT(check_clone != NULL);
   ASSERT(assert->deopt_id() == assert->env()->deopt_id());
   check_clone->InsertBefore(assert);
   assert->env()->DeepCopyTo(zone(), check_clone);
 
   (*asserts_)[defn->ssa_temp_index()] = kStrengthenedAssertMarker;
 }
@@ skipping 21 matching lines @@
     return;
   }
 
   if (ToNullableCid() != other->ToNullableCid()) {
     ASSERT(cid_ != kNullCid);
     cid_ = kDynamicCid;
   }
 
   const AbstractType* compile_type = ToAbstractType();
   const AbstractType* other_compile_type = other->ToAbstractType();
-  if (compile_type->IsMoreSpecificThan(
-          *other_compile_type, NULL, NULL, Heap::kOld)) {
+  if (compile_type->IsMoreSpecificThan(*other_compile_type, NULL, NULL,
+                                       Heap::kOld)) {
     type_ = other_compile_type;
-  } else if (other_compile_type->
-      IsMoreSpecificThan(*compile_type, NULL, NULL, Heap::kOld)) {
-  // Nothing to do.
+  } else if (other_compile_type->IsMoreSpecificThan(*compile_type, NULL, NULL,
+                                                    Heap::kOld)) {
+    // Nothing to do.
   } else {
-  // Can't unify.
-  type_ = &Object::dynamic_type();
+    // Can't unify.
+    type_ = &Object::dynamic_type();
   }
 }
 
 
 static bool IsNullableCid(intptr_t cid) {
   ASSERT(cid != kIllegalCid);
   return cid == kNullCid || cid == kDynamicCid;
 }
 
 
@@ skipping 70 matching lines @@
       // Don't infer a cid from an abstract type since there can be multiple
       // compatible classes with different cids.
       if (!CHA::IsImplemented(type_class) && !CHA::HasSubclasses(type_class)) {
         if (type_class.IsPrivate()) {
           // Type of a private class cannot change through later loaded libs.
           cid_ = type_class.id();
         } else if (FLAG_use_cha_deopt ||
                    thread->isolate()->all_classes_finalized()) {
           if (FLAG_trace_cha) {
             THR_Print("  **(CHA) Compile type not subclassed: %s\n",
-                type_class.ToCString());
+                      type_class.ToCString());
           }
           if (FLAG_use_cha_deopt) {
             cha->AddToGuardedClasses(type_class, /*subclass_count=*/0);
           }
           cid_ = type_class.id();
         } else {
           cid_ = kDynamicCid;
         }
       } else {
         cid_ = kDynamicCid;
@@ skipping 75 matching lines @@
 
   if (compile_type.IsMalformedOrMalbounded()) {
     return false;
   }
 
   // The Null type is only a subtype of Object and of dynamic.
   // Functions that do not explicitly return a value, implicitly return null,
   // except generative constructors, which return the object being constructed.
   // It is therefore acceptable for void functions to return null.
   if (compile_type.IsNullType()) {
-    *is_instance = is_nullable ||
-        type.IsObjectType() || type.IsDynamicType() || type.IsVoidType();
+    *is_instance = is_nullable || type.IsObjectType() || type.IsDynamicType() ||
+                   type.IsVoidType();
     return true;
   }
 
   // A non-null value is not an instance of void.
   if (type.IsVoidType()) {
     *is_instance = IsNull();
     return HasDecidableNullability();
   }
 
   // If the value can be null then we can't eliminate the
@@ skipping 34 matching lines @@
   // for the first time.
   return CompileType::None();
 }
 
 
 bool PhiInstr::RecomputeType() {
   CompileType result = CompileType::None();
   for (intptr_t i = 0; i < InputCount(); i++) {
     if (FLAG_support_il_printer && FLAG_trace_type_propagation) {
       THR_Print("  phi %" Pd " input %" Pd ": v%" Pd " has reaching type %s\n",
-                ssa_temp_index(),
-                i,
-                InputAt(i)->definition()->ssa_temp_index(),
+                ssa_temp_index(), i, InputAt(i)->definition()->ssa_temp_index(),
                 InputAt(i)->Type()->ToCString());
     }
     result.Union(InputAt(i)->Type());
   }
 
   if (result.IsNone()) {
     ASSERT(Type()->IsNone());
     return false;
   }
 
@@ skipping 41 matching lines @@
     // In irregexp functions, types of input parameters are known and immutable.
     // Set parameter types here in order to prevent unnecessary CheckClassInstr
     // from being generated.
     switch (index()) {
       case RegExpMacroAssembler::kParamRegExpIndex:
         return CompileType::FromCid(kRegExpCid);
       case RegExpMacroAssembler::kParamStringIndex:
         return CompileType::FromCid(function.string_specialization_cid());
       case RegExpMacroAssembler::kParamStartOffsetIndex:
         return CompileType::FromCid(kSmiCid);
-      default: UNREACHABLE();
+      default:
+        UNREACHABLE();
     }
     UNREACHABLE();
     return CompileType::Dynamic();
   }
 
   // Parameter is the receiver.
   if ((index() == 0) &&
       (function.IsDynamicFunction() || function.IsGenerativeConstructor())) {
     LocalScope* scope = graph_entry->parsed_function().node_sequence()->scope();
     const AbstractType& type = scope->VariableAt(index())->type();
     if (type.IsObjectType() || type.IsNullType()) {
       // Receiver can be null.
       return CompileType::FromAbstractType(type, CompileType::kNullable);
     }
 
     // Receiver can't be null but can be an instance of a subclass.
     intptr_t cid = kDynamicCid;
 
     if (type.HasResolvedTypeClass()) {
       Thread* thread = Thread::Current();
       const Class& type_class = Class::Handle(type.type_class());
       if (!CHA::HasSubclasses(type_class)) {
         if (type_class.IsPrivate()) {
           // Private classes can never be subclassed by later loaded libs.
           cid = type_class.id();
         } else {
           if (FLAG_use_cha_deopt ||
               thread->isolate()->all_classes_finalized()) {
             if (FLAG_trace_cha) {
-              THR_Print("  **(CHA) Computing exact type of receiver, "
+              THR_Print(
+                  "  **(CHA) Computing exact type of receiver, "
                   "no subclasses: %s\n",
                   type_class.ToCString());
             }
             if (FLAG_use_cha_deopt) {
-              thread->cha()->AddToGuardedClasses(
-                  type_class, /*subclass_count=*/0);
+              thread->cha()->AddToGuardedClasses(type_class,
+                                                 /*subclass_count=*/0);
             }
             cid = type_class.id();
           }
         }
       }
     }
 
     return CompileType(CompileType::kNonNullable, cid, &type);
   }
 
@@ skipping 10 matching lines @@
   if (value().IsNull()) {
     return CompileType::Null();
   }
 
   intptr_t cid = value().GetClassId();
   if (Field::IsExternalizableCid(cid)) {
     cid = kDynamicCid;
   }
 
   if (value().IsInstance()) {
-    return CompileType::Create(cid,
-        AbstractType::ZoneHandle(Instance::Cast(value()).GetType()));
+    return CompileType::Create(
+        cid, AbstractType::ZoneHandle(Instance::Cast(value()).GetType()));
   } else {
     // Type info for non-instance objects.
     return CompileType::FromCid(cid);
   }
 }
 
 
 CompileType AssertAssignableInstr::ComputeType() const {
   CompileType* value_type = value()->Type();
 
@@ skipping 51 matching lines @@
 }
 
 
 CompileType RelationalOpInstr::ComputeType() const {
   // Used for numeric comparisons only.
   return CompileType::Bool();
 }
 
 
 CompileType CurrentContextInstr::ComputeType() const {
-  return CompileType(CompileType::kNonNullable,
-                     kContextCid,
+  return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
 
 CompileType CloneContextInstr::ComputeType() const {
-  return CompileType(CompileType::kNonNullable,
-                     kContextCid,
+  return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
 
 CompileType AllocateContextInstr::ComputeType() const {
-  return CompileType(CompileType::kNonNullable,
-                     kContextCid,
+  return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
 
 CompileType AllocateUninitializedContextInstr::ComputeType() const {
-  return CompileType(CompileType::kNonNullable,
-                     kContextCid,
+  return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
 
 CompileType PolymorphicInstanceCallInstr::ComputeType() const {
   if (!HasSingleRecognizedTarget()) return CompileType::Dynamic();
   const Function& target = Function::Handle(ic_data().GetTargetAt(0));
   return (target.recognized_kind() != MethodRecognizer::kUnknown)
-      ? CompileType::FromCid(MethodRecognizer::ResultCid(target))
-      : CompileType::Dynamic();
+             ? CompileType::FromCid(MethodRecognizer::ResultCid(target))
+             : CompileType::Dynamic();
 }
 
 
 CompileType StaticCallInstr::ComputeType() const {
   if (result_cid_ != kDynamicCid) {
     return CompileType::FromCid(result_cid_);
   }
 
   if (Isolate::Current()->type_checks()) {
     // Void functions are known to return null, which is checked at the return
     // from the function.
     const AbstractType& result_type =
         AbstractType::ZoneHandle(function().result_type());
-    return CompileType::FromAbstractType(result_type.IsVoidType()
-        ? AbstractType::ZoneHandle(Type::NullType())
-        : result_type);
+    return CompileType::FromAbstractType(
+        result_type.IsVoidType() ? AbstractType::ZoneHandle(Type::NullType())
+                                 : result_type);
   }
 
   return CompileType::Dynamic();
 }
 
 
 CompileType LoadLocalInstr::ComputeType() const {
   if (Isolate::Current()->type_checks()) {
     return CompileType::FromAbstractType(local().type());
   }
@@ skipping 11 matching lines @@
   return *value()->Type();
 }
 
 
 CompileType OneByteStringFromCharCodeInstr::ComputeType() const {
   return CompileType::FromCid(kOneByteStringCid);
 }
 
 
 CompileType StringToCharCodeInstr::ComputeType() const {
-    return CompileType::FromCid(kSmiCid);
+  return CompileType::FromCid(kSmiCid);
 }
 
 
 CompileType StringInterpolateInstr::ComputeType() const {
   // TODO(srdjan): Do better and determine if it is a one or two byte string.
   return CompileType::String();
 }
 
 
 CompileType LoadStaticFieldInstr::ComputeType() const {
   bool is_nullable = CompileType::kNullable;
   intptr_t cid = kDynamicCid;
   AbstractType* abstract_type = NULL;
   const Field& field = this->StaticField();
   if (Isolate::Current()->type_checks()) {
     cid = kIllegalCid;
     abstract_type = &AbstractType::ZoneHandle(field.type());
   }
   ASSERT(field.is_static());
   if (field.is_final()) {
     if (!FLAG_fields_may_be_reset) {
       const Instance& obj = Instance::Handle(field.StaticValue());
       if ((obj.raw() != Object::sentinel().raw()) &&
-          (obj.raw() != Object::transition_sentinel().raw()) &&
-          !obj.IsNull()) {
+          (obj.raw() != Object::transition_sentinel().raw()) && !obj.IsNull()) {
         is_nullable = CompileType::kNonNullable;
         cid = obj.GetClassId();
       }
     } else if (field.guarded_cid() != kIllegalCid) {
       cid = field.guarded_cid();
       if (!IsNullableCid(cid)) is_nullable = CompileType::kNonNullable;
     }
   }
   if (Field::IsExternalizableCid(cid)) {
     cid = kDynamicCid;
   }
   return CompileType(is_nullable, cid, abstract_type);
 }
 
 
 CompileType CreateArrayInstr::ComputeType() const {
   // TODO(fschneider): Add abstract type and type arguments to the compile type.
   return CompileType::FromCid(kArrayCid);
 }
 
 
 CompileType AllocateObjectInstr::ComputeType() const {
   if (!closure_function().IsNull()) {
     ASSERT(cls().id() == kClosureCid);
-    return CompileType(CompileType::kNonNullable,
-                       kClosureCid,
+    return CompileType(CompileType::kNonNullable, kClosureCid,
                        &Type::ZoneHandle(closure_function().SignatureType()));
   }
   // TODO(vegorov): Incorporate type arguments into the returned type.
   return CompileType::FromCid(cls().id());
 }
 
 
 CompileType LoadUntaggedInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType LoadClassIdInstr::ComputeType() const {
   return CompileType::FromCid(kSmiCid);
 }
 
 
 CompileType LoadFieldInstr::ComputeType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
   // Keep it as null for debug purposes and do not return dynamic in production
   // mode, since misuse of the type would remain undetected.
   if (type().IsNull()) {
     return CompileType::Dynamic();
   }
 
   const AbstractType* abstract_type = NULL;
   if (Isolate::Current()->type_checks() &&
       (type().IsFunctionType() ||
        (type().HasResolvedTypeClass() &&
-       !Field::IsExternalizableCid(Class::Handle(type().type_class()).id())))) {
+        !Field::IsExternalizableCid(
+            Class::Handle(type().type_class()).id())))) {
     abstract_type = &type();
   }
 
   if ((field_ != NULL) && (field_->guarded_cid() != kIllegalCid)) {
     bool is_nullable = field_->is_nullable();
-    intptr_t field_cid =  field_->guarded_cid();
+    intptr_t field_cid = field_->guarded_cid();
     if (Field::IsExternalizableCid(field_cid)) {
       // We cannot assume that the type of the value in the field has not
       // changed on the fly.
       field_cid = kDynamicCid;
     }
     return CompileType(is_nullable, field_cid, abstract_type);
   }
 
   ASSERT(!Field::IsExternalizableCid(result_cid_));
   return CompileType::Create(result_cid_, *abstract_type);
@@ skipping 368 matching lines @@
 CompileType MergedMathInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart