VM: Use read-only handle Object::dynamic_type() where possible.

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 3474 matching lines @@
             node->scope()->LookupVariable(Symbols::Value(), true);
         Value* value = Bind(new(Z) LoadLocalInstr(*value_var));
         LoadClassIdInstr* load = new(Z) LoadClassIdInstr(value);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kGrowableArrayCapacity: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadFieldInstr* data_load = new(Z) LoadFieldInstr(
             receiver,
             Array::data_offset(),
-            Type::ZoneHandle(Z, Type::DynamicType()),
+            Object::dynamic_type(),
             node->token_pos());
         data_load->set_result_cid(kArrayCid);
         Value* data = Bind(data_load);
         LoadFieldInstr* length_load = new(Z) LoadFieldInstr(
             data,
             Array::length_offset(),
             Type::ZoneHandle(Z, Type::SmiType()),
             node->token_pos());
         length_load->set_result_cid(kSmiCid);
         length_load->set_recognized_kind(MethodRecognizer::kObjectArrayLength);
         return ReturnDefinition(length_load);
       }
       case MethodRecognizer::kObjectArrayAllocate: {
         LocalVariable* type_args_parameter =
             node->scope()->LookupVariable(Symbols::TypeArgumentsParameter(),
                                           true);
         Value* element_type = Bind(new(Z) LoadLocalInstr(*type_args_parameter));
         LocalVariable* length_parameter =
             node->scope()->LookupVariable(Symbols::Length(), true);
         Value* length = Bind(new(Z) LoadLocalInstr(*length_parameter));
         CreateArrayInstr* create_array =
             new CreateArrayInstr(node->token_pos(), element_type, length);
         return ReturnDefinition(create_array);
       }
       case MethodRecognizer::kBigint_getDigits: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, Bigint::digits_offset(),
-            Type::ZoneHandle(Z, Type::DynamicType()),
+            Object::dynamic_type(),
             kTypedDataUint32ArrayCid));
       }
       case MethodRecognizer::kBigint_getUsed: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, Bigint::used_offset(),
             Type::ZoneHandle(Z, Type::SmiType()), kSmiCid));
       }
       case MethodRecognizer::kLinkedHashMap_getIndex: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, LinkedHashMap::index_offset(),
-            Type::ZoneHandle(Z, Type::DynamicType()),
+            Object::dynamic_type(),
             kDynamicCid));
       }
       case MethodRecognizer::kLinkedHashMap_setIndex: {
         return ReturnDefinition(DoNativeSetterStoreValue(
             node, LinkedHashMap::index_offset(), kEmitStoreBarrier));
       }
       case MethodRecognizer::kLinkedHashMap_getData: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, LinkedHashMap::data_offset(),
-            Type::ZoneHandle(Z, Type::DynamicType()),
+            Object::dynamic_type(),
             kArrayCid));
       }
       case MethodRecognizer::kLinkedHashMap_setData: {
         return ReturnDefinition(DoNativeSetterStoreValue(
             node, LinkedHashMap::data_offset(), kEmitStoreBarrier));
       }
       case MethodRecognizer::kLinkedHashMap_getHashMask: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, LinkedHashMap::hash_mask_offset(),
             Type::ZoneHandle(Z, Type::SmiType()),
@@ skipping 468 matching lines @@
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = Symbols::TempParam();
           LocalVariable* temp_local = new(Z) LocalVariable(
               0,  // Token index.
               temp_name,
-              Type::ZoneHandle(Z, Type::DynamicType()));  // Type.
+              Object::dynamic_type());  // Type.
           temp_local->set_index(param_frame_index);
 
           // Mark this local as captured parameter so that the optimizer
           // correctly handles these when compiling try-catch: Captured
           // parameters are not in the stack environment, therefore they
           // must be skipped when emitting sync-code in try-blocks.
           temp_local->set_is_captured_parameter(true);
 
           // Copy parameter from local frame to current context.
           Value* load = Bind(BuildLoadLocal(*temp_local));
@@ skipping 288 matching lines @@
       Value* stacktrace = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->rethrow_stacktrace_var()));
       for_finally.PushArgument(stacktrace);
       for_finally.AddInstruction(
           new(Z) ReThrowInstr(catch_block->token_pos(), catch_handler_index));
       for_finally.CloseFragment();
     }
     ASSERT(!for_finally.is_open());
 
     const Array& types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
-    types.SetAt(0, Type::Handle(Z, Type::DynamicType()));
+    types.SetAt(0, Object::dynamic_type());
     CatchBlockEntryInstr* finally_entry =
         new(Z) CatchBlockEntryInstr(owner()->AllocateBlockId(),
                                     original_handler_index,
                                     types,
                                     catch_handler_index,
                                     catch_block->exception_var(),
                                     catch_block->stacktrace_var(),
                                     catch_block->needs_stacktrace());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
@@ skipping 253 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart