[vm] Read interface_target_reference from kernel binaries

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 1041 matching lines @@
 }
 
 Fragment FlowGraphBuilder::IntConstant(int64_t value) {
   return Fragment(
       Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
 }
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
-                                        intptr_t argument_count,
-                                        intptr_t checked_argument_count) {
-  const intptr_t kTypeArgsLen = 0;
-  return InstanceCall(position, name, kind, kTypeArgsLen, argument_count,
-                      Array::null_array(), checked_argument_count);
-}
-
-Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
-                                        const dart::String& name,
-                                        Token::Kind kind,
                                         intptr_t type_args_len,
                                         intptr_t argument_count,
                                         const Array& argument_names,
-                                        intptr_t checked_argument_count) {
+                                        intptr_t checked_argument_count,
+                                        const Function& interface_target) {
   const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
   ArgumentArray arguments = GetArguments(total_count);
-  InstanceCallInstr* call = new (Z) InstanceCallInstr(
-      position, name, kind, arguments, type_args_len, argument_names,
-      checked_argument_count, ic_data_array_, GetNextDeoptId());
+  InstanceCallInstr* call = new (Z)
+      InstanceCallInstr(position, name, kind, arguments, type_args_len,
+                        argument_names, checked_argument_count, ic_data_array_,
+                        GetNextDeoptId(), interface_target);
   Push(call);
   return Fragment(call);
 }
 
 Fragment FlowGraphBuilder::ClosureCall(intptr_t type_args_len,
                                        intptr_t argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
   const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
   ArgumentArray arguments = GetArguments(total_count);
@@ skipping 413 matching lines @@
 }
 
 RawFunction* FlowGraphBuilder::LookupMethodByMember(
     NameIndex target,
     const dart::String& method_name) {
   NameIndex kernel_class = H.EnclosingName(target);
   dart::Class& klass =
       dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
   RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
+#ifdef DEBUG
+  if (function == Object::null()) {
+    OS::PrintErr("Unable to find \'%s\' in %s\n", method_name.ToCString(),
+                 klass.ToCString());
+  }
+#endif
   ASSERT(function != Object::null());
   return function;
 }
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
   char name[64];
   intptr_t index = stack_->definition()->temp_index();
   OS::SNPrint(name, 64, ":temp%" Pd, index);
   LocalVariable* variable =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
@@ skipping 641 matching lines @@
   LocalVariable* closure = NULL;
   if (is_closure_call) {
     closure = scope->VariableAt(0);
 
     // The closure itself is the first argument.
     body += LoadLocal(closure);
   } else {
     // Invoke the getter to get the field value.
     body += LoadLocal(scope->VariableAt(0));
     body += PushArgument();
-    body +=
-        InstanceCall(TokenPosition::kMinSource, getter_name, Token::kGET, 1);
+    const intptr_t kTypeArgsLen = 0;
+    const intptr_t kNumArgsChecked = 1;
+    body += InstanceCall(TokenPosition::kMinSource, getter_name, Token::kGET,
+                         kTypeArgsLen, 1, Array::null_array(), kNumArgsChecked,
+                         Function::null_function());
   }
 
   body += PushArgument();
 
   // Push all arguments onto the stack.
   intptr_t pos = 1;
   for (; pos < descriptor.Count(); pos++) {
     body += LoadLocal(scope->VariableAt(pos));
     body += PushArgument();
   }
 
   if (is_closure_call) {
     // Lookup the function in the closure.
     body += LoadLocal(closure);
     body += LoadField(Closure::function_offset());
 
     body += ClosureCall(descriptor.TypeArgsLen(), descriptor.Count(),
                         argument_names);
   } else {
+    const intptr_t kNumArgsChecked = 1;
     body += InstanceCall(TokenPosition::kMinSource, Symbols::Call(),
                          Token::kILLEGAL, descriptor.TypeArgsLen(),
-                         descriptor.Count(), argument_names);
+                         descriptor.Count(), argument_names, kNumArgsChecked,
+                         Function::null_function());
   }
 
   body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 TargetEntryInstr* FlowGraphBuilder::BuildTargetEntry() {
   return new (Z)
       TargetEntryInstr(AllocateBlockId(), CurrentTryIndex(), GetNextDeoptId());
@@ skipping 206 matching lines @@
   array_object = AsSortedDuplicateFreeArray(&token_positions);
   script.set_debug_positions(array_object);
   array_object = AsSortedDuplicateFreeArray(&yield_positions);
   script.set_yield_positions(array_object);
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)