Share code for building recognized native getters.

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/class_finalizer.h"
@@ skipping 3250 matching lines @@
 }
 
 
 LoadLocalInstr* EffectGraphVisitor::BuildLoadThisVar(LocalScope* scope) {
   LocalVariable* receiver_var = scope->LookupVariable(Symbols::This(),
                                                       true);  // Test only.
   return new(Z) LoadLocalInstr(*receiver_var);
 }
 
 
+LoadFieldInstr* EffectGraphVisitor::BuildNativeGetter(
+    NativeBodyNode* node,
+    MethodRecognizer::Kind kind,
+    intptr_t offset,
+    const Type& type,
+    intptr_t class_id) {
+  Value* receiver = Bind(BuildLoadThisVar(node->scope()));
+  LoadFieldInstr* load = new(Z) LoadFieldInstr(receiver,
+                                               offset,
+                                               type,
+                                               node->token_pos());
+  load->set_result_cid(class_id);
+  load->set_recognized_kind(kind);
+  return load;
+}
+
+
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   const Function& function = owner()->function();
   if (!function.IsClosureFunction()) {
     MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
     switch (kind) {
       case MethodRecognizer::kObjectEquals: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LocalVariable* other_var =
             node->scope()->LookupVariable(Symbols::Other(),
                                           true);  // Test only.
         Value* other = Bind(new(Z) LoadLocalInstr(*other_var));
         // Receiver is not a number because numbers override equality.
         const bool kNoNumberCheck = false;
         StrictCompareInstr* compare =
             new(Z) StrictCompareInstr(node->token_pos(),
                                       Token::kEQ_STRICT,
                                       receiver,
                                       other,
                                       kNoNumberCheck);
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kStringBaseLength:
       case MethodRecognizer::kStringBaseIsEmpty: {
-        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         // Treat length loads as mutable (i.e. affected by side effects) to
         // avoid hoisting them since we can't hoist the preceding class-check.
         // This is because of externalization of strings that affects their
         // class-id.
-        LoadFieldInstr* load = new(Z) LoadFieldInstr(
-            receiver,
-            String::length_offset(),
-            Type::ZoneHandle(Z, Type::SmiType()),
-            node->token_pos());
-        load->set_result_cid(kSmiCid);
-        load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
+        LoadFieldInstr* load = BuildNativeGetter(
+            node, MethodRecognizer::kStringBaseLength, String::length_offset(),
+            Type::ZoneHandle(Z, Type::SmiType()), kSmiCid);
         if (kind == MethodRecognizer::kStringBaseLength) {
           return ReturnDefinition(load);
         }
         ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
         Value* zero_val = Bind(new(Z) ConstantInstr(
             Smi::ZoneHandle(Z, Smi::New(0))));
         Value* load_val = Bind(load);
         StrictCompareInstr* compare =
             new(Z) StrictCompareInstr(node->token_pos(),
                                    Token::kEQ_STRICT,
                                    load_val,
                                    zero_val,
                                    false);  // No number check.
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kGrowableArrayLength:
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
       case MethodRecognizer::kTypedDataLength: {
-        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
-        LoadFieldInstr* load = new(Z) LoadFieldInstr(
-            receiver,
-            OffsetForLengthGetter(kind),
-            Type::ZoneHandle(Z, Type::SmiType()),
-            node->token_pos());
+        LoadFieldInstr* load = BuildNativeGetter(
+            node, kind, OffsetForLengthGetter(kind),
+            Type::ZoneHandle(Z, Type::SmiType()), kSmiCid);
         load->set_is_immutable(kind != MethodRecognizer::kGrowableArrayLength);
-        load->set_result_cid(kSmiCid);
-        load->set_recognized_kind(kind);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kClassIDgetID: {
         LocalVariable* value_var =
             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: {
@@ skipping 20 matching lines @@
                                           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: {
-        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
-        LoadFieldInstr* load = new(Z) LoadFieldInstr(
-            receiver,
-            Bigint::digits_offset(),
+        return ReturnDefinition(BuildNativeGetter(
+            node, kind, Bigint::digits_offset(),
             Type::ZoneHandle(Z, Type::DynamicType()),
-            node->token_pos());
-        load->set_result_cid(kTypedDataUint32ArrayCid);
-        load->set_recognized_kind(kind);
-        return ReturnDefinition(load);
+            kTypedDataUint32ArrayCid));
       }
       case MethodRecognizer::kBigint_getUsed: {
-        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
-        LoadFieldInstr* load = new(Z) LoadFieldInstr(
-            receiver,
-            Bigint::used_offset(),
-            Type::ZoneHandle(Z, Type::SmiType()),
-            node->token_pos());
-        load->set_result_cid(kSmiCid);
-        load->set_recognized_kind(kind);
-        return ReturnDefinition(load);
+        return ReturnDefinition(BuildNativeGetter(
+            node, kind, Bigint::used_offset(),
+            Type::ZoneHandle(Z, Type::SmiType()), kSmiCid));
       }
       case MethodRecognizer::kBigint_getNeg: {
-        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
-        LoadFieldInstr* load = new(Z) LoadFieldInstr(
-            receiver,
-            Bigint::neg_offset(),
-            Type::ZoneHandle(Z, Type::BoolType()),
-            node->token_pos());
-        load->set_result_cid(kBoolCid);
-        load->set_recognized_kind(kind);
-        return ReturnDefinition(load);
+        return ReturnDefinition(BuildNativeGetter(
+            node, kind, Bigint::neg_offset(),
+            Type::ZoneHandle(Z, Type::BoolType()), kBoolCid));
       }
       default:
         break;
     }
   }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
   NativeCallInstr* native_call = new(Z) NativeCallInstr(node);
   ReturnDefinition(native_call);
 }
 
@@ skipping 962 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