Win64: Don't emit unwind info for "leaf" functions (PR30337)

[hans]

Summary

According to MSDN (see the PR), functions which don't touch any callee-saved registers (including %rsp) don't need any unwind info.

This patch takes a stab at not emitting unwind info for such functions, to save binary space. This is an area I don't now much about, so all input is welcome.

I originally wanted to put 'HasWinCFI' on X86MachineFunctionInfo, but then we wouldn't be able to check it from WinException, so it ended up on MachineFunction. I'm not sure what a better place would be. MachineFrameInfo maybe?

[hans]

I tried this out on Chrome, and it saves 376 KB (0.6%) on chrome_child.dll, so it seems worth doing. I need your expert review though :-)

[majnemer]

include/llvm/CodeGen/MachineFunction.h

378–379 ↗

(On Diff #71891)

I'd sleep a little easier at night if HasWinCFI was an optional bool. This way we can make sure that nobody is trying to access it before we calculate the state the function is in.

test/CodeGen/X86/coalescer-win64.ll

14 ↗

(On Diff #71891)

Maybe we should have a CHECK-NOT here?

16 ↗

(On Diff #71891)

ditto.

test/CodeGen/X86/pr24374.ll

33 ↗

(On Diff #71891)

Maybe we can keep the CHECK-LABEL? There should be a UD2 here too, right?

test/CodeGen/X86/win64_eh.ll

5–14 ↗

(On Diff #71891)

Why did this test get removed?

[rnk]

+1 to David's comments, otherwise looks good

include/llvm/CodeGen/MachineFunction.h

378–379 ↗

(On Diff #71891)

This is a good idea, we should do this more often.

[hans]

include/llvm/CodeGen/MachineFunction.h

378–379 ↗

(On Diff #71891)

That's a great idea. Done.

test/CodeGen/X86/win64_eh.ll

5–14 ↗

(On Diff #71891)

I wasn't sure what to do with it now that we don't emit anything special for it. I'll put it back and check it's there and has the ret.

[hans]

Addressing review comments.

[majnemer]

test/CodeGen/X86/pr24374.ll

34–35 ↗

(On Diff #72112)

Should we make these CHECK-NOT ? Should we do the same for the other tests?

[hans]

test/CodeGen/X86/pr24374.ll

34–35 ↗

(On Diff #72112)

test/CodeGen/X86/win64_eh_leaf.ll checks that we don't emit these directives for leaf functions, and I'm not sure there's any benefit to add check-nots in other test just to check for the same thing.

I'm happy to add it here though if you think there's really a benefit to it.

[majnemer]

test/CodeGen/X86/pr24374.ll

34–35 ↗

(On Diff #72112)

I guess I feel most strongly about win64_eh.ll. It contains examples of increasing complexity with the varied results we'd expect from the compiler, I feel like it'd be useful to include the CHECK-NOTs for pedagogical purposes.

[hans]

test/CodeGen/X86/pr24374.ll

34–35 ↗

(On Diff #72112)

Makes sense, I'll add them.

[hans]

CHECK-NOTs in win64_eh.ll

[majnemer]

Thanks, LGTM!

llvm/trunk/include/llvm/CodeGen/MachineFunction.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
 #define LLVM_CODEGEN_MACHINEFUNCTION_H
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/ilist.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ArrayRecycler.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Recycler.h"
class MachineFunction {
   /// the attribute itself.
   /// This is used to limit optimizations which cannot reason
   /// about the control flow of such functions.
   bool ExposesReturnsTwice = false;
 
   /// True if the function includes any inline assembly.
   bool HasInlineAsm = false;
 
+  /// True if any WinCFI instruction have been emitted in this function.
+  Optional<bool> HasWinCFI;
+
   /// Current high-level properties of the IR of the function (e.g. is in SSA
   /// form or whether registers have been allocated)
   MachineFunctionProperties Properties;
 
   // Allocation management for pseudo source values.
   std::unique_ptr<PseudoSourceValueManager> PSVManager;
 
   MachineFunction(const MachineFunction &) = delete;
bool hasInlineAsm() const {
     return HasInlineAsm;
   }
 
   /// Set a flag that indicates that the function contains inline assembly.
   void setHasInlineAsm(bool B) {
     HasInlineAsm = B;
   }
 
+  bool hasWinCFI() const {
+    assert(HasWinCFI.hasValue() && "HasWinCFI not set yet!");
+    return *HasWinCFI;
+  }
+  void setHasWinCFI(bool v) { HasWinCFI = v; }
+
   /// Get the function properties
   const MachineFunctionProperties &getProperties() const { return Properties; }
   MachineFunctionProperties &getProperties() { return Properties; }
 
   /// getInfo - Keep track of various per-function pieces of information for
   /// backends that would like to do so.
   ///
   template<typename Ty>

llvm/trunk/lib/CodeGen/AsmPrinter/WinException.cpp

shouldEmitPersonality =
                                PerEncoding != dwarf::DW_EH_PE_omit && Per);
 
   unsigned LSDAEncoding = TLOF.getLSDAEncoding();
   shouldEmitLSDA = shouldEmitPersonality &&
     LSDAEncoding != dwarf::DW_EH_PE_omit;
 
   // If we're not using CFI, we don't want the CFI or the personality, but we
   // might want EH tables if we had EH pads.
-  if (!Asm->MAI->usesWindowsCFI()) {
+  if (!Asm->MAI->usesWindowsCFI() || (!MF->hasWinCFI() && !Per)) {
     shouldEmitLSDA = hasEHFunclets;
     shouldEmitPersonality = false;
     return;
   }
 
   beginFunclet(MF->front(), Asm->CurrentFnSym);
 }
 

llvm/trunk/lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::emitPrologue(MachineFunction &MF,
   bool NeedsWinCFI = IsWin64Prologue && Fn->needsUnwindTableEntry();
   bool NeedsDwarfCFI =
       !IsWin64Prologue && (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
   unsigned FramePtr = TRI->getFrameRegister(MF);
   const unsigned MachineFramePtr =
       STI.isTarget64BitILP32()
           ? getX86SubSuperRegister(FramePtr, 64) : FramePtr;
   unsigned BasePtr = TRI->getBaseRegister();
+  bool HasWinCFI = false;
   
   // Debug location must be unknown since the first debug location is used
   // to determine the end of the prologue.
   DebugLoc DL;
 
   // Add RETADDR move area to callee saved frame size.
   int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
   if (TailCallReturnAddrDelta && IsWin64Prologue)
if (NeedsDwarfCFI) {
 
       // Change the rule for the FramePtr to be an "offset" rule.
       unsigned DwarfFramePtr = TRI->getDwarfRegNum(MachineFramePtr, true);
       BuildCFI(MBB, MBBI, DL, MCCFIInstruction::createOffset(
                                   nullptr, DwarfFramePtr, 2 * stackGrowth));
     }
 
     if (NeedsWinCFI) {
+      HasWinCFI = true;
       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg))
           .addImm(FramePtr)
           .setMIFlag(MachineInstr::FrameSetup);
     }
 
     if (!IsWin64Prologue && !IsFunclet) {
       // Update EBP with the new base value.
       BuildMI(MBB, MBBI, DL,
if (!HasFP && NeedsDwarfCFI) {
       // Define the current CFA rule to use the provided offset.
       assert(StackSize);
       BuildCFI(MBB, MBBI, DL,
                MCCFIInstruction::createDefCfaOffset(nullptr, StackOffset));
       StackOffset += stackGrowth;
     }
 
     if (NeedsWinCFI) {
+      HasWinCFI = true;
       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg)).addImm(Reg).setMIFlag(
           MachineInstr::FrameSetup);
     }
   }
 
   // Realign stack after we pushed callee-saved registers (so that we'll be
   // able to calculate their offsets from the frame pointer).
   // Don't do this for Win64, it needs to realign the stack after the prologue.
if (isEAXAlive) {
                        StackPtr, false, NumBytes - 4);
       MI->setFlag(MachineInstr::FrameSetup);
       MBB.insert(MBBI, MI);
     }
   } else if (NumBytes) {
     emitSPUpdate(MBB, MBBI, -(int64_t)NumBytes, /*InEpilogue=*/false);
   }
 
-  if (NeedsWinCFI && NumBytes)
+  if (NeedsWinCFI && NumBytes) {
+    HasWinCFI = true;
     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_StackAlloc))
         .addImm(NumBytes)
         .setMIFlag(MachineInstr::FrameSetup);
+  }
 
   int SEHFrameOffset = 0;
   unsigned SPOrEstablisher;
   if (IsFunclet) {
     if (IsClrFunclet) {
       // The establisher parameter passed to a CLR funclet is actually a pointer
       // to the (mostly empty) frame of its nearest enclosing funclet; we have
       // to find the root function establisher frame by loading the PSPSym from
if (SEHFrameOffset)
       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::LEA64r), FramePtr),
                    SPOrEstablisher, false, SEHFrameOffset);
     else
       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64rr), FramePtr)
           .addReg(SPOrEstablisher);
 
     // If this is not a funclet, emit the CFI describing our frame pointer.
     if (NeedsWinCFI && !IsFunclet) {
+      HasWinCFI = true;
       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SetFrame))
           .addImm(FramePtr)
           .addImm(SEHFrameOffset)
           .setMIFlag(MachineInstr::FrameSetup);
       if (isAsynchronousEHPersonality(Personality))
         MF.getWinEHFuncInfo()->SEHSetFrameOffset = SEHFrameOffset;
     }
   } else if (IsFunclet && STI.is32Bit()) {
while (MBBI != MBB.end() && MBBI->getFlag(MachineInstr::FrameSetup)) {
     if (NeedsWinCFI) {
       int FI;
       if (unsigned Reg = TII.isStoreToStackSlot(FrameInstr, FI)) {
         if (X86::FR64RegClass.contains(Reg)) {
           unsigned IgnoredFrameReg;
           int Offset = getFrameIndexReference(MF, FI, IgnoredFrameReg);
           Offset += SEHFrameOffset;
 
+          HasWinCFI = true;
           BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SaveXMM))
               .addImm(Reg)
               .addImm(Offset)
               .setMIFlag(MachineInstr::FrameSetup);
         }
       }
     }
   }
 
