Source/JavaScriptCore/ChangeLog

 12012-10-25 Yuqiang Xian <yuqiang.xian@intel.com>
 2
 3 x32 backend of the JIT compilers
 4 https://bugs.webkit.org/show_bug.cgi?id=100450
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 This patch adds necessary changes to support x32 in the JIT compilers.
 9
 10 * assembler/AbstractMacroAssembler.h:
 11 (TrustedImm32):
 12 (Imm32):
 13 (TrustedImm64):
 14 (Imm64):
 15 * assembler/MacroAssembler.h:
 16 (MacroAssembler):
 17 (JSC::MacroAssembler::comparePtr):
 18 (JSC::MacroAssembler::branchPtr):
 19 (JSC::MacroAssembler::move):
 20 (JSC::MacroAssembler::storePtr):
 21 (JSC::MacroAssembler::rotateRightPtr):
 22 (JSC::MacroAssembler::shouldBlind):
 23 * assembler/MacroAssemblerX86Common.h:
 24 (JSC::MacroAssemblerX86Common::push):
 25 (JSC::MacroAssemblerX86Common::move):
 26 (JSC::MacroAssemblerX86Common::jump):
 27 (JSC::MacroAssemblerX86Common::call):
 28 * assembler/MacroAssemblerX86_64.h:
 29 (MacroAssemblerX86_64):
 30 (JSC::MacroAssemblerX86_64::rotateRight32):
 31 (JSC::MacroAssemblerX86_64::store32):
 32 (JSC::MacroAssemblerX86_64::branch32):
 33 (JSC::MacroAssemblerX86_64::convertibleLoadPtr):
 34 (JSC::MacroAssemblerX86_64::moveWithPatch):
 35 (JSC::MacroAssemblerX86_64::branchPtrWithPatch):
 36 (JSC::MacroAssemblerX86_64::storePtrWithPatch):
 37 * assembler/X86Assembler.h:
 38 (JSC::X86Assembler::rorl_i8r):
 39 (X86Assembler):
 40 (JSC::X86Assembler::testl_rm):
 41 (JSC::X86Assembler::movl_mEAX):
 42 (JSC::X86Assembler::movl_EAXm):
 43 (JSC::X86Assembler::movq_mEAX):
 44 (JSC::X86Assembler::movq_EAXm):
 45 * dfg/DFGNode.h:
 46 (OpInfo):
 47 * dfg/DFGSpeculativeJIT64.cpp:
 48 (JSC::DFG::SpeculativeJIT::emitCall):
 49 * jit/ExecutableAllocator.h:
 50 (JSC):
 51 * jit/JITCall.cpp:
 52 (JSC::JIT::compileOpCall):
 53 (JSC::JIT::compileOpCallSlowCase):
 54 * jit/JITStubs.cpp:
 55 * jit/JITStubs.h:
 56 (JITStackFrame):
 57 (JSC::JITStackFrame::returnAddressSlot):
 58 * runtime/MatchResult.h:
 59 (MatchResult):
 60
1612012-10-25 Michael Saboff <msaboff@apple.com>
262
363 SymbolTableIndexHashTraits::needsDestruction should be set to true
132566

Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@public:
229229 {
230230 }
231231
232 #if !CPU(X86_64)
 232#if !CPU(X86_64) || CPU(X32)
