[X86] Provide the LSDA pointer with RIP relative addressing if necessary

[mstorsjo]

Summary

This makes sure the LSDA pointer isn't truncated to 32 bit.

Make LowerINTRINSIC_WO_CHAIN a member function instead of a static function, so that it can use the getGlobalWrapperKind method.

This solves the other half of the issues mentioned in PR34720.

[compnerd]

LGTM with the comment adjustments.

lib/Target/X86/X86ISelLowering.cpp

20108

Im not particularly fond of this comment. Adding a comment that getGlobalWrapperKind is not suitable here is fine. But please explain why it is unsuitable. Also, it took me a moment to figure out that this is not actually dependent on the PIC mode of compilation, but rather to ensure that the generated code is PIC. A comment to that effect would be nice.

[mstorsjo]

lib/Target/X86/X86ISelLowering.cpp

20108

So, something like this?

// getGlobalWrapperKind can't be used here since we're in a static function and that requires an instance of X86TargetLowering.
// If we can use RIPRel addressing, prefer that since it doesn't cost anything extra, even if the build isn't required to be PIC.

[compnerd]

lib/Target/X86/X86ISelLowering.cpp

20108

Well, just because this function is static doesnt mean that we couldnt pass it a TLI. It does technically cost a bit in code size. I was thinking something like:

// We use RIP relative addressing to generate PIC code as that is compatible across PIC and non-PIC code.  We would need to wire
// the X86TargetLowering to this function to use getGlobalWrapperKind.

Actually, how difficult would that be anyways?

[mstorsjo]

lib/Target/X86/X86ISelLowering.cpp

20108

Actually wasn't hard at all to make this a non-static function - that's probably cleaner.

[mstorsjo]

Simplified by making the enclosing function a member function to allow it using getGlobalWrapperKind instead.

lib/Target/X86/X86ISelLowering.cpp

 
   case Intrinsic::eh_sjlj_lsda: {
     MachineFunction &MF = DAG.getMachineFunction();
     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
     MVT PtrVT = TLI.getPointerTy(DAG.getDataLayout());
     auto &Context = MF.getMMI().getContext();
     MCSymbol *S = Context.getOrCreateSymbol(Twine("GCC_except_table") +
                                             Twine(MF.getFunctionNumber()));
-    return DAG.getNode(X86ISD::Wrapper, dl, VT, DAG.getMCSymbol(S, PtrVT));
+    // getGlobalWrapperKind isn't usable here.
+    return DAG.getNode(Subtarget.isPICStyleRIPRel() ? X86ISD::WrapperRIP
+                                                    : X86ISD::Wrapper,
+                       dl, VT, DAG.getMCSymbol(S, PtrVT));
   }
 
   case Intrinsic::x86_seh_lsda: {
     // Compute the symbol for the LSDA. We know it'll get emitted later.
     MachineFunction &MF = DAG.getMachineFunction();
     SDValue Op1 = Op.getOperand(1);
     auto *Fn = cast<Function>(cast<GlobalAddressSDNode>(Op1)->getGlobal());
     MCSymbol *LSDASym = MF.getMMI().getContext().getOrCreateLSDASymbol(

test/CodeGen/X86/sjlj-eh.ll

 
 ; CHECK-X64-LABEL: _Z8functionv:
 ;     struct _Unwind_FunctionContext UFC;
 ;
 ;     UFC.__personality = __gxx_personality_sj0
 ; CHECK-X64: leaq __gxx_personality_sj0(%rip), %rax
 ; CHECK-X64: movq %rax, -280(%rbp)
 ;     UFC.__lsda = $LSDA
-; CHECK-X64: movl $[[LSDA:GCC_except_table[0-9]+]], %eax
+; CHECK-X64: leaq [[LSDA:GCC_except_table[0-9]+]](%rip), %rax
 ; CHECK-X64: movq %rax, -272(%rbp)
 ;     UFC.__jbuf[0] = $RBP
 ; CHECK-X64: movq %rbp, -264(%rbp)
 ;     UFC.__jbuf[2] = $RSP
 ; CHECK-X64: movq %rsp, -248(%rbp)
 ;     UFC.__jbuf[1] = $RIP
 ; CHECK-X64: leaq .[[RESUME:LBB[0-9]+_[0-9]+]](%rip), %rax
 ; CHECK-X64: movq %rax, -256(%rbp)