LLVM 19.0.0git
DWARFLinkerGlobalData.h
Go to the documentation of this file.
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"
16
17namespace llvm {
18
19class DWARFDie;
20
21namespace dwarf_linker {
22namespace parallel {
23
24using TranslatorFuncTy = std::function<StringRef(StringRef)>;
25using MessageHandlerTy = std::function<void(
26 const Twine &Warning, StringRef Context, const DWARFDie *DIE)>;
27
28/// linking options
30 /// DWARF version for the output.
32
33 /// Generate processing log to the standard output.
34 bool Verbose = false;
35
36 /// Print statistics.
37 bool Statistics = false;
38
39 /// Verify the input DWARF.
40 bool VerifyInputDWARF = false;
41
42 /// Do not unique types according to ODR
43 bool NoODR = false;
44
45 /// Update index tables.
47
48 /// Whether we want a static variable to force us to keep its enclosing
49 /// function.
51
52 /// Allow to generate valid, but non deterministic output.
54
55 /// Number of threads.
56 unsigned Threads = 1;
57
58 /// The accelerator table kinds
60
61 /// Prepend path for the clang modules.
62 std::string PrependPath;
63
64 /// input verification handler(it might be called asynchronously).
66 nullptr;
67
68 /// A list of all .swiftinterface files referenced by the debug
69 /// info, mapping Module name to path on disk. The entries need to
70 /// be uniqued and sorted and there are only few entries expected
71 /// per compile unit, which is why this is a std::map.
72 /// this is dsymutil specific fag.
73 ///
74 /// (it might be called asynchronously).
76
77 /// A list of remappings to apply to file paths.
78 ///
79 /// (it might be called asynchronously).
81};
82
83class DWARFLinkerImpl;
84
85/// This class keeps data and services common for the whole linking process.
87 friend DWARFLinkerImpl;
88
89public:
90 /// Returns global per-thread allocator.
92 return Allocator;
93 }
94
95 /// Returns global string pool.
97
98 /// Set translation function.
100 this->Translator = Translator;
101 }
102
103 /// Translate specified string.
105 if (Translator)
106 return Translator(String);
107
108 return String;
109 }
110
111 /// Returns linking options.
112 const DWARFLinkerOptions &getOptions() const { return Options; }
113
114 /// Set warning handler.
116
117 /// Set error handler.
118 void setErrorHandler(MessageHandlerTy Handler) { ErrorHandler = Handler; }
119
120 /// Report warning.
121 void warn(const Twine &Warning, StringRef Context,
122 const DWARFDie *DIE = nullptr) {
123 if (WarningHandler)
125 }
126
127 /// Report warning.
128 void warn(Error Warning, StringRef Context, const DWARFDie *DIE = nullptr) {
129 handleAllErrors(std::move(Warning), [&](ErrorInfoBase &Info) {
130 warn(Info.message(), Context, DIE);
131 });
132 }
133
134 /// Report error.
135 void error(const Twine &Err, StringRef Context,
136 const DWARFDie *DIE = nullptr) {
137 if (ErrorHandler)
138 (ErrorHandler)(Err, Context, DIE);
139 }
140
141 /// Report error.
142 void error(Error Err, StringRef Context, const DWARFDie *DIE = nullptr) {
143 handleAllErrors(std::move(Err), [&](ErrorInfoBase &Info) {
144 error(Info.message(), Context, DIE);
145 });
146 }
147
148 /// Set target triple.
150 this->TargetTriple = TargetTriple;
151 }
152
153 /// Optionally return target triple.
154 std::optional<std::reference_wrapper<const Triple>> getTargetTriple() {
155 if (TargetTriple)
156 return std::cref(*TargetTriple);
157
158 return std::nullopt;
159 }
160
161protected:
168
169 /// Triple for output data. May be not set if generation of output
170 /// data is not requested.
171 std::optional<Triple> TargetTriple;
172};
173
174} // end of namespace parallel
175} // end of namespace dwarf_linker
176} // end of namespace llvm
177
178#endif // LLVM_LIB_DWARFLINKER_PARALLEL_DWARFLINKERGLOBALDATA_H
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
LLVMContext & Context
#define error(X)
A structured debug information entry.
Definition: DIE.h:819
Utility class that carries the DWARF compile/type unit and the debug info entry in an object.
Definition: DWARFDie.h:42
Base class for error info classes.
Definition: Error.h:45
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
std::map< std::string, std::string > ObjectPrefixMapTy
std::function< void(const DWARFFile &File, llvm::StringRef Output)> InputVerificationHandlerTy
std::map< std::string, std::string > SwiftInterfacesMapTy
This class keeps data and services common for the whole linking process.
void warn(const Twine &Warning, StringRef Context, const DWARFDie *DIE=nullptr)
Report warning.
const DWARFLinkerOptions & getOptions() const
Returns linking options.
void warn(Error Warning, StringRef Context, const DWARFDie *DIE=nullptr)
Report warning.
void setErrorHandler(MessageHandlerTy Handler)
Set error handler.
void error(const Twine &Err, StringRef Context, const DWARFDie *DIE=nullptr)
Report error.
llvm::parallel::PerThreadBumpPtrAllocator Allocator
std::optional< Triple > TargetTriple
Triple for output data.
void setTargetTriple(const Triple &TargetTriple)
Set target triple.
void error(Error Err, StringRef Context, const DWARFDie *DIE=nullptr)
Report error.
void setWarningHandler(MessageHandlerTy Handler)
Set warning handler.
void setTranslator(TranslatorFuncTy Translator)
Set translation function.
StringPool & getStringPool()
Returns global string pool.
std::optional< std::reference_wrapper< const Triple > > getTargetTriple()
Optionally return target triple.
StringRef translateString(StringRef String)
Translate specified string.
llvm::parallel::PerThreadBumpPtrAllocator & getAllocator()
Returns global per-thread allocator.
std::function< void(const Twine &Warning, StringRef Context, const DWARFDie *DIE)> MessageHandlerTy
std::function< StringRef(StringRef)> TranslatorFuncTy
PerThreadAllocator< BumpPtrAllocator > PerThreadBumpPtrAllocator
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:970
bool KeepFunctionForStatic
Whether we want a static variable to force us to keep its enclosing function.
DWARFLinkerBase::ObjectPrefixMapTy * ObjectPrefixMap
A list of remappings to apply to file paths.
bool Verbose
Generate processing log to the standard output.
DWARFLinkerBase::SwiftInterfacesMapTy * ParseableSwiftInterfaces
A list of all .swiftinterface files referenced by the debug info, mapping Module name to path on disk...
SmallVector< DWARFLinkerBase::AccelTableKind, 1 > AccelTables
The accelerator table kinds.
uint16_t TargetDWARFVersion
DWARF version for the output.
bool NoODR
Do not unique types according to ODR.
bool AllowNonDeterministicOutput
Allow to generate valid, but non deterministic output.
std::string PrependPath
Prepend path for the clang modules.
DWARFLinkerBase::InputVerificationHandlerTy InputVerificationHandler
input verification handler(it might be called asynchronously).