-  if (NeedsWinCFI)
+  if (NeedsWinCFI && HasWinCFI)
     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_EndPrologue))
         .setMIFlag(MachineInstr::FrameSetup);
 
   if (FnHasClrFunclet && !IsFunclet) {
     // Save the so-called Initial-SP (i.e. the value of the stack pointer
     // immediately after the prolog)  into the PSPSlot so that funclets
     // and the GC can recover it.
     unsigned PSPSlotOffset = getPSPSlotOffsetFromSP(MF);
void X86FrameLowering::emitPrologue(MachineFunction &MF,
   //
   // FIXME: Create "cld" instruction only in these cases:
   // 1. The interrupt handling function uses any of the "rep" instructions.
   // 2. Interrupt handling function calls another function.
   //
   if (Fn->getCallingConv() == CallingConv::X86_INTR)
     BuildMI(MBB, MBBI, DL, TII.get(X86::CLD))
         .setMIFlag(MachineInstr::FrameSetup);
+
+  // At this point we know if the function has WinCFI or not.
+  MF.setHasWinCFI(HasWinCFI);
 }
 
 bool X86FrameLowering::canUseLEAForSPInEpilogue(
     const MachineFunction &MF) const {
   // We can't use LEA instructions for adjusting the stack pointer if we don't
   // have a frame pointer in the Win64 ABI.  Only ADD instructions may be used
   // to deallocate the stack.
   // This means that we can use LEA for SP in two situations:
void X86FrameLowering::emitEpilogue(MachineFunction &MF,
   }
 
   // Windows unwinder will not invoke function's exception handler if IP is
   // either in prologue or in epilogue.  This behavior causes a problem when a
   // call immediately precedes an epilogue, because the return address points
   // into the epilogue.  To cope with that, we insert an epilogue marker here,
   // then replace it with a 'nop' if it ends up immediately after a CALL in the
   // final emitted code.
-  if (NeedsWinCFI)
+  if (NeedsWinCFI && MF.hasWinCFI())
     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_Epilogue));
 
   if (!RetOpcode || !isTailCallOpcode(*RetOpcode)) {
     // Add the return addr area delta back since we are not tail calling.
     int Offset = -1 * X86FI->getTCReturnAddrDelta();
     assert(Offset >= 0 && "TCDelta should never be positive");
     if (Offset) {
       MBBI = MBB.getFirstTerminator();

llvm/trunk/lib/Target/X86/X86MCInstLower.cpp

case X86::MORESTACK_RET_RESTORE_R10:
     // Return, then restore R10.
     EmitAndCountInstruction(MCInstBuilder(getRetOpcode(*Subtarget)));
     EmitAndCountInstruction(MCInstBuilder(X86::MOV64rr)
                             .addReg(X86::R10)
                             .addReg(X86::RAX));
     return;
 
   case X86::SEH_PushReg:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFIPushReg(RI->getSEHRegNum(MI->getOperand(0).getImm()));
     return;
 
   case X86::SEH_SaveReg:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFISaveReg(RI->getSEHRegNum(MI->getOperand(0).getImm()),
                                    MI->getOperand(1).getImm());
     return;
 
   case X86::SEH_SaveXMM:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFISaveXMM(RI->getSEHRegNum(MI->getOperand(0).getImm()),
                                    MI->getOperand(1).getImm());
     return;
 
   case X86::SEH_StackAlloc:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFIAllocStack(MI->getOperand(0).getImm());
     return;
 
   case X86::SEH_SetFrame:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFISetFrame(RI->getSEHRegNum(MI->getOperand(0).getImm()),
                                     MI->getOperand(1).getImm());
     return;
 
   case X86::SEH_PushFrame:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFIPushFrame(MI->getOperand(0).getImm());
     return;
 
   case X86::SEH_EndPrologue:
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     OutStreamer->EmitWinCFIEndProlog();
     return;
 
   case X86::SEH_Epilogue: {
+    assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
     MachineBasicBlock::const_iterator MBBI(MI);
     // Check if preceded by a call and emit nop if so.
     for (MBBI = PrevCrossBBInst(MBBI);
          MBBI != MachineBasicBlock::const_iterator();
          MBBI = PrevCrossBBInst(MBBI)) {
       // Conservatively assume that pseudo instructions don't emit code and keep
       // looking for a call. We may emit an unnecessary nop in some cases.
       if (!MBBI->isPseudo()) {

llvm/trunk/test/CodeGen/X86/coalescer-win64.ll

 ; RUN: llc < %s -verify-coalescing | FileCheck %s
 target triple = "x86_64-pc-win32"
 
 @fnptr = external global void ()*
 
 define void @test1() {
 entry:
   %p = load void ()*, void ()** @fnptr
   tail call void %p()
   ret void
 }
 
 ; CHECK-LABEL: test1{{$}}
-; CHECK: .seh_proc test1{{$}}
+; CHECK-NOT: .seh_proc test1
 ; CHECK: rex64 jmpq *fnptr(%rip)
-; CHECK: .seh_endproc
+; CHECK-NOT: .seh_endproc

llvm/trunk/test/CodeGen/X86/pr24374.ll

 ; CHECK:       callq g
 ; CHECK:               .seh_handlerdata
 ; CHECK:               .seh_endproc
 
 define void @g() {
   unreachable
 }
 ; CHECK-LABEL: g:
-; CHECK:       .seh_proc g
-; CHECK:       .seh_endproc
+; CHECK: ud2
 
 attributes #0 = { nounwind }

llvm/trunk/test/CodeGen/X86/seh-catchpad.ll

 
 define internal i32 @"\01?filt$0@0@main@@"(i8* nocapture readnone %exception_pointers, i8* nocapture readnone %frame_pointer) #1 {
 entry:
   %call = tail call i32 @filt()
   ret i32 %call
 }
 
 ; CHECK: "?filt$0@0@main@@":                     # @"\01?filt$0@0@main@@"
-; CHECK: .seh_proc "?filt$0@0@main@@"
-; CHECK:         .seh_endprologue
 ; CHECK:         jmp       filt  # TAILCALL
-; CHECK:         .seh_handlerdata
 
 declare i32 @filt() #1
 
 declare i32 @__C_specific_handler(...)
 
 ; Function Attrs: noinline nounwind
 define internal fastcc void @"\01?fin$0@0@main@@"() #2 {
 entry:

llvm/trunk/test/CodeGen/X86/win64_eh.ll

 ; RUN: llc < %s -O0 -mattr=sse2 -mtriple=x86_64-pc-windows-itanium | FileCheck %s -check-prefix=WIN64 -check-prefix=NORM
 ; RUN: llc < %s -O0 -mattr=sse2 -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=WIN64 -check-prefix=NORM
 ; RUN: llc < %s -O0 -mattr=sse2 -mtriple=x86_64-pc-mingw32 -mcpu=atom | FileCheck %s -check-prefix=WIN64 -check-prefix=ATOM
 
 ; Check function without prolog
 define void @foo0() uwtable {
 entry:
   ret void
 }
 ; WIN64-LABEL: foo0:
-; WIN64: .seh_proc foo0
-; WIN64: .seh_endprologue
+; WIN64-NOT: .seh_proc foo0
+; WIN64-NOT: .seh_endprologue
 ; WIN64: ret
-; WIN64: .seh_endproc
+; WIN64-NOT: .seh_endproc
 
 ; Checks a small stack allocation
 define void @foo1() uwtable {
 entry:
   %baz = alloca [2000 x i16], align 2
   ret void
 }
 ; WIN64-LABEL: foo1:

llvm/trunk/test/CodeGen/X86/win64_eh_leaf.ll

+; RUN: llc < %s -O1 -mtriple=x86_64-pc-win32 | FileCheck %s -check-prefix=ASM
+; RUN: llc < %s -O1 -mtriple=x86_64-pc-win32 -filetype=obj -o %t
+; RUN: llvm-readobj -unwind %t | FileCheck %s -check-prefix=READOBJ
+
+declare void @g(i32)
+
+define i32 @not_leaf(i32) uwtable {
+entry:
+  call void @g(i32 42)
+  ret i32 42
+
+; ASM-LABEL: not_leaf:
+; ASM: .seh
+
+; READOBJ: RuntimeFunction {
+; READOBJ-NEXT: StartAddress: not_leaf
+; READOBJ-NEXT: EndAddress: not_leaf
+}
+
+define void @leaf_func(i32) uwtable {
+entry:
+  tail call void @g(i32 42)
+  ret void
+
+; A Win64 "leaf" function gets no .seh directives in the asm.
+; ASM-LABEL: leaf_func:
+; ASM-NOT: .seh
+
+; and no unwind info in the object file.
+; READOBJ-NOT: leaf_func
+}