lld: CHECK->LLD_CHECK to reduce chance of conflict with other libraries

[dblaikie]

Summary

(specifically this conflicts with absl's CHECK and Halide depends on
both lld and Halide, so runs into this conflict)

[thakis]

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

Could halide undef this macro after including the lld header and before including absl headers instead?

[dblaikie]

In D140726#4018459, @thakis wrote:

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

I don't think Halide's doing something wrong here - it's including lld/Common/Driver.h which states:

// Generic entry point when using LLD as a library, safe for re-entry, supports
// crash recovery.

And that includes lld/Common/CommonLinkerContext.h which includes lld/Common/ErrorHandler.h

Could halide undef this macro after including the lld header and before including absl headers instead?

Perhaps? I guess alternatively lld/Common/Driver.h could undef it at the end, but including any other lld header would risk breakage (since they might expect the macro to still be defined) - would probably make implementing that header tricky - needing to redefine that macro back again in the implementation file, etc.

[chandlerc]

In D140726#4018463, @dblaikie wrote:

In D140726#4018459, @thakis wrote:

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

I don't think Halide's doing something wrong here - it's including lld/Common/Driver.h which states:

// Generic entry point when using LLD as a library, safe for re-entry, supports
// crash recovery.

And that includes lld/Common/CommonLinkerContext.h which includes lld/Common/ErrorHandler.h

Could halide undef this macro after including the lld header and before including absl headers instead?

Perhaps? I guess alternatively lld/Common/Driver.h could undef it at the end, but including any other lld header would risk breakage (since they might expect the macro to still be defined) - would probably make implementing that header tricky - needing to redefine that macro back again in the implementation file, etc.

Not sure this would help. If the colliding header were included *before* LLD's, this would still break.

I don't think it's realistic for any code that intends to be usable as a library with other code to be defining an un-prefixed macro. (That goes for *both* of the colliding cases here to be clear, not just LLD.) Not sure why this would be controversial.

[dblaikie]

In D140726#4018580, @chandlerc wrote:

In D140726#4018463, @dblaikie wrote:

In D140726#4018459, @thakis wrote:

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

I don't think Halide's doing something wrong here - it's including lld/Common/Driver.h which states:

// Generic entry point when using LLD as a library, safe for re-entry, supports
// crash recovery.

And that includes lld/Common/CommonLinkerContext.h which includes lld/Common/ErrorHandler.h

Could halide undef this macro after including the lld header and before including absl headers instead?

Perhaps? I guess alternatively lld/Common/Driver.h could undef it at the end, but including any other lld header would risk breakage (since they might expect the macro to still be defined) - would probably make implementing that header tricky - needing to redefine that macro back again in the implementation file, etc.

Not sure this would help. If the colliding header were included *before* LLD's, this would still break.

Ah, yeah, fair point.

I don't think it's realistic for any code that intends to be usable as a library with other code to be defining an un-prefixed macro. (That goes for *both* of the colliding cases here to be clear, not just LLD.) Not sure why this would be controversial.

Yeah - guess there's minimal chance of ABSL fixing theirs given the wide usage, at least inside Google? (then again, wide scale changes are a thing) - not that that would remove the value in fixing LLD too.

[MaskRay]

In D140726#4018459, @thakis wrote:

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

Could halide undef this macro after including the lld header and before including absl headers instead?

I think the only header user code can include is include/lld/Common/Driver.h (for lld::elf::link, etc). Others are just a problem of how llvm-project generally organizes header files: if a file happens to be shared by more than one component, it is typically moved to include/XXX, regardless whether it is intended to be used as library code.

In this case include/lld/Common/Driver.h transitively included include/lld/Common/ErrorHandler.h which defines CHECK.
This is a problem of the incomplete global state removal for Common 83d59e05b201760e3f364ff6316301d347cbad95.
I just fixed it in 6b9a80de4906c79101af3b1cadcb3ef1edc62fbc and avoided CHECK macros for user code including include/lld/Common/Driver.h .

[dblaikie]

In D140726#4018638, @MaskRay wrote:

In D140726#4018459, @thakis wrote:

This is only used in lld cpp files, and lld's header files aren't meant to be used outside it. So halide is doing something unsupported.

Could halide undef this macro after including the lld header and before including absl headers instead?

I think the only header user code can include is include/lld/Common/Driver.h (for lld::elf::link, etc). Others are just a problem of how llvm-project generally organizes header files: if a file happens to be shared by more than one component, it is typically moved to include/XXX, regardless whether it is intended to be used as library code.

In this case include/lld/Common/Driver.h transitively included include/lld/Common/ErrorHandler.h which defines CHECK.
This is a problem of the incomplete global state removal for Common 83d59e05b201760e3f364ff6316301d347cbad95.
I just fixed it in 6b9a80de4906c79101af3b1cadcb3ef1edc62fbc and avoided CHECK macros for user code including include/lld/Common/Driver.h .

Fair enough - thanks for that!

As much as I'd like lld to move more towards compatibility for more fine grained library use, I guess that's as much as we'll do today.

lld/COFF/Driver.cpp

void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
 
   // File type is detected by contents, not by file extension.
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::windows_resource:
     resources.push_back(mbref);
     break;
   case file_magic::archive:
     if (wholeArchive) {
-      std::unique_ptr<Archive> file =
-          CHECK(Archive::create(mbref), filename + ": failed to parse archive");
+      std::unique_ptr<Archive> file = LLD_CHECK(
+          Archive::create(mbref), filename + ": failed to parse archive");
       Archive *archive = file.get();
       make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
 
       int memberIndex = 0;
       for (MemoryBufferRef m : getArchiveMembers(archive))
         addArchiveBuffer(m, "<whole-archive>", filename, memberIndex++);
       return;
     }
