SEH exceptions on Win64 (LLVM)

[yaron.keren]

Summary

Patch by Martell Malone, based on Kai Nacke patch from http://wiki.dlang.org/Building_and_hacking_LDC_on_Windows_using_MSVC

See http://reviews.llvm.org/differential/revision/edit/3419/ for the clang part of the patch.

[yaron.keren]

Nico Reick comment from e-mail thread:

Unwind emission still suffers from the same problems that the old code
did. It doesn't handle realigned stacks, and as I summarized in PR16779,
I believe it's not necessary to change the prologue emission for Win64.
Currently ilist_node::getPrevNode of MachineInstr is unusable because it
segfaults on the first node in a list. I raised this issue before on
llvm-dev and proposed a patch but nobody cared, so you have to do
something like this:

static const MachineInstr *getPrevNode(const MachineInstr *MI) {
  if (&*MI->getParent()->instr_begin() == MI)
    return nullptr;
  return MI->getPrevNode();
}

Some small nits:

+ if (MI->getOperand(1).getImm() != 1 || MI->getOperand(2).getImm() != 0 ||
+ MI->getOperand(4).getImm() != 0)

Spacing. Also, a comment clarifying that scale/index/segment must be
unused might be helpful here.

+ if (MI->getNextNode()) {
+ const MachineInstr *MI2 = MI->getNextNode();
+ if (!(MI2->getFlag(MachineInstr::FrameSetup) ||
+ (MI2->isCFIInstruction() && MI2->getNextNode() &&
+ MI2->getNextNode()->getFlag(MachineInstr::FrameSetup)))) {
+ OutStreamer.EmitWin64EHEndProlog();
+ }
+ }

I'd simplify this and just skip over all CFI instructions. If there's
still a node left, and it lacks the FrameSetup flag, end the prolog.

+; WIN64: callq {{chkstk|_chkstk_ms}}

This check should really differentiate between MSVC and Mingw. You can
add additional FileCheck prefixes so the rest does not have to be
duplicated.

Overall this needs more tests covering __chkstk, alloca, manual
over-alignment and various combinations.

[yaron.keren]

PR16779 Invalid prolog/epilog on Win64
http://llvm.org/bugs/show_bug.cgi?id=16779

[yaron.keren]

Original Kai patch:

http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20131118/196105.html

[martell]

if (is64Bit && Triple.isWindowsGNUEnvironment())
should be
if (is64Bit && T.isWindowsGNUEnvironment())

[yaron.keren]

Updated if (is64Bit && T.isWindowsGNUEnvironment())

[vadimcn]

Looks like this review thread went silent. What's needed to un-stall it?

[vadimcn]

Ping... It's been a week since anything happened on this review. Is there any action that can be taken to un-stall this?

Chandler, did Kai address your concern regarding patch authorship?

[chandlerc]

First, reviews are sometimes slow, sorry. This isn't something I can easily
review, so your best bet is to ping every week or so until a reviewer can
find time.

