Changed the API in DartEntry for invoking dart code from C++ to make it more compatible with the re…

vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1106 matching lines @@
       Instance::Handle(Closure::New(closure_function, context));
   if (receiver_class.HasTypeArguments()) {
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(receiver.GetTypeArguments());
     closure.SetTypeArguments(type_arguments);
   }
   return closure.raw();
 }
 
 
-static RawInstructions* EnsureCompiled(const Function& function) {
-  if (!function.HasCode()) {
-    const Error& error = Error::Handle(Compiler::CompileFunction(function));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
-    }
-  }
-  const Code& code = Code::Handle(function.CurrentCode());
-  ASSERT(!code.IsNull());
-  const Instructions& instrs = Instructions::Handle(code.instructions());
-  ASSERT(!instrs.IsNull());
-  return instrs.raw();
-}
-
-
 static RawObject* InvokeNoSuchMethod(const Instance& receiver,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
                                      const Array& arguments) {
   // Allocate an InvocationMirror object.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& invocation_mirror_name =
       String::Handle(Symbols::InvocationMirror());
   Class& invocation_mirror_class =
       Class::Handle(core_lib.LookupClassAllowPrivate(invocation_mirror_name));
   ASSERT(!invocation_mirror_class.IsNull());
   const String& allocation_function_name =
       String::Handle(Symbols::AllocateInvocationMirror());
   const Function& allocation_function = Function::Handle(
       Resolver::ResolveStaticByName(invocation_mirror_class,
                                     allocation_function_name,
                                     Resolver::kIsQualified));
   ASSERT(!allocation_function.IsNull());
-  GrowableArray<const Object*> allocation_arguments(3);
-  allocation_arguments.Add(&target_name);
-  allocation_arguments.Add(&arguments_descriptor);
-  allocation_arguments.Add(&arguments);
-  const Array& kNoArgumentNames = Array::Handle();
+  const int kNumAllocationArgs = 3;
+  const Array& allocation_args = Array::Handle(Array::New(kNumAllocationArgs));
+  allocation_args.SetAt(0, target_name);
+  allocation_args.SetAt(1, arguments_descriptor);
+  allocation_args.SetAt(2, arguments);
   const Object& invocation_mirror =
       Object::Handle(DartEntry::InvokeStatic(allocation_function,
-                                             allocation_arguments,
-                                             kNoArgumentNames));
+                                             allocation_args));
 
+  // Now use the invocation mirror object and invoke NoSuchMethod.
   const String& function_name = String::Handle(Symbols::NoSuchMethod());
   const int kNumArguments = 2;
   const int kNumNamedArguments = 0;
   const Function& function = Function::Handle(
       Resolver::ResolveDynamic(receiver,
                                function_name,
                                kNumArguments,
                                kNumNamedArguments));
   ASSERT(!function.IsNull());
-  GrowableArray<const Object*> invoke_arguments(1);
-  invoke_arguments.Add(&invocation_mirror);
-  const Object& result =
-      Object::Handle(DartEntry::InvokeDynamic(receiver,
-                                              function,
-                                              invoke_arguments,
-                                              kNoArgumentNames));
-  CheckResultError(result);
-  return result.raw();
-}
-
-
-static RawObject* InvokeClosure(const Instance& closure,
-                                const Array& arguments_descriptor,
-                                const Array& arguments) {
-  const Function& function = Function::Handle(Closure::function(closure));
-  ASSERT(!function.IsNull());
-  const Instructions& instrs = Instructions::Handle(EnsureCompiled(function));
-  const Context& context = Context::Handle(Closure::context(closure));
-
-  // The closure object is passed as implicit first argument to closure
-  // functions, since it may be needed to throw a NoSuchMethodError, in case
-  // the wrong number of arguments is passed.
-  // Replace the original receiver in the arguments array by the closure.
-  GrowableArray<const Object*> invoke_arguments(arguments.Length());
-  invoke_arguments.Add(&closure);
-  for (intptr_t i = 1; i < arguments.Length(); i++) {
-    const Object& value = Object::Handle(arguments.At(i));
-    invoke_arguments.Add(&value);
-  }
-  // Now call the invoke stub which will invoke the closure.
-  DartEntry::invokestub entrypoint = reinterpret_cast<DartEntry::invokestub>(
-      StubCode::InvokeDartCodeEntryPoint());
-  ASSERT(context.isolate() == Isolate::Current());
-  const Object& result = Object::Handle(entrypoint(instrs.EntryPoint(),
-                                                   arguments_descriptor,
-                                                   invoke_arguments.data(),
-                                                   context));
+  const Array& args = Array::Handle(Array::New(kNumArguments));
+  args.SetAt(0, receiver);
+  args.SetAt(1, invocation_mirror);
+  const Object& result = Object::Handle(DartEntry::InvokeDynamic(function,
+                                                                 args));
   CheckResultError(result);
   return result.raw();
 }
 
 
 static RawObject* InvokeNonClosure(const Instance& receiver,
                                    const Class& receiver_class,
                                    const Array& arguments_descriptor,
                                    const Array& arguments) {
   // Resolve and invoke the "call" method if it exists.
   const String& call_symbol = String::Handle(Symbols::Call());
 
   Class& current_class = Class::Handle(receiver_class.raw());
   Function& call_function = Function::Handle();
   do {
     call_function = current_class.LookupDynamicFunction(call_symbol);
 
     if (!call_function.IsNull()) {
-      const Instructions& instrs =
-          Instructions::Handle(EnsureCompiled(call_function));
       // The non-closure object is passed as implicit first argument
       // (receiver).  It is already included in the arguments array.
-      GrowableArray<const Object*> invoke_arguments(arguments.Length());
-      for (intptr_t i = 0; i < arguments.Length(); i++) {
-        const Object& value = Object::Handle(arguments.At(i));
-        invoke_arguments.Add(&value);
-      }
 
       // Now call the invoke stub which will invoke the call method.
-      DartEntry::invokestub entrypoint =
-          reinterpret_cast<DartEntry::invokestub>(
-              StubCode::InvokeDartCodeEntryPoint());
-      const Context& context = Context::ZoneHandle(
-          Isolate::Current()->object_store()->empty_context());
       const Object& result =
-          Object::Handle(entrypoint(instrs.EntryPoint(),
-                                    arguments_descriptor,
-                                    invoke_arguments.data(),
-                                    context));
+          Object::Handle(DartEntry::InvokeDynamic(call_function,
+                                                  arguments,
+                                                  arguments_descriptor));
       CheckResultError(result);
       return result.raw();
     }
 
     current_class = current_class.SuperClass();
   } while (!current_class.IsNull());
 
   // There is no 'call' method, so invoke noSuchMethod.
   return InvokeNoSuchMethod(receiver,
                             call_symbol,
@@ skipping 17 matching lines @@
   const int kNumArguments = 1;
   const int kNumNamedArguments = 0;
   const Function& getter = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(receiver_class,
                                                getter_name,
                                                kNumArguments,
                                                kNumNamedArguments));
   if (getter.IsNull()) return false;
 
   // 2. Invoke the getter.
-  GrowableArray<const Object*> invoke_arguments(0);
-  const Array& kNoArgumentNames = Array::Handle();
-  const Object& value =
-      Object::Handle(DartEntry::InvokeDynamic(receiver,
-                                              getter,
-                                              invoke_arguments,
-                                              kNoArgumentNames));
+  const Array& args = Array::Handle(Array::New(kNumArguments));
+  args.SetAt(0, receiver);
+  const Object& value = Object::Handle(DartEntry::InvokeDynamic(getter, args));
 
   // 3. If the getter threw an exception, treat it as no such method.
   if (value.IsUnhandledException()) return false;
 
   // 4. If there was some other error, propagate it.
   if (value.IsError()) {
     Exceptions::PropagateError(Error::Cast(value));
   }
 
   // 5. If the value is a closure, invoke it and return the result.  If it
   // is a non-closure, invoke "call" on it and return the result.
   Instance& instance = Instance::Handle();
   instance ^= value.raw();
   const Class& instance_class = Class::Handle(instance.clazz());
   ASSERT(!instance_class.IsNull());
   // An object is a closure iff. its class has a non-null signature function.
   if (instance_class.signature_function() != Function::null()) {
-    *result = InvokeClosure(instance, arguments_descriptor, arguments);
+    // The closure object is passed as implicit first argument to closure
+    // functions, since it may be needed to throw a NoSuchMethodError, in case
+    // the wrong number of arguments is passed.
+    // Replace the original receiver in the arguments array by the closure.
+    arguments.SetAt(0, instance);
+    *result = DartEntry::InvokeClosure(instance,
+                                       arguments,
+                                       arguments_descriptor);
+    CheckResultError(*result);
   } else {
     *result = InvokeNonClosure(instance,
                                instance_class,
                                arguments_descriptor,
                                arguments);
   }
   return true;
 }
 
 
@@ skipping 621 matching lines @@
     return;
   }
   HeapTrace* heap_trace = Isolate::Current()->heap()->trace();
   heap_trace->TraceStoreIntoObject(RawObject::ToAddr(object),
                                    field_addr,
                                    RawObject::ToAddr(value));
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart