Merge branch 'main' into fix/172104-clang-cl-simd-intrinsics

Author: dev-priyanshu15

.github/workflows/containers/github-action-ci-tooling/Dockerfile

@@ -109,14 +109,7 @@ RUN apt-get update && \
     abi-dumper \
     autoconf \
     parallel \
-    pkg-config && \
+    pkg-config \
+    universal-ctags && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
-
-RUN git clone https://github.com/universal-ctags/ctags.git && \
-    cd ctags && \
-    ./autogen.sh && \
-    ./configure && \
-    sudo make install && \
-    rm -Rf ../ctags
-

bolt/include/bolt/Core/BinaryContext.h

@@ -65,6 +65,9 @@ namespace bolt {
 
 class BinaryFunction;
 
+using BinaryFunctionListType = std::vector<BinaryFunction *>;
+using ConstBinaryFunctionListType = std::vector<const BinaryFunction *>;
+
 /// Information on loadable part of the file.
 struct SegmentInfo {
   uint64_t Address;           /// Address of the segment in memory.
@@ -228,11 +231,11 @@ class BinaryContext {
   /// Store all functions in the binary, sorted by original address.
   std::map<uint64_t, BinaryFunction> BinaryFunctions;
 
-  /// A mutex that is used to control parallel accesses to BinaryFunctions
+  /// A mutex that is used to control parallel accesses to BinaryFunctions.
   mutable llvm::sys::RWMutex BinaryFunctionsMutex;
 
-  /// Functions injected by BOLT
-  std::vector<BinaryFunction *> InjectedBinaryFunctions;
+  /// Functions injected by BOLT.
+  BinaryFunctionListType InjectedBinaryFunctions;
 
   /// Jump tables for all functions mapped by address.
   std::map<uint64_t, JumpTable *> JumpTables;
@@ -567,13 +570,13 @@ class BinaryContext {
                          const InstructionListType &Instructions,
                          const Twine &Name = "");
 
-  std::vector<BinaryFunction *> &getInjectedBinaryFunctions() {
+  BinaryFunctionListType &getInjectedBinaryFunctions() {
     return InjectedBinaryFunctions;
   }
 
   /// Return vector with all functions, i.e. include functions from the input
   /// binary and functions created by BOLT.
-  std::vector<BinaryFunction *> getAllBinaryFunctions();
+  BinaryFunctionListType getAllBinaryFunctions();
 
   /// Construct a jump table for \p Function at \p Address or return an existing
   /// one at that location.
@@ -1385,7 +1388,7 @@ class BinaryContext {
                                   const uint32_t SrcCUID, unsigned FileIndex);
 
   /// Return functions in output layout order
-  std::vector<BinaryFunction *> getSortedFunctions();
+  BinaryFunctionListType getSortedFunctions();
 
   /// Do the best effort to calculate the size of the function by emitting
   /// its code, and relaxing branch instructions. By default, branch

bolt/include/bolt/Core/BinaryFunctionCallGraph.h

@@ -9,6 +9,7 @@
 #ifndef BOLT_PASSES_BINARY_FUNCTION_CALLGRAPH_H
 #define BOLT_PASSES_BINARY_FUNCTION_CALLGRAPH_H
 
+#include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/CallGraph.h"
 #include <deque>
 #include <functional>
@@ -18,7 +19,6 @@ namespace llvm {
 namespace bolt {
 
 class BinaryFunction;
-class BinaryContext;
 
 class BinaryFunctionCallGraph : public CallGraph {
 public:
@@ -46,7 +46,7 @@ class BinaryFunctionCallGraph : public CallGraph {
 
 private:
   std::unordered_map<const BinaryFunction *, NodeId> FuncToNodeId;
-  std::vector<BinaryFunction *> Funcs;
+  BinaryFunctionListType Funcs;
 };
 
 using CgFilterFunction = std::function<bool(const BinaryFunction &BF)>;

bolt/include/bolt/Passes/CacheMetrics.h

@@ -13,19 +13,18 @@
 #ifndef BOLT_PASSES_CACHEMETRICS_H
 #define BOLT_PASSES_CACHEMETRICS_H
 
+#include "bolt/Core/BinaryContext.h"
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace bolt {
-class BinaryFunction;
 namespace CacheMetrics {
 
 /// Calculate and print various metrics related to instruction cache performance
-void printAll(raw_ostream &OS,
-              const std::vector<BinaryFunction *> &BinaryFunctions);
+void printAll(raw_ostream &OS, const BinaryFunctionListType &BinaryFunctions);
 
 } // namespace CacheMetrics
 } // namespace bolt

bolt/include/bolt/Passes/LongJmp.h

@@ -82,15 +82,13 @@ class LongJmpPass : public BinaryFunctionPass {
   /// purposes, we need to do a size worst-case estimation. Real layout is done
   /// by RewriteInstance::mapFileSections()
   void tentativeLayout(const BinaryContext &BC,
-                       std::vector<BinaryFunction *> &SortedFunctions);
-  uint64_t
-  tentativeLayoutRelocMode(const BinaryContext &BC,
-                           std::vector<BinaryFunction *> &SortedFunctions,
-                           uint64_t DotAddress);
-  uint64_t
-  tentativeLayoutRelocColdPart(const BinaryContext &BC,
-                               std::vector<BinaryFunction *> &SortedFunctions,
-                               uint64_t DotAddress);
+                       BinaryFunctionListType &SortedFunctions);
+  uint64_t tentativeLayoutRelocMode(const BinaryContext &BC,
+                                    BinaryFunctionListType &SortedFunctions,
+                                    uint64_t DotAddress);
+  uint64_t tentativeLayoutRelocColdPart(const BinaryContext &BC,
+                                        BinaryFunctionListType &SortedFunctions,
+                                        uint64_t DotAddress);
   void tentativeBBLayout(const BinaryFunction &Func);
 
   /// Update stubs addresses with their exact address after a round of stub

bolt/include/bolt/Profile/YAMLProfileReader.h

@@ -68,7 +68,7 @@ class YAMLProfileReader : public ProfileReaderBase {
     }
 
     /// Returns the binary functions with the parameter neighbor hash.
-    std::optional<std::vector<BinaryFunction *>>
+    std::optional<BinaryFunctionListType>
     getBFsWithNeighborHash(uint64_t NeighborHash) {
       auto It = NeighborHashToBFs.find(NeighborHash);
       return It == NeighborHashToBFs.end() ? std::nullopt
@@ -93,7 +93,7 @@ class YAMLProfileReader : public ProfileReaderBase {
     DenseMap<BinaryFunction *, std::set<BinaryFunction *>> BFAdjacencyMap;
 
     /// Maps neighbor hashes to binary functions.
-    DenseMap<uint64_t, std::vector<BinaryFunction *>> NeighborHashToBFs;
+    DenseMap<uint64_t, BinaryFunctionListType> NeighborHashToBFs;
 
     /// Adjacency map for profile functions in the call graph.
     DenseMap<yaml::bolt::BinaryFunctionProfile *,
@@ -187,7 +187,7 @@ class YAMLProfileReader : public ProfileReaderBase {
   StringSet<> ProfileFunctionNames;
 
   /// BinaryFunction pointers indexed by YamlBP functions.
-  std::vector<BinaryFunction *> ProfileBFs;
+  BinaryFunctionListType ProfileBFs;
 
   // Pseudo probe function GUID to inline tree node
   GUIDInlineTreeMap TopLevelGUIDToInlineTree;

bolt/lib/Core/BinaryContext.cpp

@@ -826,7 +826,7 @@ void BinaryContext::populateJumpTables() {
 }
 
 void BinaryContext::skipMarkedFragments() {
-  std::vector<BinaryFunction *> FragmentQueue;
+  BinaryFunctionListType FragmentQueue;
   // Copy the functions to FragmentQueue.
   FragmentQueue.assign(FragmentsToSkip.begin(), FragmentsToSkip.end());
   auto addToWorklist = [&](BinaryFunction *Function) -> void {
@@ -1715,8 +1715,8 @@ unsigned BinaryContext::addDebugFilenameToUnit(const uint32_t DestCUID,
                                DestCUID, DstUnit->getVersion()));
 }
 
-std::vector<BinaryFunction *> BinaryContext::getSortedFunctions() {
-  std::vector<BinaryFunction *> SortedFunctions(BinaryFunctions.size());
+BinaryFunctionListType BinaryContext::getSortedFunctions() {
+  BinaryFunctionListType SortedFunctions(BinaryFunctions.size());
   llvm::transform(llvm::make_second_range(BinaryFunctions),
                   SortedFunctions.begin(),
                   [](BinaryFunction &BF) { return &BF; });
@@ -1725,8 +1725,8 @@ std::vector<BinaryFunction *> BinaryContext::getSortedFunctions() {
   return SortedFunctions;
 }
 
-std::vector<BinaryFunction *> BinaryContext::getAllBinaryFunctions() {
-  std::vector<BinaryFunction *> AllFunctions;
+BinaryFunctionListType BinaryContext::getAllBinaryFunctions() {
+  BinaryFunctionListType AllFunctions;
   AllFunctions.reserve(BinaryFunctions.size() + InjectedBinaryFunctions.size());
   llvm::transform(llvm::make_second_range(BinaryFunctions),
                   std::back_inserter(AllFunctions),

bolt/lib/Core/BinaryEmitter.cpp

@@ -232,7 +232,7 @@ void BinaryEmitter::emitAll(StringRef OrgSecPrefix) {
 }
 
 void BinaryEmitter::emitFunctions() {
-  auto emit = [&](const std::vector<BinaryFunction *> &Functions) {
+  auto emit = [&](const BinaryFunctionListType &Functions) {
     const bool HasProfile = BC.NumProfiledFuncs > 0;
     const bool OriginalAllowAutoPadding = Streamer.getAllowAutoPadding();
     for (BinaryFunction *Function : Functions) {
@@ -282,7 +282,7 @@ void BinaryEmitter::emitFunctions() {
   }
 
   // Emit functions in sorted order.
-  std::vector<BinaryFunction *> SortedFunctions = BC.getSortedFunctions();
+  BinaryFunctionListType SortedFunctions = BC.getSortedFunctions();
   emit(SortedFunctions);
 
   // Emit functions added by BOLT.

bolt/lib/Passes/BinaryPasses.cpp

@@ -1609,7 +1609,7 @@ Error PrintProgramStats::runOnFunctions(BinaryContext &BC) {
   }
 
   if (!opts::PrintSortedBy.empty()) {
-    std::vector<BinaryFunction *> Functions;
+    BinaryFunctionListType Functions;
     std::map<const BinaryFunction *, DynoStats> Stats;
 
     for (auto &BFI : BC.getBinaryFunctions()) {
@@ -1700,7 +1700,7 @@ Error PrintProgramStats::runOnFunctions(BinaryContext &BC) {
 
   // Collect and print information about suboptimal code layout on input.
   if (opts::ReportBadLayout) {
-    std::vector<BinaryFunction *> SuboptimalFuncs;
+    BinaryFunctionListType SuboptimalFuncs;
     for (auto &BFI : BC.getBinaryFunctions()) {
       BinaryFunction &BF = BFI.second;
       if (!BF.hasValidProfile())

bolt/lib/Passes/CacheMetrics.cpp

@@ -30,7 +30,7 @@ constexpr unsigned ITLBEntries = 16;
 
 /// Initialize and return a position map for binary basic blocks
 void extractBasicBlockInfo(
-    const std::vector<BinaryFunction *> &BinaryFunctions,
+    const BinaryFunctionListType &BinaryFunctions,
     std::unordered_map<BinaryBasicBlock *, uint64_t> &BBAddr,
     std::unordered_map<BinaryBasicBlock *, uint64_t> &BBSize) {
 
@@ -54,7 +54,7 @@ void extractBasicBlockInfo(
 /// the ordering of basic blocks. The method returns a pair
 /// (the number of fallthrough branches, the total number of branches)
 std::pair<uint64_t, uint64_t>
-calcTSPScore(const std::vector<BinaryFunction *> &BinaryFunctions,
+calcTSPScore(const BinaryFunctionListType &BinaryFunctions,
              const std::unordered_map<BinaryBasicBlock *, uint64_t> &BBAddr,
              const std::unordered_map<BinaryBasicBlock *, uint64_t> &BBSize) {
   uint64_t Score = 0;
@@ -95,7 +95,7 @@ using Predecessors = std::vector<std::pair<BinaryFunction *, uint64_t>>;
 /// Build a simplified version of the call graph: For every function, keep
 /// its callers and the frequencies of the calls
 std::unordered_map<const BinaryFunction *, Predecessors>
-extractFunctionCalls(const std::vector<BinaryFunction *> &BinaryFunctions) {
+extractFunctionCalls(const BinaryFunctionListType &BinaryFunctions) {
   std::unordered_map<const BinaryFunction *, Predecessors> Calls;
 
   for (BinaryFunction *SrcFunction : BinaryFunctions) {
@@ -140,7 +140,7 @@ extractFunctionCalls(const std::vector<BinaryFunction *> &BinaryFunctions) {
 /// the page. The following procedure detects short and long calls, and
 /// estimates the expected number of cache misses for the long ones.
 double expectedCacheHitRatio(
-    const std::vector<BinaryFunction *> &BinaryFunctions,
+    const BinaryFunctionListType &BinaryFunctions,
     const std::unordered_map<BinaryBasicBlock *, uint64_t> &BBAddr,
     const std::unordered_map<BinaryBasicBlock *, uint64_t> &BBSize) {
   std::unordered_map<const BinaryFunction *, Predecessors> Calls =
@@ -213,7 +213,7 @@ double expectedCacheHitRatio(
 } // namespace
 
 void CacheMetrics::printAll(raw_ostream &OS,
-                            const std::vector<BinaryFunction *> &BFs) {
+                            const BinaryFunctionListType &BFs) {
   // Stats related to hot-cold code splitting
   size_t NumFunctions = 0;
   size_t NumProfiledFunctions = 0;