Home | History | Annotate | Download | only in src 
      1 // Copyright 2006-2008 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #ifndef V8_ARGUMENTS_H_
     29 #define V8_ARGUMENTS_H_
     30 
     31 #include "allocation.h"
     32 
     33 namespace v8 {
     34 namespace internal {
     35 
     36 // Arguments provides access to runtime call parameters.
     37 //
     38 // It uses the fact that the instance fields of Arguments
     39 // (length_, arguments_) are "overlayed" with the parameters
     40 // (no. of parameters, and the parameter pointer) passed so
     41 // that inside the C++ function, the parameters passed can
     42 // be accessed conveniently:
     43 //
     44 //   Object* Runtime_function(Arguments args) {
     45 //     ... use args[i] here ...
     46 //   }
     47 
     48 class Arguments BASE_EMBEDDED {
     49  public:
     50   Arguments(int length, Object** arguments)
     51       : length_(length), arguments_(arguments) { }
     52 
     53   Object*& operator[] (int index) {
     54     ASSERT(0 <= index && index < length_);
     55     return arguments_[-index];
     56   }
     57 
     58   template <class S> Handle<S> at(int index) {
     59     Object** value = &((*this)[index]);
     60     // This cast checks that the object we're accessing does indeed have the
     61     // expected type.
     62     S::cast(*value);
     63     return Handle<S>(reinterpret_cast<S**>(value));
     64   }
     65 
     66   int smi_at(int index) {
     67     return Smi::cast((*this)[index])->value();
     68   }
     69 
     70   double number_at(int index) {
     71     return (*this)[index]->Number();
     72   }
     73 
     74   // Get the total number of arguments including the receiver.
     75   int length() const { return length_; }
     76 
     77   Object** arguments() { return arguments_; }
     78 
     79  private:
     80   int length_;
     81   Object** arguments_;
     82 };
     83 
     84 
     85 // Custom arguments replicate a small segment of stack that can be
     86 // accessed through an Arguments object the same way the actual stack
     87 // can.
     88 class CustomArguments : public Relocatable {
     89  public:
     90   inline CustomArguments(Isolate* isolate,
     91                          Object* data,
     92                          Object* self,
     93                          JSObject* holder) : Relocatable(isolate) {
     94     values_[2] = self;
     95     values_[1] = holder;
     96     values_[0] = data;
     97   }
     98 
     99   inline explicit CustomArguments(Isolate* isolate) : Relocatable(isolate) {
    100 #ifdef DEBUG
    101     for (size_t i = 0; i < ARRAY_SIZE(values_); i++) {
    102       values_[i] = reinterpret_cast<Object*>(kZapValue);
    103     }
    104 #endif
    105   }
    106 
    107   void IterateInstance(ObjectVisitor* v);
    108   Object** end() { return values_ + ARRAY_SIZE(values_) - 1; }
    109  private:
    110   Object* values_[3];
    111 };
    112 
    113 
    114 #define DECLARE_RUNTIME_FUNCTION(Type, Name)    \
    115 Type Name(Arguments args, Isolate* isolate)
    116 
    117 
    118 #define RUNTIME_FUNCTION(Type, Name)            \
    119 Type Name(Arguments args, Isolate* isolate)
    120 
    121 
    122 #define RUNTIME_ARGUMENTS(isolate, args) args, isolate
    123 
    124 
    125 } }  // namespace v8::internal
    126 
    127 #endif  // V8_ARGUMENTS_H_
    128