It also still has the problems that I mentioned about any of the patches
from this project (I mentioned this on the original thread, but none have
responded so I don't know if there is anything to be done there...)

[vadimcn]

There's been much back-and-forth on the mailing list thread, so I am no longer sure which problems absolutely need to be fixed, and which were mentioned just in passing. It would be helpful to restate them in one place (here probably).

I would really like to see this landing in LLVM master, because some of my work depends on it. If Kai and Martell have their hands full, I'd be happy to take over this patch to address any remaining technical problems with it. Kai, Martell, I assume that's all right with you guys?

Finally, I'd like to make sure that we have the right set of people involved in this review. Who owns this area and can give the final go ahead? According to code_owners.txt that would be Anton, right?

[vadimcn]

@nrieck, you've said above "I believe it's not necessary to change the prologue emission for Win64". However I don't see how would one express 'and ..., %rsp' with SEH unwind instructions, because the effective RSP offset here is not a compile-time constant.

As far as I understand, DWARF unwind info does not care about the exact number of bytes added to RSP, as long as it can compute the CFA, because that's where RSP is restored from.
SEH, on the other hand, wants to keep track of RSP offset at all times, so the MSVC way of realigning stack seems to be the only way possible.
An extra wrinkle here is that LLVM continues to use RSP for addressing stack variables, even though it had just established frame with RBP. Seems like a bunch of codegen will need to change if we start re-aligning RBP instead.

Am I missing something here?

(the asm code I am referring to is in http://llvm.org/bugs/show_bug.cgi?id=16779)

[Kai]

@Vadim, Chandler

Regarding the authorship of the code, I responded on llvm-dev. The base part of the code is by Charles Davis. I attach the mail communication how I received the code.

Re_Win64_Exception_Handling.txt1 KBDownload

From my point of view, I got the right to further develop this code.

@Vadim
If you like to take ownership of this code please go ahead!

[cdavis5x]

@vadimcn:
You are more than welcome to go ahead with this (pending approval to commit). I don't have a lot of time to devote to this right now.

Everyone:
This was originally my code, but from the looks of it, it's been heavily modified. I don't even recognize some parts of it anymore. I'm passing whatever little ownership over this patch I had left over to whomever will take it (probably @vadimcn, since that's whom Kai blessed).

[vadimcn]

I ended up with an almost complete rewrite, so positing it as a new review: D4081

[yaron.keren]

Continued in http://reviews.llvm.org/D4081

lib/CodeGen/AsmPrinter/Win64Exception.cpp

   if (!shouldEmitPersonality)
     return;
 
-  MCSymbol *GCCHandlerSym =
-    Asm->GetExternalSymbolSymbol("_GCC_specific_handler");
-  Asm->OutStreamer.EmitWin64EHHandler(GCCHandlerSym, true, true);
+  const MCSymbol *PersHandlerSym = TLOF.getCFIPersonalitySymbol(Per, *Asm->Mang,
+                                                                Asm->TM, MMI);
+  Asm->OutStreamer.EmitWin64EHHandler(PersHandlerSym, true, true);
 
   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("eh_func_begin",
                                                 Asm->getFunctionNumber()));

   MMI->TidyLandingPads();
 
   if (shouldEmitPersonality) {
-    const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
-    const Function *Per = MMI->getPersonalities()[MMI->getPersonalityIndex()];
-    const MCSymbol *Sym =
-        TLOF.getCFIPersonalitySymbol(Per, *Asm->Mang, Asm->TM, MMI);
-
     Asm->OutStreamer.PushSection();
     Asm->OutStreamer.EmitWin64EHHandlerData();
-    Asm->OutStreamer.EmitValue(MCSymbolRefExpr::Create(Sym, Asm->OutContext),
-                               4);
     EmitExceptionTable();
     Asm->OutStreamer.PopSection();
   }

lib/MC/MCObjectFileInfo.cpp

   // though it contains relocatable pointers.  In PIC mode, this is probably a
   // big runtime hit for C++ apps.  Either the contents of the LSDA need to be
   // adjusted or this should be a data section.
-  LSDASection =
-    Ctx->getCOFFSection(".gcc_except_table",
-                        COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
-                        COFF::IMAGE_SCN_MEM_READ,
-                        SectionKind::getReadOnly());
+  if (T.getOS() == Triple::Win32) {
+    // On Windows with SEH, the LSDA is emitted into the .xdata section
+    LSDASection = 0;
+  } else {
+    LSDASection =
+      Ctx->getCOFFSection(".gcc_except_table",
+                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+                          COFF::IMAGE_SCN_MEM_READ,
+                          SectionKind::getReadOnly());
+  }
 
   // Debug info.
   COFFDebugSymbolsSection =

lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp

 
 void X86MCAsmInfoMicrosoft::anchor() { }
 
