Remove the Section structure

ELF/CallGraphSort.cpp

double getDensity() const {
     if (Size == 0)
       return 0;
     return double(Weight) / double(Size);
   }
 
   std::vector<int> Sections;
   size_t Size = 0;
   uint64_t Weight = 0;
-};
-
-struct Section {
-  Section(const InputSectionBase *IS) : ISB(IS) { Size = ISB->getSize(); }
-
-  double getDensity() const {
-    if (Size == 0)
-      return 0;
-    return double(Weight) / double(Size);
-  }
-
-  size_t Size = 0;
-  uint64_t Weight = 0;
-  const InputSectionBase *ISB;
   std::vector<int> Preds;
   std::vector<int> Succs;
 };
 
 struct Edge {
   int From;
   int To;
   uint64_t Weight;
public:
   CallGraphSort();
 
   DenseMap<const InputSectionBase *, int> run();
 
 private:
   DenseMap<Edge, int, EdgeDenseMapInfo> EdgeMap;
   std::vector<Cluster> Clusters;
   std::vector<Edge> Edges;
-  std::vector<Section> Sections;
+  std::vector<const InputSectionBase *> Sections;
 
   void normalizeEdgeWeights();
   void generateClusters();
 };
 
 // Maximum ammount the combined cluster density can be worse than the original
 // cluster to consider merging.
 constexpr int MAX_DENSITY_DEGRADATION = 8;
 
 // Maximum cluster size in bytes.
 constexpr uint64_t MAX_CLUSTER_SIZE = 1024 * 1024;
 
 // Minimum edge probability to consider merging.
 constexpr double MIN_EDGE_PROBABILITY = 0.1;
 } // end anonymous namespace
 
 // Take the edge list in Config->CallGraphProfile, resolve symbol names to
 // Symbols, and generate a graph between InputSections with the provided
 // weights.
 CallGraphSort::CallGraphSort() {
   llvm::MapVector<std::pair<const Symbol *, const Symbol *>, uint64_t>
       &Profile = Config->CallGraphProfile;
-  DenseMap<const InputSectionBase *, int> SecToSec;
+  DenseMap<const InputSectionBase *, int> SecToCluster;
 
   auto GetOrCreateNode = [&](const InputSectionBase *IS) -> int {
-    auto Res = SecToSec.insert(std::make_pair(IS, Sections.size()));
-    if (Res.second)
-      Sections.emplace_back(IS);
+    auto Res = SecToCluster.insert(std::make_pair(IS, Clusters.size()));
+    if (Res.second) {
+      Sections.push_back(IS);
+      Clusters.emplace_back(Clusters.size(), IS);
+    }
     return Res.first->second;
   };
 
   // Create the graph.
   for (const auto &C : Profile) {
     warnUnorderableSymbol(C.first.first);
     warnUnorderableSymbol(C.first.second);
     const Defined *FromSym = dyn_cast<Defined>(C.first.first);
for (const auto &C : Profile) {
     // would also end up moving input sections in other output sections without
     // moving them closer to what calls them.
     if (FromSB->getOutputSection() != ToSB->getOutputSection())
       continue;
 
     int From = GetOrCreateNode(FromSB);
     int To = GetOrCreateNode(ToSB);
 
-    Sections[To].Weight += Weight;
+    Clusters[To].Weight += Weight;
 
     if (From == To)
       continue;
 
     Edge E{From, To, Weight, 0};
 
     // Add or increment an edge
     auto Res = EdgeMap.insert(std::make_pair(E, Edges.size()));
     int EI = Res.first->second;
     if (Res.second) {
       Edges.push_back(E);
-      Sections[From].Succs.push_back(To);
-      Sections[To].Preds.push_back(From);
+      Clusters[From].Succs.push_back(To);
+      Clusters[To].Preds.push_back(From);
     } else
       Edges[EI].Weight += Weight;
   }
   normalizeEdgeWeights();
 }
 
 // Normalize the edge weights so that we can reject edges which have a low
 // probibility.
 void CallGraphSort::normalizeEdgeWeights() {
-  for (int SI = 0, SE = Sections.size(); SI != SE; ++SI) {
-    Section &S = Sections[SI];
+  for (int SI = 0, SE = Clusters.size(); SI != SE; ++SI) {
+    Cluster &S = Clusters[SI];
     for (int PI : S.Preds) {
       Edge &E = Edges[EdgeMap[{PI, SI, 0, 0}]];
       if (S.Weight == 0)
         continue;
       E.NormalizedWeight = double(E.Weight) / double(S.Weight);
     }
   }
 }
static void mergeClusters(Cluster &Into, Cluster &From) {
   From.Sections.clear();
   From.Size = 0;
   From.Weight = 0;
 }
 
 // Group InputSections into clusters using the Call-Chain Clustering heuristic
 // then sort the clusters by density.
 void CallGraphSort::generateClusters() {
-  std::vector<int> SortedSecs;
-  std::vector<Cluster *> SecToCluster(Sections.size());
-
-  Clusters.reserve(Sections.size());
+  std::vector<int> SortedSecs(Clusters.size());
+  std::vector<Cluster *> SecToCluster(Clusters.size());
 
-  for (int SI = 0, SE = Sections.size(); SI != SE; ++SI) {
-    Cluster C(SI, Sections[SI].ISB);
-    C.Size = Sections[SI].Size;
-    C.Weight = Sections[SI].Weight;
-    Clusters.push_back(C);
-    SortedSecs.push_back(SI);
-    SecToCluster[SI] = &Clusters.back();
+  for (int SI = 0, SE = Clusters.size(); SI != SE; ++SI) {
+    SortedSecs[SI] = SI;
+    SecToCluster[SI] = &Clusters[SI];
   }
 
   std::stable_sort(SortedSecs.begin(), SortedSecs.end(), [&](int A, int B) {
-    return Sections[B].getDensity() < Sections[A].getDensity();
+    return Clusters[B].getDensity() < Clusters[A].getDensity();
   });
 
   for (int SI : SortedSecs) {
     Cluster &C = *SecToCluster[SI];
 
     int BestPred = -1;
     double BestWeight = 0;
 
-    for (int PI : Sections[SI].Preds) {
+    for (int PI : Clusters[SI].Preds) {
       Edge &E = Edges[EdgeMap[{PI, SI, 0, 0}]];
       if (BestPred == -1 || E.NormalizedWeight > BestWeight) {
         BestPred = PI;
         BestWeight = E.NormalizedWeight;
       }
     }
 
     if (BestWeight < MIN_EDGE_PROBABILITY)
DenseMap<const InputSectionBase *, int> CallGraphSort::run() {
   generateClusters();
 
   // Generate order.
   llvm::DenseMap<const InputSectionBase *, int> OrderMap;
   ssize_t CurOrder = 1;
 
   for (const Cluster &C : Clusters)
     for (int SecIndex : C.Sections)
-      OrderMap[Sections[SecIndex].ISB] = CurOrder++;
+      OrderMap[Sections[SecIndex]] = CurOrder++;
 
   return OrderMap;
 }
 
 // Sort sections by the profile data provided by -callgraph-profile-file
 //
 // This first builds a call graph based on the profile data then merges sections
 // according to the C³ huristic. All clusters are then sorted by a density
 // metric to further improve locality.
 DenseMap<const InputSectionBase *, int> elf::computeCallGraphProfileOrder() {
   return CallGraphSort().run();
 }