[NVPTX] Emit .noreturn directive

[pavelkopyl]

• Fix typo in commit msg.

[tra]

LGTM. Thank you for the patch.

Just curious, does it buy us any measurable improvements?

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

342

Nit: The mismatch between assertion condition and the message looks a bit odd. Correct, but odd.

How about restructuring the code like this:

assert(isa<Function> || isa<CallInst> ...)
if (const CallInst *CallI = dyn_cast<CallInst>(V)) {
  return CallI->doesNotReturn() &&
             CallI->getFunctionType()->getReturnType()->isVoidTy();
} else {
  const Function *F = cast<Function>(V);
  return F->doesNotReturn() &&
         F->getFunctionType()->getReturnType()->isVoidTy() &&
         !isKernelFunction(*F);
}

[pavelkopyl]

In D140238#4002294, @tra wrote:

LGTM. Thank you for the patch.

Just curious, does it buy us any measurable improvements?

Actually, I haven't tried to measure perf improvements on real tests. Here I fully relay on PTX documentation. I hope this will be beneficial in some cases.

[pavelkopyl]

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

342

I agree, thank you. I moved the assert up. But I think I will be better to leave check for "cast<Function>" unconditional to avoid else-after-return.

[pavelkopyl]

• Added fixes according to review comments

[pavelkopyl]

• Rebased
• Added run of ptxas to the test

llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp

void NVPTXAsmPrinter::emitFunctionEntryLabel() {
 
   CurrentFnSym->print(O, MAI);
 
   emitFunctionParamList(*MF, O);
 
   if (isKernelFunction(*F))
     emitKernelFunctionDirectives(*F, O);
 
+  if (shouldEmitPTXNoReturn(F, TM))
+    O << ".noreturn";
+
   OutStreamer->emitRawText(O.str());
 
   VRegMapping.clear();
   // Emit open brace for function body.
   OutStreamer->emitRawText(StringRef("{\n"));
   setAndEmitFunctionVirtualRegisters(*MF);
   // Emit initial .loc debug directive for correct relocation symbol data.
   if (MMI && MMI->hasDebugInfo())
void NVPTXAsmPrinter::emitDeclaration(const Function *F, raw_ostream &O) {
   if (isKernelFunction(*F))
     O << ".entry ";
   else
     O << ".func ";
   printReturnValStr(F, O);
   getSymbol(F)->print(O, MAI);
   O << "\n";
   emitFunctionParamList(F, O);
+  if (shouldEmitPTXNoReturn(F, TM))
+    O << ".noreturn";
   O << ";\n";
 }
 
 static bool usedInGlobalVarDef(const Constant *C) {
   if (!C)
     return false;
 
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

for (unsigned i = 0, OIdx = 0; i != NumArgs; ++i, ++OIdx) {
     O << ".param .align " << ParamByValAlign.value() << " .b8 ";
     O << "_";
     O << "[" << Outs[OIdx].Flags.getByValSize() << "]";
   }
 
   if (VAInfo)
     O << (first ? "" : ",") << " .param .align " << VAInfo->second
       << " .b8 _[]\n";
-  O << ");";
+  O << ")";
+  if (shouldEmitPTXNoReturn(&CB, *nvTM))
+    O << " .noreturn";
+  O << ";";
 
   return Prototype;
 }
 
 Align NVPTXTargetLowering::getArgumentAlignment(SDValue Callee,
                                                 const CallBase *CB, Type *Ty,
                                                 unsigned Idx,
                                                 const DataLayout &DL) const {

llvm/lib/Target/NVPTX/NVPTXSubtarget.h

public:
   bool hasAtomBitwise64() const { return SmVersion >= 32; }
   bool hasAtomMinMax64() const { return SmVersion >= 32; }
   bool hasLDG() const { return SmVersion >= 32; }
   inline bool hasHWROT32() const { return SmVersion >= 32; }
   bool hasImageHandles() const;
   bool hasFP16Math() const { return SmVersion >= 53; }
   bool allowFP16Math() const;
   bool hasMaskOperator() const { return PTXVersion >= 71; }
+  bool hasNoReturn() const { return SmVersion >= 30 && PTXVersion >= 64; }
   unsigned int getSmVersion() const { return SmVersion; }
   std::string getTargetName() const { return TargetName; }
 
   // Get maximum value of required alignments among the supported data types.
   // From the PTX ISA doc, section 8.2.3:
   //  The memory consistency model relates operations executed on memory
   //  locations with scalar data-types, which have a maximum size and alignment
   //  of 64 bits. Memory operations with a vector data-type are modelled as a

llvm/lib/Target/NVPTX/NVPTXUtilities.h

 #include "llvm/IR/Value.h"
 #include <cstdarg>
 #include <set>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
+class TargetMachine;
+
 void clearAnnotationCache(const Module *);
 
 bool findOneNVVMAnnotation(const GlobalValue *, const std::string &,
                            unsigned &);
 bool findAllNVVMAnnotation(const GlobalValue *, const std::string &,
                            std::vector<unsigned> &);
 
 bool isTexture(const Value &);

 inline unsigned promoteScalarArgumentSize(unsigned size) {
   if (size <= 32)
     return 32;
   else if (size <= 64)
     return 64;
   else
     return size;
 }
+
+bool shouldEmitPTXNoReturn(const Value *V, const TargetMachine &TM);
 }
 
 #endif

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

 //===- NVPTXUtilities.cpp - Utility Functions -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains miscellaneous utility functions
 //
 //===----------------------------------------------------------------------===//
 
 #include "NVPTXUtilities.h"
 #include "NVPTX.h"
+#include "NVPTXTargetMachine.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/Mutex.h"
 #include <algorithm>
bool getAlign(const CallInst &I, unsigned index, unsigned &align) {
   }
   return false;
 }
 
 Function *getMaybeBitcastedCallee(const CallBase *CB) {
   return dyn_cast<Function>(CB->getCalledOperand()->stripPointerCasts());
 }
 
+bool shouldEmitPTXNoReturn(const Value *V, const TargetMachine &TM) {
+  const auto &ST =
+      *static_cast<const NVPTXTargetMachine &>(TM).getSubtargetImpl();
+  if (!ST.hasNoReturn())
+    return false;
+
+  assert((isa<Function>(V) || isa<CallInst>(V)) &&
+         "Expect either a call instruction or a function");
+
+  if (const CallInst *CallI = dyn_cast<CallInst>(V))
+    return CallI->doesNotReturn() &&
+           CallI->getFunctionType()->getReturnType()->isVoidTy();
+
+  const Function *F = cast<Function>(V);
+  return F->doesNotReturn() &&
+         F->getFunctionType()->getReturnType()->isVoidTy() &&
+         !isKernelFunction(*F);
+}
+
 } // namespace llvm

llvm/test/CodeGen/NVPTX/noreturn.ll

+; RUN: llc < %s -march=nvptx64 -mattr=+ptx64 -mcpu=sm_30 | FileCheck %s
+; RUN: %if ptxas %{llc < %s -march=nvptx64 -mattr=+ptx60 -mcpu=sm_30 | %ptxas-verify %}
+
+@function_pointer = addrspace(1) global void (i32)* null
+
+; CHECK: .func trap_wrapper
+; CHECK-NEXT: ()
+; CHECK-NEXT: .noreturn;
+
+declare void @trap_wrapper() #0
+
+; CHECK: .func {{.*}} non_void_noreturn()
+; CHECK-NOT: .noreturn
+
+define i32 @non_void_noreturn() #0 {
+  ret i32 54
+}
+
+; CHECK: .func true_noreturn0()
+; CHECK-NEXT: .noreturn
+
+define void @true_noreturn0() #0 {
+  call void @trap_wrapper()
+  ret void
+}
+
+; CHECK: .entry ignore_kernel_noreturn()
+; CHECK-NOT: .noreturn
+
+define void @ignore_kernel_noreturn() #0 {
+  unreachable
+}
+
+; CHECK-LABEL: .entry callprototype_noreturn(
+; CHECK: prototype_{{[0-9]+}} : .callprototype ()_ (.param .b32 _) .noreturn;
+; CHECK: prototype_{{[0-9]+}} : .callprototype (.param .b32 _) _ (.param .b32 _);
+
+define void @callprototype_noreturn(i32) {
+  %fn = load void (i32)*, void (i32)* addrspace(1)* @function_pointer
+  call void %fn(i32 %0) #0
+  %non_void = bitcast void (i32)* %fn to i32 (i32)*
+  %2 = call i32 %non_void(i32 %0) #0
+  ret void
+}
+
+attributes #0 = { noreturn }
+
+!nvvm.annotations = !{!0, !1}
+
+!0 = !{void ()* @ignore_kernel_noreturn, !"kernel", i32 1}
+!1 = !{void (i32)* @callprototype_noreturn, !"kernel", i32 1}