[WIP] [CodeGen] Enable TrapUnreachable by default for all targets.

Author: duk-37

llvm/include/llvm/Target/TargetOptions.h

@@ -145,7 +145,7 @@ namespace llvm {
           DataSections(false), IgnoreXCOFFVisibility(false),
           XCOFFTracebackTable(true), UniqueSectionNames(true),
           UniqueBasicBlockSectionNames(false), SeparateNamedSections(false),
-          TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
+          TrapUnreachable(true), NoTrapAfterNoreturn(true), TLSSize(0),
           EmulatedTLS(false), EnableTLSDESC(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

@@ -3807,16 +3807,11 @@ bool IRTranslator::emitSPDescriptorFailure(StackProtectorDescriptor &SPD,
     return false;
   }
 
-  // On PS4/PS5, the "return address" must still be within the calling
-  // function, even if it's at the very end, so emit an explicit TRAP here.
-  // WebAssembly needs an unreachable instruction after a non-returning call,
-  // because the function return type can be different from __stack_chk_fail's
-  // return type (void).
-  const TargetMachine &TM = MF->getTarget();
-  if (TM.getTargetTriple().isPS() || TM.getTargetTriple().isWasm()) {
-    LLVM_DEBUG(dbgs() << "Unhandled trap emission for stack protector fail\n");
-    return false;
-  }
+  // Emit a trap instruction if we are required to do so.
+  const TargetOptions &TargetOpts = TLI->getTargetMachine().Options;
+  if (TargetOpts.TrapUnreachable && !TargetOpts.NoTrapAfterNoreturn)
+    CurBuilder->buildInstr(TargetOpcode::G_TRAP);
+
   return true;
 }
 

llvm/lib/CodeGen/LLVMTargetMachine.cpp

@@ -33,11 +33,11 @@
 #include "llvm/Target/TargetOptions.h"
 using namespace llvm;
 
-static cl::opt<bool>
-    EnableTrapUnreachable("trap-unreachable", cl::Hidden,
-                          cl::desc("Enable generating trap for unreachable"));
+cl::opt<bool> EnableTrapUnreachable(
+    "trap-unreachable", cl::Hidden,
+    cl::desc("Enable generating trap for unreachable"));
 
-static cl::opt<bool> EnableNoTrapAfterNoreturn(
+cl::opt<bool> EnableNoTrapAfterNoreturn(
     "no-trap-after-noreturn", cl::Hidden,
     cl::desc("Do not emit a trap instruction for 'unreachable' IR instructions "
              "after noreturn calls, even if --trap-unreachable is set."));
@@ -96,10 +96,15 @@ LLVMTargetMachine::LLVMTargetMachine(const Target &T,
   this->CMModel = CM;
   this->OptLevel = OL;
 
-  if (EnableTrapUnreachable)
-    this->Options.TrapUnreachable = true;
-  if (EnableNoTrapAfterNoreturn)
-    this->Options.NoTrapAfterNoreturn = true;
+  if (EnableTrapUnreachable.getNumOccurrences())
+    this->Options.TrapUnreachable = EnableTrapUnreachable;
+
+  if (EnableNoTrapAfterNoreturn.getNumOccurrences())
+    this->Options.NoTrapAfterNoreturn = EnableNoTrapAfterNoreturn;
+
+  // Keep all traps in debug environments.
+  else if (OL == CodeGenOptLevel::None)
+    this->Options.NoTrapAfterNoreturn = false;
 }
 
 TargetTransformInfo

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -3183,15 +3183,10 @@ SelectionDAGBuilder::visitSPDescriptorFailure(StackProtectorDescriptor &SPD) {
   SDValue Chain = TLI.makeLibCall(DAG, RTLIB::STACKPROTECTOR_CHECK_FAIL,
                                   MVT::isVoid, {}, CallOptions, getCurSDLoc())
                       .second;
-  // On PS4/PS5, the "return address" must still be within the calling
-  // function, even if it's at the very end, so emit an explicit TRAP here.
-  // Passing 'true' for doesNotReturn above won't generate the trap for us.
-  if (TM.getTargetTriple().isPS())
-    Chain = DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, Chain);
-  // WebAssembly needs an unreachable instruction after a non-returning call,
-  // because the function return type can be different from __stack_chk_fail's
-  // return type (void).
-  if (TM.getTargetTriple().isWasm())
+
+  // If our current target options require us to add a trap instruction, do so.
+  const TargetOptions &TargetOpts = DAG.getTarget().Options;
+  if (TargetOpts.TrapUnreachable && !TargetOpts.NoTrapAfterNoreturn)
     Chain = DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, Chain);
 
   DAG.setRoot(Chain);

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

@@ -360,11 +360,6 @@ AArch64TargetMachine::AArch64TargetMachine(const Target &T, const Triple &TT,
       TLOF(createTLOF(getTargetTriple())), isLittle(LittleEndian) {
   initAsmInfo();
 
-  if (TT.isOSBinFormatMachO()) {
-    this->Options.TrapUnreachable = true;
-    this->Options.NoTrapAfterNoreturn = true;
-  }
-
   if (getMCAsmInfo()->usesWindowsCFI()) {
     // Unwinding can get confused if the last instruction in an
     // exception-handling region (function, funclet, try block, etc.)
@@ -373,6 +368,7 @@ AArch64TargetMachine::AArch64TargetMachine(const Target &T, const Triple &TT,
     // FIXME: We could elide the trap if the next instruction would be in
     // the same region anyway.
     this->Options.TrapUnreachable = true;
+    this->Options.NoTrapAfterNoreturn = false;
   }
 
   if (this->Options.TLSSize == 0) // default

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

@@ -396,6 +396,8 @@ static cl::opt<bool>
                            cl::desc("Enable AMDGPUAttributorPass"),
                            cl::init(true), cl::Hidden);
 
+extern cl::opt<bool> EnableTrapUnreachable;
+
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUTarget() {
   // Register the target
   RegisterTargetMachine<R600TargetMachine> X(getTheR600Target());
@@ -612,6 +614,10 @@ AMDGPUTargetMachine::AMDGPUTargetMachine(const Target &T, const Triple &TT,
                         FS, Options, getEffectiveRelocModel(RM),
                         getEffectiveCodeModel(CM, CodeModel::Small), OptLevel),
       TLOF(createTLOF(getTargetTriple())) {
+  // FIXME: There are some scenarios where targets may not have hardware traps,
+  // and external calls to `abort` also fail. For now, do a blanket-disable.
+  if (!EnableTrapUnreachable.getNumOccurrences())
+    this->Options.TrapUnreachable = false;
   initAsmInfo();
   if (TT.getArch() == Triple::amdgcn) {
     if (getMCSubtargetInfo()->checkFeatures("+wavefrontsize64"))

llvm/lib/Target/ARM/ARMTargetMachine.cpp

@@ -251,11 +251,6 @@ ARMBaseTargetMachine::ARMBaseTargetMachine(const Target &T, const Triple &TT,
       this->Options.EABIVersion = EABI::EABI5;
   }
 
-  if (TT.isOSBinFormatMachO()) {
-    this->Options.TrapUnreachable = true;
-    this->Options.NoTrapAfterNoreturn = true;
-  }
-
   // ARM supports the debug entry values.
   setSupportsDebugEntryValues(true);
 

llvm/lib/Target/BPF/BPFTargetMachine.cpp

@@ -34,6 +34,8 @@
 #include <optional>
 using namespace llvm;
 
+extern cl::opt<bool> EnableTrapUnreachable;
+
 static cl::
 opt<bool> DisableMIPeephole("disable-bpf-peephole", cl::Hidden,
                             cl::desc("Disable machine peepholes for BPF"));
@@ -74,6 +76,12 @@ BPFTargetMachine::BPFTargetMachine(const Target &T, const Triple &TT,
                         getEffectiveCodeModel(CM, CodeModel::Small), OL),
       TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
       Subtarget(TT, std::string(CPU), std::string(FS), *this) {
+  // FIXME: If the user has not explicitly enabled TrapUnreachable,
+  // disable it. We do not have an explicit trap opcode and external calls
+  // to abort are a no-no.
+  if (!EnableTrapUnreachable.getNumOccurrences())
+    this->Options.TrapUnreachable = false;
+
   initAsmInfo();
 
   BPFMCAsmInfo *MAI =

llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp

@@ -146,6 +146,8 @@ static cl::opt<bool> EnableInstSimplify("hexagon-instsimplify", cl::Hidden,
                                         cl::init(true),
                                         cl::desc("Enable instsimplify"));
 
+extern cl::opt<bool> EnableTrapUnreachable;
+
 /// HexagonTargetMachineModule - Note that this is used on hosts that
 /// cannot link in a library unless there are references into the
 /// library.  In particular, it seems that it is not possible to get
@@ -284,6 +286,11 @@ HexagonTargetMachine::HexagonTargetMachine(const Target &T, const Triple &TT,
           (HexagonNoOpt ? CodeGenOptLevel::None : OL)),
       TLOF(std::make_unique<HexagonTargetObjectFile>()),
       Subtarget(Triple(TT), CPU, FS, *this) {
+  // FIXME: If the user has not explicitly enabled TrapUnreachable,
+  // disable it. We currently seem to have problems with EH_RETURN lowering.
+  if (!EnableTrapUnreachable.getNumOccurrences())
+    this->Options.TrapUnreachable = false;
+
   initializeHexagonCopyHoistingPass(*PassRegistry::getPassRegistry());
   initializeHexagonExpandCondsetsPass(*PassRegistry::getPassRegistry());
   initializeHexagonLoopAlignPass(*PassRegistry::getPassRegistry());

llvm/lib/Target/X86/X86TargetMachine.cpp

@@ -242,10 +242,11 @@ X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
           OL),
       TLOF(createTLOF(getTargetTriple())), IsJIT(JIT) {
   // On PS4/PS5, the "return address" of a 'noreturn' call must still be within
-  // the calling function, and TrapUnreachable is an easy way to get that.
-  if (TT.isPS() || TT.isOSBinFormatMachO()) {
+  // the calling function, and unsetting NoTrapAfterNoreturn
+  // is an easy way to get that.
+  if (TT.isPS()) {
     this->Options.TrapUnreachable = true;
-    this->Options.NoTrapAfterNoreturn = TT.isOSBinFormatMachO();
+    this->Options.NoTrapAfterNoreturn = false;
   }
 
   setMachineOutliner(true);