| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
1 parent 26cc160 commit d221cdc
9 files changed
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -36,7 +36,7 @@ | |||
| 36 | 36 | ||
| 37 | 37 | # Reset this number to 0 on major V8 upgrades. | |
| 38 | 38 | # Increment by one for each non-official patch applied to deps/v8. | |
| 39 | - 'v8_embedder_string': '-node.45', | ||
| 39 | + 'v8_embedder_string': '-node.46', | ||
| 40 | 40 | ||
| 41 | 41 | ##### V8 defaults for Node.js ##### | |
| 42 | 42 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -722,23 +722,22 @@ void TurboAssembler::CallEphemeronKeyBarrier(Register object, Operand offset, | |||
| 722 | 722 | void TurboAssembler::CallRecordWriteStub( | |
| 723 | 723 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 724 | 724 | SaveFPRegsMode fp_mode) { | |
| 725 | - CallRecordWriteStub( | ||
| 726 | - object, offset, remembered_set_action, fp_mode, | ||
| 727 | - isolate()->builtins()->builtin_handle(Builtins::kRecordWrite), | ||
| 728 | - kNullAddress); | ||
| 725 | + CallRecordWriteStub(object, offset, remembered_set_action, fp_mode, | ||
| 726 | + Builtins::kRecordWrite, kNullAddress); | ||
| 729 | 727 | } | |
| 730 | 728 | ||
| 731 | 729 | void TurboAssembler::CallRecordWriteStub( | |
| 732 | 730 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 733 | 731 | SaveFPRegsMode fp_mode, Address wasm_target) { | |
| 734 | 732 | CallRecordWriteStub(object, offset, remembered_set_action, fp_mode, | |
| 735 | - Handle<Code>::null(), wasm_target); | ||
| 733 | + Builtins::kNoBuiltinId, wasm_target); | ||
| 736 | 734 | } | |
| 737 | 735 | ||
| 738 | 736 | void TurboAssembler::CallRecordWriteStub( | |
| 739 | 737 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 740 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, Address wasm_target) { | ||
| 741 | - DCHECK_NE(code_target.is_null(), wasm_target == kNullAddress); | ||
| 738 | + SaveFPRegsMode fp_mode, int builtin_index, Address wasm_target) { | ||
| 739 | + DCHECK_NE(builtin_index == Builtins::kNoBuiltinId, | ||
| 740 | + wasm_target == kNullAddress); | ||
| 742 | 741 | // TODO(albertnetymk): For now we ignore remembered_set_action and fp_mode, | |
| 743 | 742 | // i.e. always emit remember set and save FP registers in RecordWriteStub. If | |
| 744 | 743 | // large performance regression is observed, we should use these values to | |
@@ -762,9 +761,13 @@ void TurboAssembler::CallRecordWriteStub( | |||
| 762 | 761 | ||
| 763 | 762 | Move(remembered_set_parameter, Smi::FromEnum(remembered_set_action)); | |
| 764 | 763 | Move(fp_mode_parameter, Smi::FromEnum(fp_mode)); | |
| 765 | - if (code_target.is_null()) { | ||
| 764 | + if (builtin_index == Builtins::kNoBuiltinId) { | ||
| 766 | 765 | Call(wasm_target, RelocInfo::WASM_STUB_CALL); | |
| 766 | + } else if (options().inline_offheap_trampolines) { | ||
| 767 | + CallBuiltin(builtin_index); | ||
| 767 | 768 | } else { | |
| 769 | + Handle<Code> code_target = | ||
| 770 | + isolate()->builtins()->builtin_handle(Builtins::kRecordWrite); | ||
| 768 | 771 | Call(code_target, RelocInfo::CODE_TARGET); | |
| 769 | 772 | } | |
| 770 | 773 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -588,7 +588,7 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase { | |||
| 588 | 588 | ||
| 589 | 589 | void CallRecordWriteStub(Register object, Operand offset, | |
| 590 | 590 | RememberedSetAction remembered_set_action, | |
| 591 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, | ||
| 591 | + SaveFPRegsMode fp_mode, int builtin_index, | ||
| 592 | 592 | Address wasm_target); | |
| 593 | 593 | }; | |
| 594 | 594 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -2738,23 +2738,22 @@ void TurboAssembler::CallEphemeronKeyBarrier(Register object, Operand offset, | |||
| 2738 | 2738 | void TurboAssembler::CallRecordWriteStub( | |
| 2739 | 2739 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 2740 | 2740 | SaveFPRegsMode fp_mode) { | |
| 2741 | - CallRecordWriteStub( | ||
| 2742 | - object, offset, remembered_set_action, fp_mode, | ||
| 2743 | - isolate()->builtins()->builtin_handle(Builtins::kRecordWrite), | ||
| 2744 | - kNullAddress); | ||
| 2741 | + CallRecordWriteStub(object, offset, remembered_set_action, fp_mode, | ||
| 2742 | + Builtins::kRecordWrite, kNullAddress); | ||
| 2745 | 2743 | } | |
| 2746 | 2744 | ||
| 2747 | 2745 | void TurboAssembler::CallRecordWriteStub( | |
| 2748 | 2746 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 2749 | 2747 | SaveFPRegsMode fp_mode, Address wasm_target) { | |
| 2750 | 2748 | CallRecordWriteStub(object, offset, remembered_set_action, fp_mode, | |
| 2751 | - Handle<Code>::null(), wasm_target); | ||
| 2749 | + Builtins::kNoBuiltinId, wasm_target); | ||
| 2752 | 2750 | } | |
| 2753 | 2751 | ||
| 2754 | 2752 | void TurboAssembler::CallRecordWriteStub( | |
| 2755 | 2753 | Register object, Operand offset, RememberedSetAction remembered_set_action, | |
| 2756 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, Address wasm_target) { | ||
| 2757 | - DCHECK_NE(code_target.is_null(), wasm_target == kNullAddress); | ||
| 2754 | + SaveFPRegsMode fp_mode, int builtin_index, Address wasm_target) { | ||
| 2755 | + DCHECK_NE(builtin_index == Builtins::kNoBuiltinId, | ||
| 2756 | + wasm_target == kNullAddress); | ||
| 2758 | 2757 | // TODO(albertnetymk): For now we ignore remembered_set_action and fp_mode, | |
| 2759 | 2758 | // i.e. always emit remember set and save FP registers in RecordWriteStub. If | |
| 2760 | 2759 | // large performance regression is observed, we should use these values to | |
@@ -2778,9 +2777,13 @@ void TurboAssembler::CallRecordWriteStub( | |||
| 2778 | 2777 | ||
| 2779 | 2778 | Mov(remembered_set_parameter, Smi::FromEnum(remembered_set_action)); | |
| 2780 | 2779 | Mov(fp_mode_parameter, Smi::FromEnum(fp_mode)); | |
| 2781 | - if (code_target.is_null()) { | ||
| 2780 | + if (builtin_index == Builtins::kNoBuiltinId) { | ||
| 2782 | 2781 | Call(wasm_target, RelocInfo::WASM_STUB_CALL); | |
| 2782 | + } else if (options().inline_offheap_trampolines) { | ||
| 2783 | + CallBuiltin(builtin_index); | ||
| 2783 | 2784 | } else { | |
| 2785 | + Handle<Code> code_target = | ||
| 2786 | + isolate()->builtins()->builtin_handle(Builtins::kRecordWrite); | ||
| 2784 | 2787 | Call(code_target, RelocInfo::CODE_TARGET); | |
| 2785 | 2788 | } | |
| 2786 | 2789 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1419,7 +1419,7 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase { | |||
| 1419 | 1419 | ||
| 1420 | 1420 | void CallRecordWriteStub(Register object, Operand offset, | |
| 1421 | 1421 | RememberedSetAction remembered_set_action, | |
| 1422 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, | ||
| 1422 | + SaveFPRegsMode fp_mode, int builtin_index, | ||
| 1423 | 1423 | Address wasm_target); | |
| 1424 | 1424 | }; | |
| 1425 | 1425 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -415,25 +415,24 @@ void TurboAssembler::CallEphemeronKeyBarrier(Register object, Register address, | |||
| 415 | 415 | void TurboAssembler::CallRecordWriteStub( | |
| 416 | 416 | Register object, Register address, | |
| 417 | 417 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) { | |
| 418 | - CallRecordWriteStub( | ||
| 419 | - object, address, remembered_set_action, fp_mode, | ||
| 420 | - isolate()->builtins()->builtin_handle(Builtins::kRecordWrite), | ||
| 421 | - kNullAddress); | ||
| 418 | + CallRecordWriteStub(object, address, remembered_set_action, fp_mode, | ||
| 419 | + Builtins::kRecordWrite, kNullAddress); | ||
| 422 | 420 | } | |
| 423 | 421 | ||
| 424 | 422 | void TurboAssembler::CallRecordWriteStub( | |
| 425 | 423 | Register object, Register address, | |
| 426 | 424 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode, | |
| 427 | 425 | Address wasm_target) { | |
| 428 | 426 | CallRecordWriteStub(object, address, remembered_set_action, fp_mode, | |
| 429 | - Handle<Code>::null(), wasm_target); | ||
| 427 | + Builtins::kNoBuiltinId, wasm_target); | ||
| 430 | 428 | } | |
| 431 | 429 | ||
| 432 | 430 | void TurboAssembler::CallRecordWriteStub( | |
| 433 | 431 | Register object, Register address, | |
| 434 | 432 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode, | |
| 435 | - Handle<Code> code_target, Address wasm_target) { | ||
| 436 | - DCHECK_NE(code_target.is_null(), wasm_target == kNullAddress); | ||
| 433 | + int builtin_index, Address wasm_target) { | ||
| 434 | + DCHECK_NE(builtin_index == Builtins::kNoBuiltinId, | ||
| 435 | + wasm_target == kNullAddress); | ||
| 437 | 436 | // TODO(albertnetymk): For now we ignore remembered_set_action and fp_mode, | |
| 438 | 437 | // i.e. always emit remember set and save FP registers in RecordWriteStub. If | |
| 439 | 438 | // large performance regression is observed, we should use these values to | |
@@ -461,10 +460,14 @@ void TurboAssembler::CallRecordWriteStub( | |||
| 461 | 460 | ||
| 462 | 461 | Move(remembered_set_parameter, Smi::FromEnum(remembered_set_action)); | |
| 463 | 462 | Move(fp_mode_parameter, Smi::FromEnum(fp_mode)); | |
| 464 | - if (code_target.is_null()) { | ||
| 463 | + if (builtin_index == Builtins::kNoBuiltinId) { | ||
| 465 | 464 | // Use {wasm_call} for direct Wasm call within a module. | |
| 466 | 465 | wasm_call(wasm_target, RelocInfo::WASM_STUB_CALL); | |
| 466 | + } else if (options().inline_offheap_trampolines) { | ||
| 467 | + CallBuiltin(builtin_index); | ||
| 467 | 468 | } else { | |
| 469 | + Handle<Code> code_target = | ||
| 470 | + isolate()->builtins()->builtin_handle(Builtins::kRecordWrite); | ||
| 468 | 471 | Call(code_target, RelocInfo::CODE_TARGET); | |
| 469 | 472 | } | |
| 470 | 473 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -567,7 +567,7 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase { | |||
| 567 | 567 | ||
| 568 | 568 | void CallRecordWriteStub(Register object, Register address, | |
| 569 | 569 | RememberedSetAction remembered_set_action, | |
| 570 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, | ||
| 570 | + SaveFPRegsMode fp_mode, int builtin_index, | ||
| 571 | 571 | Address wasm_target); | |
| 572 | 572 | }; | |
| 573 | 573 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -385,25 +385,24 @@ void TurboAssembler::CallEphemeronKeyBarrier(Register object, Register address, | |||
| 385 | 385 | void TurboAssembler::CallRecordWriteStub( | |
| 386 | 386 | Register object, Register address, | |
| 387 | 387 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) { | |
| 388 | - CallRecordWriteStub( | ||
| 389 | - object, address, remembered_set_action, fp_mode, | ||
| 390 | - isolate()->builtins()->builtin_handle(Builtins::kRecordWrite), | ||
| 391 | - kNullAddress); | ||
| 388 | + CallRecordWriteStub(object, address, remembered_set_action, fp_mode, | ||
| 389 | + Builtins::kRecordWrite, kNullAddress); | ||
| 392 | 390 | } | |
| 393 | 391 | ||
| 394 | 392 | void TurboAssembler::CallRecordWriteStub( | |
| 395 | 393 | Register object, Register address, | |
| 396 | 394 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode, | |
| 397 | 395 | Address wasm_target) { | |
| 398 | 396 | CallRecordWriteStub(object, address, remembered_set_action, fp_mode, | |
| 399 | - Handle<Code>::null(), wasm_target); | ||
| 397 | + Builtins::kNoBuiltinId, wasm_target); | ||
| 400 | 398 | } | |
| 401 | 399 | ||
| 402 | 400 | void TurboAssembler::CallRecordWriteStub( | |
| 403 | 401 | Register object, Register address, | |
| 404 | 402 | RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode, | |
| 405 | - Handle<Code> code_target, Address wasm_target) { | ||
| 406 | - DCHECK_NE(code_target.is_null(), wasm_target == kNullAddress); | ||
| 403 | + int builtin_index, Address wasm_target) { | ||
| 404 | + DCHECK_NE(builtin_index == Builtins::kNoBuiltinId, | ||
| 405 | + wasm_target == kNullAddress); | ||
| 407 | 406 | ||
| 408 | 407 | RecordWriteDescriptor descriptor; | |
| 409 | 408 | RegList registers = descriptor.allocatable_registers(); | |
@@ -432,10 +431,14 @@ void TurboAssembler::CallRecordWriteStub( | |||
| 432 | 431 | } else { | |
| 433 | 432 | movq(fp_mode_parameter, remembered_set_parameter); | |
| 434 | 433 | } | |
| 435 | - if (code_target.is_null()) { | ||
| 434 | + if (builtin_index == Builtins::kNoBuiltinId) { | ||
| 436 | 435 | // Use {near_call} for direct Wasm call within a module. | |
| 437 | 436 | near_call(wasm_target, RelocInfo::WASM_STUB_CALL); | |
| 437 | + } else if (options().inline_offheap_trampolines) { | ||
| 438 | + CallBuiltin(builtin_index); | ||
| 438 | 439 | } else { | |
| 440 | + Handle<Code> code_target = | ||
| 441 | + isolate()->builtins()->builtin_handle(Builtins::kRecordWrite); | ||
| 439 | 442 | Call(code_target, RelocInfo::CODE_TARGET); | |
| 440 | 443 | } | |
| 441 | 444 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -693,7 +693,7 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase { | |||
| 693 | 693 | ||
| 694 | 694 | void CallRecordWriteStub(Register object, Register address, | |
| 695 | 695 | RememberedSetAction remembered_set_action, | |
| 696 | - SaveFPRegsMode fp_mode, Handle<Code> code_target, | ||
| 696 | + SaveFPRegsMode fp_mode, int builtin_index, | ||
| 697 | 697 | Address wasm_target); | |
| 698 | 698 | }; | |
| 699 | 699 | ||
| Back | FazBrowse Home | New Git URL |
0 commit comments