if (!c.getParent()->isThin()) {
     MemoryBufferRef mb = mbOrErr.get();
     enqueueTask([=]() {
       driver->addArchiveBuffer(mb, toCOFFString(sym), parentName,
                                offsetInArchive);
     });
     return;
   }
 
-  std::string childName = CHECK(
-      c.getFullName(),
+  std::string childName =
+      LLD_CHECK(c.getFullName(),
                 "could not get the filename for the member defining symbol " +
                     toCOFFString(sym));
   auto future = std::make_shared<std::future<MBErrPair>>(
       createFutureForFile(childName));
   enqueueTask([=]() {
     auto mbOrErr = future->get();
     if (mbOrErr.second)
       reportBufferError(errorCodeToError(mbOrErr.second), childName);
     // Pass empty string as archive name so that the original filename is
     // used as the buffer identifier.
if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
     checkError(errorCodeToError(sys::fs::rename(tmpName, path)));
   } else {
     sys::fs::remove(tmpName);
   }
 }
 
 static void parseModuleDefs(StringRef path) {
   std::unique_ptr<MemoryBuffer> mb =
-      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+      LLD_CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                       /*RequiresNullTerminator=*/false,
                                       /*IsVolatile=*/true),
                 "could not open " + path);
   COFFModuleDefinition m = check(parseCOFFModuleDefinition(
       mb->getMemBufferRef(), config->machine, config->mingw));
 
   // Include in /reproduce: output if applicable.
   driver->takeBuffer(std::move(mb));
 
   if (config->outputFile.empty())
     config->outputFile = std::string(saver().save(m.OutputFile));
static void parseOrderFile(COFFLinkerContext &ctx, StringRef arg) {
   for (Chunk *c : ctx.symtab.getChunks())
     if (auto *sec = dyn_cast<SectionChunk>(c))
       if (sec->sym)
         set.insert(sec->sym->getName());
 
   // Open a file.
   StringRef path = arg.substr(1);
   std::unique_ptr<MemoryBuffer> mb =
-      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+      LLD_CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                       /*RequiresNullTerminator=*/false,
                                       /*IsVolatile=*/true),
                 "could not open " + path);
 
   // Parse a file. An order file contains one symbol per line.
   // All symbols that were not present in a given order file are
   // considered to have the lowest priority 0 and are placed at
   // end of an output section.
   for (StringRef arg : args::getLines(mb->getMemBufferRef())) {
     std::string s(arg);
     if (config->machine == I386 && !isDecorated(s))
       s = "_" + s;
 
     if (set.count(s) == 0) {
       if (config->warnMissingOrderSymbol)
         warn("/order:" + arg + ": missing symbol: " + s + " [LNK4037]");
     }
     else
       config->order[s] = INT_MIN + config->order.size();
   }
 
   // Include in /reproduce: output if applicable.
   driver->takeBuffer(std::move(mb));
 }
 
 static void parseCallGraphFile(COFFLinkerContext &ctx, StringRef path) {
   std::unique_ptr<MemoryBuffer> mb =
-      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+      LLD_CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                       /*RequiresNullTerminator=*/false,
                                       /*IsVolatile=*/true),
                 "could not open " + path);
 
   // Build a map from symbol name to section.
   DenseMap<StringRef, Symbol *> map;
   for (ObjFile *file : ctx.objFileInstances)
     for (Symbol *sym : file->getSymbols())
       if (sym)
         map[sym->getName()] = sym;
 
if (args.hasArg(OPT_kill_at))
     config->killAt = true;
 
   // Handle /lldltocache
   if (auto *arg = args.getLastArg(OPT_lldltocache))
     config->ltoCache = arg->getValue();
 
   // Handle /lldsavecachepolicy
   if (auto *arg = args.getLastArg(OPT_lldltocachepolicy))
