Fix the lowering issue of intrinsics llvm.localaddress on X86

[rnk]

lib/Target/X86/X86ISelLowering.cpp

22363

Why doesn't this already work? The comment exists just to point out that getPtrSizedFrameRegister will sometimes select SP based on exactly the condition you've listed here, unless I'm mistaken.

[LuoYuanke]

lib/Target/X86/X86ISelLowering.cpp

22363

I think when stack is realigned, compiler choose sp as base to access local variable, however bp is still used to recover sp when return from the function.

[rnk]

lgtm

lib/Target/X86/X86ISelLowering.cpp

22363

I see the issue, hasFP is true for this function, but SP is used to address local variables.

lib/Target/X86/X86ISelLowering.cpp

SDValue X86TargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
   case Intrinsic::localaddress: {
     // Returns one of the stack, base, or frame pointer registers, depending on
     // which is used to reference local variables.
     MachineFunction &MF = DAG.getMachineFunction();
     const X86RegisterInfo *RegInfo = Subtarget.getRegisterInfo();
     unsigned Reg;
     if (RegInfo->hasBasePointer(MF))
       Reg = RegInfo->getBaseRegister();
-    else // This function handles the SP or FP case.
+    else { // Handles the SP or FP case.
+      bool CantUseFP = RegInfo->needsStackRealignment(MF);
+      if (CantUseFP)
+        Reg = RegInfo->getPtrSizedStackRegister(MF);
+      else
         Reg = RegInfo->getPtrSizedFrameRegister(MF);
+    }
     return DAG.getCopyFromReg(DAG.getEntryNode(), dl, Reg, VT);
   }
   }
 }
 
 static SDValue getAVX2GatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
                                  SDValue Src, SDValue Mask, SDValue Base,
                                  SDValue Index, SDValue ScaleOp, SDValue Chain,

lib/Target/X86/X86RegisterInfo.h

public:
 
   void eliminateFrameIndex(MachineBasicBlock::iterator MI,
                            int SPAdj, unsigned FIOperandNum,
                            RegScavenger *RS = nullptr) const override;
 
   // Debug information queries.
   unsigned getFrameRegister(const MachineFunction &MF) const override;
   unsigned getPtrSizedFrameRegister(const MachineFunction &MF) const;
+  unsigned getPtrSizedStackRegister(const MachineFunction &MF) const;
   unsigned getStackRegister() const { return StackPtr; }
   unsigned getBaseRegister() const { return BasePtr; }
   /// Returns physical register used as frame pointer.
   /// This will always returns the frame pointer register, contrary to
   /// getFrameRegister() which returns the "base pointer" in situations
   /// involving a stack, frame and base pointer.
   unsigned getFramePtr() const { return FramePtr; }
   // FIXME: Move to FrameInfok
   unsigned getSlotSize() const { return SlotSize; }
 };
 
 } // End llvm namespace
 
 #endif

lib/Target/X86/X86RegisterInfo.cpp

 unsigned
 X86RegisterInfo::getPtrSizedFrameRegister(const MachineFunction &MF) const {
   const X86Subtarget &Subtarget = MF.getSubtarget<X86Subtarget>();
   unsigned FrameReg = getFrameRegister(MF);
   if (Subtarget.isTarget64BitILP32())
     FrameReg = getX86SubSuperRegister(FrameReg, 32);
   return FrameReg;
 }
+
+unsigned
+X86RegisterInfo::getPtrSizedStackRegister(const MachineFunction &MF) const {
+  const X86Subtarget &Subtarget = MF.getSubtarget<X86Subtarget>();
+  unsigned StackReg = getStackRegister();
+  if (Subtarget.isTarget64BitILP32())
+    StackReg = getX86SubSuperRegister(StackReg, 32);
+  return StackReg;
+}

test/CodeGen/X86/seh-localaddress.ll

+; RUN: llc -mtriple x86_64-pc-windows-msvc -o - %s | FileCheck %s
+
+; struct S { int x; };
+; void foo() {
+;   struct S __declspec(align(32)) o;
+;   __try { o.x; }
+;   __finally { o.x; }
+; }
+; void bar() {
+;   struct S o;
+;   __try { o.x; }
+;   __finally { o.x; }
+; }
+
+%struct.S = type { i32 }
+
+define dso_local void @"?foo@@YAXXZ"() #0 {
+entry:
+; CHECK-LABEL: foo
+; CHECK: movq  %rsp, %rdx
+; CHECK-NOT: movq  %rbp, %rdx
+
+  %o = alloca %struct.S, align 32
+  call void (...) @llvm.localescape(%struct.S* %o)
+  %x = getelementptr inbounds %struct.S, %struct.S* %o, i32 0, i32 0
+  %0 = call i8* @llvm.localaddress()
+  call void @"?fin$0@0@foo@@"(i8 0, i8* %0)
+  ret void
+}
+
+; void bar(void)
+; {
+;   int x;
+;   void (*fn)(int);
+;
+;   __try {
+;     x = 1;
+;     fn(x);
+;   } __finally {
+;     x = 2;
+;   }
+; }
+
+define dso_local void @"?bar@@YAXXZ"() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
+entry:
+; CHECK-LABEL: bar
+; CHECK: movq  %rbp, %rdx
+; CHECK-NOT: movq  %rsp, %rdx
+  %x = alloca i32, align 4
+  %fn = alloca void (i32)*, align 8
+  call void (...) @llvm.localescape(i32* %x)
+  store i32 1, i32* %x, align 4
+  %0 = load void (i32)*, void (i32)** %fn, align 8
+  %1 = load i32, i32* %x, align 4
+  invoke void %0(i32 %1)
+  to label %invoke.cont unwind label %ehcleanup
+  invoke.cont:                                      ; preds = %entry
+  %2 = call i8* @llvm.localaddress()
+  call void @"?fin$0@0@bar@@"(i8 0, i8* %2)
+  ret void
+  ehcleanup:                                        ; preds = %entry
+  %3 = cleanuppad within none []
+  %4 = call i8* @llvm.localaddress()
+  call void @"?fin$0@0@bar@@"(i8 1, i8* %4) [ "funclet"(token %3) ]
+  cleanupret from %3 unwind to caller
+}
+
+declare void @"?fin$0@0@foo@@"(i8 %abnormal_termination, i8* %frame_pointer)
+
+declare void @"?fin$0@0@bar@@"(i8 %abnormal_termination, i8* %frame_pointer)
+
+declare i8* @llvm.localrecover(i8*, i8*, i32)
+
+declare i8* @llvm.localaddress()
+
+declare void @llvm.localescape(...)
+
+declare dso_local i32 @__C_specific_handler(...)