Coverage Report

Created: 2020-09-22 08:39

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