Commit a2fd05ad authored by Amy Huang's avatar Amy Huang
Browse files

Temporarily revert "[LLD] Remove global state in lld/COFF" and "[lld] Add test to 

check for timer output"

Seems to be causing a number of asan test failures.

This reverts commit b4fa71ee
and e03c7e36.
parent 5de8c7f1

lld/COFF/CMakeLists.txt

+0 −1
Original line number Diff line number Diff line
@@ -5,7 +5,6 @@ add_public_tablegen_target(COFFOptionsTableGen) 
add_lld_library(lldCOFF

  CallGraphSort.cpp

  Chunks.cpp

  COFFLinkerContext.cpp

  DebugTypes.cpp

  DLL.cpp

  Driver.cpp

lld/COFF/COFFLinkerContext.cpp

deleted100644 → 0
+0 −53
Original line number Diff line number Diff line 
//===- COFFContext.cpp ----------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Description

//

//===----------------------------------------------------------------------===//



#include "COFFLinkerContext.h"

#include "lld/Common/Memory.h"

#include "llvm/DebugInfo/CodeView/TypeHashing.h"



namespace lld {

namespace coff {



COFFLinkerContext::COFFLinkerContext()

    : symtab(*this), rootTimer("Total Linking Time"),

      inputFileTimer("Input File Reading", rootTimer),

      ltoTimer("LTO", rootTimer), gcTimer("GC", rootTimer),

      icfTimer("ICF", rootTimer), codeLayoutTimer("Code Layout", rootTimer),

      outputCommitTimer("Commit Output File", rootTimer),

      totalMapTimer("MAP Emission (Cumulative)", rootTimer),

      symbolGatherTimer("Gather Symbols", totalMapTimer),

      symbolStringsTimer("Build Symbol Strings", totalMapTimer),

      writeTimer("Write to File", totalMapTimer),

      totalPdbLinkTimer("PDB Emission (Cumulative)", rootTimer),

      addObjectsTimer("Add Objects", totalPdbLinkTimer),

      typeMergingTimer("Type Merging", addObjectsTimer),

      loadGHashTimer("Global Type Hashing", addObjectsTimer),

      mergeGHashTimer("GHash Type Merging", addObjectsTimer),

      symbolMergingTimer("Symbol Merging", addObjectsTimer),

      publicsLayoutTimer("Publics Stream Layout", totalPdbLinkTimer),

      tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer),

      diskCommitTimer("Commit to Disk", totalPdbLinkTimer) {}



COFFLinkerContext::~COFFLinkerContext() { clearGHashes(); }



void COFFLinkerContext::clearGHashes() {

  for (TpiSource *src : tpiSourceList) {

    if (src->ownedGHashes)

      delete[] src->ghashes.data();

    src->ghashes = {};

    src->isItemIndex.clear();

    src->uniqueTypes.clear();

  }

}



} // namespace coff

} // namespace lld

lld/COFF/COFFLinkerContext.h

deleted100644 → 0
+0 −88
Original line number Diff line number Diff line 
//===- COFFLinkerContext.h --------------------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//



#ifndef LLD_COFF_COFFLinkerContext_H

#define LLD_COFF_COFFLinkerContext_H



#include "Chunks.h"

#include "Config.h"

#include "DebugTypes.h"

#include "InputFiles.h"

#include "SymbolTable.h"

#include "Writer.h"

#include "lld/Common/Timer.h"



namespace lld {

namespace coff {



class COFFLinkerContext {

public:

  COFFLinkerContext();

  COFFLinkerContext(const COFFLinkerContext &) = delete;

  COFFLinkerContext &operator=(const COFFLinkerContext &) = delete;

  ~COFFLinkerContext();



  void addTpiSource(TpiSource *tpi) { tpiSourceList.push_back(tpi); }



  /// Free heap allocated ghashes.

  void clearGHashes();



  SymbolTable symtab;



  std::vector<ObjFile *> objFileInstances;

  std::map<std::string, PDBInputFile *> pdbInputFileInstances;

  std::vector<ImportFile *> importFileInstances;

  std::vector<BitcodeFile *> bitcodeFileInstances;



