Always evaluate the second argument for CHECK() lazily.

[ruiu]

Summary

This patch is to rename check CHECK and make it a C macro, so that
we can evaluate the second argument lazily.

[ruiu]

• fix typo

[inglorion]

How much does this buy us?

[ruiu]

How much does this buy us?

I honestly don't know. The aim of this patch is to merge check and checkLazy so that we don't have to make a guess about the cost of evaluating the second argument when we use CHECK.

[inglorion]

Alright, so it's basically like being able to write CHECK instead of check(e) and checkLazy(e, messagefun). I like that.

[• rafael]

This is a duplicate with D40915?

lld/COFF/Chunks.cpp

for (const coff_relocation &Rel : Relocs) {
     auto *Sym =
         dyn_cast_or_null<Defined>(File->getSymbol(Rel.SymbolTableIndex));
     if (!Sym) {
       if (isCodeView() || isDWARF())
         continue;
       // Symbols in early discarded sections are represented using null pointers,
       // so we need to retrieve the name from the object file.
       COFFSymbolRef Sym =
-          check(File->getCOFFObj()->getSymbol(Rel.SymbolTableIndex));
+          CHECK(File->getCOFFObj()->getSymbol(Rel.SymbolTableIndex));
       StringRef Name;
       File->getCOFFObj()->getSymbolName(Sym, Name);
       fatal("relocation against symbol in discarded section: " + Name);
     }
     Chunk *C = Sym->getChunk();
     OutputSection *OS = C ? C->getOutputSection() : nullptr;
 
     // Only absolute and __ImageBase symbols lack an output section. For any

lld/COFF/Driver.cpp

void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> MB,
   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),
+          CHECK(Archive::create(MBRef),
                 MBRef.getBufferIdentifier() + ": failed to parse archive");
 
       for (MemoryBufferRef M : getArchiveMembers(File.get()))
         addArchiveBuffer(M, "<whole-archive>", MBRef.getBufferIdentifier());
       return;
     }
     Symtab->addFile(make<ArchiveFile>(MBRef));
     break;