-    config->ltoCachePolicy = CHECK(
+    config->ltoCachePolicy = LLD_CHECK(
         parseCachePruningPolicy(arg->getValue()),
         Twine("/lldltocachepolicy: invalid cache policy: ") + arg->getValue());
 
   // Handle /failifmismatch
   for (auto *arg : args.filtered(OPT_failifmismatch))
     checkFailIfMismatch(arg->getValue(), nullptr);
 
   // Handle /merge

lld/COFF/DriverUtils.cpp

public:
   }
 
   // Returns a memory buffer of this temporary file.
   // Note that this function does not leave the file open,
   // so it is safe to remove the file immediately after this function
   // is called (you cannot remove an opened file on Windows.)
   std::unique_ptr<MemoryBuffer> getMemoryBuffer() {
     // IsVolatile=true forces MemoryBuffer to not use mmap().
-    return CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+    return LLD_CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                            /*RequiresNullTerminator=*/false,
                                            /*IsVolatile=*/true),
                      "could not open " + path);
   }
 
   std::string path;
 };
 }
 
 static std::string createDefaultXml() {
   std::string ret;
if (driver->tar)
       if (auto mbOrErr = MemoryBuffer::getFile(filename))
         driver->takeBuffer(std::move(*mbOrErr));
   }
   e.add("/nologo");
   e.add("/out:" + StringRef(user.path));
   e.run();
 
   return std::string(
-      CHECK(MemoryBuffer::getFile(user.path), "could not open " + user.path)
+      LLD_CHECK(MemoryBuffer::getFile(user.path), "could not open " + user.path)
           .get()
           ->getBuffer());
 }
 
 static std::string createManifestXml() {
   std::string defaultXml = createDefaultXml();
   if (config->manifestInput.empty())
     return defaultXml;

lld/COFF/InputFiles.cpp

static bool ignoredSymbolName(StringRef name) {
   return name == "@feat.00" || name == "@comp.id";
 }
 
 ArchiveFile::ArchiveFile(COFFLinkerContext &ctx, MemoryBufferRef m)
     : InputFile(ctx, ArchiveKind, m) {}
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
-  file = CHECK(Archive::create(mb), this);
+  file = LLD_CHECK(Archive::create(mb), this);
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &sym : file->symbols())
     ctx.symtab.addLazyArchive(this, sym);
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 void ArchiveFile::addMember(const Archive::Symbol &sym) {
   const Archive::Child &c =
-      CHECK(sym.getMember(),
+      LLD_CHECK(sym.getMember(),
                 "could not get the member for symbol " + toCOFFString(sym));
 
   // Return an empty buffer if we have already returned the same buffer.
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
   driver->enqueueArchiveMember(c, sym, getName());
 }
 
 std::vector<MemoryBufferRef> lld::coff::getArchiveMembers(Archive *file) {
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
-        CHECK(c.getMemoryBufferRef(),
+        LLD_CHECK(c.getMemoryBufferRef(),
                   file->getFileName() +
                       ": could not get the buffer for a child of the archive");
     v.push_back(mbref);
   }
   if (err)
     fatal(file->getFileName() +
           ": Archive::children failed: " + toString(std::move(err)));
   return v;
 }
 
 void ObjFile::parseLazy() {
   // Native object file.
-  std::unique_ptr<Binary> coffObjPtr = CHECK(createBinary(mb), this);
+  std::unique_ptr<Binary> coffObjPtr = LLD_CHECK(createBinary(mb), this);
   COFFObjectFile *coffObj = cast<COFFObjectFile>(coffObjPtr.get());
   uint32_t numSymbols = coffObj->getNumberOfSymbols();
   for (uint32_t i = 0; i < numSymbols; ++i) {
     COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
     if (coffSym.isUndefined() || !coffSym.isExternal() ||
         coffSym.isWeakExternal())
       continue;
     StringRef name = check(coffObj->getSymbolName(coffSym));
     if (coffSym.isAbsolute() && ignoredSymbolName(name))
       continue;
     ctx.symtab.addLazyObject(this, name);
     i += coffSym.getNumberOfAuxSymbols();
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a COFF file.
-  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
+  std::unique_ptr<Binary> bin = LLD_CHECK(createBinary(mb), this);
 
   if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
     bin.release();
     coffObj.reset(obj);
   } else {
     fatal(toString(this) + " is not a COFF file");
   }
 
std::string lld::coff::replaceThinLTOSuffix(StringRef path) {
 
   if (path.consume_back(suffix))
     return (path + repl).str();
   return std::string(path);
 }
 
 static bool isRVACode(COFFObjectFile *coffObj, uint64_t rva, InputFile *file) {
   for (size_t i = 1, e = coffObj->getNumberOfSections(); i <= e; i++) {
-    const coff_section *sec = CHECK(coffObj->getSection(i), file);
+    const coff_section *sec = LLD_CHECK(coffObj->getSection(i), file);
     if (rva >= sec->VirtualAddress &&
         rva <= sec->VirtualAddress + sec->VirtualSize) {
       return (sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE) != 0;
     }
   }
   return false;
 }
 
 void DLLFile::parse() {
   // Parse a memory buffer as a PE-COFF executable.
-  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
+  std::unique_ptr<Binary> bin = LLD_CHECK(createBinary(mb), this);
 
   if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
     bin.release();
     coffObj.reset(obj);
   } else {
     error(toString(this) + " is not a COFF file");
     return;
   }

lld/COFF/Symbols.cpp

Defined *Undefined::getWeakAlias() {
   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)
     if (auto *d = dyn_cast<Defined>(a))
       return d;
   return nullptr;
 }
 
 MemoryBufferRef LazyArchive::getMemberBuffer() {
   Archive::Child c =
-    CHECK(sym.getMember(),
+      LLD_CHECK(sym.getMember(),
                 "could not get the member for symbol " + toCOFFString(sym));
-  return CHECK(c.getMemoryBufferRef(),
+  return LLD_CHECK(c.getMemoryBufferRef(),
                    "could not get the buffer for the member defining symbol " +
                        toCOFFString(sym));
 }
 } // namespace coff
 } // namespace lld

lld/COFF/Writer.cpp

template <typename PEHeaderTy> void Writer::writeHeader() {
   // The first 4 bytes is length including itself.
   buf = reinterpret_cast<uint8_t *>(&symbolTable[numberOfSymbols]);
   write32le(buf, strtab.size() + 4);
   if (!strtab.empty())
     memcpy(buf + 4, strtab.data(), strtab.size());
 }
 
 void Writer::openFile(StringRef path) {
-  buffer = CHECK(
+  buffer = LLD_CHECK(
       FileOutputBuffer::create(path, fileSize, FileOutputBuffer::F_executable),
       "failed to open " + path);
 }
 
 void Writer::createSEHTable() {
   SymbolRVASet handlers;
   for (ObjFile *file : ctx.objFileInstances) {
     if (!file->hasSafeSEH())

lld/ELF/Driver.cpp

static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef emul) {
   return std::make_tuple(ret.first, ret.second, osabi);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
     MemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
-      CHECK(Archive::create(mb),
+      LLD_CHECK(Archive::create(mb),
                 mb.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<std::pair<MemoryBufferRef, uint64_t>> v;
   Error err = Error::success();
   bool addToTar = file->isThin() && tar;
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
-        CHECK(c.getMemoryBufferRef(),
+        LLD_CHECK(c.getMemoryBufferRef(),
                   mb.getBufferIdentifier() +
                       ": could not get the buffer for a child of the archive");
     if (addToTar)
       tar->append(relativeToRoot(check(c.getFullName())), mbref.getBuffer());
     v.push_back(std::make_pair(mbref, c.getChildOffset()));
   }
   if (err)
     fatal(mb.getBufferIdentifier() + ": Archive::children failed: " +
           toString(std::move(err)));
 
processCallGraphRelocations(SmallVector<uint32_t, 32> &symbolIndices,
   cgProfile =
       check(obj.template getSectionContentsAsArray<typename ELFT::CGProfile>(
           objSections[inputObj->cgProfileSectionIndex]));
 
   for (size_t i = 0, e = objSections.size(); i < e; ++i) {
     const Elf_Shdr_Impl<ELFT> &sec = objSections[i];
     if (sec.sh_info == inputObj->cgProfileSectionIndex) {
       if (sec.sh_type == SHT_RELA) {
-        ArrayRef<typename ELFT::Rela> relas =
-            CHECK(obj.relas(sec), "could not retrieve cg profile rela section");
+        ArrayRef<typename ELFT::Rela> relas = LLD_CHECK(
+            obj.relas(sec), "could not retrieve cg profile rela section");
         for (const typename ELFT::Rela &rel : relas)
           symbolIndices.push_back(rel.getSymbol(config->isMips64EL));
         break;
       }
       if (sec.sh_type == SHT_REL) {
-        ArrayRef<typename ELFT::Rel> rels =
-            CHECK(obj.rels(sec), "could not retrieve cg profile rel section");
+        ArrayRef<typename ELFT::Rel> rels = LLD_CHECK(
+            obj.rels(sec), "could not retrieve cg profile rel section");
         for (const typename ELFT::Rel &rel : rels)
           symbolIndices.push_back(rel.getSymbol(config->isMips64EL));
         break;
       }
     }
   }
   if (symbolIndices.empty())
     warn("SHT_LLVM_CALL_GRAPH_PROFILE exists, but relocation section doesn't");
static void readConfigs(opt::InputArgList &args) {
   config->soName = args.getLastArgValue(OPT_soname);
   config->sortSection = getSortSection(args);
   config->splitStackAdjustSize = args::getInteger(args, OPT_split_stack_adjust_size, 16384);
   config->strip = getStrip(args);
   config->sysroot = args.getLastArgValue(OPT_sysroot);
   config->target1Rel = args.hasFlag(OPT_target1_rel, OPT_target1_abs, false);
   config->target2 = getTarget2(args);
   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
-  config->thinLTOCachePolicy = CHECK(
+  config->thinLTOCachePolicy = LLD_CHECK(
       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
   config->thinLTOEmitIndexFiles = args.hasArg(OPT_thinlto_emit_index_files) ||
                                   args.hasArg(OPT_thinlto_index_only) ||
                                   args.hasArg(OPT_thinlto_index_only_eq);
   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
                              args.hasArg(OPT_thinlto_index_only_eq);

lld/ELF/InputFiles.cpp

template <class ELFT> void ELFFileBase::init(InputFile::Kind k) {
   using Elf_Sym = typename ELFT::Sym;
 
   // Initialize trivial attributes.
   const ELFFile<ELFT> &obj = getObj<ELFT>();
   emachine = obj.getHeader().e_machine;
   osabi = obj.getHeader().e_ident[llvm::ELF::EI_OSABI];
   abiVersion = obj.getHeader().e_ident[llvm::ELF::EI_ABIVERSION];
 
-  ArrayRef<Elf_Shdr> sections = CHECK(obj.sections(), this);
+  ArrayRef<Elf_Shdr> sections = LLD_CHECK(obj.sections(), this);
   elfShdrs = sections.data();
   numELFShdrs = sections.size();
 
   // Find a symbol table.
   const Elf_Shdr *symtabSec =
       findSection(sections, k == SharedKind ? SHT_DYNSYM : SHT_SYMTAB);
 
   if (!symtabSec)
     return;
 
   // Initialize members corresponding to a symbol table.
   firstGlobal = symtabSec->sh_info;
 
-  ArrayRef<Elf_Sym> eSyms = CHECK(obj.symbols(symtabSec), this);
+  ArrayRef<Elf_Sym> eSyms = LLD_CHECK(obj.symbols(symtabSec), this);
   if (firstGlobal == 0 || firstGlobal > eSyms.size())
     fatal(toString(this) + ": invalid sh_info in symbol table");
 
   elfSyms = reinterpret_cast<const void *>(eSyms.data());
   numELFSyms = uint32_t(eSyms.size());
-  stringTable = CHECK(obj.getStringTableForSymtab(*symtabSec, sections), this);
+  stringTable =
+      LLD_CHECK(obj.getStringTableForSymtab(*symtabSec, sections), this);
 }
 
 template <class ELFT>
 uint32_t ObjFile<ELFT>::getSectionIndex(const Elf_Sym &sym) const {
-  return CHECK(
+  return LLD_CHECK(
       this->getObj().getSectionIndex(sym, getELFSyms<ELFT>(), shndxTable),
       this);
 }
 
 template <class ELFT> void ObjFile<ELFT>::parse(bool ignoreComdats) {
   object::ELFFile<ELFT> obj = this->getObj();
   // Read a section table. justSymbols is usually false.
   if (this->justSymbols) {
     initializeJustSymbols();
     initializeSymbols(obj);
     return;
   }
 
   // Handle dependent libraries and selection of section groups as these are not
   // done in parallel.
   ArrayRef<Elf_Shdr> objSections = getELFShdrs<ELFT>();
-  StringRef shstrtab = CHECK(obj.getSectionStringTable(objSections), this);
+  StringRef shstrtab = LLD_CHECK(obj.getSectionStringTable(objSections), this);
   uint64_t size = objSections.size();
   sections.resize(size);
   for (size_t i = 0; i != size; ++i) {
     const Elf_Shdr &sec = objSections[i];
     if (sec.sh_type == SHT_LLVM_DEPENDENT_LIBRARIES && !config->relocatable) {
       StringRef name = check(obj.getSectionName(sec, shstrtab));
-      ArrayRef<char> data = CHECK(
+      ArrayRef<char> data = LLD_CHECK(
           this->getObj().template getSectionContentsAsArray<char>(sec), this);
       if (!data.empty() && data.back() != '\0') {
         error(
             toString(this) +
             ": corrupted dependent libraries section (unterminated string): " +
             name);
       } else {
         for (const char *d = data.begin(), *e = data.end(); d < e;) {
if (sec.sh_type == SHT_ARM_ATTRIBUTES && config->emachine == EM_ARM) {
         }
       }
     }
 
     if (sec.sh_type != SHT_GROUP)
       continue;
     StringRef signature = getShtGroupSignature(objSections, sec);
     ArrayRef<Elf_Word> entries =
-        CHECK(obj.template getSectionContentsAsArray<Elf_Word>(sec), this);
+        LLD_CHECK(obj.template getSectionContentsAsArray<Elf_Word>(sec), this);
     if (entries.empty())
       fatal(toString(this) + ": empty SHT_GROUP");
 
     Elf_Word flag = entries[0];
     if (flag && flag != GRP_COMDAT)
       fatal(toString(this) + ": unsupported SHT_GROUP format");
 
     bool keepGroup =

 // returns a group name.
 template <class ELFT>
 StringRef ObjFile<ELFT>::getShtGroupSignature(ArrayRef<Elf_Shdr> sections,
                                               const Elf_Shdr &sec) {
   typename ELFT::SymRange symbols = this->getELFSyms<ELFT>();
   if (sec.sh_info >= symbols.size())
     fatal(toString(this) + ": invalid symbol index");
   const typename ELFT::Sym &sym = symbols[sec.sh_info];
-  return CHECK(sym.getName(this->stringTable), this);
+  return LLD_CHECK(sym.getName(this->stringTable), this);
 }
 
 template <class ELFT>
 bool ObjFile<ELFT>::shouldMerge(const Elf_Shdr &sec, StringRef name) {
   // On a regular link we don't merge sections if -O0 (default is -O1). This
   // sometimes makes the linker significantly faster, although the output will
   // be bigger.
   //

 template <class ELFT> void ObjFile<ELFT>::initializeJustSymbols() {
   sections.resize(numELFShdrs);
 }
 
 template <class ELFT>
 void ObjFile<ELFT>::initializeSections(bool ignoreComdats,
                                        const llvm::object::ELFFile<ELFT> &obj) {
   ArrayRef<Elf_Shdr> objSections = getELFShdrs<ELFT>();
-  StringRef shstrtab = CHECK(obj.getSectionStringTable(objSections), this);
+  StringRef shstrtab = LLD_CHECK(obj.getSectionStringTable(objSections), this);
   uint64_t size = objSections.size();
   SmallVector<ArrayRef<Elf_Word>, 0> selectedGroups;
   for (size_t i = 0; i != size; ++i) {
     if (this->sections[i] == &InputSection::discarded)
       continue;
     const Elf_Shdr &sec = objSections[i];
 
     // SHF_EXCLUDE'ed sections are discarded by the linker. However,
case SHT_GROUP: {
           cantFail(obj.template getSectionContentsAsArray<Elf_Word>(sec));
       if ((entries[0] & GRP_COMDAT) == 0 || ignoreComdats ||
           symtab.comdatGroups.find(CachedHashStringRef(signature))->second ==
               this)
         selectedGroups.push_back(entries);
       break;
     }
     case SHT_SYMTAB_SHNDX:
-      shndxTable = CHECK(obj.getSHNDXTable(sec, objSections), this);
+      shndxTable = LLD_CHECK(obj.getSHNDXTable(sec, objSections), this);
       break;
     case SHT_SYMTAB:
     case SHT_STRTAB:
     case SHT_REL:
     case SHT_RELA:
     case SHT_NULL:
       break;
     case SHT_LLVM_SYMPART:
void ObjFile<ELFT>::initializeSymbols(const object::ELFFile<ELFT> &obj) {
   if (numSymbols == 0) {
     numSymbols = eSyms.size();
     symbols = std::make_unique<Symbol *[]>(numSymbols);
   }
 
   // Some entries have been filled by LazyObjFile.
   for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i)
     if (!symbols[i])
-      symbols[i] = symtab.insert(CHECK(eSyms[i].getName(stringTable), this));
+      symbols[i] =
+          symtab.insert(LLD_CHECK(eSyms[i].getName(stringTable), this));
 
   // Perform symbol resolution on non-local symbols.
   SmallVector<unsigned, 32> undefineds;
   for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i) {
     const Elf_Sym &eSym = eSyms[i];
     uint32_t secIdx = eSym.st_shndx;
     if (secIdx == SHN_UNDEF) {
       undefineds.push_back(i);
if (LLVM_UNLIKELY(secIdx >= sections.size()))
       fatal(toString(this) + ": invalid section index: " + Twine(secIdx));
     if (LLVM_UNLIKELY(eSym.getBinding() != STB_LOCAL))
       error(toString(this) + ": non-local symbol (" + Twine(i) +
             ") found at index < .symtab's sh_info (" + Twine(end) + ")");
 
     InputSectionBase *sec = sections[secIdx];
     uint8_t type = eSym.getType();
     if (type == STT_FILE)
-      sourceFile = CHECK(eSym.getName(stringTable), this);
+      sourceFile = LLD_CHECK(eSym.getName(stringTable), this);
     if (LLVM_UNLIKELY(stringTable.size() <= eSym.st_name))
       fatal(toString(this) + ": invalid symbol name offset");
     StringRef name(stringTable.data() + eSym.st_name);
 
     symbols[i] = reinterpret_cast<Symbol *>(locals + i);
     if (eSym.st_shndx == SHN_UNDEF || sec == &InputSection::discarded)
       new (symbols[i]) Undefined(this, name, STB_LOCAL, eSym.st_other, type,
                                  /*discardedSecIdx=*/secIdx);

 // implement sophisticated error checking like in llvm-readobj because the value
 // of such diagnostics is low.
 template <typename ELFT>
 std::vector<uint32_t> SharedFile::parseVerneed(const ELFFile<ELFT> &obj,
                                                const typename ELFT::Shdr *sec) {
   if (!sec)
     return {};
   std::vector<uint32_t> verneeds;
-  ArrayRef<uint8_t> data = CHECK(obj.getSectionContents(*sec), this);
+  ArrayRef<uint8_t> data = LLD_CHECK(obj.getSectionContents(*sec), this);
   const uint8_t *verneedBuf = data.begin();
   for (unsigned i = 0; i != sec->sh_info; ++i) {
     if (verneedBuf + sizeof(typename ELFT::Verneed) > data.end())
       fatal(toString(this) + " has an invalid Verneed");
     auto *vn = reinterpret_cast<const typename ELFT::Verneed *>(verneedBuf);
     const uint8_t *vernauxBuf = verneedBuf + vn->vn_aux;
     for (unsigned j = 0; j != vn->vn_cnt; ++j) {
       if (vernauxBuf + sizeof(typename ELFT::Vernaux) > data.end())
template <class ELFT> void SharedFile::parse() {
 
   // Search for .dynsym, .dynamic, .symtab, .gnu.version and .gnu.version_d.
   for (const Elf_Shdr &sec : sections) {
     switch (sec.sh_type) {
     default:
       continue;
     case SHT_DYNAMIC:
       dynamicTags =
-          CHECK(obj.template getSectionContentsAsArray<Elf_Dyn>(sec), this);
+          LLD_CHECK(obj.template getSectionContentsAsArray<Elf_Dyn>(sec), this);
       break;
     case SHT_GNU_versym:
       versymSec = &sec;
       break;
     case SHT_GNU_verdef:
       verdefSec = &sec;
       break;
     case SHT_GNU_verneed:
template <class ELFT> void SharedFile::parse() {
 
   // Parse ".gnu.version" section which is a parallel array for the symbol
   // table. If a given file doesn't have a ".gnu.version" section, we use
   // VER_NDX_GLOBAL.
   size_t size = numELFSyms - firstGlobal;
   std::vector<uint16_t> versyms(size, VER_NDX_GLOBAL);
   if (versymSec) {
     ArrayRef<Elf_Versym> versym =
-        CHECK(obj.template getSectionContentsAsArray<Elf_Versym>(*versymSec),
-              this)
+        LLD_CHECK(
+            obj.template getSectionContentsAsArray<Elf_Versym>(*versymSec),
             .slice(firstGlobal);
     for (size_t i = 0; i < size; ++i)
       versyms[i] = versym[i].vs_index;
   }
 
   // System libraries can have a lot of symbols with versions. Using a
   // fixed buffer for computing the versions name (foo@ver) can save a
   // lot of allocations.
   SmallString<0> versionedNameBuffer;
 
   // Add symbols to the symbol table.
   ArrayRef<Elf_Sym> syms = this->getGlobalELFSyms<ELFT>();
   for (size_t i = 0, e = syms.size(); i != e; ++i) {
     const Elf_Sym &sym = syms[i];
 
     // ELF spec requires that all local symbols precede weak or global
     // symbols in each symbol table, and the index of first non-local symbol
     // is stored to sh_info. If a local symbol appears after some non-local
     // symbol, that's a violation of the spec.
-    StringRef name = CHECK(sym.getName(stringTable), this);
+    StringRef name = LLD_CHECK(sym.getName(stringTable), this);
     if (sym.getBinding() == STB_LOCAL) {
       errorOrWarn(toString(this) + ": invalid local symbol '" + name +
                   "' in global part of symbol table");
       continue;
     }
 
     const uint16_t ver = versyms[i], idx = ver & ~VERSYM_HIDDEN;
     if (sym.isUndefined()) {
BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
   // symbols later in the link stage). So we append file offset to make
   // filename unique.
   StringRef name = archiveName.empty()
                        ? saver().save(path)
                        : saver().save(archiveName + "(" + path::filename(path) +
                                       " at " + utostr(offsetInArchive) + ")");
   MemoryBufferRef mbref(mb.getBuffer(), name);
 
-  obj = CHECK(lto::InputFile::create(mbref), this);
+  obj = LLD_CHECK(lto::InputFile::create(mbref), this);
 
   Triple t(obj->getTargetTriple());
   ekind = getBitcodeELFKind(t);
   emachine = getBitcodeMachineKind(mb.getBufferIdentifier(), t);
   osabi = getOsAbi(t);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) {
template <class ELFT> void ObjFile<ELFT>::parseLazy() {
   symbols = std::make_unique<Symbol *[]>(numSymbols);
 
   // resolve() may trigger this->extract() if an existing symbol is an undefined
   // symbol. If that happens, this function has served its purpose, and we can
   // exit from the loop early.
   for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i) {
     if (eSyms[i].st_shndx == SHN_UNDEF)
       continue;
-    symbols[i] = symtab.insert(CHECK(eSyms[i].getName(stringTable), this));
+    symbols[i] = symtab.insert(LLD_CHECK(eSyms[i].getName(stringTable), this));
     symbols[i]->resolve(LazyObject{*this});
     if (!lazy)
       break;
   }
 }
 
 bool InputFile::shouldExtractForCommon(StringRef name) {
   if (isa<BitcodeFile>(this))

lld/ELF/InputSection.cpp

if (sym.type == STT_SECTION) {
       auto *d = dyn_cast<Defined>(&sym);
       if (!d) {
         if (!isDebugSection(*sec) && sec->name != ".eh_frame" &&
             sec->name != ".gcc_except_table" && sec->name != ".got2" &&
             sec->name != ".toc") {
           uint32_t secIdx = cast<Undefined>(sym).discardedSecIdx;
           Elf_Shdr_Impl<ELFT> sec = file->template getELFShdrs<ELFT>()[secIdx];
           warn("relocation refers to a discarded section: " +
-               CHECK(file->getObj().getSectionName(sec), file) +
+               LLD_CHECK(file->getObj().getSectionName(sec), file) +
                "\n>>> referenced by " + getObjMsg(p->r_offset));
         }
         p->setSymbolAndType(0, 0, false);
         continue;
       }
       SectionBase *section = d->section;
       if (!section->isLive()) {
         p->setSymbolAndType(0, 0, false);

lld/ELF/Relocations.cpp

if (!file || !sym.discardedSecIdx ||
       file->getSections()[sym.discardedSecIdx] != &InputSection::discarded)
     return "";
   ArrayRef<typename ELFT::Shdr> objSections =
       file->template getELFShdrs<ELFT>();
 
   std::string msg;
   if (sym.type == ELF::STT_SECTION) {
     msg = "relocation refers to a discarded section: ";
-    msg += CHECK(
+    msg += LLD_CHECK(
         file->getObj().getSectionName(objSections[sym.discardedSecIdx]), file);
   } else {
     msg = "relocation refers to a symbol in a discarded section: " +
           toString(sym);
   }
   msg += "\n>>> defined in " + toString(file);
 
   Elf_Shdr_Impl<ELFT> elfSec = objSections[sym.discardedSecIdx - 1];

lld/MachO/Driver.cpp

for (const Arg *arg :
     case OPT_prune_after_lto:
       add(Twine("prune_after=") + arg->getValue() + "s");
       break;
     case OPT_max_relative_cache_size_lto:
       add(Twine("cache_size=") + arg->getValue() + "%");
       break;
     }
   }
-  return CHECK(parseCachePruningPolicy(ltoPolicy), "invalid LTO cache policy");
+  return LLD_CHECK(parseCachePruningPolicy(ltoPolicy),
+                   "invalid LTO cache policy");
 }
 
 // What caused a given library to be loaded. Only relevant for archives.
 // Note that this does not tell us *how* we should load the library, i.e.
 // whether we should do it lazily or eagerly (AKA force loading). The "how" is
 // decided within addFile().
 enum class LoadType {
   CommandLine,      // Library was passed as a regular CLI argument
case file_magic::archive: {
     // We don't take a reference to cachedFile here because the
     // loadArchiveMember() call below may recursively call addFile() and
     // invalidate this reference.
     auto entry = loadedArchives.find(path);
 
     ArchiveFile *file;
     if (entry == loadedArchives.end()) {
       // No cached archive, we need to create a new one
-      std::unique_ptr<object::Archive> archive = CHECK(
+      std::unique_ptr<object::Archive> archive = LLD_CHECK(
           object::Archive::create(mbref), path + ": failed to parse archive");
 
       if (!archive->isEmpty() && !archive->hasSymbolTable())
         error(path + ": archive has no index; run ranlib to add one");
       file = make<ArchiveFile>(std::move(archive), isForceHidden);
     } else {
       file = entry->second.file;
       // Command-line loads take precedence. If file is previously loaded via

lld/MachO/InputFiles.cpp

if (!seen.insert(c.getChildOffset()).second)
     return Error::success();
 
   Expected<MemoryBufferRef> mb = c.getMemoryBufferRef();
   if (!mb)
     return mb.takeError();
 
   // Thin archives refer to .o files, so --reproduce needs the .o files too.
   if (tar && c.getParent()->isThin())
-    tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb->getBuffer());
+    tar->append(relativeToRoot(LLD_CHECK(c.getFullName(), this)),
+                mb->getBuffer());
 
   Expected<TimePoint<std::chrono::seconds>> modTime = c.getLastModified();
   if (!modTime)
     return modTime.takeError();
 
   Expected<InputFile *> file = loadArchiveMember(
       *mb, toTimeT(*modTime), getName(), c.getChildOffset(), forceHidden);
 
   if (!file)
     return file.takeError();
 
   inputFiles.insert(*file);
   printArchiveMemberLoad(reason, *file);
   return Error::success();
 }
 
 void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
   object::Archive::Child c =
-      CHECK(sym.getMember(), toString(this) +
-                                 ": could not get the member defining symbol " +
-                                 toMachOString(sym));
+      LLD_CHECK(sym.getMember(),
+                toString(this) + ": could not get the member defining symbol " +
 
   // `sym` is owned by a LazySym, which will be replace<>()d by make<ObjFile>
   // and become invalid after that call. Copy it to the stack so we can refer
   // to it later.
   const object::Archive::Symbol symCopy = sym;
 
   // ld64 doesn't demangle sym here even with -demangle.
   // Match that: intentionally don't call toMachOString().

lld/MachO/SyntheticSections.cpp

#pragma clang diagnostic pop
 
   file_size(xarPath, xarSize);
 #endif // defined(LLVM_HAVE_LIBXAR)
 }
 
 void BitcodeBundleSection::writeTo(uint8_t *buf) const {
   using namespace llvm::sys::fs;
   file_t handle =
-      CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),
+      LLD_CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),
                 "failed to open XAR file");
   std::error_code ec;
   mapped_file_region xarMap(handle, mapped_file_region::mapmode::readonly,
                             xarSize, 0, ec);
   if (ec)
     fatal("failed to map XAR file");
   memcpy(buf, xarMap.const_data(), xarSize);
 
   closeFile(handle);

lld/include/lld/Common/ErrorHandler.h

T check2(Expected<T> e, llvm::function_ref<std::string()> prefix) {
   if (!e)
     fatal(prefix() + ": " + toString(e.takeError()));
   return std::move(*e);
 }
 
 inline std::string toString(const Twine &s) { return s.str(); }
 
 // To evaluate the second argument lazily, we use C macro.
-#define CHECK(E, S) check2((E), [&] { return toString(S); })
+#define LLD_CHECK(E, S) check2((E), [&] { return toString(S); })
 
 } // namespace lld
 
 #endif

lld/wasm/Driver.cpp

if (Optional<MemoryBufferRef> buf = readFile(filename))
     for (StringRef sym : args::getLines(*buf))
       config->allowUndefinedSymbols.insert(sym);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
-      CHECK(Archive::create(mb),
+      LLD_CHECK(Archive::create(mb),
                 mb.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
-        CHECK(c.getMemoryBufferRef(),
+        LLD_CHECK(c.getMemoryBufferRef(),
                   mb.getBufferIdentifier() +
                       ": could not get the buffer for a child of the archive");
     v.push_back(mbref);
   }
   if (err)
     fatal(mb.getBufferIdentifier() +
           ": Archive::children failed: " + toString(std::move(err)));
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
if (inWholeArchive) {
         object->markLive();
         files.push_back(object);
       }
 
       return;
     }
 
     std::unique_ptr<Archive> file =
-        CHECK(Archive::create(mbref), path + ": failed to parse archive");
+        LLD_CHECK(Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable()) {
       error(mbref.getBufferIdentifier() +
             ": archive has no index; run ranlib to add one");
     }
 
     files.push_back(make<ArchiveFile>(mbref));
     return;
static void readConfigs(opt::InputArgList &args) {
   config->saveTemps = args.hasArg(OPT_save_temps);
   config->searchPaths = args::getStrings(args, OPT_library_path);
   config->shared = args.hasArg(OPT_shared);
   config->stripAll = args.hasArg(OPT_strip_all);
   config->stripDebug = args.hasArg(OPT_strip_debug);
   config->stackFirst = args.hasArg(OPT_stack_first);
   config->trace = args.hasArg(OPT_trace);
   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
-  config->thinLTOCachePolicy = CHECK(
+  config->thinLTOCachePolicy = LLD_CHECK(
       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
   errorHandler().verbose = args.hasArg(OPT_verbose);
   LLVM_DEBUG(errorHandler().verbose = true);
 
   config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
   config->globalBase = args::getInteger(args, OPT_global_base, 0);

lld/wasm/InputFiles.cpp

Optional<MemoryBufferRef> readFile(StringRef path) {
   return mbref;
 }
 
 InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName,
                             uint64_t offsetInArchive) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::wasm_object) {
     std::unique_ptr<Binary> bin =
-        CHECK(createBinary(mb), mb.getBufferIdentifier());
+        LLD_CHECK(createBinary(mb), mb.getBufferIdentifier());
     auto *obj = cast<WasmObjectFile>(bin.get());
     if (obj->isSharedObject())
       return make<SharedFile>(mb);
     return make<ObjFile>(mb, archiveName);
   }
 
   if (magic == file_magic::bitcode)
     return make<BitcodeFile>(mb, archiveName, offsetInArchive);
if (seg.Data.Content.size() == 0)
     return false;
 
   return true;
 }
 
 void ObjFile::parse(bool ignoreComdats) {
   // Parse a memory buffer as a wasm file.
   LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
-  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), toString(this));
+  std::unique_ptr<Binary> bin = LLD_CHECK(createBinary(mb), toString(this));
 
   auto *obj = dyn_cast<WasmObjectFile>(bin.get());
   if (!obj)
     fatal(toString(this) + ": not a wasm file");
   if (!obj->isRelocatableObject())
     fatal(toString(this) + ": not a relocatable wasm file");
 
   bin.release();
case WASM_SYMBOL_TYPE_SECTION:
     llvm_unreachable("section symbols cannot be undefined");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
-  file = CHECK(Archive::create(mb), toString(this));
+  file = LLD_CHECK(Archive::create(mb), toString(this));
 
   // Read the symbol table to construct Lazy symbols.
   int count = 0;
   for (const Archive::Symbol &sym : file->symbols()) {
     symtab->addLazy(this, &sym);
     ++count;
   }
   LLVM_DEBUG(dbgs() << "Read " << count << " symbols\n");
   (void) count;
 }
 
 void ArchiveFile::addMember(const Archive::Symbol *sym) {
   const Archive::Child &c =
-      CHECK(sym->getMember(),
+      LLD_CHECK(sym->getMember(),
                 "could not get the member for symbol " + sym->getName());
 
   // Don't try to load the same member twice (this can happen when members
   // mutually reference each other).
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
   LLVM_DEBUG(dbgs() << "loading lazy: " << sym->getName() << "\n");
   LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
 
   MemoryBufferRef mb =
-      CHECK(c.getMemoryBufferRef(),
+      LLD_CHECK(c.getMemoryBufferRef(),
                 "could not get the buffer for the member defining symbol " +
                     sym->getName());
 
   InputFile *obj = createObjectFile(mb, getName(), c.getChildOffset());
   symtab->addFile(obj);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) {
   switch (gvVisibility) {
   case GlobalValue::DefaultVisibility:

lld/wasm/Symbols.cpp

 void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
 
 void LazySymbol::setWeak() {
   flags |= (flags & ~WASM_SYMBOL_BINDING_MASK) | WASM_SYMBOL_BINDING_WEAK;
 }
 
 MemoryBufferRef LazySymbol::getMemberBuffer() {
   Archive::Child c =
-      CHECK(archiveSymbol.getMember(),
+      LLD_CHECK(archiveSymbol.getMember(),
                 "could not get the member for symbol " + toString(*this));
 
-  return CHECK(c.getMemoryBufferRef(),
+  return LLD_CHECK(c.getMemoryBufferRef(),
                    "could not get the buffer for the member defining symbol " +
                        toString(*this));
 }
 
 void printTraceSymbolUndefined(StringRef name, const InputFile* file) {
   message(toString(file) + ": reference to " + name);
 }
 
 // Print out a log message for --trace-symbol.
 void printTraceSymbol(Symbol *sym) {