Add missing arity check for native entry in arm64 and mips simulators.

runtime/vm/native_entry.cc

 // Copyright (c) 2011, 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/native_entry.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap.h"
 #include "vm/code_patcher.h"
@@ skipping 166 matching lines @@
   VERIFY_ON_TRANSITION;
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   /* Tell MemorySanitizer 'arguments' is initialized by generated code. */
   MSAN_UNPOISON(arguments, sizeof(*arguments));
   TRACE_NATIVE_CALL("%s", "LinkNative");
 
   NativeFunction target_function = NULL;
   bool call_through_wrapper = false;
 #ifdef USING_SIMULATOR
   bool is_native_auto_setup_scope = false;
-  intptr_t num_parameters = -1;
 #endif
 
   {
     StackZone zone(arguments->thread());
 
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
 
     const Code& code = Code::Handle(caller_frame->LookupDartCode());
     const Function& func = Function::Handle(code.function());
 #ifdef USING_SIMULATOR
     is_native_auto_setup_scope = func.IsNativeAutoSetupScope();
-    num_parameters = func.NumParameters();
 #endif
 
     if (FLAG_trace_natives) {
       OS::Print("Resolving native target for %s\n", func.ToCString());
     }
 
     bool is_bootstrap_native = false;
     target_function = ResolveNativeFunction(
         arguments->thread()->isolate(), func, &is_bootstrap_native);
     ASSERT(target_function != NULL);
 
 #if defined(DEBUG)
     {
       NativeFunction current_function = NULL;
       uword current_trampoline =
           CodePatcher::GetNativeCallAt(caller_frame->pc(),
                                        code,
                                        &current_function);
 #if !defined(USING_SIMULATOR)
       ASSERT(current_function ==
              reinterpret_cast<NativeFunction>(LinkNativeCall));
 #else
       ASSERT(current_function ==
              reinterpret_cast<NativeFunction>(
                  Simulator::RedirectExternalReference(
                      reinterpret_cast<uword>(LinkNativeCall),
                      Simulator::kBootstrapNativeCall,
-                     func.NumParameters())));
+                     NativeEntry::kNumArguments)));
 #endif
       ASSERT(current_trampoline ==
              StubCode::CallBootstrapCFunction_entry()->EntryPoint());
     }
 #endif
 
     const intptr_t argc_tag = NativeArguments::ComputeArgcTag(func);
     const bool is_leaf_call =
       (argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;
 
     call_through_wrapper = !is_bootstrap_native && !is_leaf_call;
 
     const Code& trampoline = Code::Handle(call_through_wrapper ?
         StubCode::CallNativeCFunction_entry()->code() :
         StubCode::CallBootstrapCFunction_entry()->code());
 
     NativeFunction patch_target_function = target_function;
 #if defined(USING_SIMULATOR)
     if (!call_through_wrapper || !is_native_auto_setup_scope) {
       patch_target_function = reinterpret_cast<NativeFunction>(
           Simulator::RedirectExternalReference(
               reinterpret_cast<uword>(patch_target_function),
-              Simulator::kBootstrapNativeCall, num_parameters));
+              Simulator::kBootstrapNativeCall, NativeEntry::kNumArguments));
     }
 #endif
 
     CodePatcher::PatchNativeCallAt(
         caller_frame->pc(), code, patch_target_function, trampoline);
 
     if (FLAG_trace_natives) {
       OS::Print("    -> %p (%s, %s)\n",
                 target_function,
                 is_bootstrap_native ? "bootstrap" : "non-bootstrap",
                 is_leaf_call ? "leaf" : "non-leaf");
     }
   }
   VERIFY_ON_TRANSITION;
 
   // Tail-call resolved target.
   if (call_through_wrapper) {
     NativeEntry::NativeCallWrapper(
         args, reinterpret_cast<Dart_NativeFunction>(target_function));
   } else {
     target_function(arguments);
   }
 }
 
 
 }  // namespace dart