[vm] Use strong mode types to calculate CompileType

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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 #include "vm/regexp_assembler.h"
 #include "vm/resolver.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool,
             trace_type_propagation,
             false,
             "Trace flow graph type propagation");
 
 DECLARE_FLAG(bool, propagate_types);
 
+static void TraceStrongModeType(const Instruction* instr,
+                                const AbstractType& type) {
+  if (FLAG_trace_experimental_strong_mode) {
+    OS::PrintErr("[Strong mode] Type of %s - %s\n", instr->ToCString(),

[rmacnak, 2017/08/22 21:24:23]

Use THR_Print in the compiler. THR_Print applies an isolate filter, which
defaults to hiding the service isolate.

[alexmarkov, 2017/08/22 22:53:11]

Done.

+                 type.ToCString());
+  }
+}
+
+static void TraceStrongModeType(const Instruction* instr,
+                                CompileType* compileType) {
+  if (FLAG_trace_experimental_strong_mode) {
+    const AbstractType* type = compileType->ToAbstractType();
+    if ((type != NULL) && !type->IsDynamicType()) {
+      TraceStrongModeType(instr, *type);
+    }
+  }
+}
+
 void FlowGraphTypePropagator::Propagate(FlowGraph* flow_graph) {
 #ifndef PRODUCT
   Thread* thread = flow_graph->thread();
   TimelineStream* compiler_timeline = Timeline::GetCompilerStream();
   TimelineDurationScope tds2(thread, compiler_timeline,
                              "FlowGraphTypePropagator");
 #endif  // !PRODUCT
   FlowGraphTypePropagator propagator(flow_graph);
   propagator.Propagate();
 }
@@ skipping 787 matching lines @@
             }
             cid = type_class.id();
           }
         }
       }
     }
 
     return CompileType(CompileType::kNonNullable, cid, &type);
   }
 
