[AArch64] [Windows] Trap after noreturn calls.

[efriedma]

Summary

Like the comment says, this isn't the most efficient fix in terms of codesize, but it works.

[probinson]

We already do this for X86, would it be better to make the check in non-target-specific code? (Just asking, not expressing an opinion.)

[rnk]

We came up with a different solution for this called SEH_Epilogue. It basically inserts a nop if the last real instruction was a call. It's slightly complicated because it looks backwards across empty basic blocks and things. You can see it here:
https://github.com/llvm-mirror/llvm/blob/master/lib/Target/X86/X86MCInstLower.cpp#L1800

I'd rather take that approach. I don't like that just going to Windows gets you this extra trapping behavior. That should be something else that the user controls. Otherwise soon they'll start relying on it. =/

[efriedma]

The case I'm trying to fix is functions/funclets which don't have an epilogue at all. As far as I can tell, the x86 only emits SEH_Epilogue before an epilogue; I don't see how it's related.

[rnk]

In D54129#1289509, @efriedma wrote:

The case I'm trying to fix is functions/funclets which don't have an epilogue at all. As far as I can tell, the x86 only emits SEH_Epilogue before an epilogue; I don't see how it's related.

Right, I remember how this works now. Go ahead and do this.

You could imagine adding an instruction after a call that only turns into a real nop if the next instruction is in a different EH region.

[mstorsjo]

Sorry for not commenting earlier on this one, but, should we only do this if actually using SEH exceptions? (Currently I'm using dwarf exceptions for arm64/mingw, but once all this is done and libunwind supports it, I'll probably switch my mingw setups.)

[efriedma]

Changed to check usesWindowsCFI() in r346366.

llvm/trunk/lib/Target/AArch64/AArch64TargetMachine.cpp

: LLVMTargetMachine(T,
       TLOF(createTLOF(getTargetTriple())), isLittle(LittleEndian) {
   initAsmInfo();
 
   if (TT.isOSBinFormatMachO()) {
     this->Options.TrapUnreachable = true;
     this->Options.NoTrapAfterNoreturn = true;
   }
 
+  if (TT.isOSWindows()) {
+    // Unwinding can get confused if the last instruction in an
+    // exception-handling region (function, funclet, try block, etc.)
+    // is a call.
+    //
+    // FIXME: We could elide the trap if the next instruction would be in
+    // the same region anyway.
+    this->Options.TrapUnreachable = true;
+  }
+
   // Enable GlobalISel at or below EnableGlobalISelAt0.
   if (getOptLevel() <= EnableGlobalISelAtO)
     setGlobalISel(true);
 
   // AArch64 supports the MachineOutliner.
   setMachineOutliner(true);
 
   // AArch64 supports default outlining behaviour.

llvm/trunk/test/CodeGen/AArch64/windows-trap.ll

+; RUN: llc -mtriple=aarch64-win32 %s -o - | FileCheck %s
+
+declare void @callee() noreturn
+
+; Make sure the call isn't the last instruction in the function; if it is,
+; unwinding may break.
+;
+; (The instruction after the call doesn't have to be anything in particular,
+; but trapping has the nice side-effect of catching bugs.)
+
+define void @test_unreachable() {
+; CHECK-LABEL: test_unreachable:
+; CHECK: bl      callee
+; CHECK-NEXT: brk #0x1
+  call void @callee() noreturn
+  unreachable
+}