Use the return value of vm native methods to set the return value,

vm/native_entry.h

 // 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.
 
 #ifndef VM_NATIVE_ENTRY_H_
 #define VM_NATIVE_ENTRY_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/exceptions.h"
@@ skipping 15 matching lines @@
 
 #define NATIVE_ENTRY_FUNCTION(name) DN_##name
 
 
 // Helper macros for declaring and defining native entries.
 #define REGISTER_NATIVE_ENTRY(name, count)                                     \
   { ""#name, NATIVE_ENTRY_FUNCTION(name), count },
 
 
 #define DEFINE_NATIVE_ENTRY(name, argument_count)                              \
-  static void DN_Helper##name(Isolate* isolate, NativeArguments* arguments);   \
+  static RawObject* DN_Helper##name(Isolate* isolate,                          \
+                                    NativeArguments* arguments);               \
   void NATIVE_ENTRY_FUNCTION(name)(Dart_NativeArguments args) {                \
     CHECK_STACK_ALIGNMENT;                                                     \
     VERIFY_ON_TRANSITION;                                                      \
     NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);     \
     ASSERT(arguments->Count() == argument_count);                              \
     if (FLAG_trace_natives) OS::Print("Calling native: %s\n", ""#name);        \
     {                                                                          \
       Zone zone(arguments->isolate());                                         \
       HANDLESCOPE(arguments->isolate());                                       \
-      DN_Helper##name(arguments->isolate(), arguments);                        \
+      arguments->SetReturnUnsafe(                                              \
+          DN_Helper##name(arguments->isolate(), arguments));                   \

[siva, 2012/08/28 18:21:20]

I was also proposing that we set the return value in the stub code so that there
would be no need for this SetReturnUnsafe function.

These native functions would return Raw<type>* just like all regular VM
functions and the stub code has access to arguments area it would just store the
return value into that return area of arguments.

Only if the VERIFY_ON_TRANSITION FLAG is on we would need to  store the return
value in a handle do the verification and then return.

     }                                                                          \
     VERIFY_ON_TRANSITION;                                                      \
   }                                                                            \
-  static void DN_Helper##name(Isolate* isolate, NativeArguments* arguments)
+  static RawObject* DN_Helper##name(Isolate* isolate,                          \
+                                    NativeArguments* arguments)
 
 
 #define DECLARE_NATIVE_ENTRY(name, argument_count)                             \
   extern void NATIVE_ENTRY_FUNCTION(name)(Dart_NativeArguments arguments);
 
 // Natives should throw an exception if an illegal argument is passed.
 // type name = value.
 #define GET_NATIVE_ARGUMENT(type, name, value)                                 \
   const Instance& __##name##_instance__ =                                      \
       Instance::CheckedHandle(isolate, value);                                 \
@@ skipping 11 matching lines @@
  public:
   // Resolve specified dart native function to the actual native entrypoint.
   static NativeFunction ResolveNative(const Class& cls,
                                       const String& function_name,
                                       int number_of_arguments);
 };
 
 }  // namespace dart
 
 #endif  // VM_NATIVE_ENTRY_H_