Coverage Report

Created: 2019-02-20 07:29

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