[SelectionDAG] Not issue TRAP node if naked function

In [1], Nikita Popov suggested that during lowering 'unreachable' insn
should not generate extra code for naked functions, and this applies
to all architectures. Note that for naked functions, 'unreachable'
insn is necessary in IR since the basic block needs a terminator to end.

This patch checked whether a function is naked function or not.
If it is a naked function, 'unreachable' insn will not generate
ISD::TRAP.

  [1] #131731

Author: Yonghong Song

llvm/include/llvm/IR/Instructions.h

@@ -4497,6 +4497,9 @@ class UnreachableInst : public Instruction {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
+  // Whether to do target lowering in SelectionDAG.
+  bool allowISelLowering(bool TrapUnreachable, bool NoTrapAfterNoreturn) const;
+
 private:
   BasicBlock *getSuccessor(unsigned idx) const {
     llvm_unreachable("UnreachableInst has no successors!");

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

@@ -3144,20 +3144,10 @@ bool IRTranslator::translateVAArg(const User &U, MachineIRBuilder &MIRBuilder) {
 }
 
 bool IRTranslator::translateUnreachable(const User &U, MachineIRBuilder &MIRBuilder) {
-  if (!MF->getTarget().Options.TrapUnreachable)
-    return true;
-
   auto &UI = cast<UnreachableInst>(U);
-
-  // We may be able to ignore unreachable behind a noreturn call.
-  if (const CallInst *Call = dyn_cast_or_null<CallInst>(UI.getPrevNode());
-      Call && Call->doesNotReturn()) {
-    if (MF->getTarget().Options.NoTrapAfterNoreturn)
-      return true;
-    // Do not emit an additional trap instruction.
-    if (Call->isNonContinuableTrap())
-      return true;
-  }
+  if (!UI.allowISelLowering(MF->getTarget().Options.TrapUnreachable,
+                            MF->getTarget().Options.NoTrapAfterNoreturn))
+    return true;
 
   MIRBuilder.buildTrap();
   return true;

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

@@ -1854,17 +1854,12 @@ bool FastISel::selectOperator(const User *I, unsigned Opcode) {
   }
 
   case Instruction::Unreachable: {
-    if (TM.Options.TrapUnreachable) {
-      if (TM.Options.NoTrapAfterNoreturn) {
-        const auto *Call =
-            dyn_cast_or_null<CallInst>(cast<Instruction>(I)->getPrevNode());
-        if (Call && Call->doesNotReturn())
-          return true;
-      }
+    auto UI = cast<UnreachableInst>(I);
+    if (!UI->allowISelLowering(TM.Options.TrapUnreachable,
+                               TM.Options.NoTrapAfterNoreturn))
+      return true;
 
-      return fastEmit_(MVT::Other, MVT::Other, ISD::TRAP) != 0;
-    }
-    return true;
+    return fastEmit_(MVT::Other, MVT::Other, ISD::TRAP) != 0;
   }
 
   case Instruction::Alloca:

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -3501,19 +3501,10 @@ void SelectionDAGBuilder::visitIndirectBr(const IndirectBrInst &I) {
 }
 
 void SelectionDAGBuilder::visitUnreachable(const UnreachableInst &I) {
-  if (!DAG.getTarget().Options.TrapUnreachable)
+  if (!I.allowISelLowering(DAG.getTarget().Options.TrapUnreachable,
+                           DAG.getTarget().Options.NoTrapAfterNoreturn))
     return;
 
-  // We may be able to ignore unreachable behind a noreturn call.
-  if (const CallInst *Call = dyn_cast_or_null<CallInst>(I.getPrevNode());
-      Call && Call->doesNotReturn()) {
-    if (DAG.getTarget().Options.NoTrapAfterNoreturn)
-      return;
-    // Do not emit an additional trap instruction.
-    if (Call->isNonContinuableTrap())
-      return;
-  }
-
   DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
 }
 

llvm/lib/IR/Instructions.cpp

@@ -4529,6 +4529,27 @@ UnreachableInst *UnreachableInst::cloneImpl() const {
   return new UnreachableInst(Context);
 }
 
+bool UnreachableInst::allowISelLowering(bool TrapUnreachable,
+                                        bool NoTrapAfterNoreturn) const {
+  if (!TrapUnreachable)
+    return false;
+
+  // We may be able to ignore unreachable behind a noreturn call.
+  if (const CallInst *Call = dyn_cast_or_null<CallInst>(getPrevNode());
+      Call && Call->doesNotReturn()) {
+    if (NoTrapAfterNoreturn)
+      return false;
+    // Do not emit an additional trap instruction.
+    if (Call->isNonContinuableTrap())
+      return false;
+  }
+
+  if (getFunction()->hasFnAttribute(Attribute::Naked))
+    return false;
+
+  return true;
+}
+
 FreezeInst *FreezeInst::cloneImpl() const {
   return new FreezeInst(getOperand(0));
 }

llvm/test/CodeGen/WebAssembly/naked-fn-with-frame-pointer.ll

@@ -9,13 +9,11 @@ define dso_local void @naked() naked "frame-pointer"="all" {
 ; CHECK-32:         .functype naked () -> ()
 ; CHECK-32-NEXT:  # %bb.0:
 ; CHECK-32-NEXT:    call main
-; CHECK-32-NEXT:    unreachable
 ;
 ; CHECK-64-LABEL: naked:
 ; CHECK-64:         .functype naked () -> ()
 ; CHECK-64-NEXT:  # %bb.0:
 ; CHECK-64-NEXT:    call main
-; CHECK-64-NEXT:    unreachable
   call void @main()
   unreachable
 }

llvm/test/CodeGen/X86/naked-fn-with-unreachable-trap.ll

@@ -0,0 +1,11 @@
+; RUN: llc -o - %s -mtriple=x86_64-linux-gnu -trap-unreachable | FileCheck %s
+; RUN: llc -o - %s -mtriple=x86_64-linux-gnu -trap-unreachable -fast-isel | FileCheck %s
+
+define dso_local void @foo() #0 {
+entry:
+  tail call void asm sideeffect "movl 3,%eax", "~{dirflag},~{fpsr},~{flags}"()
+  unreachable
+}
+; CHECK-NOT: ud2
+
+attributes #0 = { naked }