+  if (FLAG_experimental_strong_mode && block_->IsGraphEntry()) {
+    LocalScope* scope = graph_entry->parsed_function().node_sequence()->scope();
+    const AbstractType& param_type = scope->VariableAt(index())->type();
+    TraceStrongModeType(this, param_type);
+    return CompileType::FromAbstractType(param_type);
+  }
+
   return CompileType::Dynamic();
 }
 
 CompileType PushArgumentInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 CompileType ConstantInstr::ComputeType() const {
   if (value().IsNull()) {
     return CompileType::Null();
@@ skipping 80 matching lines @@
 CompileType AllocateContextInstr::ComputeType() const {
   return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
 CompileType AllocateUninitializedContextInstr::ComputeType() const {
   return CompileType(CompileType::kNonNullable, kContextCid,
                      &Object::dynamic_type());
 }
 
+CompileType InstanceCallInstr::ComputeType() const {
+  if (FLAG_experimental_strong_mode) {
+    const Function& target = interface_target();
+    if (!target.IsNull()) {
+      // TODO(alexmarkov): instantiate generic result_type
+      const AbstractType& result_type =
+          AbstractType::ZoneHandle(target.result_type());
+      TraceStrongModeType(this, result_type);
+      return CompileType::FromAbstractType(result_type);
+    }
+  }
+
+  return CompileType::Dynamic();
+}
+
 CompileType PolymorphicInstanceCallInstr::ComputeType() const {
-  if (!IsSureToCallSingleRecognizedTarget()) return CompileType::Dynamic();
-  const Function& target = *targets_.TargetAt(0)->target;
-  return (target.recognized_kind() != MethodRecognizer::kUnknown)
-             ? CompileType::FromCid(MethodRecognizer::ResultCid(target))
-             : CompileType::Dynamic();
+  if (IsSureToCallSingleRecognizedTarget()) {
+    const Function& target = *targets_.TargetAt(0)->target;
+    if (target.recognized_kind() != MethodRecognizer::kUnknown) {
+      return CompileType::FromCid(MethodRecognizer::ResultCid(target));
+    }
+  }
+
+  if (FLAG_experimental_strong_mode) {
+    CompileType* type = instance_call()->Type();
+    TraceStrongModeType(this, type);
+    return *type;
+  }
+
+  return CompileType::Dynamic();
 }
 
 CompileType StaticCallInstr::ComputeType() const {
   if (result_cid_ != kDynamicCid) {
     return CompileType::FromCid(result_cid_);
   }
 
-  if (Isolate::Current()->type_checks()) {
+  if (function_.recognized_kind() != MethodRecognizer::kUnknown) {
+    return CompileType::FromCid(MethodRecognizer::ResultCid(function_));
+  }
+
+  if (FLAG_experimental_strong_mode || Isolate::Current()->type_checks()) {
     const AbstractType& result_type =
         AbstractType::ZoneHandle(function().result_type());
+    TraceStrongModeType(this, result_type);
     return CompileType::FromAbstractType(result_type);
   }
 
-  return (function_.recognized_kind() != MethodRecognizer::kUnknown)
-             ? CompileType::FromCid(MethodRecognizer::ResultCid(function_))
-             : CompileType::Dynamic();
+  return CompileType::Dynamic();
 }
 
 CompileType LoadLocalInstr::ComputeType() const {
-  if (Isolate::Current()->type_checks()) {
-    return CompileType::FromAbstractType(local().type());
+  if (FLAG_experimental_strong_mode || Isolate::Current()->type_checks()) {
+    const AbstractType& local_type = local().type();
+    TraceStrongModeType(this, local_type);
+    return CompileType::FromAbstractType(local_type);
   }
   return CompileType::Dynamic();
 }
 
 CompileType DropTempsInstr::ComputeType() const {
   return *value()->Type();
 }
 
 CompileType StoreLocalInstr::ComputeType() const {
   // Returns stored value.
@@ skipping 11 matching lines @@
 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()) {
+  if (FLAG_experimental_strong_mode || Isolate::Current()->type_checks()) {
     cid = kIllegalCid;
     abstract_type = &AbstractType::ZoneHandle(field.type());
+    TraceStrongModeType(this, *abstract_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()) {
         is_nullable = CompileType::kNonNullable;
         cid = obj.GetClassId();
       }
@@ skipping 30 matching lines @@
 
 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())) {
+  if (FLAG_experimental_strong_mode ||
+      (Isolate::Current()->type_checks() &&
+       (type().IsFunctionType() || type().HasResolvedTypeClass()))) {
     abstract_type = &type();
+    TraceStrongModeType(this, *abstract_type);
   }
 
   if ((field_ != NULL) && (field_->guarded_cid() != kIllegalCid)) {
     bool is_nullable = field_->is_nullable();
     intptr_t field_cid = field_->guarded_cid();
     return CompileType(is_nullable, field_cid, abstract_type);
   }
 
   return CompileType::Create(result_cid_, *abstract_type);
 }
@@ skipping 44 matching lines @@
 }
 
 CompileType ShiftInt64OpInstr::ComputeType() const {
   return CompileType::Int();
 }
 
 CompileType UnaryInt64OpInstr::ComputeType() const {
   return CompileType::Int();
 }
 
+CompileType CheckedSmiOpInstr::ComputeType() const {
+  if (FLAG_experimental_strong_mode) {
+    CompileType* type = call()->Type();
+    TraceStrongModeType(this, type);
+    return *type;
+  }
+  return CompileType::Dynamic();
+}
+
+CompileType CheckedSmiComparisonInstr::ComputeType() const {
+  if (FLAG_experimental_strong_mode) {
+    CompileType* type = call()->Type();
+    TraceStrongModeType(this, type);
+    return *type;
+  }
+  return CompileType::Dynamic();
+}
+
 CompileType BoxIntegerInstr::ComputeType() const {
   return ValueFitsSmi() ? CompileType::FromCid(kSmiCid) : CompileType::Int();
 }
 
 bool BoxIntegerInstr::RecomputeType() {
   return UpdateType(ComputeType());
 }
 
 CompileType UnboxIntegerInstr::ComputeType() const {
   return CompileType::Int();
@@ skipping 243 matching lines @@
 
 CompileType TruncDivModInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart