[Support] Remove LLVM_ATTRIBUTE_NORETURN

[gAlfonso-bit]

Summary

Code should use C++11 [[noreturn]] or C11 _Noreturn instead.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[mclow.lists]

I would like to see you undo all the formatting changes.
They are not germane for this patch, and (IMHO) reduce the readability of the code.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[mclow.lists]

In D106899#2908395, @gAlfonso-bit wrote:

Done!

Thank you. That's *much* easier to review.

[mclow.lists]

I am not an approver for LLVM, but this LGTM.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[MaskRay]

[[noreturn]] is C++11.
In Oct 2016, the minimum compiler requirement was raised to GCC 4.8/MSVC 2015.
We can use [[noreturn]] since then.

I migrated lld/. I will watch the build bots and migrate llvm/

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[MaskRay]

I migrated all llvm/ files. You need to remove them from the patch.

It is a good idea to drop the macro definition in llvm/include/llvm/Support/Compiler.h separately.

It makes it easy to bring back the definition if some important downstream users want extended time for migration.
(Note: the policy is that downstream is on their own. Our thinking of this is kindness, not an obligation of llvm-project.)
For example, swift is using LLVM_ATTRIBUTE_NORETURN.
(I researched a bit: LLVM_ATTRIBUTE_NORETURN is not common in downstream projects.)

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[MaskRay]

Drop llvm/include/llvm/Support/Compiler.h change.

[gAlfonso-bit]

Removed Compiler.h changes

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[MaskRay]

In D106899#2913925, @gAlfonso-bit wrote:

Still not passing (what is going on?)

If you click a harbomaster URI, sometimes the builds are good

x64 debian passed
x64 windows passed

and sometimes there may be failures apparently unrelated to your patch.
Some discretion is needed.

I ended up making the refactoring by myself. Your change included some whole-file clang-format formatting which wasn't suitable.
I usually run git diff -U0 --no-color 'HEAD^' | clang/tools/clang-format/clang-format-diff.py -i -p1 to only format related lines.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

clang-tools-extra/pp-trace/PPTrace.cpp

     cl::desc("Output trace to the given file name or '-' for stdout."),
     cl::cat(Cat));
 
-LLVM_ATTRIBUTE_NORETURN static void error(Twine Message) {
+[[noreturn]] static void error(Twine Message) {
   WithColor::error() << Message << '\n';
   exit(1);
 }

clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

     return It->second.Root;
   }
 
-  LLVM_ATTRIBUTE_NORETURN void PrintFatalError(llvm::Twine const &Msg) const {
+  [[noreturn]] void PrintFatalError(llvm::Twine const &Msg) const {
     assert(EvaluatingRecord && "not evaluating a record?");
     llvm::PrintFatalError(EvaluatingRecord->getLoc(), Msg);
   }

flang/include/flang/Optimizer/Support/FatalError.h

 
 /// Fatal error reporting helper. Report a fatal error with a source location
 /// and immediately abort flang.
-LLVM_ATTRIBUTE_NORETURN inline void emitFatalError(mlir::Location loc,
+[[noreturn]] inline void emitFatalError(mlir::Location loc,
                                                    const llvm::Twine &message) {
   mlir::emitError(loc, message);
   llvm::report_fatal_error("aborting");

lld/tools/lld/lld.cpp

   Wasm,      // -flavor wasm
 };
 
-[[noreturn]] static void die(const Twine &s) {
+[[noreturn]]d die(const Twine &s) {
   llvm::errs() << s << "\n";
   exit(1);
 }

lldb/source/Host/posix/ProcessLauncherPosixFork.cpp

 #endif
 }
 
-static void LLVM_ATTRIBUTE_NORETURN ExitWithError(int error_fd,
+static void [[noreturn]] ExitWithError(int error_fd,
                                                   const char *operation) {
   int err = errno;
   llvm::raw_fd_ostream os(error_fd, true);

   return;
 }
 
-static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
+static void [[noreturn]] ChildFunc(int error_fd,
                                               const ProcessLaunchInfo &info) {
   if (info.GetFlags().Test(eLaunchFlagLaunchInSeparateProcessGroup)) {
     if (setpgid(0, 0) != 0)

lldb/source/Plugins/Process/Linux/SingleStepCheck.cpp

 #if defined(__arm64__) || defined(__aarch64__)
 namespace {
 
-void LLVM_ATTRIBUTE_NORETURN Child() {
+void [[noreturn]] Child() {
   if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1)
     _exit(1);
 

llvm/include/llvm/MC/MCContext.h

     // Unrecoverable error has occurred. Display the best diagnostic we can
     // and bail via exit(1). For now, most MC backend errors are unrecoverable.
     // FIXME: We should really do something about that.
-    LLVM_ATTRIBUTE_NORETURN void reportFatalError(SMLoc L, const Twine &Msg);
+    [[noreturn]] void reportFatalError(SMLoc L, const Twine &Msg);
 
     const MCAsmMacro *lookupMacro(StringRef Name) {
       StringMap<MCAsmMacro>::iterator I = MacroMap.find(Name);

llvm/include/llvm/Support/Compiler.h

 #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
 #endif
 
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define LLVM_ATTRIBUTE_NORETURN
-#endif
-
 #if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
 #define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
 #elif defined(_MSC_VER)

llvm/include/llvm/Support/CrashRecoveryContext.h

 
   /// Explicitly trigger a crash recovery in the current process, and
   /// return failure from RunSafely(). This function does not return.
-  LLVM_ATTRIBUTE_NORETURN
+  [[noreturn]]
   void HandleExit(int RetCode);
 
   /// Throw again a signal or an exception, after it was catched once by a

llvm/include/llvm/Support/Error.h

   // of debug prints can cause the function to be too large for inlining.  So
   // it's important that we define this function out of line so that it can't be
   // inlined.
-  LLVM_ATTRIBUTE_NORETURN
+  [[noreturn]]
   void fatalUncheckedError() const;
 #endif
 

   }
 
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-  LLVM_ATTRIBUTE_NORETURN
+  [[noreturn]]
   LLVM_ATTRIBUTE_NOINLINE
   void fatalUncheckedExpected() const {
     dbgs() << "Expected<T> must be checked before access or destruction.\n";

 
 /// Report a serious error, calling any installed error handler. See
 /// ErrorHandling.h.
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err,
+[[noreturn]] void report_fatal_error(Error Err,
                                                 bool gen_crash_diag = true);
 
 /// Report a fatal error if Err is a failure value.

llvm/include/llvm/Support/ErrorHandling.h

 /// standard error, followed by a newline.
 /// After the error handler is called this function will call abort(), it
 /// does not return.
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason,
+[[noreturn]] void report_fatal_error(const char *reason,
                                                 bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const std::string &reason,
+[[noreturn]] void report_fatal_error(const std::string &reason,
                                                 bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(StringRef reason,
+[[noreturn]] void report_fatal_error(StringRef reason,
                                                 bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const Twine &reason,
+[[noreturn]] void report_fatal_error(const Twine &reason,
                                                 bool gen_crash_diag = true);
 
 /// Installs a new bad alloc error handler that should be used whenever a

 /// If no error handler is installed (default), throws a bad_alloc exception
 /// if LLVM is compiled with exception support. Otherwise prints the error
 /// to standard error and calls abort().
-LLVM_ATTRIBUTE_NORETURN void report_bad_alloc_error(const char *Reason,
+[[noreturn]] void report_bad_alloc_error(const char *Reason,
                                                     bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the llvm_unreachable macro (that adds location info), instead of
 /// calling this function directly.
-LLVM_ATTRIBUTE_NORETURN void
+[[noreturn]] void
 llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 }

llvm/include/llvm/Support/Process.h

   /// In that case, the control flow will resume after RunSafely(), like for a
   /// crash, rather than exiting the current process.
   /// Use \arg NoCleanup for calling _exit() instead of exit().
-  LLVM_ATTRIBUTE_NORETURN
+  [[noreturn]]
   static void Exit(int RetCode, bool NoCleanup = false);
 
 private:
-  LLVM_ATTRIBUTE_NORETURN
+  [[noreturn]]
   static void ExitNoCleanup(int RetCode);
 };
 

llvm/include/llvm/Support/Windows/WindowsSupport.h

 bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix);
 
 // Include GetLastError() in a fatal error message.
-LLVM_ATTRIBUTE_NORETURN inline void ReportLastErrorFatal(const char *Msg) {
+[[noreturn]] inline void ReportLastErrorFatal(const char *Msg) {
   std::string ErrMsg;
   MakeErrMsg(&ErrMsg, Msg);
   llvm::report_fatal_error(ErrMsg);

llvm/include/llvm/TableGen/Error.h

 void PrintNote(const Twine &Msg);
 void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg);
 
-LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(ArrayRef<SMLoc> ErrorLoc,
+[[noreturn]] void PrintFatalNote(const Twine &Msg);
+[[noreturn]] void PrintFatalNote(ArrayRef<SMLoc> ErrorLoc,
                                             const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Record *Rec,
+[[noreturn]] void PrintFatalNote(const Record *Rec,
                                             const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const RecordVal *RecVal,
+[[noreturn]] void PrintFatalNote(const RecordVal *RecVal,
                                             const Twine &Msg);
 
 void PrintWarning(const Twine &Msg);

 void PrintError(const Record *Rec, const Twine &Msg);
 void PrintError(const RecordVal *RecVal, const Twine &Msg);
 
-LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
+[[noreturn]] void PrintFatalError(const Twine &Msg);
+[[noreturn]] void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
                                              const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Record *Rec,
+[[noreturn]] void PrintFatalError(const Record *Rec,
                                              const Twine &Msg);
-LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const RecordVal *RecVal,
+[[noreturn]] void PrintFatalError(const RecordVal *RecVal,
                                              const Twine &Msg);
 
 void CheckAssert(SMLoc Loc, Init *Condition, Init *Message);

llvm/lib/LTO/LTOBackend.cpp

     cl::desc("Assume the input has already undergone ThinLTO function "
              "importing and the other pre-optimization pipeline changes."));
 
-LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
+[[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
   exit(1);

llvm/lib/Support/CrashRecoveryContext.cpp

 
 #endif // !_MSC_VER
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 void CrashRecoveryContext::HandleExit(int RetCode) {
 #if defined(_WIN32)
   // SEH and VEH

llvm/lib/Support/Process.cpp

 
 bool Process::AreCoreFilesPrevented() { return coreFilesPrevented; }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 void Process::Exit(int RetCode, bool NoCleanup) {
   if (CrashRecoveryContext *CRC = CrashRecoveryContext::GetCurrent())
     CRC->HandleExit(RetCode);

llvm/lib/Support/SmallVector.cpp

 
 /// Report that MinSize doesn't fit into this vector's size type. Throws
 /// std::length_error or calls report_fatal_error.
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void report_size_overflow(size_t MinSize, size_t MaxSize);
 static void report_size_overflow(size_t MinSize, size_t MaxSize) {
   std::string Reason = "SmallVector unable to grow. Requested capacity (" +

 
 /// Report that this vector is already at maximum capacity. Throws
 /// std::length_error or calls report_fatal_error.
-LLVM_ATTRIBUTE_NORETURN static void report_at_maximum_capacity(size_t MaxSize);
+[[noreturn]] static void report_at_maximum_capacity(size_t MaxSize);
 static void report_at_maximum_capacity(size_t MaxSize) {
   std::string Reason =
       "SmallVector capacity unable to grow. Already at maximum size " +

llvm/lib/Support/Unix/Process.inc

 #endif
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 void Process::ExitNoCleanup(int RetCode) { _Exit(RetCode); }

llvm/lib/Support/Unix/Unix.h

 }
 
 // Include StrError(errnum) in a fatal error message.
-LLVM_ATTRIBUTE_NORETURN static inline void ReportErrnumFatal(const char *Msg,
+[[noreturn]] static inline void ReportErrnumFatal(const char *Msg,
                                                              int errnum) {
   std::string ErrMsg;
   MakeErrMsg(&ErrMsg, Msg, errnum);

llvm/lib/Support/Windows/Process.inc

   return GetWindowsOSVersion() >= llvm::VersionTuple(6, 2, 0, 0);
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 void Process::ExitNoCleanup(int RetCode) {
   TerminateProcess(GetCurrentProcess(), RetCode);
   llvm_unreachable("TerminateProcess doesn't return");

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp

   ++MCNumEmitted;
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void raise_relocation_error(unsigned Width, unsigned Kind) {
   std::string Text;
   raw_string_ostream Stream(Text);

llvm/lib/Transforms/Coroutines/Coroutines.cpp

   llvm_unreachable("Unknown coro::ABI enum");
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void fail(const Instruction *I, const char *Reason, Value *V) {
 #ifndef NDEBUG
   I->dump();

llvm/tools/llc/llc.cpp

 
 static int compileModule(char **, LLVMContext &);
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(Twine Msg,
+[[noreturn]] static void reportError(Twine Msg,
                                                 StringRef Filename = "") {
   SmallString<256> Prefix;
   if (!Filename.empty()) {

   exit(1);
 }
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(Error Err, StringRef Filename) {
+[[noreturn]] static void reportError(Error Err, StringRef Filename) {
   assert(Err);
   handleAllErrors(createFileError(Filename, std::move(Err)),
                   [&](const ErrorInfoBase &EI) { reportError(EI.message()); });

llvm/tools/lli/lli.cpp

   llvm_unreachable("Unrecognized opt level.");
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void reportError(SMDiagnostic Err, const char *ProgName) {
   Err.print(ProgName, errs());
   exit(1);

llvm/tools/llvm-ar/llvm-ar.cpp

 static bool ParsingMRIScript;
 
 // Show the error plus the usage message, and exit.
-LLVM_ATTRIBUTE_NORETURN static void badUsage(Twine Error) {
+[[noreturn]] static void badUsage(Twine Error) {
   WithColor::error(errs(), ToolName) << Error << "\n";
   printHelpMessage();
   exit(1);
 }
 
 // Show the error message and exit.
-LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) {
+[[noreturn]] static void fail(Twine Error) {
   if (ParsingMRIScript) {
     WithColor::error(errs(), ToolName)
         << "script line " << MRILineNumber << ": " << Error << "\n";

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

 };
 }
 
-static LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
+[[noreturn]] static void reportError(Twine Msg) {
   errs() << Msg;
   exit(1);
 }

llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp

   exit(1);
 }
 
-LLVM_ATTRIBUTE_NORETURN static void error(Error Err) {
+[[noreturn]] static void error(Error Err) {
   logAllUnhandledErrors(std::move(Err), WithColor::error(outs()),
                         "reading file: ");
   outs().flush();

llvm/tools/llvm-ifs/ErrorCollector.h

   bool allErrorsHandled() const;
 
   /// Dump output and crash.
-  LLVM_ATTRIBUTE_NORETURN void fatalUnhandledError();
+  [[noreturn]] void fatalUnhandledError();
 
   bool ErrorsAreFatal;
   std::vector<Error> Errors;

llvm/tools/llvm-ifs/ErrorCollector.cpp

   }
 }
 
-LLVM_ATTRIBUTE_NORETURN void ErrorCollector::fatalUnhandledError() {
+[[noreturn]] void ErrorCollector::fatalUnhandledError() {
   errs() << "Program aborted due to unhandled Error(s):\n";
   log(errs());
   errs() << "\n";

llvm/tools/llvm-lipo/llvm-lipo.cpp

 static const StringRef ToolName = "llvm-lipo";
 static LLVMContext LLVMCtx;
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(Twine Message) {
+[[noreturn]] static void reportError(Twine Message) {
   WithColor::error(errs(), ToolName) << Message << "\n";
   errs().flush();
   exit(EXIT_FAILURE);
 }
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(Error E) {
+[[noreturn]] static void reportError(Error E) {
   assert(E);
   std::string Buf;
   raw_string_ostream OS(Buf);

   reportError(Buf);
 }
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(StringRef File, Error E) {
+[[noreturn]] static void reportError(StringRef File, Error E) {
   assert(E);
   std::string Buf;
   raw_string_ostream OS(Buf);

   return InputBinaries;
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void verifyArch(ArrayRef<OwningBinary<Binary>> InputBinaries,
                        ArrayRef<std::string> VerifyArchList) {
   assert(!VerifyArchList.empty() &&

   OS << SliceOrErr->getArchString() << " \n";
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void printArchs(ArrayRef<OwningBinary<Binary>> InputBinaries) {
   assert(InputBinaries.size() == 1 && "Incorrect number of input binaries");
   printBinaryArchs(InputBinaries.front().getBinary(), outs());
   exit(EXIT_SUCCESS);
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void printInfo(ArrayRef<OwningBinary<Binary>> InputBinaries) {
   // Group universal and thin files together for compatibility with cctools lipo
   for (auto &IB : InputBinaries) {

   exit(EXIT_SUCCESS);
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void thinSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
                       StringRef ArchType, StringRef OutputFileName) {
   assert(!ArchType.empty() && "The architecture type should be non-empty");

   return Slices;
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void createUniversalBinary(ArrayRef<OwningBinary<Binary>> InputBinaries,
                                   const StringMap<const uint32_t> &Alignments,
                                   StringRef OutputFileName) {

   exit(EXIT_SUCCESS);
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
                          const StringMap<const uint32_t> &Alignments,
                          StringRef ArchType, StringRef OutputFileName) {

   return Slices;
 }
 
-LLVM_ATTRIBUTE_NORETURN
+[[noreturn]]
 static void replaceSlices(ArrayRef<OwningBinary<Binary>> InputBinaries,
                           const StringMap<const uint32_t> &Alignments,
                           StringRef OutputFileName,

llvm/tools/llvm-mt/llvm-mt.cpp

 };
 } // namespace
 
-LLVM_ATTRIBUTE_NORETURN static void reportError(Twine Msg) {
+[[noreturn]] static void reportError(Twine Msg) {
   WithColor::error(errs(), "llvm-mt") << Msg << '\n';
   exit(1);
 }

llvm/tools/llvm-objdump/llvm-objdump.h

 void printSymbol(const object::ObjectFile *O, const object::SymbolRef &Symbol,
                  StringRef FileName, StringRef ArchiveName,
                  StringRef ArchitectureName, bool DumpDynamic);
-LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, const Twine &Message);
-LLVM_ATTRIBUTE_NORETURN void reportError(Error E, StringRef FileName,
+[[noreturn]] void reportError(StringRef File, const Twine &Message);
+[[noreturn]] void reportError(Error E, StringRef FileName,
                                          StringRef ArchiveName = "",
                                          StringRef ArchitectureName = "");
 void reportWarning(const Twine &Message, StringRef File);

llvm/tools/llvm-objdump/llvm-objdump.cpp

       << "'" << File << "': " << Message << "\n";
 }
 
-LLVM_ATTRIBUTE_NORETURN void objdump::reportError(StringRef File,
+[[noreturn]] void objdump::reportError(StringRef File,
                                                   const Twine &Message) {
   outs().flush();
   WithColor::error(errs(), ToolName) << "'" << File << "': " << Message << "\n";
   exit(1);
 }
 
-LLVM_ATTRIBUTE_NORETURN void objdump::reportError(Error E, StringRef FileName,
+[[noreturn]] void objdump::reportError(Error E, StringRef FileName,
                                                   StringRef ArchiveName,
                                                   StringRef ArchitectureName) {
   assert(E);

   WithColor::warning(errs(), ToolName) << Message << "\n";
 }
 
-LLVM_ATTRIBUTE_NORETURN static void reportCmdLineError(const Twine &Message) {
+[[noreturn]] static void reportCmdLineError(const Twine &Message) {
   WithColor::error(errs(), ToolName) << Message << "\n";
   exit(1);
 }

llvm/tools/llvm-profgen/ErrorHandling.h

 
 using namespace llvm;
 
-LLVM_ATTRIBUTE_NORETURN inline void
+[[noreturn]] inline void
 exitWithError(const Twine &Message, StringRef Whence = StringRef(),
               StringRef Hint = StringRef()) {
   WithColor::error(errs(), "llvm-profgen");

   ::exit(EXIT_FAILURE);
 }
 
-LLVM_ATTRIBUTE_NORETURN inline void
+[[noreturn]] inline void
 exitWithError(std::error_code EC, StringRef Whence = StringRef()) {
   exitWithError(EC.message(), Whence);
 }
 
-LLVM_ATTRIBUTE_NORETURN inline void exitWithError(Error E, StringRef Whence) {
+[[noreturn]] inline void exitWithError(Error E, StringRef Whence) {
   exitWithError(errorToErrorCode(std::move(E)), Whence);
 }
 

llvm/tools/llvm-rc/llvm-rc.cpp

 static FileRemover TempPreprocFile;
 static FileRemover TempResFile;
 
-LLVM_ATTRIBUTE_NORETURN static void fatalError(const Twine &Message) {
+[[noreturn]] static void fatalError(const Twine &Message) {
   errs() << Message << "\n";
   exit(1);
 }

llvm/tools/llvm-readobj/llvm-readobj.h

   }
 
   // Various helper functions.
-  LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input); 
+  [[noreturn]] void reportError(Error Err, StringRef Input); 
   void reportWarning(Error Err, StringRef Input);
 
   template <class T> T unwrapOrError(StringRef Input, Expected<T> EO) {

llvm/tools/llvm-readobj/llvm-readobj.cpp

 
 namespace llvm {
 
-LLVM_ATTRIBUTE_NORETURN static void error(Twine Msg) {
+[[noreturn]] static void error(Twine Msg) {
   // Flush the standard output to print the error at a
   // proper place.
   fouts().flush();

   exit(1);
 }
 
-LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input) {
+[[noreturn]] void reportError(Error Err, StringRef Input) {
   assert(Err);
   if (Input == "-")
     Input = "<stdin>";

llvm/tools/llvm-strings/llvm-strings.cpp

 enum radix { none, octal, hexadecimal, decimal };
 static radix Radix;
 
-LLVM_ATTRIBUTE_NORETURN static void reportCmdLineError(const Twine &Message) {
+[[noreturn]] static void reportCmdLineError(const Twine &Message) {
   WithColor::error(errs(), ToolName) << Message << "\n";
   exit(1);
 }

llvm/tools/split-file/split-file.cpp

 static StringRef toolName;
 static int errorCount;
 
-LLVM_ATTRIBUTE_NORETURN static void fatal(StringRef filename,
+[[noreturn]] static void fatal(StringRef filename,
                                           const Twine &message) {
   if (filename.empty())
     WithColor::error(errs(), toolName) << message << '\n';