Change DEBUG() macro to LLVM_DEBUG() in lld

[Nicola]

Summary

The DEBUG() macro is too generic so it might clash with other projects.
This is going to be deprecated and replaced by LLVM_DEBUG() as soon as https://reviews.llvm.org/D43624 is submitted.

This is the command I used to do the replacement and formatting:
git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g'
git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM

lld/trunk/lib/Driver/DarwinLdDriver.cpp

if (parsedArgs.hasArg(OPT_rpath)) {
     }
 
     for (auto rPath : parsedArgs.filtered(OPT_rpath)) {
       ctx.addRpath(rPath->getValue());
     }
   }
 
   // Parse the LLVM options before we process files in case the file handling
-  // makes use of things like DEBUG().
+  // makes use of things like LLVM_DEBUG().
   parseLLVMOptions(ctx);
 
   // Handle input files and sectcreate.
   for (auto &arg : parsedArgs) {
     bool upward;
     llvm::Optional<StringRef> resolvedPath;
     switch (arg->getOption().getID()) {
     default:

lld/trunk/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

CompactUnwindPass(const MachOLinkingContext &context)
       : _ctx(context), _archHandler(_ctx.archHandler()),
         _file(*_ctx.make_file<MachOFile>("<mach-o Compact Unwind Pass>")),
         _isBig(MachOLinkingContext::isBigEndian(_ctx.arch())) {
     _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
   }
 
 private:
   llvm::Error perform(SimpleFile &mergedFile) override {
-    DEBUG(llvm::dbgs() << "MachO Compact Unwind pass\n");
+    LLVM_DEBUG(llvm::dbgs() << "MachO Compact Unwind pass\n");
 
     std::map<const Atom *, CompactUnwindEntry> unwindLocs;
     std::map<const Atom *, const Atom *> dwarfFrames;
     std::vector<const Atom *> personalities;
     uint32_t numLSDAs = 0;
 
     // First collect all __compact_unwind and __eh_frame entries, addressable by
     // the function referred to.
llvm::Error perform(SimpleFile &mergedFile) override {
     std::vector<CompactUnwindEntry> unwindInfos = createUnwindInfoEntries(
         mergedFile, unwindLocs, personalities, dwarfFrames);
 
     // Remove any unused eh-frame atoms.
     pruneUnusedEHFrames(mergedFile, unwindInfos, unwindLocs, dwarfFrames);
 
     // Finally, we can start creating pages based on these entries.
 
-    DEBUG(llvm::dbgs() << "  Splitting entries into pages\n");
+    LLVM_DEBUG(llvm::dbgs() << "  Splitting entries into pages\n");
     // FIXME: we split the entries into pages naively: lots of 4k pages followed
     // by a small one. ld64 tried to minimize space and align them to real 4k
     // boundaries. That might be worth doing, or perhaps we could perform some
     // minor balancing for expected number of lookups.
     std::vector<UnwindInfoPage> pages;
     auto remainingInfos = llvm::makeArrayRef(unwindInfos);
     do {
       pages.push_back(UnwindInfoPage());
 
       // FIXME: we only create regular pages at the moment. These can hold up to
       // 1021 entries according to the documentation.
       unsigned entriesInPage = std::min(1021U, (unsigned)remainingInfos.size());
 
       pages.back().entries = remainingInfos.slice(0, entriesInPage);
       remainingInfos = remainingInfos.slice(entriesInPage);
 
-      DEBUG(llvm::dbgs()
-            << "    Page from " << pages.back().entries[0].rangeStart->name()
-            << " to " << pages.back().entries.back().rangeStart->name() << " + "
-            << llvm::format("0x%x", pages.back().entries.back().rangeLength)
+      LLVM_DEBUG(llvm::dbgs()
+                 << "    Page from "
+                 << pages.back().entries[0].rangeStart->name() << " to "
+                 << pages.back().entries.back().rangeStart->name() << " + "
+                 << llvm::format("0x%x",
+                                 pages.back().entries.back().rangeLength)
                  << " has " << entriesInPage << " entries\n");
     } while (!remainingInfos.empty());
 
     auto *unwind = new (_file.allocator())
         UnwindInfoAtom(_archHandler, _file, _isBig, personalities,
                        commonEncodings, pages, numLSDAs);
     mergedFile.addAtom(*unwind);
 
     // Finally, remove all __compact_unwind atoms now that we've processed them.
     mergedFile.removeDefinedAtomsIf([](const DefinedAtom *atom) {
       return atom->contentType() == DefinedAtom::typeCompactUnwindInfo;
     });
 
     return llvm::Error::success();
   }
 
   void collectCompactUnwindEntries(
       const SimpleFile &mergedFile,
       std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       std::vector<const Atom *> &personalities, uint32_t &numLSDAs) {
-    DEBUG(llvm::dbgs() << "  Collecting __compact_unwind entries\n");
+    LLVM_DEBUG(llvm::dbgs() << "  Collecting __compact_unwind entries\n");
 
     for (const DefinedAtom *atom : mergedFile.defined()) {
       if (atom->contentType() != DefinedAtom::typeCompactUnwindInfo)
         continue;
 
       auto unwindEntry = extractCompactUnwindEntry(atom);
       unwindLocs.insert(std::make_pair(unwindEntry.rangeStart, unwindEntry));
 
-      DEBUG(llvm::dbgs() << "    Entry for " << unwindEntry.rangeStart->name()
-                         << ", encoding="
+      LLVM_DEBUG(llvm::dbgs() << "    Entry for "
+                              << unwindEntry.rangeStart->name() << ", encoding="
                               << llvm::format("0x%08x", unwindEntry.encoding));
       if (unwindEntry.personalityFunction)
-        DEBUG(llvm::dbgs() << ", personality="
-                           << unwindEntry.personalityFunction->name()
-                           << ", lsdaLoc=" << unwindEntry.lsdaLocation->name());
-      DEBUG(llvm::dbgs() << '\n');
+        LLVM_DEBUG(llvm::dbgs()
+                   << ", personality="
+      LLVM_DEBUG(llvm::dbgs() << '\n');
 
       // Count number of LSDAs we see, since we need to know how big the index
       // will be while laying out the section.
       if (unwindEntry.lsdaLocation)
         ++numLSDAs;
 
       // Gather the personality functions now, so that they're in deterministic
       // order (derived from the DefinedAtom order).
private:
   ///     or too many personality functions to be accommodated.
   std::vector<CompactUnwindEntry> createUnwindInfoEntries(
       const SimpleFile &mergedFile,
       const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       const std::vector<const Atom *> &personalities,
       const std::map<const Atom *, const Atom *> &dwarfFrames) {
     std::vector<CompactUnwindEntry> unwindInfos;
 
-    DEBUG(llvm::dbgs() << "  Creating __unwind_info entries\n");
+    LLVM_DEBUG(llvm::dbgs() << "  Creating __unwind_info entries\n");
     // The final order in the __unwind_info section must be derived from the
     // order of typeCode atoms, since that's how they'll be put into the object
     // file eventually (yuck!).
     for (const DefinedAtom *atom : mergedFile.defined()) {
       if (atom->contentType() != DefinedAtom::typeCode)
         continue;
 
       unwindInfos.push_back(finalizeUnwindInfoEntryForAtom(
           atom, unwindLocs, personalities, dwarfFrames));
 
-      DEBUG(llvm::dbgs() << "    Entry for " << atom->name()
-                         << ", final encoding="
-                         << llvm::format("0x%08x", unwindInfos.back().encoding)
-                         << '\n');
+      LLVM_DEBUG(llvm::dbgs()
+                 << "    Entry for " << atom->name() << ", final encoding="
     }
 
     return unwindInfos;
   }
 
   /// Remove unused EH frames.
   ///
   /// An EH frame is considered unused if there is a corresponding compact

lld/trunk/lib/ReaderWriter/MachO/LayoutPass.cpp

static bool compareAtomsSub(const LayoutPass::SortKey &lc,
 
   // Find the root of the chain if it is a part of a follow-on chain.
   const DefinedAtom *leftRoot = lc._root;
   const DefinedAtom *rightRoot = rc._root;
 
   // Sort atoms by their ordinal overrides only if they fall in the same
   // chain.
   if (leftRoot == rightRoot) {
-    DEBUG(reason = formatReason("override", lc._override, rc._override));
+    LLVM_DEBUG(reason = formatReason("override", lc._override, rc._override));
     return lc._override < rc._override;
   }
 
   // Sort same permissions together.
   DefinedAtom::ContentPermissions leftPerms = leftRoot->permissions();
   DefinedAtom::ContentPermissions rightPerms = rightRoot->permissions();
 
   if (leftPerms != rightPerms) {
-    DEBUG(reason =
-              formatReason("contentPerms", (int)leftPerms, (int)rightPerms));
+    LLVM_DEBUG(
+        reason = formatReason("contentPerms", (int)leftPerms, (int)rightPerms));
     return leftPerms < rightPerms;
   }
 
   // Sort same content types together.
   DefinedAtom::ContentType leftType = leftRoot->contentType();
   DefinedAtom::ContentType rightType = rightRoot->contentType();
 
   if (leftType != rightType) {
-    DEBUG(reason = formatReason("contentType", (int)leftType, (int)rightType));
+    LLVM_DEBUG(reason =
+                   formatReason("contentType", (int)leftType, (int)rightType));
     return leftType < rightType;
   }
 
   // Use custom sorter if supplied.
   if (customSorter) {
     bool leftBeforeRight;
     if (customSorter(leftRoot, rightRoot, leftBeforeRight))
       return leftBeforeRight;
   }
 
   // Sort by .o order.
   const File *leftFile = &leftRoot->file();
   const File *rightFile = &rightRoot->file();
 
   if (leftFile != rightFile) {
-    DEBUG(reason = formatReason(".o order", (int)leftFile->ordinal(),
+    LLVM_DEBUG(reason = formatReason(".o order", (int)leftFile->ordinal(),
                                      (int)rightFile->ordinal()));
     return leftFile->ordinal() < rightFile->ordinal();
   }
 
   // Sort by atom order with .o file.
   uint64_t leftOrdinal = leftRoot->ordinal();
   uint64_t rightOrdinal = rightRoot->ordinal();
 
   if (leftOrdinal != rightOrdinal) {
-    DEBUG(reason = formatReason("ordinal", (int)leftRoot->ordinal(),
+    LLVM_DEBUG(reason = formatReason("ordinal", (int)leftRoot->ordinal(),
                                      (int)rightRoot->ordinal()));
     return leftOrdinal < rightOrdinal;
   }
 
   llvm::errs() << "Unordered: <" << left->name() << "> <"
                << right->name() << ">\n";
   llvm_unreachable("Atoms with Same Ordinal!");
 }
 
 static bool compareAtoms(const LayoutPass::SortKey &lc,
                          const LayoutPass::SortKey &rc,
                          LayoutPass::SortOverride customSorter) {
   std::string reason;
   bool result = compareAtomsSub(lc, rc, customSorter, reason);
-  DEBUG({
+  LLVM_DEBUG({
     StringRef comp = result ? "<" : ">=";
     llvm::dbgs() << "Layout: '" << lc._atom.get()->name()
                  << "' " << comp << " '"
                  << rc._atom.get()->name() << "' (" << reason << ")\n";
   });
   return result;
 }
 
void LayoutPass::undecorate(File::AtomRange<DefinedAtom> &atomRange,
                             std::vector<SortKey> &keys) const {
   size_t i = 0;
   for (SortKey &k : keys)
     atomRange[i++] = std::move(k._atom);
 }
 
 /// Perform the actual pass
 llvm::Error LayoutPass::perform(SimpleFile &mergedFile) {
-  DEBUG(llvm::dbgs() << "******** Laying out atoms:\n");
+  LLVM_DEBUG(llvm::dbgs() << "******** Laying out atoms:\n");
   // sort the atoms
   ScopedTask task(getDefaultDomain(), "LayoutPass");
   File::AtomRange<DefinedAtom> atomRange = mergedFile.defined();
 
   // Build follow on tables
   buildFollowOnTable(atomRange);
 
   // Check the structure of followon graph if running in debug mode.
-  DEBUG(checkFollowonChain(atomRange));
+  LLVM_DEBUG(checkFollowonChain(atomRange));
 
   // Build override maps
   buildOrdinalOverrideMap(atomRange);
 
-  DEBUG({
+  LLVM_DEBUG({
     llvm::dbgs() << "unsorted atoms:\n";
     printDefinedAtoms(atomRange);
   });
 
   std::vector<LayoutPass::SortKey> vec = decorate(atomRange);
   sort(llvm::parallel::par, vec.begin(), vec.end(),
        [&](const LayoutPass::SortKey &l, const LayoutPass::SortKey &r) -> bool {
          return compareAtoms(l, r, _customSorter);
        });
-  DEBUG(checkTransitivity(vec, _customSorter));
+  LLVM_DEBUG(checkTransitivity(vec, _customSorter));
   undecorate(atomRange, vec);
 
-  DEBUG({
+  LLVM_DEBUG({
     llvm::dbgs() << "sorted atoms:\n";
     printDefinedAtoms(atomRange);
   });
 
-  DEBUG(llvm::dbgs() << "******** Finished laying out atoms\n");
+  LLVM_DEBUG(llvm::dbgs() << "******** Finished laying out atoms\n");
   return llvm::Error::success();
 }
 
 void addLayoutPass(PassManager &pm, const MachOLinkingContext &ctx) {
   pm.add(llvm::make_unique<LayoutPass>(
       ctx.registry(), [&](const DefinedAtom * left, const DefinedAtom * right,
                           bool & leftBeforeRight) ->bool {
     return ctx.customAtomOrderer(left, right, leftBeforeRight);
   }));
 }
 
 } // namespace mach_o
 } // namespace lld

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

static bool isObjCImageInfo(const Section &sect) {
   return (sect.segmentName == "__OBJC" && sect.sectionName == "__image_info") ||
     (sect.segmentName == "__DATA" && sect.sectionName == "__objc_imageinfo");
 }
 
 llvm::Error
 normalizedObjectToAtoms(MachOFile *file,
                         const NormalizedFile &normalizedFile,
                         bool copyRefs) {
-  DEBUG(llvm::dbgs() << "******** Normalizing file to atoms: "
+  LLVM_DEBUG(llvm::dbgs() << "******** Normalizing file to atoms: "
                           << file->path() << "\n");
   bool scatterable = ((normalizedFile.flags & MH_SUBSECTIONS_VIA_SYMBOLS) != 0);
 
   // Create atoms from each section.
   for (auto &sect : normalizedFile.sections) {
 
     // If this is a debug-info section parse it specially.
     if (isDebugInfoSection(sect))
       continue;

lld/trunk/wasm/InputChunks.cpp

void InputChunk::writeTo(uint8_t *Buf) const {
   // Apply relocations
   if (Relocations.empty())
     return;
 
 #ifndef NDEBUG
   verifyRelocTargets();
 #endif
 
-  DEBUG(dbgs() << "applying relocations: " << getName()
+  LLVM_DEBUG(dbgs() << "applying relocations: " << getName()
                     << " count=" << Relocations.size() << "\n");
   int32_t Off = OutputOffset - getInputSectionOffset();
 
   for (const WasmRelocation &Rel : Relocations) {
     uint8_t *Loc = Buf + Rel.Offset + Off;
     uint32_t Value = File->calcNewValue(Rel);
-    DEBUG(dbgs() << "apply reloc: type=" << ReloctTypeToString(Rel.Type)
+    LLVM_DEBUG(dbgs() << "apply reloc: type=" << ReloctTypeToString(Rel.Type)
                       << " addend=" << Rel.Addend << " index=" << Rel.Index
-                 << " value=" << Value << " offset=" << Rel.Offset << "\n");
+                      << " value=" << Value << " offset=" << Rel.Offset
+                      << "\n");
 
     switch (Rel.Type) {
     case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       encodeULEB128(Value, Loc, 5);
       break;

 // Copy relocation entries to a given output stream.
 // This function is used only when a user passes "-r". For a regular link,
 // we consume relocations instead of copying them to an output file.
 void InputChunk::writeRelocations(raw_ostream &OS) const {
   if (Relocations.empty())
     return;
 
   int32_t Off = OutputOffset - getInputSectionOffset();
-  DEBUG(dbgs() << "writeRelocations: " << File->getName()
+  LLVM_DEBUG(dbgs() << "writeRelocations: " << File->getName()
                     << " offset=" << Twine(Off) << "\n");
 
   for (const WasmRelocation &Rel : Relocations) {
     writeUleb128(OS, Rel.Type, "reloc type");
     writeUleb128(OS, Rel.Offset + Off, "reloc offset");
     writeUleb128(OS, File->calcNewIndex(Rel), "reloc index");
 
     switch (Rel.Type) {
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       writeSleb128(OS, File->calcNewAddend(Rel), "reloc addend");
       break;
     }
   }
 }
 
 void InputFunction::setFunctionIndex(uint32_t Index) {
-  DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName() << " -> "
-               << Index << "\n");
+  LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName()
+                    << " -> " << Index << "\n");
   assert(!hasFunctionIndex());
   FunctionIndex = Index;
 }
 
 void InputFunction::setTableIndex(uint32_t Index) {
-  DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
+  LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
                     << Index << "\n");
   assert(!hasTableIndex());
   TableIndex = Index;
 }

lld/trunk/wasm/InputFiles.cpp

case R_WEBASSEMBLY_SECTION_OFFSET_I32:
     return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
-  DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
+  LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   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");
 
Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   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.
-  DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
+  LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   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");
+  LLVM_DEBUG(dbgs() << "Read " << Count << " symbols\n");
 }
 
 void ArchiveFile::addMember(const Archive::Symbol *Sym) {
   const Archive::Child &C =
       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");
+  LLVM_DEBUG(dbgs() << "loading lazy: " << Sym->getName() << "\n");
+  LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
 
   MemoryBufferRef MB =
       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());

lld/trunk/wasm/MarkLive.cpp

 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 void lld::wasm::markLive() {
   if (!Config->GcSections)
     return;
 
-  DEBUG(dbgs() << "markLive\n");
+  LLVM_DEBUG(dbgs() << "markLive\n");
   SmallVector<InputChunk *, 256> Q;
 
   auto Enqueue = [&](Symbol *Sym) {
     if (!Sym || Sym->isLive())
       return;
     Sym->markLive();
     if (InputChunk *Chunk = Sym->getChunk())
       Q.push_back(Chunk);

lld/trunk/wasm/SymbolTable.cpp

 static void checkDataType(const Symbol *Existing, const InputFile *File) {
   if (!isa<DataSymbol>(Existing))
     reportTypeError(Existing, File, WASM_SYMBOL_TYPE_DATA);
 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    uint32_t Flags,
                                                    InputFunction *Function) {
-  DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   assert(!find(Name));
   SyntheticFunctions.emplace_back(Function);
   return replaceSymbol<DefinedFunction>(insert(Name).first, Name, Flags,
                                         nullptr, Function);
 }
 
 DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
                                                  uint32_t Flags) {
-  DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   assert(!find(Name));
   return replaceSymbol<DefinedData>(insert(Name).first, Name, Flags);
 }
 
 DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                                InputGlobal *Global) {
-  DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global << "\n");
+  LLVM_DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global
+                    << "\n");
   assert(!find(Name));
   SyntheticGlobals.emplace_back(Global);
   return replaceSymbol<DefinedGlobal>(insert(Name).first, Name, Flags, nullptr,
                                       Global);
 }
 
 static bool shouldReplace(const Symbol *Existing, InputFile *NewFile,
                           uint32_t NewFlags) {
   // If existing symbol is undefined, replace it.
   if (!Existing->isDefined()) {
-    DEBUG(dbgs() << "resolving existing undefined symbol: "
+    LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: "
                       << Existing->getName() << "\n");
     return true;
   }
 
   // Now we have two defined symbols. If the new one is weak, we can ignore it.
   if ((NewFlags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
-    DEBUG(dbgs() << "existing symbol takes precedence\n");
+    LLVM_DEBUG(dbgs() << "existing symbol takes precedence\n");
     return false;
   }
 
   // If the existing symbol is weak, we should replace it.
   if (Existing->isWeak()) {
-    DEBUG(dbgs() << "replacing existing weak symbol\n");
+    LLVM_DEBUG(dbgs() << "replacing existing weak symbol\n");
     return true;
   }
 
   // Neither symbol is week. They conflict.
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
   return true;
 }
 
 Symbol *SymbolTable::addDefinedFunction(StringRef Name, uint32_t Flags,
                                         InputFile *File,
                                         InputFunction *Function) {
-  DEBUG(dbgs() << "addDefinedFunction: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addDefinedFunction: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedFunction>(S, Name, Flags, File, Function);
     return S;
   }
 
   checkFunctionType(S, File, &Function->Signature);
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedFunction>(S, Name, Flags, File, Function);
   return S;
 }
 
 Symbol *SymbolTable::addDefinedData(StringRef Name, uint32_t Flags,
                                     InputFile *File, InputSegment *Segment,
                                     uint32_t Address, uint32_t Size) {
-  DEBUG(dbgs() << "addDefinedData:" << Name << " addr:" << Address << "\n");
+  LLVM_DEBUG(dbgs() << "addDefinedData:" << Name << " addr:" << Address
+                    << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedData>(S, Name, Flags, File, Segment, Address, Size);
     return S;
   }
 
   checkDataType(S, File);
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedData>(S, Name, Flags, File, Segment, Address, Size);
   return S;
 }
 
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Flags,
                                       InputFile *File, InputGlobal *Global) {
-  DEBUG(dbgs() << "addDefinedGlobal:" << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addDefinedGlobal:" << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global);
     return S;
   }
 
   checkGlobalType(S, File, &Global->getType());
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global);
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name, uint32_t Flags,
                                           InputFile *File,
                                           const WasmSignature *Sig) {
-  DEBUG(dbgs() << "addUndefinedFunction: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted)
     replaceSymbol<UndefinedFunction>(S, Name, Flags, File, Sig);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkFunctionType(S, File, Sig);
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedData(StringRef Name, uint32_t Flags,
                                       InputFile *File) {
-  DEBUG(dbgs() << "addUndefinedData: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addUndefinedData: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted)
     replaceSymbol<UndefinedData>(S, Name, Flags, File);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkDataType(S, File);
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, uint32_t Flags,
                                         InputFile *File,
                                         const WasmGlobalType *Type) {
-  DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n");
+  LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted)
     replaceSymbol<UndefinedGlobal>(S, Name, Flags, File, Type);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkGlobalType(S, File, Type);
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *File, const Archive::Symbol *Sym) {
-  DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
+  LLVM_DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   if (WasInserted) {
     replaceSymbol<LazySymbol>(S, Name, File, *Sym);
     return;
   }
 
   // If there is an existing undefined symbol, load a new one from the archive.
   if (S->isUndefined()) {
-    DEBUG(dbgs() << "replacing existing undefined\n");
+    LLVM_DEBUG(dbgs() << "replacing existing undefined\n");
     File->addMember(Sym);
   }
 }
 
 bool SymbolTable::addComdat(StringRef Name) {
   return Comdats.insert(CachedHashStringRef(Name)).second;
 }

lld/trunk/wasm/Symbols.cpp

 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   assert(OutputSymbolIndex != INVALID_INDEX);
   return OutputSymbolIndex;
 }
 
 void Symbol::setOutputSymbolIndex(uint32_t Index) {
-  DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index << "\n");
+  LLVM_DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index
+                    << "\n");
   assert(OutputSymbolIndex == INVALID_INDEX);
   OutputSymbolIndex = Index;
 }
 
 bool Symbol::isWeak() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
 }
 
 bool Symbol::isLocal() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
 }
 
 bool Symbol::isHidden() const {
   return (Flags & WASM_SYMBOL_VISIBILITY_MASK) == WASM_SYMBOL_VISIBILITY_HIDDEN;
 }
 
 void Symbol::setHidden(bool IsHidden) {
-  DEBUG(dbgs() << "setHidden: " << Name << " -> " << IsHidden << "\n");
+  LLVM_DEBUG(dbgs() << "setHidden: " << Name << " -> " << IsHidden << "\n");
   Flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
   if (IsHidden)
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   else
     Flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }
 
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function->getFunctionIndex();
   assert(FunctionIndex != INVALID_INDEX);
   return FunctionIndex;
 }
 
 void FunctionSymbol::setFunctionIndex(uint32_t Index) {
-  DEBUG(dbgs() << "setFunctionIndex " << Name << " -> " << Index << "\n");
+  LLVM_DEBUG(dbgs() << "setFunctionIndex " << Name << " -> " << Index << "\n");
   assert(FunctionIndex == INVALID_INDEX);
   FunctionIndex = Index;
 }
 
 bool FunctionSymbol::hasFunctionIndex() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function->hasFunctionIndex();
   return FunctionIndex != INVALID_INDEX;

 void FunctionSymbol::setTableIndex(uint32_t Index) {
   // For imports, we set the table index here on the Symbol; for defined
   // functions we set the index on the InputFunction so that we don't export
   // the same thing twice (keeps the table size down).
   if (auto *F = dyn_cast<DefinedFunction>(this)) {
     F->Function->setTableIndex(Index);
     return;
   }
-  DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
+  LLVM_DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(TableIndex == INVALID_INDEX);
   TableIndex = Index;
 }
 
 DefinedFunction::DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
                                  InputFunction *Function)
     : FunctionSymbol(Name, DefinedFunctionKind, Flags, F,
                      Function ? &Function->Signature : nullptr),
       Function(Function) {}
 
 uint32_t DefinedData::getVirtualAddress() const {
-  DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   if (Segment)
     return Segment->OutputSeg->StartVA + Segment->OutputSegmentOffset + Offset;
   return Offset;
 }
 
 void DefinedData::setVirtualAddress(uint32_t Value) {
-  DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
+  LLVM_DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   assert(!Segment);
   Offset = Value;
 }
 
 uint32_t DefinedData::getOutputSegmentOffset() const {
-  DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
   return Segment->OutputSegmentOffset + Offset;
 }
 
 uint32_t DefinedData::getOutputSegmentIndex() const {
-  DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   return Segment->OutputSeg->Index;
 }
 
 uint32_t GlobalSymbol::getGlobalIndex() const {
   if (auto *F = dyn_cast<DefinedGlobal>(this))
     return F->Global->getGlobalIndex();
   assert(GlobalIndex != INVALID_INDEX);
   return GlobalIndex;
 }
 
 void GlobalSymbol::setGlobalIndex(uint32_t Index) {
-  DEBUG(dbgs() << "setGlobalIndex " << Name << " -> " << Index << "\n");
+  LLVM_DEBUG(dbgs() << "setGlobalIndex " << Name << " -> " << Index << "\n");
   assert(GlobalIndex == INVALID_INDEX);
   GlobalIndex = Index;
 }
 
 bool GlobalSymbol::hasGlobalIndex() const {
   if (auto *F = dyn_cast<DefinedGlobal>(this))
     return F->Global->hasGlobalIndex();
   return GlobalIndex != INVALID_INDEX;
 }
 
 DefinedGlobal::DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                              InputGlobal *Global)
     : GlobalSymbol(Name, DefinedGlobalKind, Flags, File,
                    Global ? &Global->getType() : nullptr),
       Global(Global) {}
 
 uint32_t SectionSymbol::getOutputSectionIndex() const {
-  DEBUG(dbgs() << "getOutputSectionIndex: " << getName() << "\n");
+  LLVM_DEBUG(dbgs() << "getOutputSectionIndex: " << getName() << "\n");
   assert(OutputSectionIndex != INVALID_INDEX);
   return OutputSectionIndex;
 }
 
 void SectionSymbol::setOutputSectionIndex(uint32_t Index) {
-  DEBUG(dbgs() << "setOutputSectionIndex: " << getName() << " -> " << Index
+  LLVM_DEBUG(dbgs() << "setOutputSectionIndex: " << getName() << " -> " << Index
                     << "\n");
   assert(Index != INVALID_INDEX);
   OutputSectionIndex = Index;
 }
 
 void LazySymbol::fetch() { cast<ArchiveFile>(File)->addMember(&ArchiveSymbol); }
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)

lld/trunk/wasm/Writer.cpp

for (auto &Pair : CustomSectionMapping) {
     StringRef Name = Pair.first();
 
     auto P = CustomSectionSymbols.find(Name);
     if (P != CustomSectionSymbols.end()) {
       uint32_t SectionIndex = OutputSections.size();
       P->second->setOutputSectionIndex(SectionIndex);
     }
 
-    DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
+    LLVM_DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
     OutputSections.push_back(make<CustomSection>(Name, Pair.second));
   }
 }
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
     return;
 
if (!Sym->isUndefined())
       continue;
     if (isa<DataSymbol>(Sym))
       continue;
     if (Sym->isWeak() && !Config->Relocatable)
       continue;
     if (!Sym->isLive())
       continue;
 
-    DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
+    LLVM_DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
     ImportedSymbols.emplace_back(Sym);
     if (auto *F = dyn_cast<FunctionSymbol>(Sym))
       F->setFunctionIndex(NumImportedFunctions++);
     else
       cast<GlobalSymbol>(Sym)->setGlobalIndex(NumImportedGlobals++);
   }
 }
 
for (Symbol *Sym : Symtab->getSymbols()) {
     } else if (auto *G = dyn_cast<DefinedGlobal>(Sym)) {
       Export = {Name, WASM_EXTERNAL_GLOBAL, G->getGlobalIndex()};
     } else {
       auto *D = cast<DefinedData>(Sym);
       DefinedFakeGlobals.emplace_back(D);
       Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++};
     }
 
-    DEBUG(dbgs() << "Export: " << Name << "\n");
+    LLVM_DEBUG(dbgs() << "Export: " << Name << "\n");
     Exports.push_back(Export);
   }
 }
 
 void Writer::assignSymtab() {
   if (!Config->Relocatable)
     return;
 
   StringMap<uint32_t> SectionSymbolIndices;
 
   unsigned SymbolIndex = SymtabEntries.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
+    LLVM_DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->getFile() != File)
         continue;
 
       if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
         StringRef Name = S->getName();
         if (CustomSectionMapping.count(Name) == 0)
           continue;
if (It == TypeIndices.end()) {
     return 0;
   }
   return It->second;
 }
 
 uint32_t Writer::registerType(const WasmSignature &Sig) {
   auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
   if (Pair.second) {
-    DEBUG(dbgs() << "type " << toString(Sig) << "\n");
+    LLVM_DEBUG(dbgs() << "type " << toString(Sig) << "\n");
     Types.push_back(&Sig);
   }
   return Pair.first->second;
 }
 
 void Writer::calculateTypes() {
   // The output type section is the union of the following sets:
   // 1. Any signature used in the TYPE relocation
auto AddDefinedFunction = [&](InputFunction *Func) {
     InputFunctions.emplace_back(Func);
     Func->setFunctionIndex(FunctionIndex++);
   };
 
   for (InputFunction *Func : Symtab->SyntheticFunctions)
     AddDefinedFunction(Func);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
+    LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions)
       AddDefinedFunction(Func);
   }
 
   uint32_t TableIndex = kInitialTableOffset;
   auto HandleRelocs = [&](InputChunk *Chunk) {
     if (!Chunk->Live)
       return;
for (const WasmRelocation &Reloc : Chunk->getRelocations()) {
         // Mark target type as live
         File->TypeMap[Reloc.Index] = registerType(Types[Reloc.Index]);
         File->TypeIsUsed[Reloc.Index] = true;
       }
     }
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
+    LLVM_DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     for (InputChunk *Chunk : File->Functions)
       HandleRelocs(Chunk);
     for (InputChunk *Chunk : File->Segments)
       HandleRelocs(Chunk);
     for (auto &P : File->CustomSections)
       HandleRelocs(P);
   }
 
   uint32_t GlobalIndex = NumImportedGlobals + InputGlobals.size();
   auto AddDefinedGlobal = [&](InputGlobal *Global) {
     if (Global->Live) {
-      DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
+      LLVM_DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
       Global->setGlobalIndex(GlobalIndex++);
       InputGlobals.push_back(Global);
     }
   };
 
   for (InputGlobal *Global : Symtab->SyntheticGlobals)
     AddDefinedGlobal(Global);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
+    LLVM_DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
     for (InputGlobal *Global : File->Globals)
       AddDefinedGlobal(Global);
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   if (!Config->MergeDataSegments)
     return Name;

 void Writer::createOutputSegments() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSegment *Segment : File->Segments) {
       if (!Segment->Live)
         continue;
       StringRef Name = getOutputDataSegmentName(Segment->getName());
       OutputSegment *&S = SegmentMap[Name];
       if (S == nullptr) {
-        DEBUG(dbgs() << "new segment: " << Name << "\n");
+        LLVM_DEBUG(dbgs() << "new segment: " << Name << "\n");
         S = make<OutputSegment>(Name, Segments.size());
         Segments.push_back(S);
       }
       S->addInputSegment(Segment);
-      DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
+      LLVM_DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
     }
   }
 }
 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions

lld/trunk/wasm/WriterUtils.cpp

static const char *valueTypeToString(uint8_t Type) {
   default:
     llvm_unreachable("invalid value type");
   }
 }
 
 namespace lld {
 
 void wasm::debugWrite(uint64_t Offset, const Twine &Msg) {
-  DEBUG(dbgs() << format("  | %08lld: ", Offset) << Msg << "\n");
+  LLVM_DEBUG(dbgs() << format("  | %08lld: ", Offset) << Msg << "\n");
 }
 
 void wasm::writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg) {
   debugWrite(OS.tell(), Msg + "[" + utohexstr(Number) + "]");
   encodeULEB128(Number, OS);
 }
 
 void wasm::writeSleb128(raw_ostream &OS, int32_t Number, const Twine &Msg) {