llvm/lib/DWARFLinker/Parallel/DWARFLinkerGlobalData.h

   1 //===- DWARFLinkerGlobalData.h ----------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERGLOBALDATA_H
  10 #define LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERGLOBALDATA_H
  11
  12 #include "TypePool.h"
  13 #include "llvm/DWARFLinker/Parallel/DWARFLinker.h"
  14 #include "llvm/DWARFLinker/StringPool.h"
  15 #include "llvm/Support/PerThreadBumpPtrAllocator.h"
  16
  17 namespace llvm {
  18
  19 class DWARFDie;
  20
  21 namespace dwarf_linker {
  22 namespace parallel {
  23
  24 using MessageHandlerTy = std::function<void(
  25     const Twine &Warning, StringRef Context, const DWARFDie *DIE)>;
  26
  27 /// linking options
  28 struct DWARFLinkerOptions {
  29   /// DWARF version for the output.
  30   uint16_t TargetDWARFVersion = 0;
  31
  32   /// Generate processing log to the standard output.
  33   bool Verbose = false;
  34
  35   /// Print statistics.
  36   bool Statistics = false;
  37
  38   /// Verify the input DWARF.
  39   bool VerifyInputDWARF = false;
  40
  41   /// Do not unique types according to ODR
  42   bool NoODR = false;
  43
  44   /// Update index tables.
  45   bool UpdateIndexTablesOnly = false;
  46
  47   /// Whether we want a static variable to force us to keep its enclosing
  48   /// function.
  49   bool KeepFunctionForStatic = false;
  50
  51   /// Allow to generate valid, but non deterministic output.
  52   bool AllowNonDeterministicOutput = false;
  53
  54   /// Number of threads.
  55   unsigned Threads = 1;
  56
  57   /// The accelerator table kinds
  58   SmallVector<DWARFLinkerBase::AccelTableKind, 1> AccelTables;
  59
  60   /// Prepend path for the clang modules.
  61   std::string PrependPath;
  62
  63   /// input verification handler(it might be called asynchronously).
  64   DWARFLinkerBase::InputVerificationHandlerTy InputVerificationHandler =
  65       nullptr;
  66
  67   /// A list of all .swiftinterface files referenced by the debug
  68   /// info, mapping Module name to path on disk. The entries need to
  69   /// be uniqued and sorted and there are only few entries expected
  70   /// per compile unit, which is why this is a std::map.
  71   /// this is dsymutil specific fag.
  72   ///
  73   /// (it might be called asynchronously).
  74   DWARFLinkerBase::SwiftInterfacesMapTy *ParseableSwiftInterfaces = nullptr;
  75
  76   /// A list of remappings to apply to file paths.
  77   ///
  78   /// (it might be called asynchronously).
  79   DWARFLinkerBase::ObjectPrefixMapTy *ObjectPrefixMap = nullptr;
  80 };
  81
  82 class DWARFLinkerImpl;
  83
  84 /// This class keeps data and services common for the whole linking process.
  85 class LinkingGlobalData {
  86   friend DWARFLinkerImpl;
  87
  88 public:
  89   /// Returns global per-thread allocator.
  90   llvm::parallel::PerThreadBumpPtrAllocator &getAllocator() {
  91     return Allocator;
  92   }
  93
  94   /// Returns global string pool.
  95   StringPool &getStringPool() { return Strings; }
  96
  97   /// Returns linking options.
  98   const DWARFLinkerOptions &getOptions() const { return Options; }
  99
 100   /// Set warning handler.
 101   void setWarningHandler(MessageHandlerTy Handler) { WarningHandler = Handler; }
 102
 103   /// Set error handler.
 104   void setErrorHandler(MessageHandlerTy Handler) { ErrorHandler = Handler; }
 105
 106   /// Report warning.
 107   void warn(const Twine &Warning, StringRef Context,
 108             const DWARFDie *DIE = nullptr) {
 109     if (WarningHandler)
 110       (WarningHandler)(Warning, Context, DIE);
 111   }
 112
 113   /// Report warning.
 114   void warn(Error Warning, StringRef Context, const DWARFDie *DIE = nullptr) {
 115     handleAllErrors(std::move(Warning), [&](ErrorInfoBase &Info) {
 116       warn(Info.message(), Context, DIE);
 117     });
 118   }
 119
 120   /// Report error.
 121   void error(const Twine &Err, StringRef Context,
 122              const DWARFDie *DIE = nullptr) {
 123     if (ErrorHandler)
 124       (ErrorHandler)(Err, Context, DIE);
 125   }
 126
 127   /// Report error.
 128   void error(Error Err, StringRef Context, const DWARFDie *DIE = nullptr) {
 129     handleAllErrors(std::move(Err), [&](ErrorInfoBase &Info) {
 130       error(Info.message(), Context, DIE);
 131     });
 132   }
 133
 134   /// Set target triple.
 135   void setTargetTriple(const Triple &TargetTriple) {
 136     this->TargetTriple = TargetTriple;
 137   }
 138
 139   /// Optionally return target triple.
 140   std::optional<std::reference_wrapper<const Triple>> getTargetTriple() {
 141     if (TargetTriple)
 142       return std::cref(*TargetTriple);
 143
 144     return std::nullopt;
 145   }
 146
 147 protected:
 148   llvm::parallel::PerThreadBumpPtrAllocator Allocator;
 149   StringPool Strings;
 150   DWARFLinkerOptions Options;
 151   MessageHandlerTy WarningHandler;
 152   MessageHandlerTy ErrorHandler;
 153
 154   /// Triple for output data. May be not set if generation of output
 155   /// data is not requested.
 156   std::optional<Triple> TargetTriple;
 157 };
 158
 159 } // end of namespace parallel
 160 } // end of namespace dwarf_linker
 161 } // end of namespace llvm
 162
 163 #endif // LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERGLOBALDATA_H