-X86MCAsmInfoMicrosoft::X86MCAsmInfoMicrosoft(const Triple &Triple) {
-  if (Triple.getArch() == Triple::x86_64)
+X86MCAsmInfoMicrosoft::X86MCAsmInfoMicrosoft(const Triple &T) {
+  bool is64Bit = T.getArch() == Triple::x86_64;
+
+  if (is64Bit) {
     PrivateGlobalPrefix = ".L";
+    ExceptionsType = ExceptionHandling::Win64;
+  }
+
+  PointerSize = is64Bit ? 8 : 4;
 
   AssemblerDialect = AsmWriterFlavor;
 

 
 void X86MCAsmInfoGNUCOFF::anchor() { }
 
-X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(const Triple &Triple) {
-  if (Triple.getArch() == Triple::x86_64) {
+X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(const Triple &T) {
+  bool is64Bit = T.getArch() == Triple::x86_64;
+
+  if (is64Bit)
     PrivateGlobalPrefix = ".L";
-    PointerSize = 8;
-  }
+
+  PointerSize = is64Bit ? 8 : 4;
 
   AssemblerDialect = AsmWriterFlavor;
 
   TextAlignFillValue = 0x90;
 
   // Exceptions handling
-  ExceptionsType = ExceptionHandling::DwarfCFI;
+  if (is64Bit && T.isWindowsGNUEnvironment())
+    ExceptionsType = ExceptionHandling::Win64;
+  else
+    ExceptionsType = ExceptionHandling::DwarfCFI;
 
   UseIntegratedAssembler = true;
 }

lib/Target/X86/X86AsmPrinter.h

   const X86Subtarget *Subtarget;
   StackMaps SM;
 
+  void EmitUnwindingInstruction(const MachineInstr *MI);
+
  public:
   explicit X86AsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
     : AsmPrinter(TM, Streamer), SM(*this) {

lib/Target/X86/X86ISelLowering.cpp

   // FIXME - use subtarget debug flags
   if (!Subtarget->isTargetDarwin() &&
       !Subtarget->isTargetELF() &&
-      !Subtarget->isTargetCygMing()) {
+      !Subtarget->isTargetCygMing() &&
+      !Subtarget->isTargetWin64()) {
     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
   }
 

lib/Target/X86/X86MCInstLower.cpp

 //===----------------------------------------------------------------------===//
 
 #include "X86AsmPrinter.h"
+#include "X86RegisterInfo.h"
 #include "InstPrinter/X86ATTInstPrinter.h"
 #include "MCTargetDesc/X86BaseInfo.h"
 #include "llvm/ADT/SmallString.h"

 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCAsmInfo.h"

   EmitNops(OS, NumBytes - EncodedBytes, Is64Bit, STI);
 }
 
+static bool isCalleeSavedReg(const MachineFunction *MF,
+                             const X86RegisterInfo *RI, unsigned Reg) {
+  const uint16_t *NVRegs = RI->getCalleeSavedRegs(MF);
+  while (*NVRegs) {
+    if (*NVRegs == Reg)
+      return true;
+    NVRegs++;
+  }
+  return false;
+}
+
+void X86AsmPrinter::EmitUnwindingInstruction(const MachineInstr *MI) {
+  assert(MI->getFlag(MachineInstr::FrameSetup) &&
+         "Only call frame setup instructions allowed here!");
+  unsigned SReg, DReg;
+  int64_t Offset;
+  const X86RegisterInfo *RI =
+    static_cast<const X86RegisterInfo *>(TM.getRegisterInfo());
+  switch (MI->getOpcode()) {
+  default: llvm_unreachable("Unknown frame setup opcode!");
+  case X86::PUSH64r:
+    SReg = MI->getOperand(0).getReg();
+    if (isCalleeSavedReg(MI->getParent()->getParent(), RI, SReg))
+      OutStreamer.EmitWin64EHPushReg(RI->getSEHRegNum(SReg));
+    else
+      OutStreamer.EmitWin64EHAllocStack(8);
+    break;
+  case X86::SUB64ri8:
+  case X86::SUB64ri32:
+    DReg = MI->getOperand(0).getReg();
+    Offset = MI->getOperand(2).getImm();
+    if (DReg == RI->getStackRegister()) {
+      OutStreamer.EmitWin64EHAllocStack(Offset);
+    } else
+      llvm_unreachable("X86::SUB64ri8/32 not allowed with these operands");
+    break;
+  case X86::MOV64rr:
+    DReg = MI->getOperand(0).getReg();
+    SReg = MI->getOperand(1).getReg();
+    if (DReg == RI->getFrameRegister(*MF) && SReg == RI->getStackRegister())
+      OutStreamer.EmitWin64EHSetFrame(RI->getSEHRegNum(DReg), 0);
+    else
+      llvm_unreachable("X86::MOV64rr not allowed with these operands");
+    break;
+  case X86::MOV64mr:
+  case X86::MOVAPSmr:
+    DReg = MI->getOperand(0).getReg();
+    SReg = MI->getOperand(5).getReg();
+    if (DReg == RI->getFrameRegister(*MF) || DReg == RI->getStackRegister()) {
+      Offset = MI->getOperand(3).getImm();
+      if (MI->getOperand(1).getImm() != 1 || MI->getOperand(2).getImm() != 0 ||
+          MI->getOperand(4).getImm()  != 0)
+        llvm_unreachable("X86::MOV64mr not allowed with these operands");
+      if (MI->getOpcode() == X86::MOVAPSmr)
+        OutStreamer.EmitWin64EHSaveXMM(RI->getSEHRegNum(SReg), Offset);
+      else
+        OutStreamer.EmitWin64EHSaveReg(RI->getSEHRegNum(SReg), Offset);
+    } else
+      llvm_unreachable("X86::MOV64mr not allowed with these operands");
+    break;
+  case X86::LEA64r:
+    DReg = MI->getOperand(0).getReg();
+    SReg = MI->getOperand(1).getReg();
+    Offset = MI->getOperand(4).getImm();
+    if (SReg == RI->getStackRegister() && Offset > 0) {
+      // Check stack register first in case there is no frame register.
+      if (DReg == RI->getStackRegister()) {
+        OutStreamer.EmitWin64EHAllocStack(Offset);
+      } else if (DReg == RI->getFrameRegister(*MF)) {
+        OutStreamer.EmitWin64EHSetFrame(RI->getSEHRegNum(DReg), Offset);
+      } else
+        llvm_unreachable("X86::LEA64r not allowed with these operands");
+    }
+    else
+      llvm_unreachable("X86::LEA64r not allowed with these operands");
+    break;
+  case X86::MOV64ri:
+    // Occurs before alloca()/call to __chkstk/___chkstk_ms
+    if (!(MI->getNextNode()
+            && MI->getNextNode()->getOpcode() == X86::W64ALLOCA
+            && MI->getOperand(0).getReg() == X86::RAX))
+      llvm_unreachable("X86::MOV64ri only allowed before X86::W64ALLOCA");
+    break;
+  case X86::W64ALLOCA:
+    // Occurs if call to __chkstk/___chkstk_ms is used.
+    break;
+  case X86::SUB64rr:
+    // Occurs after call to __chkstk/___chkstk_ms on Win64
+    if (!(MI->getPrevNode()
+            && MI->getPrevNode()->getOpcode() == X86::W64ALLOCA
+            && MI->getOperand(0).getReg() == RI->getStackRegister()
+            && MI->getOperand(2).getReg() == X86::RAX
+            && getSubtarget().isTargetWin64()))
+      llvm_unreachable("X86::SUB64rr only allowed after X86::W64ALLOCA");
+    const MachineInstr *MoveMI = MI->getPrevNode()->getPrevNode();
+    if (!(MoveMI && MoveMI->getOpcode() == X86::MOV64ri))
+      llvm_unreachable("X86::MOV64ri required before X86::W64ALLOCA");
+    Offset = MoveMI->getOperand(1).getImm();
+    OutStreamer.EmitWin64EHAllocStack(Offset);
+    break;
+  }
+  // Prolog ends if next instruction does not have the FrameSetup flag
+  // and is not the CFI_Instruction.
+  if (MI->getNextNode()) {
+    const MachineInstr *MI2 = MI->getNextNode();
+    if (!(MI2->getFlag(MachineInstr::FrameSetup) ||
+          (MI2->isCFIInstruction() && MI2->getNextNode() &&
+           MI2->getNextNode()->getFlag(MachineInstr::FrameSetup)))) {
+      OutStreamer.EmitWin64EHEndProlog();
+    }
+  }
+}
+
 void X86AsmPrinter::EmitInstruction(const MachineInstr *MI) {
+  // Emit end of prolog for Win64-style EH if there is no framesetup.
+  if (MAI->getExceptionHandlingType() == ExceptionHandling::Win64 &&
+      !MI->getFlag(MachineInstr::FrameSetup) &&
+      MI->getParent()->getParent()->getFunction()->needsUnwindTableEntry() &&
+      MI == MI->getParent()->instr_begin() &&
+      MI->getParent()->getNumber() == 0) {
+    OutStreamer.EmitWin64EHEndProlog();
+  }
+
   X86MCInstLower MCInstLowering(*MF, *this);
   switch (MI->getOpcode()) {
   case TargetOpcode::DBG_VALUE:

   MCInst TmpInst;
   MCInstLowering.Lower(MI, TmpInst);
   EmitToStreamer(OutStreamer, TmpInst);
+
+  // Emit SEH unwind info for Win64-style EH.
+  if (MAI->getExceptionHandlingType() == ExceptionHandling::Win64 &&
+      MI->getFlag(MachineInstr::FrameSetup) &&
+      MI->getParent()->getParent()->getFunction()->needsUnwindTableEntry()) {
+    EmitUnwindingInstruction(MI);
+  }
 }

test/CodeGen/X86/avx-win64-args.ll

 ; RUN: llc < %s -mcpu=corei7-avx -mattr=+avx | FileCheck %s
+; XFAIL: *
+; See PR16779.
 target triple = "x86_64-pc-win32"
 
 declare <8 x float> @foo(<8 x float>, i32)

test/CodeGen/X86/win64_eh.ll

+; RUN: llc < %s -O0 -mcpu=corei7 -mtriple=x86_64-pc-win32 | FileCheck %s -check-prefix=WIN64
+; RUN: llc < %s -O0 -mcpu=corei7 -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=WIN64
+
+; Check function without prolog
+define void @foo0() uwtable {
+entry:
+  ret void
+}
+; WIN64: .seh_proc foo0
+; WIN64: .seh_endprologue
+; WIN64: ret
+; WIN64: .seh_endproc
+
+; Checks a small stack allocation
+define void @foo1() uwtable {
+entry:
+  %baz = alloca [2000 x i16], align 2
+  ret void
+}
+; WIN64: .seh_proc foo1
+; WIN64: subq $4000, %rsp
+; WIN64: .seh_stackalloc 4000
+; WIN64: .seh_endprologue
+; WIN64: addq $4000, %rsp
+; WIN64: ret
+; WIN64: .seh_endproc
+
+; Checks a stack allocation requiring call to __chkstk/___chkstk_ms
+define void @foo2() uwtable {
+entry:
+  %baz = alloca [4000 x i16], align 2
+  ret void
+}
+; WIN64: .seh_proc foo2
+; WIN64: movabsq $8000, %rax
+; WIN64: callq {{__chkstk|___chkstk_ms}}
+; WIN64: subq %rax, %rsp
+; WIN64: .seh_stackalloc 8000
+; WIN64: .seh_endprologue
+; WIN64: addq $8000, %rsp
+; WIN64: ret
+; WIN64: .seh_endproc
+
+
+; Checks stack push
+define i32 @foo3(i32 %f_arg, i32 %e_arg, i32 %d_arg, i32 %c_arg, i32 %b_arg, i32 %a_arg) uwtable {
+entry:
+  %a = alloca i32
+  %b = alloca i32
+  %c = alloca i32
+  %d = alloca i32
+  %e = alloca i32
+  %f = alloca i32
+  store i32 %a_arg, i32* %a
+  store i32 %b_arg, i32* %b
+  store i32 %c_arg, i32* %c
+  store i32 %d_arg, i32* %d
+  store i32 %e_arg, i32* %e
+  store i32 %f_arg, i32* %f
+  %tmp = load i32* %a
+  %tmp1 = mul i32 %tmp, 2
+  %tmp2 = load i32* %b
+  %tmp3 = mul i32 %tmp2, 3
+  %tmp4 = add i32 %tmp1, %tmp3
+  %tmp5 = load i32* %c
+  %tmp6 = mul i32 %tmp5, 5
+  %tmp7 = add i32 %tmp4, %tmp6
+  %tmp8 = load i32* %d
+  %tmp9 = mul i32 %tmp8, 7
+  %tmp10 = add i32 %tmp7, %tmp9
+  %tmp11 = load i32* %e
+  %tmp12 = mul i32 %tmp11, 11
+  %tmp13 = add i32 %tmp10, %tmp12
+  %tmp14 = load i32* %f
+  %tmp15 = mul i32 %tmp14, 13
+  %tmp16 = add i32 %tmp13, %tmp15
+  ret i32 %tmp16
+}
+; WIN64: .seh_proc foo3
+; WIN64: pushq %rsi
+; WIN64: .seh_pushreg 6
+; WIN64: subq $24, %rsp
+; WIN64: .seh_stackalloc 24
+; WIN64: .seh_endprologue
+; WIN64: addq $24, %rsp
+; WIN64: popq %rsi
+; WIN64: ret
+; WIN64: .seh_endproc
+
+
+; Check emission of eh handler and handler data
+declare i32 @_d_eh_personality(i32, i32, i64, i8*, i8*)
+declare void @_d_eh_resume_unwind(i8*)
+
+declare i32 @bar()
+
+define i32 @foo4() #0 {
+entry:
+  %step = alloca i32, align 4
+  store i32 0, i32* %step
+  %tmp = load i32* %step
+
+  %tmp1 = invoke i32 @bar()
+          to label %finally unwind label %landingpad
+
+finally:
+  store i32 1, i32* %step
+  br label %endtryfinally
+
+landingpad:
+  %landing_pad = landingpad { i8*, i32 } personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality
+          cleanup
+  %tmp3 = extractvalue { i8*, i32 } %landing_pad, 0
+  store i32 2, i32* %step
+  call void @_d_eh_resume_unwind(i8* %tmp3)
+  unreachable
+
+endtryfinally:
+  %tmp10 = load i32* %step
+  ret i32 %tmp10
+}
+; WIN64: .seh_proc foo4
+; WIN64: .seh_handler _d_eh_personality, @unwind, @except
+; WIN64: subq $56, %rsp
+; WIN64: .seh_stackalloc 56
+; WIN64: .seh_endprologue
+; WIN64: addq $56, %rsp
+; WIN64: ret
+; WIN64: .seh_handlerdata
+; WIN64: .seh_endproc