233233 explicit TrustedImm32(TrustedImmPtr ptr)
234234 : m_value(ptr.asIntptr())
235235 {

@@public:
251251 : TrustedImm32(value)
252252 {
253253 }
254 #if !CPU(X86_64)
 254#if !CPU(X86_64) || CPU(X32)
255255 explicit Imm32(TrustedImmPtr ptr)
256256 : TrustedImm32(ptr)
257257 {

@@public:
275275 {
276276 }
277277
278 #if CPU(X86_64)
 278#if CPU(X86_64) && !CPU(X32)
279279 explicit TrustedImm64(TrustedImmPtr ptr)
280280 : m_value(ptr.asIntptr())
281281 {

@@public:
296296 : TrustedImm64(value)
297297 {
298298 }
299 #if CPU(X86_64)
 299#if CPU(X86_64) && !CPU(X32)
300300 explicit Imm64(TrustedImmPtr ptr)
301301 : TrustedImm64(ptr)
302302 {
132556

Source/JavaScriptCore/assembler/MacroAssembler.h

@@public:
311311 // Ptr methods
312312 // On 32-bit platforms (i.e. x86), these methods directly map onto their 32-bit equivalents.
313313 // FIXME: should this use a test for 32-bitness instead of this specific exception?
314 #if !CPU(X86_64)
 314#if !CPU(X86_64) || CPU(X32)
315315 void addPtr(Address src, RegisterID dest)
316316 {
317317 add32(src, dest);

@@public:
433433 return load32WithCompactAddressOffsetPatch(address, dest);
434434 }
435435
436  void move(ImmPtr imm, RegisterID dest)
 436 void comparePtr(RelationalCondition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
437437 {
438  move(Imm32(imm.asTrustedImmPtr()), dest);
 438 compare32(cond, left, right, dest);
439439 }
440440
441  void comparePtr(RelationalCondition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
 441 void comparePtr(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID dest)
442442 {
443443 compare32(cond, left, right, dest);
444444 }
445 
 445
446446 void storePtr(RegisterID src, ImplicitAddress address)
447447 {
448448 store32(src, address);

@@public:
463463 store32(TrustedImm32(imm), address);
464464 }
465465
466  void storePtr(ImmPtr imm, Address address)
467  {
468  store32(Imm32(imm.asTrustedImmPtr()), address);
469  }
470 
471466 void storePtr(TrustedImmPtr imm, void* address)
472467 {
473468 store32(TrustedImm32(imm), address);

@@public:
487482 {
488483 return branch32(cond, left, TrustedImm32(right));
489484 }
490 
491  Jump branchPtr(RelationalCondition cond, RegisterID left, ImmPtr right)
492  {
493  return branch32(cond, left, Imm32(right.asTrustedImmPtr()));
494  }
495485
496486 Jump branchPtr(RelationalCondition cond, RegisterID left, Address right)
497487 {

@@public:
557547 {
558548 return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
559549 }
 550
 551#if !CPU(X86_64)
 552 void move(ImmPtr imm, RegisterID dest)
 553 {
 554 move(Imm32(imm.asTrustedImmPtr()), dest);
 555 }
 556
 557 void storePtr(ImmPtr imm, Address address)
 558 {
 559 store32(Imm32(imm.asTrustedImmPtr()), address);
 560 }
 561
 562 Jump branchPtr(RelationalCondition cond, RegisterID left, ImmPtr right)
 563 {
 564 return branch32(cond, left, Imm32(right.asTrustedImmPtr()));
 565 }
 566#else
 567 void rotateRightPtr(TrustedImm32 imm, RegisterID srcDst)
 568 {
 569 rotateRight32(imm, srcDst);
 570 }
 571#endif
560572#else
561573 void addPtr(RegisterID src, RegisterID dest)
562574 {

@@public:
832844 {
833845 return branchSub64(cond, src1, src2, dest);
834846 }
 847#endif // !CPU(X86_64) || CPU(X32)
 848
 849#if CPU(X86_64)
835850
836851#if ENABLE(JIT_CONSTANT_BLINDING)
837852 using MacroAssemblerBase::and64;

@@public:
877892 case 0xffff:
878893 case 0xffffff:
879894 case 0xffffffffL:
 895#if !CPU(X32)
880896 case 0xffffffffffL:
881897 case 0xffffffffffffL:
882898 case 0xffffffffffffffL:
883899 case 0xffffffffffffffffL:
 900#endif
884901 return false;
885902 default: {
886903 if (value <= 0xff)

@@public:
10431060
10441061#endif
10451062
1046 #endif // !CPU(X86_64)
 1063#endif // CPU(X86_64)
10471064
10481065#if ENABLE(JIT_CONSTANT_BLINDING)
10491066 bool shouldBlind(Imm32 imm)
132556

Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

@@public:
959959
960960 void push(Address address)
961961 {
 962#if CPU(X32)
 963 // On X86_64 (also in X32 mode), the default operand size for call/jump/push/pop
 964 // is 64-bit. This means if we use a memory operand for those instructions,
 965 // we'll be loading a 64-bit data from the memory address. It's not our intention.
 966 load32(address, scratchRegister);
 967 m_assembler.push_r(scratchRegister);
 968#else
962969 m_assembler.push_m(address.offset, address.base);
 970#endif
963971 }
964972
965973 void push(TrustedImm32 imm)

@@public:
9931001
9941002 void move(TrustedImmPtr imm, RegisterID dest)
9951003 {
 1004#if CPU(X32)
 1005 m_assembler.movl_i32r(imm.asIntptr(), dest);
 1006#else
9961007 m_assembler.movq_i64r(imm.asIntptr(), dest);
 1008#endif
9971009 }
9981010
9991011 void move(TrustedImm64 imm, RegisterID dest)

@@public:
11921204 // Address is a memory location containing the address to jump to
11931205 void jump(Address address)
11941206 {
 1207#if CPU(X32)
 1208 // On X86_64 (also in X32 mode), the default operand size for call/jump/push/pop
 1209 // is 64-bit. This means if we use a memory operand for those instructions,
 1210 // we'll be loading a 64-bit data from the memory address. It's not our intention.
 1211 load32(address, scratchRegister);
 1212 m_assembler.jmp_r(scratchRegister);
 1213#else
11951214 m_assembler.jmp_m(address.offset, address.base);
 1215#endif
11961216 }
11971217
11981218

@@public:
13591379
13601380 void call(Address address)
13611381 {
 1382#if CPU(X32)
 1383 // On X86_64 (also in X32 mode), the default operand size for call/jump/push/pop
 1384 // is 64-bit. This means if we use a memory operand for those instructions,
 1385 // we'll be loading a 64-bit data from the memory address. It's not our intention.
 1386 load32(address, scratchRegister);
 1387 m_assembler.call(scratchRegister);
 1388#else
13621389 m_assembler.call_m(address.offset, address.base);
 1390#endif
13631391 }
13641392
13651393 void ret()
132556

Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h

@@namespace JSC {
3636
3737class MacroAssemblerX86_64 : public MacroAssemblerX86Common {
3838public:
 39#if CPU(X32)
 40 static const Scale ScalePtr = TimesFour;
 41#else
3942 static const Scale ScalePtr = TimesEight;
 43#endif
4044
4145 using MacroAssemblerX86Common::add32;
4246 using MacroAssemblerX86Common::and32;
 47 using MacroAssemblerX86Common::branch32;
4348 using MacroAssemblerX86Common::branchAdd32;
4449 using MacroAssemblerX86Common::or32;
4550 using MacroAssemblerX86Common::sub32;

@@public:
110115 m_assembler.cvtsi2sd_rr(scratchRegister, dest);
111116 }
112117
 118 void rotateRight32(TrustedImm32 imm, RegisterID srcDst)
 119 {
 120 m_assembler.rorl_i8r(imm.m_value, srcDst);
 121 }
 122
113123 void store32(TrustedImm32 imm, void* address)
114124 {
115125 move(TrustedImmPtr(address), scratchRegister);
116126 store32(imm, scratchRegister);
117127 }
118128
 129 void store32(RegisterID src, void* address)
 130 {
 131 if (src == X86Registers::eax)
 132 m_assembler.movl_EAXm(address);
 133 else {
 134 move(TrustedImmPtr(address), scratchRegister);
 135 store32(src, scratchRegister);
 136 }
 137 }
 138
 139 Jump branch32(RelationalCondition cond, AbsoluteAddress left, RegisterID right)
 140 {
 141 move(TrustedImmPtr(left.m_ptr), scratchRegister);
 142 return branch32(cond, Address(scratchRegister), right);
 143 }
 144
 145 Jump branch32(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
 146 {
 147 move(TrustedImmPtr(left.m_ptr), scratchRegister);
 148 return branch32(cond, left, right);
 149 }
 150
119151 void store8(TrustedImm32 imm, void* address)
120152 {
121153 move(TrustedImmPtr(address), scratchRegister);

@@public:
528560 ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
529561 {
530562 ConvertibleLoadLabel result = ConvertibleLoadLabel(this);
 563#if CPU(X32)
 564 m_assembler.movl_mr(address.offset, address.base, dest);
 565#else
531566 m_assembler.movq_mr(address.offset, address.base, dest);
 567#endif
532568 return result;
533569 }
534570
535571 DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
536572 {
537573 padBeforePatch();
 574#if CPU(X32)
 575 m_assembler.movl_i32r(initialValue.asIntptr(), dest);
 576#else
538577 m_assembler.movq_i64r(initialValue.asIntptr(), dest);
 578#endif
539579 return DataLabelPtr(this);
540580 }
541581
542582 Jump branchPtrWithPatch(RelationalCondition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
543583 {
544584 dataLabel = moveWithPatch(initialRightValue, scratchRegister);
 585#if CPU(X32)
 586 return branch32(cond, left, scratchRegister);
 587#else
545588 return branch64(cond, left, scratchRegister);
 589#endif
546590 }
547591
548592 Jump branchPtrWithPatch(RelationalCondition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
549593 {
550594 dataLabel = moveWithPatch(initialRightValue, scratchRegister);
 595#if CPU(X32)
 596 return branch32(cond, left, scratchRegister);
 597#else
551598 return branch64(cond, left, scratchRegister);
 599#endif
552600 }
553601
554602 DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
555603 {
556604 DataLabelPtr label = moveWithPatch(initialValue, scratchRegister);
 605#if CPU(X32)
 606 store32(scratchRegister, address);
 607#else
557608 store64(scratchRegister, address);
 609#endif
558610 return label;
559611 }
560612
132556

Source/JavaScriptCore/assembler/X86Assembler.h

@@public:
683683 }
684684 }
685685
 686 void rorl_i8r(int imm, RegisterID dst)
 687 {
 688 if (imm == 1)
 689 m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_ROR, dst);
 690 else {
 691 m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_ROR, dst);
 692 m_formatter.immediate8(imm);
 693 }
 694 }
 695
686696#endif
687697
688698 void sarl_i8r(int imm, RegisterID dst)

@@public:
10071017 m_formatter.oneByteOp64(OP_TEST_EvGv, src, base, offset);
10081018 }
10091019
 1020 void testl_rm(RegisterID src, int offset, RegisterID base)
 1021 {
 1022 m_formatter.oneByteOp(OP_TEST_EvGv, src, base, offset);
 1023 }
 1024
10101025 void testq_i32r(int imm, RegisterID dst)
10111026 {
10121027 m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, dst);

@@public:
11111126 {
11121127 m_formatter.oneByteOp(OP_MOV_EAXOv);
11131128#if CPU(X86_64)
1114  m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
 1129 // Make sure the addr is zero extended (if it's a 32-bit addr in X32 mode).
 1130 m_formatter.immediate64(reinterpret_cast<uintptr_t>(addr));
11151131#else
11161132 m_formatter.immediate32(reinterpret_cast<int>(addr));
11171133#endif

@@public:
11931209 {
11941210 m_formatter.oneByteOp(OP_MOV_OvEAX);
11951211#if CPU(X86_64)
1196  m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
 1212 // Make sure the addr is zero extended (if it's a 32-bit addr in X32 mode).
 1213 m_formatter.immediate64(reinterpret_cast<uintptr_t>(addr));
11971214#else
11981215 m_formatter.immediate32(reinterpret_cast<int>(addr));
11991216#endif

@@public:
12231240 void movq_mEAX(const void* addr)
12241241 {
12251242 m_formatter.oneByteOp64(OP_MOV_EAXOv);
1226  m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
 1243 // Make sure the addr is zero extended (if it's a 32-bit addr in X32 mode).
 1244 m_formatter.immediate64(reinterpret_cast<uintptr_t>(addr));
12271245 }
12281246
12291247 void movq_EAXm(const void* addr)
12301248 {
12311249 m_formatter.oneByteOp64(OP_MOV_OvEAX);
1232  m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
 1250 // Make sure the addr is zero extended (if it's a 32-bit addr in X32 mode).
 1251 m_formatter.immediate64(reinterpret_cast<uintptr_t>(addr));
12331252 }
12341253
12351254 void movq_mr(int offset, RegisterID base, RegisterID dst)
132556

Source/JavaScriptCore/dfg/DFGNode.h

@@struct NewArrayBufferData {
7070struct OpInfo {
7171 explicit OpInfo(int32_t value) : m_value(static_cast<uintptr_t>(value)) { }
7272 explicit OpInfo(uint32_t value) : m_value(static_cast<uintptr_t>(value)) { }
73 #if OS(DARWIN) || USE(JSVALUE64)
 73#if OS(DARWIN) || (CPU(X86_64) && !CPU(X32))
7474 explicit OpInfo(size_t value) : m_value(static_cast<uintptr_t>(value)) { }
7575#endif
7676 explicit OpInfo(void* value) : m_value(reinterpret_cast<uintptr_t>(value)) { }
132556

Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

@@void SpeculativeJIT::emitCall(Node& node
10331033 m_jit.addPtr(TrustedImm32(m_jit.codeBlock()->m_numCalleeRegisters * sizeof(Register)), GPRInfo::callFrameRegister);
10341034
10351035 slowPath.append(m_jit.branchPtrWithPatch(MacroAssembler::NotEqual, calleeGPR, targetToCheck, MacroAssembler::TrustedImmPtr(0)));
 1036#if CPU(X32)
 1037 slowPath.append(m_jit.branchTest64(MacroAssembler::NonZero, calleeGPR, GPRInfo::tagMaskRegister));
 1038#endif
10361039
10371040 m_jit.loadPtr(MacroAssembler::Address(calleeGPR, OBJECT_OFFSETOF(JSFunction, m_scope)), resultGPR);
10381041 m_jit.store64(resultGPR, MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain));
132556

Source/JavaScriptCore/jit/ExecutableAllocator.h

@@class DemandExecutableAllocator;
106106#if ENABLE(EXECUTABLE_ALLOCATOR_FIXED)
107107#if CPU(ARM)
108108static const size_t fixedExecutableMemoryPoolSize = 16 * 1024 * 1024;
109 #elif CPU(X86_64)
 109#elif CPU(X86_64) && !CPU(X32)
110110static const size_t fixedExecutableMemoryPoolSize = 1024 * 1024 * 1024;
111111#else
112112static const size_t fixedExecutableMemoryPoolSize = 32 * 1024 * 1024;
132556

Source/JavaScriptCore/jit/JITCall.cpp

@@void JIT::compileOpCall(OpcodeID opcodeI
194194 END_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
195195 addSlowCase(slowCase);
196196
 197#if CPU(X32)
 198 // The above branchPtr doesn't catch the case where the callee isn't a cell.
 199 addSlowCase(branchTest64(NonZero, regT0, tagMaskRegister));
 200#endif
 201
197202 ASSERT(m_callStructureStubCompilationInfo.size() == callLinkInfoIndex);
198203 m_callStructureStubCompilationInfo.append(StructureStubCompilationInfo());
199204 m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;

@@void JIT::compileOpCallSlowCase(OpcodeID
215220 }
216221
217222 linkSlowCase(iter);
 223#if CPU(X32)
 224 linkSlowCase(iter);
 225#endif
218226
219227 m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(opcodeID == op_construct ? m_globalData->jitStubs->ctiVirtualConstructLink() : m_globalData->jitStubs->ctiVirtualCallLink());
220228
132556

Source/JavaScriptCore/jit/JITStubs.cpp

@@SYMBOL_STRING(ctiOpThrowNotCaught) ":" "
366366
367367#if COMPILER(GCC) && CPU(X86_64)
368368
 369#if !CPU(X32)
369370// These ASSERTs remind you that, if you change the layout of JITStackFrame, you
370371// need to change the assembly trampolines below to match.
371372COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);

@@SYMBOL_STRING(ctiOpThrowNotCaught) ":" "
432433 "popq %rbp" "\n"
433434 "ret" "\n"
434435);
 436#else
 437COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x48, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
 438COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x40, JITStackFrame_code_offset_matches_ctiTrampoline);
 439COMPILE_ASSERT(offsetof(struct JITStackFrame, savedRBX) == 0x58, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
 440
 441asm (
 442".text\n"
 443".globl " SYMBOL_STRING(ctiTrampoline) "\n"
 444HIDE_SYMBOL(ctiTrampoline) "\n"
 445SYMBOL_STRING(ctiTrampoline) ":" "\n"
 446 "pushq %rbp" "\n"
 447 "movl %esp, %ebp" "\n"
 448 "pushq %r12" "\n"
 449 "pushq %r13" "\n"
 450 "pushq %r14" "\n"
 451 "pushq %r15" "\n"
 452 "pushq %rbx" "\n"
 453 // Form the JIT stubs area
 454 "subl $0x58, %esp" "\n"
 455 "movl %r9d, 0x54(%esp)" "\n"
 456 "movl %r8d, 0x50(%esp)" "\n"
 457 "movl %ecx, 0x4c(%esp)" "\n"
 458 "movl %edx, 0x48(%esp)" "\n"
 459 "movl %esi, 0x44(%esp)" "\n"
 460 "movl %edi, 0x40(%esp)" "\n"
 461 "movq $512, %r12" "\n"
 462 "movq $0xFFFF000000000000, %r14" "\n"
 463 "movq $0xFFFF000000000002, %r15" "\n"
 464 "movl %edx, %r13d" "\n"
 465 "call *%rdi" "\n"
 466 "addl $0x58, %esp" "\n"
 467 "popq %rbx" "\n"
 468 "popq %r15" "\n"
 469 "popq %r14" "\n"
 470 "popq %r13" "\n"
 471 "popq %r12" "\n"
 472 "popq %rbp" "\n"
 473 "ret" "\n"
 474".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
 475HIDE_SYMBOL(ctiTrampolineEnd) "\n"
 476SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
 477);
 478
 479asm (
 480".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
 481HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
 482SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
 483 "movl %esp, %edi" "\n"
 484 "call " LOCAL_REFERENCE(cti_vm_throw) "\n"
 485 "int3" "\n"
 486);
 487
 488asm (
 489".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
 490HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
 491SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
 492 "addl $0x58, %esp" "\n"
 493 "popq %rbx" "\n"
 494 "popq %r15" "\n"
 495 "popq %r14" "\n"
 496 "popq %r13" "\n"
 497 "popq %r12" "\n"
 498 "popq %rbp" "\n"
 499 "ret" "\n"
 500);
 501#endif
435502
436503#else
437504 #error "JIT not supported on this platform."
132556

Source/JavaScriptCore/jit/JITStubs.h

@@namespace JSC {
9999
100100#if CPU(X86_64)
101101 struct JITStackFrame {
102  void* reserved; // Unused
 102 int64_t reserved; // Unused
103103 JITStubArg args[6];
104  void* padding[2]; // Maintain 32-byte stack alignment (possibly overkill).
 104 void* padding[2]; // Maintain 16-byte stack alignment.
105105
106106 void* code;
107107 JSStack* stack;

@@namespace JSC {
110110 void* unused2;
111111 JSGlobalData* globalData;
112112
113  void* savedRBX;
114  void* savedR15;
115  void* savedR14;
116  void* savedR13;
117  void* savedR12;
118  void* savedRBP;
119  void* savedRIP;
 113 int64_t savedRBX;
 114 int64_t savedR15;
 115 int64_t savedR14;
 116 int64_t savedR13;
 117 int64_t savedR12;
 118 int64_t savedRBP;
 119 int64_t savedRIP;
120120
121121 // When JIT code makes a call, it pushes its return address just below the rest of the stack.
 122#if CPU(X32)
 123 // On X32 the return address occupies a 8-byte slot (with the higher 4 bytes zero'ed)
 124 ReturnAddressPtr* returnAddressSlot() { return reinterpret_cast<ReturnAddressPtr*>(this) - 2; }
 125#else
122126 ReturnAddressPtr* returnAddressSlot() { return reinterpret_cast<ReturnAddressPtr*>(this) - 1; }
 127#endif
123128 };
124129#elif CPU(X86)
125130#if COMPILER(MSVC) || (OS(WINDOWS) && COMPILER(GCC))
132556

Source/JavaScriptCore/runtime/MatchResult.h

@@struct MatchResult {
6464 return start == end;
6565 }
6666
 67#if CPU(X32)
 68 // On X32, size_t is 32-bit while the register size is 64-bit.
 69 // Make each member to be 64-bit so that they will be placed in two registers
 70 // when a function (a Yarr JIT function) returns a MatchResult structure,
 71 // a behavior consistent with any other architecture.
 72 uint64_t start;
 73 uint64_t end;
 74#else
6775 size_t start;
6876 size_t end;
 77#endif
6978};
7079
7180#endif
132556

Source/WTF/ChangeLog

 12012-10-25 Yuqiang Xian <yuqiang.xian@intel.com>
 2
 3 x32 backend of the JIT compilers
 4 https://bugs.webkit.org/show_bug.cgi?id=100450
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 This patch adds necessary changes to support x32 in the JIT compilers.
 9
 10 * wtf/Platform.h: Add the definition of CPU(X32)
 11
1122012-10-25 Michael Saboff <msaboff@apple.com>
213
314 REGRESSION (r131836): failures in list styles tests on EFL, GTK
132566

Source/WTF/wtf/Platform.h

160160#if defined(__x86_64__) \
161161 || defined(_M_X64)
162162#define WTF_CPU_X86_64 1
 163#if defined(__ILP32__)
 164#define WTF_CPU_X32 1
 165#endif
163166#endif
164167
165168/* CPU(ARM) - ARM, any version*/
132556