1 // Copyright 2013 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 #include "v8.h"
29 #include "arguments.h"
30
31 #include "vm-state-inl.h"
32
33 namespace v8 {
34 namespace internal {
35
36
37 template<typename T>
38 template<typename V>
GetReturnValue(Isolate * isolate)39 v8::Handle<V> CustomArguments<T>::GetReturnValue(Isolate* isolate) {
40 // Check the ReturnValue.
41 Object** handle = &this->begin()[kReturnValueOffset];
42 // Nothing was set, return empty handle as per previous behaviour.
43 if ((*handle)->IsTheHole()) return v8::Handle<V>();
44 return Utils::Convert<Object, V>(Handle<Object>(handle));
45 }
46
47
Call(FunctionCallback f)48 v8::Handle<v8::Value> FunctionCallbackArguments::Call(FunctionCallback f) {
49 Isolate* isolate = this->isolate();
50 VMState<EXTERNAL> state(isolate);
51 ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));
52 FunctionCallbackInfo<v8::Value> info(begin(),
53 argv_,
54 argc_,
55 is_construct_call_);
56 f(info);
57 return GetReturnValue<v8::Value>(isolate);
58 }
59
60
61 #define WRITE_CALL_0(Function, ReturnValue) \
62 v8::Handle<ReturnValue> PropertyCallbackArguments::Call(Function f) { \
63 Isolate* isolate = this->isolate(); \
64 VMState<EXTERNAL> state(isolate); \
65 ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \
66 PropertyCallbackInfo<ReturnValue> info(begin()); \
67 f(info); \
68 return GetReturnValue<ReturnValue>(isolate); \
69 }
70
71
72 #define WRITE_CALL_1(Function, ReturnValue, Arg1) \
73 v8::Handle<ReturnValue> PropertyCallbackArguments::Call(Function f, \
74 Arg1 arg1) { \
75 Isolate* isolate = this->isolate(); \
76 VMState<EXTERNAL> state(isolate); \
77 ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \
78 PropertyCallbackInfo<ReturnValue> info(begin()); \
79 f(arg1, info); \
80 return GetReturnValue<ReturnValue>(isolate); \
81 }
82
83
84 #define WRITE_CALL_2(Function, ReturnValue, Arg1, Arg2) \
85 v8::Handle<ReturnValue> PropertyCallbackArguments::Call(Function f, \
86 Arg1 arg1, \
87 Arg2 arg2) { \
88 Isolate* isolate = this->isolate(); \
89 VMState<EXTERNAL> state(isolate); \
90 ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \
91 PropertyCallbackInfo<ReturnValue> info(begin()); \
92 f(arg1, arg2, info); \
93 return GetReturnValue<ReturnValue>(isolate); \
94 }
95
96
97 #define WRITE_CALL_2_VOID(Function, ReturnValue, Arg1, Arg2) \
98 void PropertyCallbackArguments::Call(Function f, \
99 Arg1 arg1, \
100 Arg2 arg2) { \
101 Isolate* isolate = this->isolate(); \
102 VMState<EXTERNAL> state(isolate); \
103 ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \
104 PropertyCallbackInfo<ReturnValue> info(begin()); \
105 f(arg1, arg2, info); \
106 }
107
108
109 FOR_EACH_CALLBACK_TABLE_MAPPING_0(WRITE_CALL_0)
FOR_EACH_CALLBACK_TABLE_MAPPING_1(WRITE_CALL_1)110 FOR_EACH_CALLBACK_TABLE_MAPPING_1(WRITE_CALL_1)
111 FOR_EACH_CALLBACK_TABLE_MAPPING_2(WRITE_CALL_2)
112 FOR_EACH_CALLBACK_TABLE_MAPPING_2_VOID_RETURN(WRITE_CALL_2_VOID)
113
114 #undef WRITE_CALL_0
115 #undef WRITE_CALL_1
116 #undef WRITE_CALL_2
117 #undef WRITE_CALL_2_VOID
118
119
120 double ClobberDoubleRegisters(double x1, double x2, double x3, double x4) {
121 // TODO(ulan): This clobbers only subset of registers depending on compiler,
122 // Rewrite this in assembly to really clobber all registers.
123 // GCC for ia32 uses the FPU and does not touch XMM registers.
124 return x1 * 1.01 + x2 * 2.02 + x3 * 3.03 + x4 * 4.04;
125 }
126
127
128 } } // namespace v8::internal
129