void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
   Symtab->addFile(Obj);
   log("Loaded " + toString(Obj) + " for " + SymName);
 }
 
 void LinkerDriver::enqueueArchiveMember(const Archive::Child &C,
                                         StringRef SymName,
                                         StringRef ParentName) {
   if (!C.getParent()->isThin()) {
-    MemoryBufferRef MB = check(
+    MemoryBufferRef MB = CHECK(
         C.getMemoryBufferRef(),
         "could not get the buffer for the member defining symbol " + SymName);
     enqueueTask([=]() { Driver->addArchiveBuffer(MB, SymName, ParentName); });
     return;
   }
 
   auto Future = std::make_shared<std::future<MBErrPair>>(createFutureForFile(
-      check(C.getFullName(),
+      CHECK(C.getFullName(),
             "could not get the filename for the member defining symbol " +
                 SymName)));
   enqueueTask([=]() {
     auto MBOrErr = Future->get();
     if (MBOrErr.second)
       fatal("could not get the buffer for the member defining " + SymName +
             ": " + MBOrErr.second.message());
     Driver->addArchiveBuffer(takeBuffer(std::move(MBOrErr.first)), SymName,
static void createImportLibrary(bool AsLib) {
 
   auto E = writeImportLibrary(getImportName(AsLib), getImplibPath(), Exports,
                               Config->Machine, false);
   handleAllErrors(std::move(E),
                   [&](ErrorInfoBase &EIB) { error(EIB.message()); });
 }
 
 static void parseModuleDefs(StringRef Path) {
-  std::unique_ptr<MemoryBuffer> MB = check(
+  std::unique_ptr<MemoryBuffer> MB = CHECK(
       MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path);
-  COFFModuleDefinition M = check(parseCOFFModuleDefinition(
+  COFFModuleDefinition M = CHECK(parseCOFFModuleDefinition(
       MB->getMemBufferRef(), Config->Machine, Config->MinGW));
 
   if (Config->OutputFile.empty())
     Config->OutputFile = Saver.save(M.OutputFile);
   Config->ImportName = Saver.save(M.ImportName);
   if (M.ImageBase)
     Config->ImageBase = M.ImageBase;
   if (M.StackReserve)
static void parseModuleDefs(StringRef Path) {
   }
 }
 
 // A helper function for filterBitcodeFiles.
 static bool needsRebuilding(MemoryBufferRef MB) {
   // The MSVC linker doesn't support thin archives, so if it's a thin
   // archive, we always need to rebuild it.
   std::unique_ptr<Archive> File =
-      check(Archive::create(MB), "Failed to read " + MB.getBufferIdentifier());
+      CHECK(Archive::create(MB), "Failed to read " + MB.getBufferIdentifier());
   if (File->isThin())
     return true;
 
   // Returns true if the archive contains at least one bitcode file.
   for (MemoryBufferRef Member : getArchiveMembers(File.get()))
     if (identify_magic(Member.getBuffer()) == file_magic::bitcode)
       return true;
   return false;
 }
 
 // Opens a given path as an archive file and removes bitcode files
 // from them if exists. This function is to appease the MSVC linker as
 // their linker doesn't like archive files containing non-native
 // object files.
 //
 // If a given archive doesn't contain bitcode files, the archive path
 // is returned as-is. Otherwise, a new temporary file is created and
 // its path is returned.
 static Optional<std::string>
 filterBitcodeFiles(StringRef Path, std::vector<std::string> &TemporaryFiles) {
-  std::unique_ptr<MemoryBuffer> MB = check(
+  std::unique_ptr<MemoryBuffer> MB = CHECK(
       MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path);
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   file_magic Magic = identify_magic(MBRef.getBuffer());
 
   if (Magic == file_magic::bitcode)
     return None;
   if (Magic != file_magic::archive)
     return Path.str();
   if (!needsRebuilding(MBRef))
     return Path.str();
 
   std::unique_ptr<Archive> File =
-      check(Archive::create(MBRef),
+      CHECK(Archive::create(MBRef),
             MBRef.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<NewArchiveMember> New;
   for (MemoryBufferRef Member : getArchiveMembers(File.get()))
     if (identify_magic(Member.getBuffer()) != file_magic::bitcode)
       New.emplace_back(Member);
 
   if (New.empty())
if (Args.hasArg(OPT_lldsavetemps))
     Config->SaveTemps = 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 = CHECK(
         parseCachePruningPolicy(Arg->getValue()),
         Twine("/lldltocachepolicy: invalid cache policy: ") + Arg->getValue());
 
   // Handle /failifmismatch
   for (auto *Arg : Args.filtered(OPT_failifmismatch))
     checkFailIfMismatch(Arg->getValue());
 
   // 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() {
     // IsVolatileSize=true forces MemoryBuffer to not use mmap().
-    return check(MemoryBuffer::getFile(Path, /*FileSize=*/-1,
+    return CHECK(MemoryBuffer::getFile(Path, /*FileSize=*/-1,
                                        /*RequiresNullTerminator=*/false,
                                        /*IsVolatileSize=*/true),
                  "could not open " + Path);
   }
 
   std::string Path;
 };
 }
static std::string createManifestXmlWithInternalMt(StringRef DefaultXml) {
 
   windows_manifest::WindowsManifestMerger Merger;
   if (auto E = Merger.merge(*DefaultXmlCopy.get()))
     fatal("internal manifest tool failed on default xml: " +
           toString(std::move(E)));
 
   for (StringRef Filename : Config->ManifestInput) {
     std::unique_ptr<MemoryBuffer> Manifest =
-        check(MemoryBuffer::getFile(Filename));
+        CHECK(MemoryBuffer::getFile(Filename));
     if (auto E = Merger.merge(*Manifest.get()))
       fatal("internal manifest tool failed on file " + Filename + ": " +
             toString(std::move(E)));
   }
 
   return Merger.getMergedManifest().get()->getBuffer();
 }
 
static std::string createManifestXmlWithExternalMt(StringRef DefaultXml) {
   for (StringRef Filename : Config->ManifestInput) {
     E.add("/manifest");
     E.add(Filename);
   }
   E.add("/nologo");
   E.add("/out:" + StringRef(User.Path));
   E.run();
 
-  return check(MemoryBuffer::getFile(User.Path), "could not open " + User.Path)
+  return 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;
void checkFailIfMismatch(StringRef Arg) {
   Config->MustMatch[K] = V;
 }
 
 // Convert Windows resource files (.res files) to a .obj file.
 MemoryBufferRef convertResToCOFF(const std::vector<MemoryBufferRef> &MBs) {
   object::WindowsResourceParser Parser;
 
   for (MemoryBufferRef MB : MBs) {
-    std::unique_ptr<object::Binary> Bin = check(object::createBinary(MB));
+    std::unique_ptr<object::Binary> Bin = CHECK(object::createBinary(MB));
     object::WindowsResource *RF = dyn_cast<object::WindowsResource>(Bin.get());
     if (!RF)
       fatal("cannot compile non-resource file as resource");
     if (auto EC = Parser.parse(RF))
       fatal("failed to parse .res file: " + toString(std::move(EC)));
   }
 
   Expected<std::unique_ptr<MemoryBuffer>> E =

lld/COFF/InputFiles.cpp

if (auto *U = dyn_cast<Undefined>(Source)) {
     U->WeakAlias = Target;
   }
 }
 
 ArchiveFile::ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
-  File = check(Archive::create(MB), toString(this));
+  File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &Sym : File->symbols())
     Symtab->addLazy(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(),
+      CHECK(Sym->getMember(),
             "could not get the member for symbol " + Sym->getName());
 
   // Return an empty buffer if we have already returned the same buffer.
   if (!Seen.insert(C.getChildOffset()).second)
     return;
 
   Driver->enqueueArchiveMember(C, Sym->getName(), getName());
 }
 
 std::vector<MemoryBufferRef> getArchiveMembers(Archive *File) {
   std::vector<MemoryBufferRef> V;
   Error Err = Error::success();
   for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) {
     Archive::Child C =
-        check(COrErr,
+        CHECK(COrErr,
               File->getFileName() + ": could not get the child of the archive");
     MemoryBufferRef MBRef =
-        check(C.getMemoryBufferRef(),
+        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::parse() {
   // Parse a memory buffer as a COFF file.
-  std::unique_ptr<Binary> Bin = check(createBinary(MB), toString(this));
+  std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
 
   if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
     Bin.release();
     COFFObj.reset(Obj);
   } else {
     fatal(toString(this) + " is not a COFF file");
   }
 
void ObjFile::initializeSymbols() {
   SmallVector<std::pair<Symbol *, uint32_t>, 8> WeakAliases;
   std::vector<uint32_t> PendingIndexes;
   PendingIndexes.reserve(NumSymbols);
 
   std::vector<const coff_aux_section_definition *> ComdatDefs(
       COFFObj->getNumberOfSections() + 1);
 
   for (uint32_t I = 0; I < NumSymbols; ++I) {
-    COFFSymbolRef COFFSym = check(COFFObj->getSymbol(I));
+    COFFSymbolRef COFFSym = CHECK(COFFObj->getSymbol(I));
     if (COFFSym.isUndefined()) {
       Symbols[I] = createUndefined(COFFSym);
     } else if (COFFSym.isWeakExternal()) {
       Symbols[I] = createUndefined(COFFSym);
       uint32_t TagIndex = COFFSym.getAux<coff_aux_weak_external>()->TagIndex;
       WeakAliases.emplace_back(Symbols[I], TagIndex);
     } else if (Optional<Symbol *> OptSym = createDefined(COFFSym, ComdatDefs)) {
       Symbols[I] = *OptSym;
     } else {
       // createDefined() returns None if a symbol belongs to a section that
       // was pending at the point when the symbol was read. This can happen in
       // two cases:
       // 1) section definition symbol for a comdat leader;
       // 2) symbol belongs to a comdat section associated with a section whose
       //    section definition symbol appears later in the symbol table.
       // In both of these cases, we can expect the section to be resolved by
       // the time we finish visiting the remaining symbols in the symbol
       // table. So we postpone the handling of this symbol until that time.
       PendingIndexes.push_back(I);
     }
     I += COFFSym.getNumberOfAuxSymbols();
   }
 
   for (uint32_t I : PendingIndexes) {
-    COFFSymbolRef Sym = check(COFFObj->getSymbol(I));
+    COFFSymbolRef Sym = CHECK(COFFObj->getSymbol(I));
     if (auto *Def = Sym.getSectionDefinition())
       if (Def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
         readAssociativeDefinition(Sym, Def);
     Symbols[I] = createRegular(Sym);
   }
 
   for (auto &KV : WeakAliases) {
     Symbol *Sym = KV.first;
void ImportFile::parse() {
   // If type is function, we need to create a thunk which jump to an
   // address pointed by the __imp_ symbol. (This allows you to call
   // DLL functions just like regular non-DLL functions.)
   if (Hdr->getType() == llvm::COFF::IMPORT_CODE)
     ThunkSym = Symtab->addImportThunk(Name, ImpSym, Hdr->Machine);
 }
 
 void BitcodeFile::parse() {
-  Obj = check(lto::InputFile::create(MemoryBufferRef(
+  Obj = CHECK(lto::InputFile::create(MemoryBufferRef(
       MB.getBuffer(), Saver.save(ParentName + MB.getBufferIdentifier()))));
   std::vector<std::pair<Symbol *, bool>> Comdat(Obj->getComdatTable().size());
   for (size_t I = 0; I != Obj->getComdatTable().size(); ++I)
     Comdat[I] = Symtab->addComdat(this, Saver.save(Obj->getComdatTable()[I]));
   for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) {
     StringRef SymName = Saver.save(ObjSym.getName());
     int ComdatIndex = ObjSym.getComdatIndex();
     Symbol *Sym;

lld/COFF/LTO.cpp

std::vector<StringRef> BitcodeCompiler::compile() {
   Buff.resize(MaxTasks);
   Files.resize(MaxTasks);
 
   // The /lldltocache option specifies the path to a directory in which to cache
   // native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache Cache;
   if (!Config->LTOCache.empty())
-    Cache = check(
+    Cache = CHECK(
         lto::localCache(Config->LTOCache,
                         [&](size_t Task, std::unique_ptr<MemoryBuffer> MB,
                             StringRef Path) { Files[Task] = std::move(MB); }));
 
   checkError(LTOObj->run(
       [&](size_t Task) {
         return llvm::make_unique<lto::NativeObjectStream>(
             llvm::make_unique<raw_svector_ostream>(Buff[Task]));

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 = CHECK(
       FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable),
       "failed to open " + Path);
 }
 
 void Writer::createSEHTable(OutputSection *RData) {
   // Create SEH table. x86-only.
   if (Config->Machine != I386)
     return;

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),
+      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 ErrorOr<Archive::Child> &COrErr : File->children(Err)) {
     Archive::Child C =
-        check(COrErr, MB.getBufferIdentifier() +
+        CHECK(COrErr, MB.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef MBRef =
-        check(C.getMemoryBufferRef(),
+        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());
+      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)));
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &MB : File->takeThinBuffers())
case file_magic::archive: {
     // Handle -whole-archive.
     if (InWholeArchive) {
       for (const auto &P : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(P.first, Path, P.second));
       return;
     }
 
     std::unique_ptr<Archive> File =
-        check(Archive::create(MBRef), Path + ": failed to parse archive");
+        CHECK(Archive::create(MBRef), Path + ": failed to parse archive");
 
     // If an archive file has no symbol table, it is likely that a user
     // is attempting LTO and using a default ar command that doesn't
     // understand the LLVM bitcode file. It is a pretty common error, so
     // we'll handle it as if it had a symbol table.
     if (!File->isEmpty() && !File->hasSymbolTable()) {
       for (const auto &P : getArchiveMembers(MBRef))
         Files.push_back(make<LazyObjFile>(P.first, Path, P.second));
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->SingleRoRx = Args.hasArg(OPT_no_rosegment);
   Config->SoName = Args.getLastArgValue(OPT_soname);
   Config->SortSection = getSortSection(Args);
   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 = CHECK(
       parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Undefined = args::getStrings(Args, OPT_undefined);
   Config->UnresolvedSymbols = getUnresolvedSymbolPolicy(Args);
   Config->Verbose = Args.hasArg(OPT_verbose);

lld/ELF/InputFiles.h

public:
 
   ELFFileBase(Kind K, MemoryBufferRef M);
   static bool classof(const InputFile *F) {
     Kind K = F->kind();
     return K == ObjKind || K == SharedKind;
   }
 
   llvm::object::ELFFile<ELFT> getObj() const {
-    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
+    return CHECK(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
   }
 
   StringRef getStringTable() const { return StringTable; }
 
   uint32_t getSectionIndex(const Elf_Sym &Sym) const;
 
   Elf_Sym_Range getGlobalELFSyms();
   Elf_Sym_Range getELFSyms() const { return ELFSyms; }

lld/ELF/InputFiles.cpp

 
 template <class ELFT>
 typename ELFT::SymRange ELFFileBase<ELFT>::getGlobalELFSyms() {
   return makeArrayRef(ELFSyms.begin() + FirstNonLocal, ELFSyms.end());
 }
 
 template <class ELFT>
 uint32_t ELFFileBase<ELFT>::getSectionIndex(const Elf_Sym &Sym) const {
-  return checkLazy(getObj().getSectionIndex(&Sym, ELFSyms, SymtabSHNDX),
-                   [=]() { return toString(this); });
+  return CHECK(getObj().getSectionIndex(&Sym, ELFSyms, SymtabSHNDX),
+               toString(this));
 }
 
 template <class ELFT>
 void ELFFileBase<ELFT>::initSymtab(ArrayRef<Elf_Shdr> Sections,
                                    const Elf_Shdr *Symtab) {
   FirstNonLocal = Symtab->sh_info;
-  ELFSyms = check(getObj().symbols(Symtab), toString(this));
+  ELFSyms = CHECK(getObj().symbols(Symtab), toString(this));
   if (FirstNonLocal == 0 || FirstNonLocal > ELFSyms.size())
     fatal(toString(this) + ": invalid sh_info in symbol table");
 
-  StringTable = check(getObj().getStringTableForSymtab(*Symtab, Sections),
+  StringTable = CHECK(getObj().getStringTableForSymtab(*Symtab, Sections),
                       toString(this));
 }
 
 template <class ELFT>
 ObjFile<ELFT>::ObjFile(MemoryBufferRef M, StringRef ArchiveName)
     : ELFFileBase<ELFT>(Base::ObjKind, M) {
   this->ArchiveName = ArchiveName;
 }

 // They are identified and deduplicated by group name. This function
 // returns a group name.
 template <class ELFT>
 StringRef ObjFile<ELFT>::getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
                                               const Elf_Shdr &Sec) {
   // Group signatures are stored as symbol names in object files.
   // sh_info contains a symbol index, so we fetch a symbol and read its name.
   if (this->ELFSyms.empty())
-    this->initSymtab(Sections,
-                     checkLazy(object::getSection<ELFT>(Sections, Sec.sh_link),
-                               [=]() { return toString(this); }));
-
-  const Elf_Sym *Sym =
-      checkLazy(object::getSymbol<ELFT>(this->ELFSyms, Sec.sh_info),
-                [=]() { return toString(this); });
-  StringRef Signature = checkLazy(Sym->getName(this->StringTable),
-                                  [=]() { return toString(this); });
+    this->initSymtab(
+        Sections,
+        CHECK(object::getSection<ELFT>(Sections, Sec.sh_link), toString(this)));
+
+  const Elf_Sym *Sym = CHECK(
+      object::getSymbol<ELFT>(this->ELFSyms, Sec.sh_info), toString(this));
+  StringRef Signature = CHECK(Sym->getName(this->StringTable), toString(this));
 
   // As a special case, if a symbol is a section symbol and has no name,
   // we use a section name as a signature.
   //
   // Such SHT_GROUP sections are invalid from the perspective of the ELF
   // standard, but GNU gold 1.14 (the neweset version as of July 2017) or
   // older produce such sections as outputs for the -r option, so we need
   // a bug-compatibility.
   if (Signature.empty() && Sym->getType() == STT_SECTION)
     return getSectionName(Sec);
   return Signature;
 }
 
 template <class ELFT>
 ArrayRef<typename ObjFile<ELFT>::Elf_Word>
 ObjFile<ELFT>::getShtGroupEntries(const Elf_Shdr &Sec) {
   const ELFFile<ELFT> &Obj = this->getObj();
-  ArrayRef<Elf_Word> Entries =
-      checkLazy(Obj.template getSectionContentsAsArray<Elf_Word>(&Sec),
-                [=]() { return toString(this); });
+  ArrayRef<Elf_Word> Entries = CHECK(
+      Obj.template getSectionContentsAsArray<Elf_Word>(&Sec), toString(this));
   if (Entries.empty() || Entries[0] != GRP_COMDAT)
     fatal(toString(this) + ": unsupported SHT_GROUP format");
   return Entries.slice(1);
 }
 
 template <class ELFT> bool ObjFile<ELFT>::shouldMerge(const Elf_Shdr &Sec) {
   // We don't merge sections if -O0 (default is -O1). This makes sometimes
   // the linker significantly faster, although the output will be bigger.

 }
 
 template <class ELFT>
 void ObjFile<ELFT>::initializeSections(
     DenseSet<CachedHashStringRef> &ComdatGroups) {
   const ELFFile<ELFT> &Obj = this->getObj();
 
   ArrayRef<Elf_Shdr> ObjSections =
-      check(this->getObj().sections(), toString(this));
+      CHECK(this->getObj().sections(), toString(this));
   uint64_t Size = ObjSections.size();
   this->Sections.resize(Size);
   this->SectionStringTable =
-      check(Obj.getSectionStringTable(ObjSections), toString(this));
+      CHECK(Obj.getSectionStringTable(ObjSections), toString(this));
 
   for (size_t I = 0, E = ObjSections.size(); I < E; I++) {
     if (this->Sections[I] == &InputSection::Discarded)
       continue;
     const Elf_Shdr &Sec = ObjSections[I];
 
     // SHF_EXCLUDE'ed sections are discarded by the linker. However,
     // if -r is given, we'll let the final link discard such sections.
case SHT_GROUP: {
       }
       break;
     }
     case SHT_SYMTAB:
       this->initSymtab(ObjSections, &Sec);
       break;
     case SHT_SYMTAB_SHNDX:
       this->SymtabSHNDX =
-          check(Obj.getSHNDXTable(Sec, ObjSections), toString(this));
+          CHECK(Obj.getSHNDXTable(Sec, ObjSections), toString(this));
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     default:
       this->Sections[I] = createInputSection(Sec);
     }
 

 InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   StringRef Name = getSectionName(Sec);
 
   switch (Sec.sh_type) {
   case SHT_ARM_ATTRIBUTES: {
     if (Config->EMachine != EM_ARM)
       break;
     ARMAttributeParser Attributes;
-    ArrayRef<uint8_t> Contents = check(this->getObj().getSectionContents(&Sec));
+    ArrayRef<uint8_t> Contents = CHECK(this->getObj().getSectionContents(&Sec));
     Attributes.Parse(Contents, /*isLittle*/Config->EKind == ELF32LEKind);
     updateSupportedARMFeatures(Attributes);
     // FIXME: Retain the first attribute section we see. The eglibc ARM
     // dynamic loaders require the presence of an attribute section for dlopen
     // to work. In a full implementation we would merge all attribute sections.
     if (InX::ARMAttributes == nullptr) {
       InX::ARMAttributes = make<InputSection>(this, &Sec, Name);
       return InX::ARMAttributes;
case SHT_REL: {
     // sections with relocations as non-mergeable.
     if (auto *MS = dyn_cast<MergeInputSection>(Target)) {
       Target = toRegularSection(MS);
       this->Sections[Sec.sh_info] = Target;
     }
 
     size_t NumRelocations;
     if (Sec.sh_type == SHT_RELA) {
-      ArrayRef<Elf_Rela> Rels = checkLazy(this->getObj().relas(&Sec),
-                                          [=]() { return toString(this); });
+      ArrayRef<Elf_Rela> Rels =
+          CHECK(this->getObj().relas(&Sec), toString(this));
       Target->FirstRelocation = Rels.begin();
       NumRelocations = Rels.size();
       Target->AreRelocsRela = true;
     } else {
-      ArrayRef<Elf_Rel> Rels = checkLazy(this->getObj().rels(&Sec),
-                                         [=]() { return toString(this); });
+      ArrayRef<Elf_Rel> Rels = CHECK(this->getObj().rels(&Sec), toString(this));
       Target->FirstRelocation = Rels.begin();
       NumRelocations = Rels.size();
       Target->AreRelocsRela = false;
     }
     assert(isUInt<31>(NumRelocations));
     Target->NumRelocations = NumRelocations;
 
     // Relocation sections processed by the linker are usually removed
InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
 
   if (shouldMerge(Sec))
     return make<MergeInputSection>(this, &Sec, Name);
   return make<InputSection>(this, &Sec, Name);
 }
 
 template <class ELFT>
 StringRef ObjFile<ELFT>::getSectionName(const Elf_Shdr &Sec) {
-  return checkLazy(this->getObj().getSectionName(&Sec, SectionStringTable),
-                   [=]() { return toString(this); });
+  return CHECK(this->getObj().getSectionName(&Sec, SectionStringTable),
+               toString(this));
 }
 
 template <class ELFT> void ObjFile<ELFT>::initializeSymbols() {
   this->Symbols.reserve(this->ELFSyms.size());
   for (const Elf_Sym &Sym : this->ELFSyms)
     this->Symbols.push_back(createSymbol(&Sym));
 }
 
template <class ELFT> Symbol *ObjFile<ELFT>::createSymbol(const Elf_Sym *Sym) {
 
   uint8_t StOther = Sym->st_other;
   uint8_t Type = Sym->getType();
   uint64_t Value = Sym->st_value;
   uint64_t Size = Sym->st_size;
 
   if (Binding == STB_LOCAL) {
     if (Sym->getType() == STT_FILE)
-      SourceFile = check(Sym->getName(this->StringTable), toString(this));
+      SourceFile = CHECK(Sym->getName(this->StringTable), toString(this));
 
     if (this->StringTable.size() <= Sym->st_name)
       fatal(toString(this) + ": invalid symbol name offset");
 
     StringRefZ Name = this->StringTable.data() + Sym->st_name;
     if (Sym->st_shndx == SHN_UNDEF)
       return make<Undefined>(this, Name, Binding, StOther, Type);
 
     return make<Defined>(this, Name, Binding, StOther, Type, Value, Size, Sec);
   }
 
-  StringRef Name = checkLazy(Sym->getName(this->StringTable),
-                             [=]() { return toString(this); });
+  StringRef Name = CHECK(Sym->getName(this->StringTable), toString(this));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return Symtab->addUndefined<ELFT>(Name, Binding, StOther, Type,
                                       /*CanOmitFromDynSym=*/false, this);
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
       fatal(toString(this) + ": common symbol '" + Name +
template <class ELFT> void ArchiveFile::parse() {
   for (const Archive::Symbol &Sym : File->symbols())
     Symbols.push_back(Symtab->addLazyArchive<ELFT>(Sym.getName(), this, Sym));
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 std::pair<MemoryBufferRef, uint64_t>
 ArchiveFile::getMember(const Archive::Symbol *Sym) {
   Archive::Child C =
-      check(Sym->getMember(), toString(this) +
+      CHECK(Sym->getMember(), toString(this) +
                                   ": could not get the member for symbol " +
                                   Sym->getName());
 
   if (!Seen.insert(C.getChildOffset()).second)
     return {MemoryBufferRef(), 0};
 
   MemoryBufferRef Ret =
-      check(C.getMemoryBufferRef(),
+      CHECK(C.getMemoryBufferRef(),
             toString(this) +
                 ": could not get the buffer for the member defining symbol " +
                 Sym->getName());
 
   if (C.getParent()->isThin() && Tar)
-    Tar->append(relativeToRoot(check(C.getFullName(), toString(this))),
+    Tar->append(relativeToRoot(CHECK(C.getFullName(), toString(this))),
                 Ret.getBuffer());
   if (C.getParent()->isThin())
     return {Ret, 0};
   return {Ret, C.getChildOffset()};
 }
 
 template <class ELFT>
 SharedFile<ELFT>::SharedFile(MemoryBufferRef M, StringRef DefaultSoName)
     : ELFFileBase<ELFT>(Base::SharedKind, M), SoName(DefaultSoName),
       IsNeeded(!Config->AsNeeded) {}
 
 // Partially parse the shared object file so that we can call
 // getSoName on this object.
 template <class ELFT> void SharedFile<ELFT>::parseSoName() {
   const Elf_Shdr *DynamicSec = nullptr;
   const ELFFile<ELFT> Obj = this->getObj();
-  ArrayRef<Elf_Shdr> Sections = check(Obj.sections(), toString(this));
+  ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), toString(this));
 
   // 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_DYNSYM:
       this->initSymtab(Sections, &Sec);
       break;
     case SHT_DYNAMIC:
       DynamicSec = &Sec;
       break;
     case SHT_SYMTAB_SHNDX:
       this->SymtabSHNDX =
-          check(Obj.getSHNDXTable(Sec, Sections), toString(this));
+          CHECK(Obj.getSHNDXTable(Sec, Sections), toString(this));
       break;
     case SHT_GNU_versym:
       this->VersymSec = &Sec;
       break;
     case SHT_GNU_verdef:
       this->VerdefSec = &Sec;
       break;
     }
   }
 
   if (this->VersymSec && this->ELFSyms.empty())
     error("SHT_GNU_versym should be associated with symbol table");
 
   // Search for a DT_SONAME tag to initialize this->SoName.
   if (!DynamicSec)
     return;
   ArrayRef<Elf_Dyn> Arr =
-      check(Obj.template getSectionContentsAsArray<Elf_Dyn>(DynamicSec),
+      CHECK(Obj.template getSectionContentsAsArray<Elf_Dyn>(DynamicSec),
             toString(this));
   for (const Elf_Dyn &Dyn : Arr) {
     if (Dyn.d_tag == DT_SONAME) {
       uint64_t Val = Dyn.getVal();
       if (Val >= this->StringTable.size())
         fatal(toString(this) + ": invalid DT_SONAME entry");
       SoName = this->StringTable.data() + Val;
       return;

 
 // Fully parse the shared object file. This must be called after parseSoName().
 template <class ELFT> void SharedFile<ELFT>::parseRest() {
   // Create mapping from version identifiers to Elf_Verdef entries.
   const Elf_Versym *Versym = nullptr;
   std::vector<const Elf_Verdef *> Verdefs = parseVerdefs(Versym);
 
   ArrayRef<Elf_Shdr> Sections =
-      check(this->getObj().sections(), toString(this));
+      CHECK(this->getObj().sections(), toString(this));
 
   // Add symbols to the symbol table.
   Elf_Sym_Range Syms = this->getGlobalELFSyms();
   for (const Elf_Sym &Sym : Syms) {
     unsigned VersymIndex = 0;
     if (Versym) {
       VersymIndex = Versym->vs_index;
       ++Versym;
     }
     bool Hidden = VersymIndex & VERSYM_HIDDEN;
     VersymIndex = VersymIndex & ~VERSYM_HIDDEN;
 
-    StringRef Name = check(Sym.getName(this->StringTable), toString(this));
+    StringRef Name = CHECK(Sym.getName(this->StringTable), toString(this));
     if (Sym.isUndefined()) {
       Undefs.push_back(Name);
       continue;
     }
 
     // Ignore local symbols.
     if (Versym && VersymIndex == VER_NDX_LOCAL)
       continue;
BitcodeFile::BitcodeFile(MemoryBufferRef MB, StringRef ArchiveName,
   // ThinLTO uses the MemoryBufferRef identifier to access its internal
   // data structures and if two archives define two members with the same name,
   // this causes a collision which result in only one of the objects being
   // taken into consideration at LTO time (which very likely causes undefined
   // symbols later in the link stage).
   MemoryBufferRef MBRef(MB.getBuffer(),
                         Saver.save(ArchiveName + MB.getBufferIdentifier() +
                                    utostr(OffsetInArchive)));
-  Obj = check(lto::InputFile::create(MBRef), toString(this));
+  Obj = CHECK(lto::InputFile::create(MBRef), toString(this));
 
   Triple T(Obj->getTargetTriple());
   EKind = getBitcodeELFKind(T);
   EMachine = getBitcodeMachineKind(MB.getBufferIdentifier(), T);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes GvVisibility) {
   switch (GvVisibility) {
for (StringRef Sym : getSymbolNames())
     Symtab->addLazyObject<ELFT>(Sym, *this);
 }
 
 template <class ELFT> std::vector<StringRef> LazyObjFile::getElfSymbols() {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
 
-  ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(this->MB.getBuffer()));
-  ArrayRef<Elf_Shdr> Sections = check(Obj.sections(), toString(this));
+  ELFFile<ELFT> Obj = CHECK(ELFFile<ELFT>::create(this->MB.getBuffer()));
+  ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), toString(this));
   for (const Elf_Shdr &Sec : Sections) {
     if (Sec.sh_type != SHT_SYMTAB)
       continue;
 
-    Elf_Sym_Range Syms = check(Obj.symbols(&Sec), toString(this));
+    Elf_Sym_Range Syms = CHECK(Obj.symbols(&Sec), toString(this));
     uint32_t FirstNonLocal = Sec.sh_info;
     StringRef StringTable =
-        check(Obj.getStringTableForSymtab(Sec, Sections), toString(this));
+        CHECK(Obj.getStringTableForSymtab(Sec, Sections), toString(this));
     std::vector<StringRef> V;
 
     for (const Elf_Sym &Sym : Syms.slice(FirstNonLocal))
       if (Sym.st_shndx != SHN_UNDEF)
-        V.push_back(check(Sym.getName(StringTable), toString(this)));
+        V.push_back(CHECK(Sym.getName(StringTable), toString(this)));
     return V;
   }
   return {};
 }
 
 std::vector<StringRef> LazyObjFile::getBitcodeSymbols() {
   std::unique_ptr<lto::InputFile> Obj =
-      check(lto::InputFile::create(this->MB), toString(this));
+      CHECK(lto::InputFile::create(this->MB), toString(this));
   std::vector<StringRef> V;
   for (const lto::InputFile::Symbol &Sym : Obj->symbols())
     if (!Sym.isUndefined())
       V.push_back(Saver.save(Sym.getName()));
   return V;
 }
 
 // Returns a vector of globally-visible defined symbol names.

lld/ELF/InputSection.cpp

DenseMap<SectionBase *, int> elf::buildSectionOrder() {
   return SectionOrder;
 }
 
 template <class ELFT>
 static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> *File,
                                             const typename ELFT::Shdr *Hdr) {
   if (!File || Hdr->sh_type == SHT_NOBITS)
     return makeArrayRef<uint8_t>(nullptr, Hdr->sh_size);
-  return check(File->getObj().getSectionContents(Hdr));
+  return CHECK(File->getObj().getSectionContents(Hdr));
 }
 
 InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags,
                                    uint32_t Type, uint64_t Entsize,
                                    uint32_t Link, uint32_t Info,
                                    uint32_t Alignment, ArrayRef<uint8_t> Data,
                                    StringRef Name, Kind SectionKind)
     : SectionBase(SectionKind, Name, Flags, Entsize, Alignment, Type, Info,

 }
 
 // Uncompress section contents if required. Note that this function
 // is called from parallelForEach, so it must be thread-safe.
 void InputSectionBase::maybeUncompress() {
   if (UncompressBuf || !Decompressor::isCompressedELFSection(Flags, Name))
     return;
 
-  Decompressor Dec = check(Decompressor::create(Name, toStringRef(Data),
+  Decompressor Dec = CHECK(Decompressor::create(Name, toStringRef(Data),
                                                 Config->IsLE, Config->Is64));
 
   size_t Size = Dec.getDecompressedSize();
   UncompressBuf.reset(new char[Size]());
   if (Error E = Dec.decompress({UncompressBuf.get(), Size}))
     fatal(toString(this) +
           ": decompress failed: " + llvm::toString(std::move(E)));
 

lld/ELF/LTO.cpp

std::vector<InputFile *> BitcodeCompiler::compile() {
   Buff.resize(MaxTasks);
   Files.resize(MaxTasks);
 
   // The --thinlto-cache-dir option specifies the path to a directory in which
   // to cache native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache Cache;
   if (!Config->ThinLTOCacheDir.empty())
-    Cache = check(
+    Cache = CHECK(
         lto::localCache(Config->ThinLTOCacheDir,
                         [&](size_t Task, std::unique_ptr<MemoryBuffer> MB,
                             StringRef Path) { Files[Task] = std::move(MB); }));
 
   checkError(LTOObj->run(
       [&](size_t Task) {
         return llvm::make_unique<lto::NativeObjectStream>(
             llvm::make_unique<raw_svector_ostream>(Buff[Task]));

lld/ELF/Relocations.cpp

 }
 
 // Returns true if a given shared symbol is in a read-only segment in a DSO.
 template <class ELFT> static bool isReadOnly(SharedSymbol *SS) {
   typedef typename ELFT::Phdr Elf_Phdr;
 
   // Determine if the symbol is read-only by scanning the DSO's program headers.
   const SharedFile<ELFT> *File = SS->getFile<ELFT>();
-  for (const Elf_Phdr &Phdr : check(File->getObj().program_headers()))
+  for (const Elf_Phdr &Phdr : CHECK(File->getObj().program_headers()))
     if ((Phdr.p_type == ELF::PT_LOAD || Phdr.p_type == ELF::PT_GNU_RELRO) &&
         !(Phdr.p_flags & ELF::PF_W) && SS->Value >= Phdr.p_vaddr &&
         SS->Value < Phdr.p_vaddr + Phdr.p_memsz)
       return true;
   return false;
 }
 
 // Returns symbols at the same offset as a given symbol, including SS itself.
 //
 // If two or more symbols are at the same offset, and at least one of
 // them are copied by a copy relocation, all of them need to be copied.
 // Otherwise, they would refer different places at runtime.
 template <class ELFT>
 static std::vector<SharedSymbol *> getSymbolsAt(SharedSymbol *SS) {
   typedef typename ELFT::Sym Elf_Sym;
 
   SharedFile<ELFT> *File = SS->getFile<ELFT>();
 
   std::vector<SharedSymbol *> Ret;
   for (const Elf_Sym &S : File->getGlobalELFSyms()) {
     if (S.st_shndx == SHN_UNDEF || S.st_shndx == SHN_ABS ||
         S.st_value != SS->Value)
       continue;
-    StringRef Name = check(S.getName(File->getStringTable()));
+    StringRef Name = CHECK(S.getName(File->getStringTable()));
     Symbol *Sym = Symtab->find(Name);
     if (auto *Alias = dyn_cast_or_null<SharedSymbol>(Sym))
       Ret.push_back(Alias);
   }
   return Ret;
 }
 
 // Reserve space in .bss or .bss.rel.ro for copy relocation.

lld/include/lld/Common/ErrorHandler.h

 }
 inline void log(const Twine &Msg) { errorHandler().log(Msg); }
 inline void message(const Twine &Msg) { errorHandler().message(Msg); }
 inline void warn(const Twine &Msg) { errorHandler().warn(Msg); }
 inline uint64_t errorCount() { return errorHandler().ErrorCount; }
 
 LLVM_ATTRIBUTE_NORETURN void exitLld(int Val);
 
-// check() functions are convenient functions to strip errors
+// check functions are convenient functions to strip errors
 // from error-or-value objects.
-template <class T> T check(ErrorOr<T> E) {
+template <class T> T check1(ErrorOr<T> E) {
   if (auto EC = E.getError())
     fatal(EC.message());
   return std::move(*E);
 }
 
-template <class T> T check(Expected<T> E) {
+template <class T> T check1(Expected<T> E) {
   if (!E)
     fatal(llvm::toString(E.takeError()));
   return std::move(*E);
 }
 
-template <class T> T check(ErrorOr<T> E, const Twine &Prefix) {
+template <class T> T check2(ErrorOr<T> E, std::function<std::string()> Prefix) {
   if (auto EC = E.getError())
-    fatal(Prefix + ": " + EC.message());
+    fatal(Prefix() + ": " + EC.message());
   return std::move(*E);
 }
 
-template <class T> T check(Expected<T> E, const Twine &Prefix) {
-  if (!E)
-    fatal(Prefix + ": " + toString(E.takeError()));
-  return std::move(*E);
-}
-
-// A lazy variant that only allocates error messages when there is an error.
 template <class T>
-T checkLazy(Expected<T> E, llvm::function_ref<std::string()> getPrefix) {
+T check2(Expected<T> E, std::function<std::string()> Prefix) {
   if (!E)
-    fatal(getPrefix() + ": " + toString(E.takeError()));
+    fatal(Prefix() + ": " + toString(E.takeError()));
   return std::move(*E);
 }
+
+// These are C macros to expand
+//
+// CHECK(x)    -> check1(x)
+// CHECK(x, y) -> check2(x, [&] { return checkToString(y) })
+inline std::string checkToString(const Twine &S) { return S.str(); }
+inline std::string checkToString(std::string S) { return S; }
+inline std::string checkToString(const char *S) { return S; }
+
+#define CHECK2(E, S) check2(E, [&] { return checkToString(S); })
+
+#define CHECK_FN(_0, _1, _2, ...) _2
+
+#define CHECK(...) CHECK_FN(__VA_ARGS__, CHECK2, check1, dummy)(__VA_ARGS__)
+
 } // namespace lld
 
 #endif

lld/wasm/InputFiles.cpp

uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
 
   DEBUG(dbgs() << " -> " << Index << "\n");
   return Index;
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
-  std::unique_ptr<Binary> Bin = check(createBinary(MB), toString(this));
+  std::unique_ptr<Binary> Bin = 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();
if (Sym.isLocal()) {
     return S;
   }
   return Symtab->addDefined(this, &Sym, Segment);
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
-  File = check(Archive::create(MB), toString(this));
+  File = 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;
   }
   DEBUG(dbgs() << "Read " << Count << " symbols\n");
 }
 
 void ArchiveFile::addMember(const Archive::Symbol *Sym) {
   const Archive::Child &C =
-      check(Sym->getMember(),
+      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;
 
   DEBUG(dbgs() << "loading lazy: " << Sym->getName() << "\n");
   DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
 
   MemoryBufferRef MB =
-      check(C.getMemoryBufferRef(),
+      CHECK(C.getMemoryBufferRef(),
             "could not get the buffer for the member defining symbol " +
                 Sym->getName());
 
   if (identify_magic(MB.getBuffer()) != file_magic::wasm_object) {
     error("unknown file type: " + MB.getBufferIdentifier());
     return;
   }