Coverage Report

Created: 2021-09-21 08:58

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Lex/PreprocessorOptions.h
Line
Count
Source
1
//===- PreprocessorOptions.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_CLANG_LEX_PREPROCESSOROPTIONS_H_
10
#define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
11
12
#include "clang/Basic/BitmaskEnum.h"
13
#include "clang/Basic/LLVM.h"
14
#include "clang/Lex/PreprocessorExcludedConditionalDirectiveSkipMapping.h"
15
#include "llvm/ADT/StringRef.h"
16
#include "llvm/ADT/StringSet.h"
17
#include <functional>
18
#include <map>
19
#include <memory>
20
#include <set>
21
#include <string>
22
#include <utility>
23
#include <vector>
24
25
namespace llvm {
26
27
class MemoryBuffer;
28
29
} // namespace llvm
30
31
namespace clang {
32
33
/// Enumerate the kinds of standard library that
34
enum ObjCXXARCStandardLibraryKind {
35
  ARCXX_nolib,
36
37
  /// libc++
38
  ARCXX_libcxx,
39
40
  /// libstdc++
41
  ARCXX_libstdcxx
42
};
43
44
/// Whether to disable the normal validation performed on precompiled
45
/// headers and module files when they are loaded.
46
enum class DisableValidationForModuleKind {
47
  /// Perform validation, don't disable it.
48
  None = 0,
49
50
  /// Disable validation for a precompiled header and the modules it depends on.
51
  PCH = 0x1,
52
53
  /// Disable validation for module files.
54
  Module = 0x2,
55
56
  /// Disable validation for all kinds.
57
  All = PCH | Module,
58
59
  LLVM_MARK_AS_BITMASK_ENUM(Module)
60
};
61
62
/// PreprocessorOptions - This class is used for passing the various options
63
/// used in preprocessor initialization to InitializePreprocessor().
64
class PreprocessorOptions {
65
public:
66
  std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
67
  std::vector<std::string> Includes;
68
  std::vector<std::string> MacroIncludes;
69
70
  /// Initialize the preprocessor with the compiler and target specific
71
  /// predefines.
72
  bool UsePredefines = true;
73
74
  /// Whether we should maintain a detailed record of all macro
75
  /// definitions and expansions.
76
  bool DetailedRecord = false;
77
78
  /// When true, we are creating or using a PCH where a #pragma hdrstop is
79
  /// expected to indicate the beginning or end of the PCH.
80
  bool PCHWithHdrStop = false;
81
82
  /// When true, we are creating a PCH or creating the PCH object while
83
  /// expecting a #pragma hdrstop to separate the two.  Allow for a
84
  /// missing #pragma hdrstop, which generates a PCH for the whole file,
85
  /// and creates an empty PCH object.
86
  bool PCHWithHdrStopCreate = false;
87
88
  /// If non-empty, the filename used in an #include directive in the primary
89
  /// source file (or command-line preinclude) that is used to implement
90
  /// MSVC-style precompiled headers. When creating a PCH, after the #include
91
  /// of this header, the PCH generation stops. When using a PCH, tokens are
92
  /// skipped until after an #include of this header is seen.
93
  std::string PCHThroughHeader;
94
95
  /// The implicit PCH included at the start of the translation unit, or empty.
96
  std::string ImplicitPCHInclude;
97
98
  /// Headers that will be converted to chained PCHs in memory.
99
  std::vector<std::string> ChainedIncludes;
100
101
  /// Whether to disable most of the normal validation performed on
102
  /// precompiled headers and module files.
103
  DisableValidationForModuleKind DisablePCHOrModuleValidation =
104
      DisableValidationForModuleKind::None;
105
106
  /// When true, a PCH with compiler errors will not be rejected.
107
  bool AllowPCHWithCompilerErrors = false;
108
109
  /// When true, a PCH with modules cache path different to the current
110
  /// compilation will not be rejected.
111
  bool AllowPCHWithDifferentModulesCachePath = false;
112
113
  /// Dump declarations that are deserialized from PCH, for testing.
114
  bool DumpDeserializedPCHDecls = false;
115
116
  /// This is a set of names for decls that we do not want to be
117
  /// deserialized, and we emit an error if they are; for testing purposes.
118
  std::set<std::string> DeserializedPCHDeclsToErrorOn;
119
120
  /// If non-zero, the implicit PCH include is actually a precompiled
121
  /// preamble that covers this number of bytes in the main source file.
122
  ///
123
  /// The boolean indicates whether the preamble ends at the start of a new
124
  /// line.
125
  std::pair<unsigned, bool> PrecompiledPreambleBytes;
126
127
  /// True indicates that a preamble is being generated.
128
  ///
129
  /// When the lexer is done, one of the things that need to be preserved is the
130
  /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
131
  /// processing the rest of the file.
132
  bool GeneratePreamble = false;
133
134
  /// Whether to write comment locations into the PCH when building it.
135
  /// Reading the comments from the PCH can be a performance hit even if the
136
  /// clients don't use them.
137
  bool WriteCommentListToPCH = true;
138
139
  /// When enabled, preprocessor is in a mode for parsing a single file only.
140
  ///
141
  /// Disables #includes of other files and if there are unresolved identifiers
142
  /// in preprocessor directive conditions it causes all blocks to be parsed so
143
  /// that the client can get the maximum amount of information from the parser.
144
  bool SingleFileParseMode = false;
145
146
  /// When enabled, the preprocessor will construct editor placeholder tokens.
147
  bool LexEditorPlaceholders = true;
148
149
  /// True if the SourceManager should report the original file name for
150
  /// contents of files that were remapped to other files. Defaults to true.
151
  bool RemappedFilesKeepOriginalName = true;
152
153
  /// The set of file remappings, which take existing files on
154
  /// the system (the first part of each pair) and gives them the
155
  /// contents of other files on the system (the second part of each
156
  /// pair).
157
  std::vector<std::pair<std::string, std::string>> RemappedFiles;
158
159
  /// The set of file-to-buffer remappings, which take existing files
160
  /// on the system (the first part of each pair) and gives them the contents
161
  /// of the specified memory buffer (the second part of each pair).
162
  std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
163
164
  /// Whether the compiler instance should retain (i.e., not free)
165
  /// the buffers associated with remapped files.
166
  ///
167
  /// This flag defaults to false; it can be set true only through direct
168
  /// manipulation of the compiler invocation object, in cases where the
169
  /// compiler invocation and its buffers will be reused.
170
  bool RetainRemappedFileBuffers = false;
171
172
  /// When enabled, excluded conditional blocks retain in the main file.
173
  bool RetainExcludedConditionalBlocks = false;
174
175
  /// The Objective-C++ ARC standard library that we should support,
176
  /// by providing appropriate definitions to retrofit the standard library
177
  /// with support for lifetime-qualified pointers.
178
  ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
179
180
  /// Records the set of modules
181
  class FailedModulesSet {
182
    llvm::StringSet<> Failed;
183
184
  public:
185
817
    bool hasAlreadyFailed(StringRef module) {
186
817
      return Failed.count(module) > 0;
187
817
    }
188
189
34
    void addFailed(StringRef module) {
190
34
      Failed.insert(module);
191
34
    }
192
  };
193
194
  /// The set of modules that failed to build.
195
  ///
196
  /// This pointer will be shared among all of the compiler instances created
197
  /// to (re)build modules, so that once a module fails to build anywhere,
198
  /// other instances will see that the module has failed and won't try to
199
  /// build it again.
200
  std::shared_ptr<FailedModulesSet> FailedModules;
201
202
  /// Contains the currently active skipped range mappings for skipping excluded
203
  /// conditional directives.
204
  ///
205
  /// The pointer is passed to the Preprocessor when it's constructed. The
206
  /// pointer is unowned, the client is responsible for its lifetime.
207
  ExcludedPreprocessorDirectiveSkipMapping
208
      *ExcludedConditionalDirectiveSkipMappings = nullptr;
209
210
  /// Set up preprocessor for RunAnalysis action.
211
  bool SetUpStaticAnalyzer = false;
212
213
  /// Prevents intended crashes when using #pragma clang __debug. For testing.
214
  bool DisablePragmaDebugCrash = false;
215
216
public:
217
203k
  PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
218
219
689k
  void addMacroDef(StringRef Name) {
220
689k
    Macros.emplace_back(std::string(Name), false);
221
689k
  }
222
90
  void addMacroUndef(StringRef Name) {
223
90
    Macros.emplace_back(std::string(Name), true);
224
90
  }
225
226
19
  void addRemappedFile(StringRef From, StringRef To) {
227
19
    RemappedFiles.emplace_back(std::string(From), std::string(To));
228
19
  }
229
230
4.10k
  void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
231
4.10k
    RemappedFileBuffers.emplace_back(std::string(From), To);
232
4.10k
  }
233
234
1.54k
  void clearRemappedFiles() {
235
1.54k
    RemappedFiles.clear();
236
1.54k
    RemappedFileBuffers.clear();
237
1.54k
  }
238
239
  /// Reset any options that are not considered when building a
240
  /// module.
241
1.73k
  void resetNonModularOptions() {
242
1.73k
    Includes.clear();
243
1.73k
    MacroIncludes.clear();
244
1.73k
    ChainedIncludes.clear();
245
1.73k
    DumpDeserializedPCHDecls = false;
246
1.73k
    ImplicitPCHInclude.clear();
247
1.73k
    SingleFileParseMode = false;
248
1.73k
    LexEditorPlaceholders = true;
249
1.73k
    RetainRemappedFileBuffers = true;
250
1.73k
    PrecompiledPreambleBytes.first = 0;
251
1.73k
    PrecompiledPreambleBytes.second = false;
252
1.73k
    RetainExcludedConditionalBlocks = false;
253
1.73k
  }
254
};
255
256
} // namespace clang
257
258
#endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_