| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
1 parent fd1ffe4 commit e774de1
23 files changed
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -3177,12 +3177,13 @@ class FunctionCallbackInfo { | |||
| 3177 | 3177 | Local<Function> Callee() const); | |
| 3178 | 3178 | V8_INLINE Local<Object> This() const; | |
| 3179 | 3179 | V8_INLINE Local<Object> Holder() const; | |
| 3180 | + V8_INLINE Local<Value> NewTarget() const; | ||
| 3180 | 3181 | V8_INLINE bool IsConstructCall() const; | |
| 3181 | 3182 | V8_INLINE Local<Value> Data() const; | |
| 3182 | 3183 | V8_INLINE Isolate* GetIsolate() const; | |
| 3183 | 3184 | V8_INLINE ReturnValue<T> GetReturnValue() const; | |
| 3184 | 3185 | // This shouldn't be public, but the arm compiler needs it. | |
| 3185 | - static const int kArgsLength = 7; | ||
| 3186 | + static const int kArgsLength = 8; | ||
| 3186 | 3187 | ||
| 3187 | 3188 | protected: | |
| 3188 | 3189 | friend class internal::FunctionCallbackArguments; | |
@@ -3194,6 +3195,7 @@ class FunctionCallbackInfo { | |||
| 3194 | 3195 | static const int kDataIndex = 4; | |
| 3195 | 3196 | static const int kCalleeIndex = 5; | |
| 3196 | 3197 | static const int kContextSaveIndex = 6; | |
| 3198 | + static const int kNewTargetIndex = 7; | ||
| 3197 | 3199 | ||
| 3198 | 3200 | V8_INLINE FunctionCallbackInfo(internal::Object** implicit_args, | |
| 3199 | 3201 | internal::Object** values, | |
@@ -7902,6 +7904,11 @@ Local<Object> FunctionCallbackInfo<T>::Holder() const { | |||
| 7902 | 7904 | &implicit_args_[kHolderIndex])); | |
| 7903 | 7905 | } | |
| 7904 | 7906 | ||
| 7907 | + template<typename T> | ||
| 7908 | + Local<Value> FunctionCallbackInfo<T>::NewTarget() const { | ||
| 7909 | + return Local<Value>( | ||
| 7910 | + reinterpret_cast<Value*>(&implicit_args_[kNewTargetIndex])); | ||
| 7911 | + } | ||
| 7905 | 7912 | ||
| 7906 | 7913 | template<typename T> | |
| 7907 | 7914 | Local<Value> FunctionCallbackInfo<T>::Data() const { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -206,19 +206,22 @@ class FunctionCallbackArguments | |||
| 206 | 206 | static const int kIsolateIndex = T::kIsolateIndex; | |
| 207 | 207 | static const int kCalleeIndex = T::kCalleeIndex; | |
| 208 | 208 | static const int kContextSaveIndex = T::kContextSaveIndex; | |
| 209 | + static const int kNewTargetIndex = T::kNewTargetIndex; | ||
| 209 | 210 | ||
| 210 | 211 | FunctionCallbackArguments(internal::Isolate* isolate, internal::Object* data, | |
| 211 | 212 | internal::HeapObject* callee, | |
| 212 | - internal::Object* holder, internal::Object** argv, | ||
| 213 | - int argc, bool is_construct_call) | ||
| 213 | + internal::Object* holder, | ||
| 214 | + internal::HeapObject* new_target, | ||
| 215 | + internal::Object** argv, int argc) | ||
| 214 | 216 | : Super(isolate), | |
| 215 | 217 | argv_(argv), | |
| 216 | 218 | argc_(argc), | |
| 217 | - is_construct_call_(is_construct_call) { | ||
| 219 | + is_construct_call_(!new_target->IsUndefined()) { | ||
| 218 | 220 | Object** values = begin(); | |
| 219 | 221 | values[T::kDataIndex] = data; | |
| 220 | 222 | values[T::kCalleeIndex] = callee; | |
| 221 | 223 | values[T::kHolderIndex] = holder; | |
| 224 | + values[T::kNewTargetIndex] = new_target; | ||
| 222 | 225 | values[T::kContextSaveIndex] = isolate->heap()->the_hole_value(); | |
| 223 | 226 | values[T::kIsolateIndex] = reinterpret_cast<internal::Object*>(isolate); | |
| 224 | 227 | // Here the hole is set as default value. | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -604,16 +604,9 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, | |||
| 604 | 604 | // r0: number of arguments | |
| 605 | 605 | // r1: constructor function | |
| 606 | 606 | // r3: new target | |
| 607 | - if (is_api_function) { | ||
| 608 | - __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); | ||
| 609 | - Handle<Code> code = | ||
| 610 | - masm->isolate()->builtins()->HandleApiCallConstruct(); | ||
| 611 | - __ Call(code, RelocInfo::CODE_TARGET); | ||
| 612 | - } else { | ||
| 613 | - ParameterCount actual(r0); | ||
| 614 | - __ InvokeFunction(r1, r3, actual, CALL_FUNCTION, | ||
| 615 | - CheckDebugStepCallWrapper()); | ||
| 616 | - } | ||
| 607 | + ParameterCount actual(r0); | ||
| 608 | + __ InvokeFunction(r1, r3, actual, CALL_FUNCTION, | ||
| 609 | + CheckDebugStepCallWrapper()); | ||
| 617 | 610 | ||
| 618 | 611 | // Store offset of return address for deoptimizer. | |
| 619 | 612 | if (create_implicit_receiver && !is_api_function) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -5423,7 +5423,11 @@ void CallApiCallbackStub::Generate(MacroAssembler* masm) { | |||
| 5423 | 5423 | STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2); | |
| 5424 | 5424 | STATIC_ASSERT(FCA::kIsolateIndex == 1); | |
| 5425 | 5425 | STATIC_ASSERT(FCA::kHolderIndex == 0); | |
| 5426 | - STATIC_ASSERT(FCA::kArgsLength == 7); | ||
| 5426 | + STATIC_ASSERT(FCA::kNewTargetIndex == 7); | ||
| 5427 | + STATIC_ASSERT(FCA::kArgsLength == 8); | ||
| 5428 | + | ||
| 5429 | + // new target | ||
| 5430 | + __ PushRoot(Heap::kUndefinedValueRootIndex); | ||
| 5427 | 5431 | ||
| 5428 | 5432 | // context save | |
| 5429 | 5433 | __ push(context); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -605,16 +605,9 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, | |||
| 605 | 605 | // x0: number of arguments | |
| 606 | 606 | // x1: constructor function | |
| 607 | 607 | // x3: new target | |
| 608 | - if (is_api_function) { | ||
| 609 | - __ Ldr(cp, FieldMemOperand(constructor, JSFunction::kContextOffset)); | ||
| 610 | - Handle<Code> code = | ||
| 611 | - masm->isolate()->builtins()->HandleApiCallConstruct(); | ||
| 612 | - __ Call(code, RelocInfo::CODE_TARGET); | ||
| 613 | - } else { | ||
| 614 | - ParameterCount actual(argc); | ||
| 615 | - __ InvokeFunction(constructor, new_target, actual, CALL_FUNCTION, | ||
| 616 | - CheckDebugStepCallWrapper()); | ||
| 617 | - } | ||
| 608 | + ParameterCount actual(argc); | ||
| 609 | + __ InvokeFunction(constructor, new_target, actual, CALL_FUNCTION, | ||
| 610 | + CheckDebugStepCallWrapper()); | ||
| 618 | 611 | ||
| 619 | 612 | // Store offset of return address for deoptimizer. | |
| 620 | 613 | if (create_implicit_receiver && !is_api_function) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -5807,9 +5807,15 @@ void CallApiCallbackStub::Generate(MacroAssembler* masm) { | |||
| 5807 | 5807 | STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2); | |
| 5808 | 5808 | STATIC_ASSERT(FCA::kIsolateIndex == 1); | |
| 5809 | 5809 | STATIC_ASSERT(FCA::kHolderIndex == 0); | |
| 5810 | - STATIC_ASSERT(FCA::kArgsLength == 7); | ||
| 5810 | + STATIC_ASSERT(FCA::kNewTargetIndex == 7); | ||
| 5811 | + STATIC_ASSERT(FCA::kArgsLength == 8); | ||
| 5811 | 5812 | ||
| 5812 | - // FunctionCallbackArguments: context, callee and call data. | ||
| 5813 | + // FunctionCallbackArguments | ||
| 5814 | + | ||
| 5815 | + // new target | ||
| 5816 | + __ PushRoot(Heap::kUndefinedValueRootIndex); | ||
| 5817 | + | ||
| 5818 | + // context, callee and call data. | ||
| 5813 | 5819 | __ Push(context, callee, call_data); | |
| 5814 | 5820 | ||
| 5815 | 5821 | if (!is_lazy()) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -89,17 +89,6 @@ Handle<S> BuiltinArguments<BuiltinExtraArguments::kTarget>::target() { | |||
| 89 | 89 | return Arguments::at<S>(Arguments::length() - 1); | |
| 90 | 90 | } | |
| 91 | 91 | ||
| 92 | - template <> | ||
| 93 | - int BuiltinArguments<BuiltinExtraArguments::kNewTarget>::length() const { | ||
| 94 | - return Arguments::length() - 1; | ||
| 95 | - } | ||
| 96 | - | ||
| 97 | - template <> | ||
| 98 | - Handle<HeapObject> | ||
| 99 | - BuiltinArguments<BuiltinExtraArguments::kNewTarget>::new_target() { | ||
| 100 | - return Arguments::at<HeapObject>(Arguments::length() - 1); | ||
| 101 | - } | ||
| 102 | - | ||
| 103 | 92 | template <> | |
| 104 | 93 | int BuiltinArguments<BuiltinExtraArguments::kTargetAndNewTarget>::length() | |
| 105 | 94 | const { | |
@@ -4247,11 +4236,13 @@ BUILTIN(RestrictedStrictArgumentsPropertiesThrower) { | |||
| 4247 | 4236 | ||
| 4248 | 4237 | namespace { | |
| 4249 | 4238 | ||
| 4250 | - template <bool is_construct> | ||
| 4251 | 4239 | MUST_USE_RESULT MaybeHandle<Object> HandleApiCallHelper( | |
| 4252 | - Isolate* isolate, BuiltinArguments<BuiltinExtraArguments::kTarget> args) { | ||
| 4240 | + Isolate* isolate, | ||
| 4241 | + BuiltinArguments<BuiltinExtraArguments::kTargetAndNewTarget> args) { | ||
| 4253 | 4242 | HandleScope scope(isolate); | |
| 4254 | 4243 | Handle<HeapObject> function = args.target<HeapObject>(); | |
| 4244 | + Handle<HeapObject> new_target = args.new_target(); | ||
| 4245 | + bool is_construct = !new_target->IsUndefined(); | ||
| 4255 | 4246 | Handle<JSReceiver> receiver; | |
| 4256 | 4247 | ||
| 4257 | 4248 | DCHECK(function->IsFunctionTemplateInfo() || | |
@@ -4311,13 +4302,9 @@ MUST_USE_RESULT MaybeHandle<Object> HandleApiCallHelper( | |||
| 4311 | 4302 | LOG(isolate, ApiObjectAccess("call", JSObject::cast(*args.receiver()))); | |
| 4312 | 4303 | DCHECK(raw_holder->IsJSObject()); | |
| 4313 | 4304 | ||
| 4314 | - FunctionCallbackArguments custom(isolate, | ||
| 4315 | - data_obj, | ||
| 4316 | - *function, | ||
| 4317 | - raw_holder, | ||
| 4318 | - &args[0] - 1, | ||
| 4319 | - args.length() - 1, | ||
| 4320 | - is_construct); | ||
| 4305 | + FunctionCallbackArguments custom(isolate, data_obj, *function, raw_holder, | ||
| 4306 | + *new_target, &args[0] - 1, | ||
| 4307 | + args.length() - 1); | ||
| 4321 | 4308 | ||
| 4322 | 4309 | Handle<Object> result = custom.Call(callback); | |
| 4323 | 4310 | if (result.is_null()) result = isolate->factory()->undefined_value(); | |
@@ -4338,19 +4325,11 @@ BUILTIN(HandleApiCall) { | |||
| 4338 | 4325 | HandleScope scope(isolate); | |
| 4339 | 4326 | Handle<Object> result; | |
| 4340 | 4327 | ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, | |
| 4341 | - HandleApiCallHelper<false>(isolate, args)); | ||
| 4328 | + HandleApiCallHelper(isolate, args)); | ||
| 4342 | 4329 | return *result; | |
| 4343 | 4330 | } | |
| 4344 | 4331 | ||
| 4345 | 4332 | ||
| 4346 | - BUILTIN(HandleApiCallConstruct) { | ||
| 4347 | - HandleScope scope(isolate); | ||
| 4348 | - Handle<Object> result; | ||
| 4349 | - ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, | ||
| 4350 | - HandleApiCallHelper<true>(isolate, args)); | ||
| 4351 | - return *result; | ||
| 4352 | - } | ||
| 4353 | - | ||
| 4354 | 4333 | Handle<Code> Builtins::CallFunction(ConvertReceiverMode mode, | |
| 4355 | 4334 | TailCallMode tail_call_mode) { | |
| 4356 | 4335 | switch (tail_call_mode) { | |
@@ -4432,11 +4411,12 @@ Handle<Code> Builtins::InterpreterPushArgsAndCall(TailCallMode tail_call_mode) { | |||
| 4432 | 4411 | namespace { | |
| 4433 | 4412 | ||
| 4434 | 4413 | class RelocatableArguments | |
| 4435 | - : public BuiltinArguments<BuiltinExtraArguments::kTarget>, | ||
| 4414 | + : public BuiltinArguments<BuiltinExtraArguments::kTargetAndNewTarget>, | ||
| 4436 | 4415 | public Relocatable { | |
| 4437 | 4416 | public: | |
| 4438 | 4417 | RelocatableArguments(Isolate* isolate, int length, Object** arguments) | |
| 4439 | - : BuiltinArguments<BuiltinExtraArguments::kTarget>(length, arguments), | ||
| 4418 | + : BuiltinArguments<BuiltinExtraArguments::kTargetAndNewTarget>(length, | ||
| 4419 | + arguments), | ||
| 4440 | 4420 | Relocatable(isolate) {} | |
| 4441 | 4421 | ||
| 4442 | 4422 | virtual inline void IterateInstance(ObjectVisitor* v) { | |
@@ -4468,24 +4448,26 @@ MaybeHandle<Object> Builtins::InvokeApiFunction(Handle<HeapObject> function, | |||
| 4468 | 4448 | } | |
| 4469 | 4449 | } | |
| 4470 | 4450 | } | |
| 4471 | - // Construct BuiltinArguments object: function, arguments reversed, receiver. | ||
| 4451 | + // Construct BuiltinArguments object: | ||
| 4452 | + // new target, function, arguments reversed, receiver. | ||
| 4472 | 4453 | const int kBufferSize = 32; | |
| 4473 | 4454 | Object* small_argv[kBufferSize]; | |
| 4474 | 4455 | Object** argv; | |
| 4475 | - if (argc + 2 <= kBufferSize) { | ||
| 4456 | + if (argc + 3 <= kBufferSize) { | ||
| 4476 | 4457 | argv = small_argv; | |
| 4477 | 4458 | } else { | |
| 4478 | - argv = new Object* [argc + 2]; | ||
| 4459 | + argv = new Object*[argc + 3]; | ||
| 4479 | 4460 | } | |
| 4480 | - argv[argc + 1] = *receiver; | ||
| 4461 | + argv[argc + 2] = *receiver; | ||
| 4481 | 4462 | for (int i = 0; i < argc; ++i) { | |
| 4482 | - argv[argc - i] = *args[i]; | ||
| 4463 | + argv[argc - i + 1] = *args[i]; | ||
| 4483 | 4464 | } | |
| 4484 | - argv[0] = *function; | ||
| 4465 | + argv[1] = *function; | ||
| 4466 | + argv[0] = isolate->heap()->undefined_value(); // new target | ||
| 4485 | 4467 | MaybeHandle<Object> result; | |
| 4486 | 4468 | { | |
| 4487 | - RelocatableArguments arguments(isolate, argc + 2, &argv[argc + 1]); | ||
| 4488 | - result = HandleApiCallHelper<false>(isolate, arguments); | ||
| 4469 | + RelocatableArguments arguments(isolate, argc + 3, &argv[argc] + 2); | ||
| 4470 | + result = HandleApiCallHelper(isolate, arguments); | ||
| 4489 | 4471 | } | |
| 4490 | 4472 | if (argv != small_argv) { | |
| 4491 | 4473 | delete[] argv; | |
@@ -4505,6 +4487,18 @@ MUST_USE_RESULT static Object* HandleApiCallAsFunctionOrConstructor( | |||
| 4505 | 4487 | // Get the object called. | |
| 4506 | 4488 | JSObject* obj = JSObject::cast(*receiver); | |
| 4507 | 4489 | ||
| 4490 | + // Set the new target. | ||
| 4491 | + HeapObject* new_target; | ||
| 4492 | + if (is_construct_call) { | ||
| 4493 | + // TODO(adamk): This should be passed through in args instead of | ||
| 4494 | + // being patched in here. We need to set a non-undefined value | ||
| 4495 | + // for v8::FunctionCallbackInfo::IsConstructCall() to get the | ||
| 4496 | + // right answer. | ||
| 4497 | + new_target = obj; | ||
| 4498 | + } else { | ||
| 4499 | + new_target = isolate->heap()->undefined_value(); | ||
| 4500 | + } | ||
| 4501 | + | ||
| 4508 | 4502 | // Get the invocation callback from the function descriptor that was | |
| 4509 | 4503 | // used to create the called object. | |
| 4510 | 4504 | DCHECK(obj->map()->is_callable()); | |
@@ -4527,13 +4521,9 @@ MUST_USE_RESULT static Object* HandleApiCallAsFunctionOrConstructor( | |||
| 4527 | 4521 | HandleScope scope(isolate); | |
| 4528 | 4522 | LOG(isolate, ApiObjectAccess("call non-function", obj)); | |
| 4529 | 4523 | ||
| 4530 | - FunctionCallbackArguments custom(isolate, | ||
| 4531 | - call_data->data(), | ||
| 4532 | - constructor, | ||
| 4533 | - obj, | ||
| 4534 | - &args[0] - 1, | ||
| 4535 | - args.length() - 1, | ||
| 4536 | - is_construct_call); | ||
| 4524 | + FunctionCallbackArguments custom(isolate, call_data->data(), constructor, | ||
| 4525 | + obj, new_target, &args[0] - 1, | ||
| 4526 | + args.length() - 1); | ||
| 4537 | 4527 | Handle<Object> result_handle = custom.Call(callback); | |
| 4538 | 4528 | if (result_handle.is_null()) { | |
| 4539 | 4529 | result = isolate->heap()->undefined_value(); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -166,8 +166,7 @@ inline bool operator&(BuiltinExtraArguments lhs, BuiltinExtraArguments rhs) { | |||
| 166 | 166 | V(SymbolConstructor, kNone) \ | |
| 167 | 167 | V(SymbolConstructor_ConstructStub, kTarget) \ | |
| 168 | 168 | \ | |
| 169 | - V(HandleApiCall, kTarget) \ | ||
| 170 | - V(HandleApiCallConstruct, kTarget) \ | ||
| 169 | + V(HandleApiCall, kTargetAndNewTarget) \ | ||
| 171 | 170 | V(HandleApiCallAsFunction, kNone) \ | |
| 172 | 171 | V(HandleApiCallAsConstructor, kNone) \ | |
| 173 | 172 | \ | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -186,16 +186,9 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, | |||
| 186 | 186 | __ j(greater_equal, &loop); | |
| 187 | 187 | ||
| 188 | 188 | // Call the function. | |
| 189 | - if (is_api_function) { | ||
| 190 | - __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset)); | ||
| 191 | - Handle<Code> code = | ||
| 192 | - masm->isolate()->builtins()->HandleApiCallConstruct(); | ||
| 193 | - __ call(code, RelocInfo::CODE_TARGET); | ||
| 194 | - } else { | ||
| 195 | - ParameterCount actual(eax); | ||
| 196 | - __ InvokeFunction(edi, edx, actual, CALL_FUNCTION, | ||
| 197 | - CheckDebugStepCallWrapper()); | ||
| 198 | - } | ||
| 189 | + ParameterCount actual(eax); | ||
| 190 | + __ InvokeFunction(edi, edx, actual, CALL_FUNCTION, | ||
| 191 | + CheckDebugStepCallWrapper()); | ||
| 199 | 192 | ||
| 200 | 193 | // Store offset of return address for deoptimizer. | |
| 201 | 194 | if (create_implicit_receiver && !is_api_function) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -5686,9 +5686,14 @@ void CallApiCallbackStub::Generate(MacroAssembler* masm) { | |||
| 5686 | 5686 | STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2); | |
| 5687 | 5687 | STATIC_ASSERT(FCA::kIsolateIndex == 1); | |
| 5688 | 5688 | STATIC_ASSERT(FCA::kHolderIndex == 0); | |
| 5689 | - STATIC_ASSERT(FCA::kArgsLength == 7); | ||
| 5689 | + STATIC_ASSERT(FCA::kNewTargetIndex == 7); | ||
| 5690 | + STATIC_ASSERT(FCA::kArgsLength == 8); | ||
| 5690 | 5691 | ||
| 5691 | 5692 | __ pop(return_address); | |
| 5693 | + | ||
| 5694 | + // new target | ||
| 5695 | + __ PushRoot(Heap::kUndefinedValueRootIndex); | ||
| 5696 | + | ||
| 5692 | 5697 | // context save. | |
| 5693 | 5698 | __ push(context); | |
| 5694 | 5699 | ||
| Back | FazBrowse Home | New Git URL |
0 commit comments