  MergeChunk *mergeChunkInstances[Log2MaxSectionAlignment + 1] = {};



  /// All sources of type information in the program.

  std::vector<TpiSource *> tpiSourceList;



  std::map<llvm::codeview::GUID, TpiSource *> typeServerSourceMappings;

  std::map<uint32_t, TpiSource *> precompSourceMappings;



  /// List of all output sections. After output sections are finalized, this

  /// can be indexed by getOutputSection.

  std::vector<OutputSection *> outputSections;



  OutputSection *getOutputSection(const Chunk *c) const {

    return c->osidx == 0 ? nullptr : outputSections[c->osidx - 1];

  }



  // All timers used in the COFF linker.

  Timer rootTimer;

  Timer inputFileTimer;

  Timer ltoTimer;

  Timer gcTimer;

  Timer icfTimer;



  // Writer timers.

  Timer codeLayoutTimer;

  Timer outputCommitTimer;

  Timer totalMapTimer;

  Timer symbolGatherTimer;

  Timer symbolStringsTimer;

  Timer writeTimer;



  // PDB timers.

  Timer totalPdbLinkTimer;

  Timer addObjectsTimer;

  Timer typeMergingTimer;

  Timer loadGHashTimer;

  Timer mergeGHashTimer;

  Timer symbolMergingTimer;

  Timer publicsLayoutTimer;

  Timer tpiStreamLayoutTimer;

  Timer diskCommitTimer;

};



} // namespace coff

} // namespace lld



#endif

lld/COFF/CallGraphSort.cpp

+5 −7
Original line number Diff line number Diff line
@@ -12,7 +12,6 @@ 
//===----------------------------------------------------------------------===//



#include "CallGraphSort.h"

#include "COFFLinkerContext.h"

#include "InputFiles.h"

#include "SymbolTable.h"

#include "Symbols.h"
@@ -49,7 +48,7 @@ struct Cluster { 


class CallGraphSort {

public:

  CallGraphSort(const COFFLinkerContext &ctx);

  CallGraphSort();



  DenseMap<const SectionChunk *, int> run();
@@ -71,7 +70,7 @@ using SectionPair = std::pair<const SectionChunk *, const SectionChunk *>; 
// Take the edge list in Config->CallGraphProfile, resolve symbol names to

// Symbols, and generate a graph between InputSections with the provided

// weights.

CallGraphSort::CallGraphSort(const COFFLinkerContext &ctx) {

CallGraphSort::CallGraphSort() {

  MapVector<SectionPair, uint64_t> &profile = config->callGraphProfile;

  DenseMap<const SectionChunk *, int> secToCluster;
@@ -96,7 +95,7 @@ CallGraphSort::CallGraphSort(const COFFLinkerContext &ctx) { 
    // output.  This messes with the cluster size and density calculations.  We

    // would also end up moving input sections in other output sections without

    // moving them closer to what calls them.

    if (ctx.getOutputSection(fromSec) != ctx.getOutputSection(toSec))

    if (fromSec->getOutputSection() != toSec->getOutputSection())

      continue;



    int from = getOrCreateNode(fromSec);
@@ -241,7 +240,6 @@ DenseMap<const SectionChunk *, int> CallGraphSort::run() { 
// This first builds a call graph based on the profile data then merges sections

// according to the C³ heuristic. All clusters are then sorted by a density

// metric to further improve locality.

DenseMap<const SectionChunk *, int>

coff::computeCallGraphProfileOrder(const COFFLinkerContext &ctx) {

  return CallGraphSort(ctx).run();

DenseMap<const SectionChunk *, int> coff::computeCallGraphProfileOrder() {

  return CallGraphSort().run();

}

lld/COFF/CallGraphSort.h

+1 −3
Original line number Diff line number Diff line
@@ -14,10 +14,8 @@ 
namespace lld {

namespace coff {

class SectionChunk;

class COFFLinkerContext;



llvm::DenseMap<const SectionChunk *, int>

computeCallGraphProfileOrder(const COFFLinkerContext &ctx);

llvm::DenseMap<const SectionChunk *, int> computeCallGraphProfileOrder();

} // namespace coff

} // namespace lld