Automerge: [SelectionDAG] Not issue TRAP node if naked function (#132147)

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] llvm/llvm-project#131731

Co-authored-by: Yonghong Song <[email protected]>

Author: 2 people

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 shouldLowerToTrap(bool TrapUnreachable, bool NoTrapAfterNoreturn) const;
+
 private:
   BasicBlock *getSuccessor(unsigned idx) const {
     llvm_unreachable("UnreachableInst has no successors!");

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

@@ -3143,21 +3143,12 @@ bool IRTranslator::translateVAArg(const User &U, MachineIRBuilder &MIRBuilder) {
   return true;
 }
 
-bool IRTranslator::translateUnreachable(const User &U, MachineIRBuilder &MIRBuilder) {
-  if (!MF->getTarget().Options.TrapUnreachable)
-    return true;
-
+bool IRTranslator::translateUnreachable(const User &U,
+                                        MachineIRBuilder &MIRBuilder) {
   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.shouldLowerToTrap(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->shouldLowerToTrap(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.shouldLowerToTrap(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::shouldLowerToTrap(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 }