- Add special access for receiver as it is a frequently used operation

runtime/vm/native_arguments.h

 // 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.
 
 #ifndef VM_NATIVE_ARGUMENTS_H_
 #define VM_NATIVE_ARGUMENTS_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/handles_impl.h"
@@ skipping 69 matching lines @@
 // The return value is set as follows:
 //   arguments.SetReturn(result);
 // NOTE: Since we pass 'this' as a pass-by-value argument in the stubs we don't
 // have DISALLOW_COPY_AND_ASSIGN in the class definition and do not make it a
 // subclass of ValueObject.
 class NativeArguments {
  public:
   Isolate* isolate() const { return isolate_; }
   int ArgCount() const { return ArgcBits::decode(argc_tag_); }
 
-  // Returns true if the arguments are those of an instance function call.
-  bool ToInstanceFunction() const {
-    return InstanceFunctionBit::decode(argc_tag_);
-  }
-
-  // Returns true if the arguments are those of a closure function call.
-  bool ToClosureFunction() const {
-    return ClosureFunctionBit::decode(argc_tag_);
-  }
-
   RawObject* ArgAt(int index) const {
     ASSERT((index >= 0) && (index < ArgCount()));
     return (*argv_)[-index];
   }
 
-  int NumHiddenArgs() const {
-    // For static closure functions, the closure at index 0 is hidden.
-    // In the instance closure function case, the receiver is accessed from
-    // the context and the closure at index 0 is hidden, so the apparent
-    // argument count remains unchanged.
-    if (ToClosureFunction() && !ToInstanceFunction()) {
-      return 1;
-    }
-    return 0;
+  int NativeArgCount() const {
+    int function_bits = FunctionBits::decode(argc_tag_);
+    return ArgCount() - NumHiddenArgs(function_bits);
   }
 
-  int NativeArgCount() const {
-    return ArgCount() - NumHiddenArgs();
+  RawObject* NativeReceiver() const {
+    int function_bits = FunctionBits::decode(argc_tag_);
+    if (function_bits == (kClosureFunctionBit | kInstanceFunctionBit)) {
+      // Retrieve the receiver from the context.
+      const Context& context = Context::Handle(isolate_->top_context());
+      return context.At(0);
+    }
+    return ArgAt(NumHiddenArgs(function_bits));
   }
 
   RawObject* NativeArgAt(int index) const {
     ASSERT((index >= 0) && (index < NativeArgCount()));
-    if ((index == 0) && ToClosureFunction() && ToInstanceFunction()) {
-      // Retrieve the receiver from the context.
-      const Context& context = Context::Handle(isolate_->top_context());
-      return context.At(0);
-    } else {
-      const int actual_index = index + NumHiddenArgs();
-      return ArgAt(actual_index);
+    if (index == 0) {
+      return NativeReceiver();

[regis, 2013/09/27 19:34:39]

I would add a comment that calling NativeReceiver() on a static function will
return the first argument without error.
Doing this internally is fine, but it is somewhat surprising to let the user do
it. You probably do not want to add a check, maybe an assert and then inline
NativeReceiver here without the assert? I'm fine either way. 

[siva, 2013/09/27 21:12:37]

Good point.

As discussed offline I have added a private helper method to
get argument 0 and in NativeReceiver I have an assert that it is
not about to invoke a static method.

On 2013/09/27 19:34:39, regis wrote:

     }
+    int function_bits = FunctionBits::decode(argc_tag_);
+    const int actual_index = index + NumHiddenArgs(function_bits);
+    return ArgAt(actual_index);
   }
 
   void SetReturn(const Object& value) const {
     *retval_ = value.raw();
   }
 
   static intptr_t isolate_offset() {
     return OFFSET_OF(NativeArguments, isolate_);
   }
   static intptr_t argc_tag_offset() {
@@ skipping 15 matching lines @@
       // index 0, thereby hidding the closure object at index 0.
       count--;
     }
     return count;
   }
 
   static int ComputeArgcTag(const Function& function) {
     ASSERT(function.is_native());
     ASSERT(!function.IsConstructor());  // Not supported.
     int tag = ArgcBits::encode(function.NumParameters());
-    tag = InstanceFunctionBit::update(!function.is_static(), tag);
-    tag = ClosureFunctionBit::update(function.IsClosureFunction(), tag);
-    return tag;
+    int function_bits = 0;
+    if (!function.is_static()) {
+      function_bits |= kInstanceFunctionBit;
+    }
+    if (function.IsClosureFunction()) {
+      function_bits |= kClosureFunctionBit;
+    }
+    return FunctionBits::update(function_bits, tag);
   }
 
  private:
+  enum {
+    kInstanceFunctionBit = 1,
+    kClosureFunctionBit = 2,
+  };
   enum ArgcTagBits {
     kArgcBit = 0,
     kArgcSize = 24,
-    kInstanceFunctionBit = 24,
-    kClosureFunctionBit = 25,
+    kFunctionBit = 24,
+    kFunctionSize = 2,
   };
   class ArgcBits : public BitField<int, kArgcBit, kArgcSize> {};
-  class InstanceFunctionBit : public BitField<bool, kInstanceFunctionBit, 1> {};
-  class ClosureFunctionBit : public BitField<bool, kClosureFunctionBit, 1> {};
+  class FunctionBits : public BitField<int, kFunctionBit, kFunctionSize> {};
   friend class Api;
   friend class BootstrapNatives;
   friend class Simulator;
 
   // Since this function is passed a RawObject directly, we need to be
   // exceedingly careful when we use it.  If there are any other side
   // effects in the statement that may cause GC, it could lead to
   // bugs.
   void SetReturnUnsafe(RawObject* value) const {
     *retval_ = value;
   }
 
+  // Returns true if the arguments are those of an instance function call.
+  bool ToInstanceFunction() const {
+    return (FunctionBits::decode(argc_tag_) & kInstanceFunctionBit);
+  }
+
+  // Returns true if the arguments are those of a closure function call.
+  bool ToClosureFunction() const {
+    return (FunctionBits::decode(argc_tag_) & kClosureFunctionBit);
+  }
+
+  int NumHiddenArgs(int function_bits) const {
+    // For static closure functions, the closure at index 0 is hidden.
+    // In the instance closure function case, the receiver is accessed from
+    // the context and the closure at index 0 is hidden, so the apparent
+    // argument count remains unchanged.
+    if (function_bits == kClosureFunctionBit) {
+      return 1;
+    }
+    return 0;
+  }
+
   Isolate* isolate_;  // Current isolate pointer.
   int argc_tag_;  // Encodes argument count and invoked native call type.
   RawObject*(*argv_)[];  // Pointer to an array of arguments to runtime call.
   RawObject** retval_;  // Pointer to the return value area.
 };
 
 }  // namespace dart
 
 #endif  // VM_NATIVE_ARGUMENTS_H_