[BOLT][NFC] Replace anonymous namespace functions with static

[Amir]

Summary

Follow LLVM Coding Standards guideline on using anonymous namespaces
(https://llvm.org/docs/CodingStandards.html#anonymous-namespaces)
and use static modifier for function definitions.

[maksfb]

LGTM

bolt/lib/Core/BinaryFunction.cpp

 
 } // namespace opts
 
 namespace llvm {
 namespace bolt {
 
 constexpr unsigned BinaryFunction::MinAlign;
 
-namespace {
-
-template <typename R> bool emptyRange(const R &Range) {
+template <typename R> static bool emptyRange(const R &Range) {
   return Range.begin() == Range.end();
 }
 
 /// Gets debug line information for the instruction located at the given
 /// address in the original binary. The SMLoc's pointer is used
 /// to point to this information, which is represented by a
 /// DebugLineTableRowRef. The returned pointer is null if no debug line
 /// information for this instruction was found.
-SMLoc findDebugLineInformationForInstructionAt(
+static SMLoc findDebugLineInformationForInstructionAt(
     uint64_t Address, DWARFUnit *Unit,
     const DWARFDebugLine::LineTable *LineTable) {
   // We use the pointer in SMLoc to store an instance of DebugLineTableRowRef,
   // which occupies 64 bits. Thus, we can only proceed if the struct fits into
   // the pointer itself.
   assert(sizeof(decltype(SMLoc().getPointer())) >=
              sizeof(DebugLineTableRowRef) &&
          "Cannot fit instruction debug line information into SMLoc's pointer");
DebugLineTableRowRef *InstructionLocation =
       reinterpret_cast<DebugLineTableRowRef *>(&Ptr);
 
   InstructionLocation->DwCompileUnitIndex = Unit->getOffset();
   InstructionLocation->RowIndex = RowIndex + 1;
 
   return SMLoc::getFromPointer(Ptr);
 }
 
-std::string buildSectionName(StringRef Prefix, StringRef Name,
+static std::string buildSectionName(StringRef Prefix, StringRef Name,
                                     const BinaryContext &BC) {
   if (BC.isELF())
     return (Prefix + Name).str();
   static NameShortener NS;
   return (Prefix + Twine(NS.getID(Name))).str();
 }
 
-raw_ostream &operator<<(raw_ostream &OS, const BinaryFunction::State State) {
+static raw_ostream &operator<<(raw_ostream &OS,
+                               const BinaryFunction::State State) {
   switch (State) {
   case BinaryFunction::State::Empty:         OS << "empty"; break;
   case BinaryFunction::State::Disassembled:  OS << "disassembled"; break;
   case BinaryFunction::State::CFG:           OS << "CFG constructed"; break;
   case BinaryFunction::State::CFG_Finalized: OS << "CFG finalized"; break;
   case BinaryFunction::State::EmittedCFG:    OS << "emitted with CFG"; break;
   case BinaryFunction::State::Emitted:       OS << "emitted"; break;
   }
 
   return OS;
 }
 
-} // namespace
-
 std::string BinaryFunction::buildCodeSectionName(StringRef Name,
                                                  const BinaryContext &BC) {
   return buildSectionName(BC.isELF() ? ".local.text." : ".l.text.", Name, BC);
 }
 
 std::string BinaryFunction::buildColdCodeSectionName(StringRef Name,
                                                      const BinaryContext &BC) {
   return buildSectionName(BC.isELF() ? ".local.cold.text." : ".l.c.text.", Name,
void BinaryFunction::printRelocations(raw_ostream &OS, uint64_t Offset,
   auto RI = Relocations.lower_bound(Offset);
   while (RI != Relocations.end() && RI->first < Offset + Size) {
     OS << Sep << "(R: " << RI->second << ")";
     Sep = ", ";
     ++RI;
   }
 }
 
-namespace {
-std::string mutateDWARFExpressionTargetReg(const MCCFIInstruction &Instr,
+static std::string mutateDWARFExpressionTargetReg(const MCCFIInstruction &Instr,
                                                   MCPhysReg NewReg) {
   StringRef ExprBytes = Instr.getValues();
   assert(ExprBytes.size() > 1 && "DWARF expression CFI is too short");
   uint8_t Opcode = ExprBytes[0];
   assert((Opcode == dwarf::DW_CFA_expression ||
           Opcode == dwarf::DW_CFA_val_expression) &&
          "invalid DWARF expression CFI");
   (void)Opcode;
   const uint8_t *const Start =
       reinterpret_cast<const uint8_t *>(ExprBytes.drop_front(1).data());
   const uint8_t *const End =
       reinterpret_cast<const uint8_t *>(Start + ExprBytes.size() - 1);
   unsigned Size = 0;
   decodeULEB128(Start, &Size, End);
   assert(Size > 0 && "Invalid reg encoding for DWARF expression CFI");
   SmallString<8> Tmp;
   raw_svector_ostream OSE(Tmp);
   encodeULEB128(NewReg, OSE);
   return Twine(ExprBytes.slice(0, 1))
       .concat(OSE.str())
       .concat(ExprBytes.drop_front(1 + Size))
       .str();
 }
-} // namespace
 
 void BinaryFunction::mutateCFIRegisterFor(const MCInst &Instr,
                                           MCPhysReg NewReg) {
   const MCCFIInstruction *OldCFI = getCFIFor(Instr);
   assert(OldCFI && "invalid CFI instr");
   switch (OldCFI->getOperation()) {
   default:
     llvm_unreachable("Unexpected instruction");
for (MCInst &Inst : *BB) {
                                     *BC.Ctx),
             *BC.Ctx, 0));
         ++OpNum;
       }
     }
   }
 }
 
-namespace {
-
 #ifndef MAX_PATH
 #define MAX_PATH 255
 #endif
 
-std::string constructFilename(std::string Filename, std::string Annotation,
+static std::string constructFilename(std::string Filename,
+                                     std::string Annotation,
                                      std::string Suffix) {
   std::replace(Filename.begin(), Filename.end(), '/', '-');
   if (!Annotation.empty())
     Annotation.insert(0, "-");
   if (Filename.size() + Annotation.size() + Suffix.size() > MAX_PATH) {
     assert(Suffix.size() + Annotation.size() <= MAX_PATH);
     if (opts::Verbosity >= 1) {
       errs() << "BOLT-WARNING: Filename \"" << Filename << Annotation << Suffix
              << "\" exceeds the " << MAX_PATH << " size limit, truncating.\n";
     }
     Filename.resize(MAX_PATH - (Suffix.size() + Annotation.size()));
   }
   Filename += Annotation;
   Filename += Suffix;
   return Filename;
 }
 
-std::string formatEscapes(const std::string &Str) {
+static std::string formatEscapes(const std::string &Str) {
   std::string Result;
   for (unsigned I = 0; I < Str.size(); ++I) {
     char C = Str[I];
     switch (C) {
     case '\n':
       Result += "&#13;";
       break;
     case '"':
       break;
     default:
       Result += C;
       break;
     }
   }
   return Result;
 }
 
-} // namespace
-
 void BinaryFunction::dumpGraph(raw_ostream &OS) const {
   OS << "digraph \"" << getPrintName() << "\" {\n"
      << "node [fontname=courier, shape=box, style=filled, colorscheme=brbg9]\n";
   uint64_t Offset = Address;
   for (BinaryBasicBlock *BB : BasicBlocks) {
     auto LayoutPos = find(Layout.blocks(), BB);
     unsigned LayoutIndex = LayoutPos - Layout.block_begin();
     const char *ColdStr = BB->isCold() ? " (cold)" : "";

bolt/lib/Core/DebugData.cpp

std::optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
   std::optional<uint32_t> Index = AbbrevDecl->findAttributeIndex(Attr);
   if (!Index)
     return std::nullopt;
   return findAttributeInfo(DIE, AbbrevDecl, *Index);
 }
 
 const DebugLineTableRowRef DebugLineTableRowRef::NULL_ROW{0, 0};
 
-namespace {
-
 LLVM_ATTRIBUTE_UNUSED
 static void printLE64(const std::string &S) {
   for (uint32_t I = 0, Size = S.size(); I < Size; ++I) {
     errs() << Twine::utohexstr(S[I]);
     errs() << Twine::utohexstr((int8_t)S[I]);
   }
   errs() << "\n";
 }
 
 // Writes address ranges to Writer as pairs of 64-bit (address, size).
 // If RelativeRange is true, assumes the address range to be written must be of
 // the form (begin address, range size), otherwise (begin address, end address).
 // Terminates the list by writing a pair of two zeroes.
 // Returns the number of written bytes.
-uint64_t writeAddressRanges(raw_svector_ostream &Stream,
-                            const DebugAddressRangesVector &AddressRanges,
-                            const bool WriteRelativeRanges = false) {
+static uint64_t
+writeAddressRanges(raw_svector_ostream &Stream,
   for (const DebugAddressRange &Range : AddressRanges) {
     support::endian::write(Stream, Range.LowPC, support::little);
     support::endian::write(
         Stream, WriteRelativeRanges ? Range.HighPC - Range.LowPC : Range.HighPC,
         support::little);
   }
   // Finish with 0 entries.
   support::endian::write(Stream, 0ULL, support::little);
   support::endian::write(Stream, 0ULL, support::little);
   return AddressRanges.size() * 16 + 16;
 }
 
-} // namespace
-
 DebugRangesSectionWriter::DebugRangesSectionWriter() {
   RangesBuffer = std::make_unique<DebugBufferVector>();
   RangesStream = std::make_unique<raw_svector_ostream>(*RangesBuffer);
 
   // Add an empty range as the first entry;
   SectionOffset +=
       writeAddressRanges(*RangesStream.get(), DebugAddressRangesVector{});
   Kind = RangesWriterKind::DebugRangesWriter;

bolt/lib/Core/Relocation.cpp

 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Object/ELF.h"
 
 using namespace llvm;
 using namespace bolt;
 
 Triple::ArchType Relocation::Arch;
 
-namespace {
-
-bool isSupportedX86(uint64_t Type) {
+static bool isSupportedX86(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_X86_64_8:
   case ELF::R_X86_64_16:
   case ELF::R_X86_64_32:
   case ELF::R_X86_64_32S:
   case ELF::R_X86_64_64:
   case ELF::R_X86_64_PC8:
   case ELF::R_X86_64_PC32:
   case ELF::R_X86_64_PC64:
   case ELF::R_X86_64_PLT32:
   case ELF::R_X86_64_GOTPCREL:
   case ELF::R_X86_64_GOTTPOFF:
   case ELF::R_X86_64_TPOFF32:
   case ELF::R_X86_64_GOTPCRELX:
   case ELF::R_X86_64_REX_GOTPCRELX:
     return true;
   }
 }
 
-bool isSupportedAArch64(uint64_t Type) {
+static bool isSupportedAArch64(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_AARCH64_CALL26:
   case ELF::R_AARCH64_JUMP26:
   case ELF::R_AARCH64_TSTBR14:
   case ELF::R_AARCH64_CONDBR19:
   case ELF::R_AARCH64_ADR_PREL_LO21:
static bool isSupportedAArch64(uint64_t Type) {
   case ELF::R_AARCH64_MOVW_UABS_G1_NC:
   case ELF::R_AARCH64_MOVW_UABS_G2:
   case ELF::R_AARCH64_MOVW_UABS_G2_NC:
   case ELF::R_AARCH64_MOVW_UABS_G3:
     return true;
   }
 }
 
-size_t getSizeForTypeX86(uint64_t Type) {
+static size_t getSizeForTypeX86(uint64_t Type) {
   switch (Type) {
   default:
     errs() << object::getELFRelocationTypeName(ELF::EM_X86_64, Type) << '\n';
     llvm_unreachable("unsupported relocation type");
   case ELF::R_X86_64_8:
   case ELF::R_X86_64_PC8:
     return 1;
   case ELF::R_X86_64_16:
static size_t getSizeForTypeX86(uint64_t Type) {
   case ELF::R_X86_64_REX_GOTPCRELX:
     return 4;
   case ELF::R_X86_64_PC64:
   case ELF::R_X86_64_64:
     return 8;
   }
 }
 
-size_t getSizeForTypeAArch64(uint64_t Type) {
+static size_t getSizeForTypeAArch64(uint64_t Type) {
   switch (Type) {
   default:
     errs() << object::getELFRelocationTypeName(ELF::EM_AARCH64, Type) << '\n';
     llvm_unreachable("unsupported relocation type");
   case ELF::R_AARCH64_ABS16:
   case ELF::R_AARCH64_PREL16:
     return 2;
   case ELF::R_AARCH64_CALL26:
static size_t getSizeForTypeAArch64(uint64_t Type) {
   case ELF::R_AARCH64_ABS32:
     return 4;
   case ELF::R_AARCH64_ABS64:
   case ELF::R_AARCH64_PREL64:
     return 8;
   }
 }
 
-bool skipRelocationTypeX86(uint64_t Type) { return Type == ELF::R_X86_64_NONE; }
+static bool skipRelocationTypeX86(uint64_t Type) {
+  return Type == ELF::R_X86_64_NONE;
+}
 
-bool skipRelocationTypeAArch64(uint64_t Type) {
+static bool skipRelocationTypeAArch64(uint64_t Type) {
   return Type == ELF::R_AARCH64_NONE || Type == ELF::R_AARCH64_LD_PREL_LO19;
 }
 
-bool skipRelocationProcessX86(uint64_t &Type, uint64_t Contents) {
+static bool skipRelocationProcessX86(uint64_t &Type, uint64_t Contents) {
   return false;
 }
 
-bool skipRelocationProcessAArch64(uint64_t &Type, uint64_t Contents) {
+static bool skipRelocationProcessAArch64(uint64_t &Type, uint64_t Contents) {
   auto IsMov = [](uint64_t Contents) -> bool {
     // The bits 28-23 are 0b100101
     return (Contents & 0x1f800000) == 0x12800000;
   };
 
   auto IsB = [](uint64_t Contents) -> bool {
     // The bits 31-26 are 0b000101
     return (Contents & 0xfc000000) == 0x14000000;
static bool skipRelocationProcessAArch64(uint64_t &Type, uint64_t Contents) {
   case ELF::R_AARCH64_LD64_GOT_LO12_NC:
     if (IsAdr(Contents))
       return true;
   }
 
   return false;
 }
 
-uint64_t adjustValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t adjustValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
     llvm_unreachable("not supported relocation");
   case ELF::R_X86_64_32:
     break;
   case ELF::R_X86_64_PC32:
     Value -= PC;
     break;
   }
   return Value;
 }
 
-uint64_t adjustValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t adjustValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
     llvm_unreachable("not supported relocation");
   case ELF::R_AARCH64_ABS32:
     break;
   case ELF::R_AARCH64_PREL16:
   case ELF::R_AARCH64_PREL32:
   case ELF::R_AARCH64_PREL64:
     Value -= PC;
     break;
   }
   return Value;
 }
 
-uint64_t extractValueX86(uint64_t Type, uint64_t Contents, uint64_t PC) {
+static uint64_t extractValueX86(uint64_t Type, uint64_t Contents, uint64_t PC) {
   if (Type == ELF::R_X86_64_32S)
     return SignExtend64<32>(Contents);
   if (Relocation::isPCRelative(Type))
     return SignExtend64(Contents, 8 * Relocation::getSizeForType(Type));
   return Contents;
 }
 
-uint64_t extractValueAArch64(uint64_t Type, uint64_t Contents, uint64_t PC) {
+static uint64_t extractValueAArch64(uint64_t Type, uint64_t Contents,
+                                    uint64_t PC) {
   switch (Type) {
   default:
     errs() << object::getELFRelocationTypeName(ELF::EM_AARCH64, Type) << '\n';
     llvm_unreachable("unsupported relocation type");
   case ELF::R_AARCH64_ABS16:
   case ELF::R_AARCH64_ABS32:
   case ELF::R_AARCH64_ABS64:
     return Contents;
case ELF::R_AARCH64_MOVW_UABS_G0:
     // The shift goest in bits 22:21 of MOV* instructions
     uint8_t Shift = (Contents >> 21) & 0x3;
     // Immediate goes in bits 20:5
     Contents = (Contents >> 5) & 0xffff;
     return Contents << (16 * Shift);
   }
 }
 
-bool isGOTX86(uint64_t Type) {
+static bool isGOTX86(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_X86_64_GOT32:
   case ELF::R_X86_64_GOTPCREL:
   case ELF::R_X86_64_GOTTPOFF:
   case ELF::R_X86_64_GOTOFF64:
   case ELF::R_X86_64_GOTPC32:
   case ELF::R_X86_64_GOT64:
   case ELF::R_X86_64_GOTPCREL64:
   case ELF::R_X86_64_GOTPC64:
   case ELF::R_X86_64_GOTPLT64:
   case ELF::R_X86_64_GOTPC32_TLSDESC:
   case ELF::R_X86_64_GOTPCRELX:
   case ELF::R_X86_64_REX_GOTPCRELX:
     return true;
   }
 }
 
-bool isGOTAArch64(uint64_t Type) {
+static bool isGOTAArch64(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_AARCH64_ADR_GOT_PAGE:
   case ELF::R_AARCH64_LD64_GOT_LO12_NC:
   case ELF::R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
   case ELF::R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
   case ELF::R_AARCH64_TLSDESC_ADR_PREL21:
   case ELF::R_AARCH64_TLSDESC_ADR_PAGE21:
   case ELF::R_AARCH64_TLSDESC_LD64_LO12:
   case ELF::R_AARCH64_TLSDESC_ADD_LO12:
   case ELF::R_AARCH64_TLSDESC_CALL:
     return true;
   }
 }
 
-bool isTLSX86(uint64_t Type) {
+static bool isTLSX86(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_X86_64_TPOFF32:
   case ELF::R_X86_64_TPOFF64:
   case ELF::R_X86_64_GOTTPOFF:
     return true;
   }
 }
 
-bool isTLSAArch64(uint64_t Type) {
+static bool isTLSAArch64(uint64_t Type) {
   switch (Type) {
   default:
     return false;
   case ELF::R_AARCH64_TLSDESC_ADR_PREL21:
   case ELF::R_AARCH64_TLSDESC_ADR_PAGE21:
   case ELF::R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
   case ELF::R_AARCH64_TLSLE_ADD_TPREL_HI12:
   case ELF::R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
   case ELF::R_AARCH64_TLSDESC_LD64_LO12:
   case ELF::R_AARCH64_TLSDESC_ADD_LO12:
   case ELF::R_AARCH64_TLSDESC_CALL:
   case ELF::R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
     return true;
   }
 }
 
-bool isPCRelativeX86(uint64_t Type) {
+static bool isPCRelativeX86(uint64_t Type) {
   switch (Type) {
   default:
     llvm_unreachable("Unknown relocation type");
   case ELF::R_X86_64_64:
   case ELF::R_X86_64_32:
   case ELF::R_X86_64_32S:
   case ELF::R_X86_64_16:
   case ELF::R_X86_64_8:
   case ELF::R_X86_64_TPOFF32:
     return false;
   case ELF::R_X86_64_PC8:
   case ELF::R_X86_64_PC32:
   case ELF::R_X86_64_PC64:
   case ELF::R_X86_64_GOTPCREL:
   case ELF::R_X86_64_PLT32:
   case ELF::R_X86_64_GOTOFF64:
   case ELF::R_X86_64_GOTPC32:
   case ELF::R_X86_64_GOTTPOFF:
   case ELF::R_X86_64_GOTPCRELX:
   case ELF::R_X86_64_REX_GOTPCRELX:
     return true;
   }
 }
 
-bool isPCRelativeAArch64(uint64_t Type) {
+static bool isPCRelativeAArch64(uint64_t Type) {
   switch (Type) {
   default:
     llvm_unreachable("Unknown relocation type");
   case ELF::R_AARCH64_ABS16:
   case ELF::R_AARCH64_ABS32:
   case ELF::R_AARCH64_ABS64:
   case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
   case ELF::R_AARCH64_ADD_ABS_LO12_NC:
static bool isPCRelativeAArch64(uint64_t Type) {
   case ELF::R_AARCH64_TLSDESC_ADR_PAGE21:
   case ELF::R_AARCH64_PREL16:
   case ELF::R_AARCH64_PREL32:
   case ELF::R_AARCH64_PREL64:
     return true;
   }
 }
 
-} // end anonymous namespace
-
 bool Relocation::isSupported(uint64_t Type) {
   if (Arch == Triple::aarch64)
     return isSupportedAArch64(Type);
   return isSupportedX86(Type);
 }
 
 size_t Relocation::getSizeForType(uint64_t Type) {
   if (Arch == Triple::aarch64)

bolt/lib/Passes/Aligner.cpp

UseCompactAligner("use-compact-aligner",
                       cl::desc("Use compact approach for aligning functions"),
                       cl::init(true), cl::cat(BoltOptCategory));
 
 } // end namespace opts
 
 namespace llvm {
 namespace bolt {
 
-namespace {
-
 // Align function to the specified byte-boundary (typically, 64) offsetting
 // the fuction by not more than the corresponding value
-void alignMaxBytes(BinaryFunction &Function) {
+static void alignMaxBytes(BinaryFunction &Function) {
   Function.setAlignment(opts::AlignFunctions);
   Function.setMaxAlignmentBytes(opts::AlignFunctionsMaxBytes);
   Function.setMaxColdAlignmentBytes(opts::AlignFunctionsMaxBytes);
 }
 
 // Align function to the specified byte-boundary (typically, 64) offsetting
 // the fuction by not more than the minimum over
 // -- the size of the function
 // -- the specified number of bytes
-void alignCompact(BinaryFunction &Function, const MCCodeEmitter *Emitter) {
+static void alignCompact(BinaryFunction &Function,
+                         const MCCodeEmitter *Emitter) {
   const BinaryContext &BC = Function.getBinaryContext();
   size_t HotSize = 0;
   size_t ColdSize = 0;
 
   for (const BinaryBasicBlock &BB : Function)
     if (BB.isSplit())
       ColdSize += BC.computeCodeSize(BB.begin(), BB.end(), Emitter);
     else
       HotSize += BC.computeCodeSize(BB.begin(), BB.end(), Emitter);
 
   Function.setAlignment(opts::AlignFunctions);
   if (HotSize > 0)
     Function.setMaxAlignmentBytes(
       std::min(size_t(opts::AlignFunctionsMaxBytes), HotSize));
 
   // using the same option, max-align-bytes, both for cold and hot parts of the
   // functions, as aligning cold functions typically does not affect performance
   if (ColdSize > 0)
     Function.setMaxColdAlignmentBytes(
       std::min(size_t(opts::AlignFunctionsMaxBytes), ColdSize));
 }
 
-} // end anonymous namespace
-
 void AlignerPass::alignBlocks(BinaryFunction &Function,
                               const MCCodeEmitter *Emitter) {
   if (!Function.hasValidProfile() || !Function.isSimple())
     return;
 
   const BinaryContext &BC = Function.getBinaryContext();
 
   const uint64_t FuncCount =

bolt/lib/Passes/AllocCombiner.cpp

 
 extern cl::opt<bolt::FrameOptimizationType> FrameOptimization;
 
 } // end namespace opts
 
 namespace llvm {
 namespace bolt {
 
-namespace {
-
-bool getStackAdjustmentSize(const BinaryContext &BC, const MCInst &Inst,
+static bool getStackAdjustmentSize(const BinaryContext &BC, const MCInst &Inst,
                                    int64_t &Adjustment) {
   return BC.MIB->evaluateStackOffsetExpr(
       Inst, Adjustment, std::make_pair(BC.MIB->getStackPointer(), 0LL),
       std::make_pair(0, 0LL));
 }
 
-bool isIndifferentToSP(const MCInst &Inst, const BinaryContext &BC) {
+static bool isIndifferentToSP(const MCInst &Inst, const BinaryContext &BC) {
   if (BC.MIB->isCFI(Inst))
     return true;
 
   const MCInstrDesc &II = BC.MII->get(Inst.getOpcode());
   if (BC.MIB->isTerminator(Inst) ||
       II.hasImplicitDefOfPhysReg(BC.MIB->getStackPointer(), BC.MRI.get()) ||
       II.hasImplicitUseOfPhysReg(BC.MIB->getStackPointer()))
     return false;
 
   for (const MCOperand &Operand : MCPlus::primeOperands(Inst))
     if (Operand.isReg() && Operand.getReg() == BC.MIB->getStackPointer())
       return false;
   return true;
 }
 
-bool shouldProcess(const BinaryFunction &Function) {
+static bool shouldProcess(const BinaryFunction &Function) {
   return Function.isSimple() && Function.hasCFG() && !Function.isIgnored();
 }
 
-void runForAllWeCare(std::map<uint64_t, BinaryFunction> &BFs,
+static void runForAllWeCare(std::map<uint64_t, BinaryFunction> &BFs,
                             std::function<void(BinaryFunction &)> Task) {
   for (auto &It : BFs) {
     BinaryFunction &Function = It.second;
     if (shouldProcess(Function))
       Task(Function);
   }
 }
 
-} // end anonymous namespace
-
 void AllocCombinerPass::combineAdjustments(BinaryFunction &BF) {
   BinaryContext &BC = BF.getBinaryContext();
   for (BinaryBasicBlock &BB : BF) {
     MCInst *Prev = nullptr;
     for (MCInst &Inst : llvm::reverse(BB)) {
       if (isIndifferentToSP(Inst, BC))
         continue; // Skip updating Prev
 

bolt/lib/Passes/BinaryPasses.cpp

 #include <numeric>
 #include <vector>
 
 #define DEBUG_TYPE "bolt-opts"
 
 using namespace llvm;
 using namespace bolt;
 
-namespace {
-
-const char *dynoStatsOptName(const bolt::DynoStats::Category C) {
+static const char *dynoStatsOptName(const bolt::DynoStats::Category C) {
   assert(C > bolt::DynoStats::FIRST_DYNO_STAT &&
          C < DynoStats::LAST_DYNO_STAT && "Unexpected dyno stat category.");
 
   static std::string OptNames[bolt::DynoStats::LAST_DYNO_STAT + 1];
 
   OptNames[C] = bolt::DynoStats::Description(C);
 
   std::replace(OptNames[C].begin(), OptNames[C].end(), ' ', '-');
 
   return OptNames[C].c_str();
 }
-}
 
 namespace opts {
 
 extern cl::OptionCategory BoltCategory;
 extern cl::OptionCategory BoltOptCategory;
 
 extern cl::opt<bolt::MacroFusionType> AlignMacroOpFusion;
 extern cl::opt<unsigned> Verbosity;
void LowerAnnotations::runOnFunctions(BinaryContext &BC) {
   // Release all memory taken by annotations
   BC.MIB->freeAnnotations();
 
   // Reinsert preserved annotations we need during code emission.
   for (const std::pair<MCInst *, uint32_t> &Item : PreservedOffsetAnnotations)
     BC.MIB->setOffset(*Item.first, Item.second);
 }
 
-namespace {
-
 // This peephole fixes jump instructions that jump to another basic
 // block with a single jump instruction, e.g.
 //
 // B0: ...
 //     jmp  B1   (or jcc B1)
 //
 // B1: jmp  B2
 //
 // ->
 //
 // B0: ...
 //     jmp  B2   (or jcc B2)
 //
-uint64_t fixDoubleJumps(BinaryFunction &Function, bool MarkInvalid) {
+static uint64_t fixDoubleJumps(BinaryFunction &Function, bool MarkInvalid) {
   uint64_t NumDoubleJumps = 0;
 
   MCContext *Ctx = Function.getBinaryContext().Ctx.get();
   MCPlusBuilder *MIB = Function.getBinaryContext().MIB.get();
   for (BinaryBasicBlock &BB : Function) {
     auto checkAndPatch = [&](BinaryBasicBlock *Pred, BinaryBasicBlock *Succ,
                              const MCSymbol *SuccSym) {
       // Ignore infinite loop jumps or fallthrough tail jumps.
for (BinaryBasicBlock *Pred : Preds) {
         if (checkAndPatch(Pred, Succ, SuccSym) && MarkInvalid)
           BB.markValid(BB.pred_size() != 0 || BB.isLandingPad() ||
                        BB.isEntryPoint());
     }
   }
 
   return NumDoubleJumps;
 }
-} // namespace
 
 bool SimplifyConditionalTailCalls::shouldRewriteBranch(
     const BinaryBasicBlock *PredBB, const MCInst &CondBranch,
     const BinaryBasicBlock *BB, const bool DirectionFlag) {
   if (BeenOptimized.count(PredBB))
     return false;
 
   const bool IsForward = BinaryFunction::isForwardBranch(PredBB, BB);

bolt/lib/Passes/CallGraph.cpp

 #if defined(__x86_64__) && !defined(_MSC_VER)
 #  if (!defined USE_SSECRC)
 #    define USE_SSECRC
 #  endif
 #else
 #  undef USE_SSECRC
 #endif
 
-namespace {
-
-LLVM_ATTRIBUTE_UNUSED inline size_t hash_int64_fallback(int64_t k) {
+static LLVM_ATTRIBUTE_UNUSED inline size_t hash_int64_fallback(int64_t k) {
   uint64_t key = (unsigned long long)k;
   // "64 bit Mix Functions", from Thomas Wang's "Integer Hash Function."
   // http://www.concentric.net/~ttwang/tech/inthash.htm
   key = (~key) + (key << 21); // key = (key << 21) - key - 1;
   key = key ^ (key >> 24);
   key = (key + (key << 3)) + (key << 8); // key * 265
   key = key ^ (key >> 14);
   key = (key + (key << 2)) + (key << 4); // key * 21
   key = key ^ (key >> 28);
   return static_cast<size_t>(static_cast<uint32_t>(key));
 }
 
-LLVM_ATTRIBUTE_UNUSED inline size_t hash_int64(int64_t k) {
+static LLVM_ATTRIBUTE_UNUSED inline size_t hash_int64(int64_t k) {
 #if defined(USE_SSECRC) && defined(__SSE4_2__)
   size_t h = 0;
   __asm("crc32q %1, %0\n" : "+r"(h) : "rm"(k));
   return h;
 #else
   return hash_int64_fallback(k);
 #endif
 }
 
-inline size_t hash_int64_pair(int64_t k1, int64_t k2) {
+static inline size_t hash_int64_pair(int64_t k1, int64_t k2) {
 #if defined(USE_SSECRC) && defined(__SSE4_2__)
   // crc32 is commutative, so we need to perturb k1 so that (k1, k2) hashes
   // differently from (k2, k1).
   k1 += k1;
   __asm("crc32q %1, %0\n" : "+r" (k1) : "rm"(k2));
   return k1;
 #else
   return (hash_int64(k1) << 1) ^ hash_int64(k2);
 #endif
 }
 
-}
-
 namespace llvm {
 namespace bolt {
 
 int64_t CallGraph::Arc::Hash::operator()(const Arc &Arc) const {
 #ifdef USE_STD_HASH
   std::hash<int64_t> Hasher;
   return hashCombine(Hasher(Arc.src()), Arc.dst());
 #else

bolt/lib/Passes/IdenticalCodeFolding.cpp

 static cl::opt<bool>
 TimeICF("time-icf",
   cl::desc("time icf steps"),
   cl::ReallyHidden,
   cl::ZeroOrMore,
   cl::cat(BoltOptCategory));
 } // namespace opts
 
-namespace {
-using JumpTable = bolt::JumpTable;
-
 /// Compare two jump tables in 2 functions. The function relies on consistent
 /// ordering of basic blocks in both binary functions (e.g. DFS).
-bool equalJumpTables(const JumpTable &JumpTableA, const JumpTable &JumpTableB,
+static bool equalJumpTables(const JumpTable &JumpTableA,
+                            const JumpTable &JumpTableB,
                             const BinaryFunction &FunctionA,
                             const BinaryFunction &FunctionB) {
   if (JumpTableA.EntrySize != JumpTableB.EntrySize)
     return false;
 
   if (JumpTableA.Type != JumpTableB.Type)
     return false;
 
   if (JumpTableA.getSize() != JumpTableB.getSize())
     return false;
static bool equalJumpTables(const JumpTable &JumpTableA,
 
   return true;
 }
 
 /// Helper function that compares an instruction of this function to the
 /// given instruction of the given function. The functions should have
 /// identical CFG.
 template <class Compare>
-bool isInstrEquivalentWith(const MCInst &InstA, const BinaryBasicBlock &BBA,
-                           const MCInst &InstB, const BinaryBasicBlock &BBB,
-                           Compare Comp) {
+static bool isInstrEquivalentWith(const MCInst &InstA,
+                                  const BinaryBasicBlock &BBA,
+                                  const MCInst &InstB,
+                                  const BinaryBasicBlock &BBB, Compare Comp) {
   if (InstA.getOpcode() != InstB.getOpcode())
     return false;
 
   const BinaryContext &BC = BBA.getFunction()->getBinaryContext();
 
   // In this function we check for special conditions:
   //
   //    * instructions with landing pads

 }
 
 /// Returns true if this function has identical code and CFG with
 /// the given function \p BF.
 ///
 /// If \p CongruentSymbols is set to true, then symbolic operands that reference
 /// potentially identical but different functions are ignored during the
 /// comparison.
-bool isIdenticalWith(const BinaryFunction &A, const BinaryFunction &B,
+static bool isIdenticalWith(const BinaryFunction &A, const BinaryFunction &B,
                             bool CongruentSymbols) {
   assert(A.hasCFG() && B.hasCFG() && "both functions should have CFG");
 
   // Compare the two functions, one basic block at a time.
   // Currently we require two identical basic blocks to have identical
   // instruction sequences and the same index in their corresponding
   // functions. The latter is important for CFG equality.
 
   if (A.getLayout().block_size() != B.getLayout().block_size())

 typedef std::unordered_map<BinaryFunction *, std::set<BinaryFunction *>,
                            KeyHash, KeyCongruent>
     CongruentBucketsMap;
 
 typedef std::unordered_map<BinaryFunction *, std::vector<BinaryFunction *>,
                            KeyHash, KeyEqual>
     IdenticalBucketsMap;
 
-std::string hashInteger(uint64_t Value) {
+static std::string hashInteger(uint64_t Value) {
   std::string HashString;
   if (Value == 0)
     HashString.push_back(0);
 
   while (Value) {
     uint8_t LSB = Value & 0xff;
     HashString.push_back(LSB);
     Value >>= 8;
   }
 
   return HashString;
 }
 
-std::string hashSymbol(BinaryContext &BC, const MCSymbol &Symbol) {
+static std::string hashSymbol(BinaryContext &BC, const MCSymbol &Symbol) {
   std::string HashString;
 
   // Ignore function references.
   if (BC.getFunctionForSymbol(&Symbol))
     return HashString;
 
   llvm::ErrorOr<uint64_t> ErrorOrValue = BC.getSymbolValue(Symbol);
   if (!ErrorOrValue)
     return HashString;
 
   // Ignore jump table references.
   if (BC.getJumpTableContainingAddress(*ErrorOrValue))
     return HashString;
 
   return HashString.append(hashInteger(*ErrorOrValue));
 }
 
-std::string hashExpr(BinaryContext &BC, const MCExpr &Expr) {
+static std::string hashExpr(BinaryContext &BC, const MCExpr &Expr) {
   switch (Expr.getKind()) {
   case MCExpr::Constant:
     return hashInteger(cast<MCConstantExpr>(Expr).getValue());
   case MCExpr::SymbolRef:
     return hashSymbol(BC, cast<MCSymbolRefExpr>(Expr).getSymbol());
   case MCExpr::Unary: {
     const auto &UnaryExpr = cast<MCUnaryExpr>(Expr);
     return hashInteger(UnaryExpr.getOpcode())
         .append(hashExpr(BC, *UnaryExpr.getSubExpr()));
   }
   case MCExpr::Binary: {
     const auto &BinaryExpr = cast<MCBinaryExpr>(Expr);
     return hashExpr(BC, *BinaryExpr.getLHS())
         .append(hashInteger(BinaryExpr.getOpcode()))
         .append(hashExpr(BC, *BinaryExpr.getRHS()));
   }
   case MCExpr::Target:
     return std::string();
   }
 
   llvm_unreachable("invalid expression kind");
 }
 
-std::string hashInstOperand(BinaryContext &BC, const MCOperand &Operand) {
+static std::string hashInstOperand(BinaryContext &BC,
+                                   const MCOperand &Operand) {
   if (Operand.isImm())
     return hashInteger(Operand.getImm());
   if (Operand.isReg())
     return hashInteger(Operand.getReg());
   if (Operand.isExpr())
     return hashExpr(BC, *Operand.getExpr());
 
   return std::string();
 }
 
-} // namespace
-
 namespace llvm {
 namespace bolt {
 
 void IdenticalCodeFolding::runOnFunctions(BinaryContext &BC) {
   const size_t OriginalFunctionCount = BC.getBinaryFunctions().size();
   uint64_t NumFunctionsFolded = 0;
   std::atomic<uint64_t> NumJTFunctionsFolded{0};
   std::atomic<uint64_t> BytesSavedEstimate{0};

bolt/lib/Passes/Instrumentation.cpp

Instrumentation::createInstrumentationSnippet(BinaryContext &BC, bool IsLeaf) {
   MCSymbol *Label;
   Label = BC.Ctx->createNamedTempSymbol("InstrEntry");
   Summary->Counters.emplace_back(Label);
   InstructionListType CounterInstrs;
   BC.MIB->createInstrIncMemory(CounterInstrs, Label, &*BC.Ctx, IsLeaf);
   return CounterInstrs;
 }
 
-namespace {
-
 // Helper instruction sequence insertion function
-BinaryBasicBlock::iterator insertInstructions(InstructionListType &Instrs,
-                                              BinaryBasicBlock &BB,
-                                              BinaryBasicBlock::iterator Iter) {
+static BinaryBasicBlock::iterator
+insertInstructions(InstructionListType &Instrs, BinaryBasicBlock &BB,
   for (MCInst &NewInst : Instrs) {
     Iter = BB.insertInstruction(Iter, NewInst);
     ++Iter;
   }
   return Iter;
 }
-} // namespace
 
 void Instrumentation::instrumentLeafNode(BinaryBasicBlock &BB,
                                          BinaryBasicBlock::iterator Iter,
                                          bool IsLeaf,
                                          FunctionDescription &FuncDesc,
                                          uint32_t Node) {
   createLeafNodeDescription(FuncDesc, Node);
   InstructionListType CounterInstrs = createInstrumentationSnippet(

bolt/lib/Passes/LongJmp.cpp

 static cl::opt<bool> GroupStubs("group-stubs",
                                 cl::desc("share stubs across functions"),
                                 cl::init(true), cl::cat(BoltOptCategory));
 }
 
 namespace llvm {
 namespace bolt {
 
-namespace {
 constexpr unsigned ColdFragAlign = 16;
 
-void relaxStubToShortJmp(BinaryBasicBlock &StubBB, const MCSymbol *Tgt) {
+static void relaxStubToShortJmp(BinaryBasicBlock &StubBB, const MCSymbol *Tgt) {
   const BinaryContext &BC = StubBB.getFunction()->getBinaryContext();
   InstructionListType Seq;
   BC.MIB->createShortJmp(Seq, Tgt, BC.Ctx.get());
   StubBB.clear();
   StubBB.addInstructions(Seq.begin(), Seq.end());
 }
 
-void relaxStubToLongJmp(BinaryBasicBlock &StubBB, const MCSymbol *Tgt) {
+static void relaxStubToLongJmp(BinaryBasicBlock &StubBB, const MCSymbol *Tgt) {
   const BinaryContext &BC = StubBB.getFunction()->getBinaryContext();
   InstructionListType Seq;
   BC.MIB->createLongJmp(Seq, Tgt, BC.Ctx.get());
   StubBB.clear();
   StubBB.addInstructions(Seq.begin(), Seq.end());
 }
 
-BinaryBasicBlock *getBBAtHotColdSplitPoint(BinaryFunction &Func) {
+static BinaryBasicBlock *getBBAtHotColdSplitPoint(BinaryFunction &Func) {
   if (!Func.isSplit() || Func.empty())
     return nullptr;
 
   assert(!(*Func.begin()).isCold() && "Entry cannot be cold");
   for (auto I = Func.getLayout().block_begin(),
             E = Func.getLayout().block_end();
        I != E; ++I) {
     auto Next = std::next(I);
     if (Next != E && (*Next)->isCold())
       return *I;
   }
   llvm_unreachable("No hot-colt split point found");
 }
 
-bool shouldInsertStub(const BinaryContext &BC, const MCInst &Inst) {
+static bool shouldInsertStub(const BinaryContext &BC, const MCInst &Inst) {
   return (BC.MIB->isBranch(Inst) || BC.MIB->isCall(Inst)) &&
          !BC.MIB->isIndirectBranch(Inst) && !BC.MIB->isIndirectCall(Inst);
 }
 
-} // end anonymous namespace
-
 std::pair<std::unique_ptr<BinaryBasicBlock>, MCSymbol *>
 LongJmpPass::createNewStub(BinaryBasicBlock &SourceBB, const MCSymbol *TgtSym,
                            bool TgtIsFunc, uint64_t AtAddress) {
   BinaryFunction &Func = *SourceBB.getFunction();
   const BinaryContext &BC = Func.getBinaryContext();
   const bool IsCold = SourceBB.isCold();
   MCSymbol *StubSym = BC.Ctx->createNamedTempSymbol("Stub");
   std::unique_ptr<BinaryBasicBlock> StubBB = Func.createBasicBlock(StubSym);