1//===- PreprocessingRecord.h - Record of Preprocessing ----------*- 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// This file defines the PreprocessingRecord class, which maintains a record
10// of what occurred during preprocessing.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
15#define LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
16
17#include "clang/Basic/IdentifierTable.h"
18#include "clang/Basic/LLVM.h"
19#include "clang/Basic/SourceLocation.h"
20#include "clang/Lex/PPCallbacks.h"
21#include "llvm/ADT/DenseMap.h"
22#include "llvm/ADT/PointerUnion.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/iterator.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/Support/Allocator.h"
27#include "llvm/Support/Compiler.h"
28#include <cassert>
29#include <cstddef>
30#include <iterator>
31#include <optional>
32#include <utility>
33#include <vector>
34
35namespace clang {
36
37class PreprocessingRecord;
38
39} // namespace clang
40
41/// Allocates memory within a Clang preprocessing record.
42void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
43 unsigned alignment = 8) noexcept;
44
45/// Frees memory allocated in a Clang preprocessing record.
46void operator delete(void *ptr, clang::PreprocessingRecord &PR,
47 unsigned) noexcept;
48
49namespace clang {
50
51class IdentifierInfo;
52class MacroInfo;
53class SourceManager;
54class Token;
55
56 /// Base class that describes a preprocessed entity, which may be a
57 /// preprocessor directive or macro expansion.
58 class PreprocessedEntity {
59 public:
60 /// The kind of preprocessed entity an object describes.
61 enum EntityKind {
62 /// Indicates a problem trying to load the preprocessed entity.
63 InvalidKind,
64
65 /// A macro expansion.
66 MacroExpansionKind,
67
68 /// \defgroup Preprocessing directives
69 /// @{
70
71 /// A macro definition.
72 MacroDefinitionKind,
73
74 /// An inclusion directive, such as \c \#include, \c
75 /// \#import, or \c \#include_next.
76 InclusionDirectiveKind,
77
78 /// @}
79
80 FirstPreprocessingDirective = MacroDefinitionKind,
81 LastPreprocessingDirective = InclusionDirectiveKind
82 };
83
84 private:
85 /// The kind of preprocessed entity that this object describes.
86 EntityKind Kind;
87
88 /// The source range that covers this preprocessed entity.
89 SourceRange Range;
90
91 protected:
92 friend class PreprocessingRecord;
93
94 PreprocessedEntity(EntityKind Kind, SourceRange Range)
95 : Kind(Kind), Range(Range) {}
96
97 public:
98 /// Retrieve the kind of preprocessed entity stored in this object.
99 EntityKind getKind() const { return Kind; }
100
101 /// Retrieve the source range that covers this entire preprocessed
102 /// entity.
103 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
104
105 /// Returns true if there was a problem loading the preprocessed
106 /// entity.
107 bool isInvalid() const { return Kind == InvalidKind; }
108
109 // Only allow allocation of preprocessed entities using the allocator
110 // in PreprocessingRecord or by doing a placement new.
111 void *operator new(size_t bytes, PreprocessingRecord &PR,
112 unsigned alignment = 8) noexcept {
113 return ::operator new(bytes, PR, alignment);
114 }
115
116 void *operator new(size_t bytes, void *mem) noexcept { return mem; }
117
118 void operator delete(void *ptr, PreprocessingRecord &PR,
119 unsigned alignment) noexcept {
120 return ::operator delete(ptr, PR, alignment);
121 }
122
123 void operator delete(void *, std::size_t) noexcept {}
124 void operator delete(void *, void *) noexcept {}
125
126 private:
127 // Make vanilla 'new' and 'delete' illegal for preprocessed entities.
128 void *operator new(size_t bytes) noexcept;
129 void operator delete(void *data) noexcept;
130 };
131
132 /// Records the presence of a preprocessor directive.
133 class PreprocessingDirective : public PreprocessedEntity {
134 public:
135 PreprocessingDirective(EntityKind Kind, SourceRange Range)
136 : PreprocessedEntity(Kind, Range) {}
137
138 // Implement isa/cast/dyncast/etc.
139 static bool classof(const PreprocessedEntity *PD) {
140 return PD->getKind() >= FirstPreprocessingDirective &&
141 PD->getKind() <= LastPreprocessingDirective;
142 }
143 };
144
145 /// Record the location of a macro definition.
146 class MacroDefinitionRecord : public PreprocessingDirective {
147 /// The name of the macro being defined.
148 const IdentifierInfo *Name;
149
150 public:
151 explicit MacroDefinitionRecord(const IdentifierInfo *Name,
152 SourceRange Range)
153 : PreprocessingDirective(MacroDefinitionKind, Range), Name(Name) {}
154
155 /// Retrieve the name of the macro being defined.
156 const IdentifierInfo *getName() const { return Name; }
157
158 /// Retrieve the location of the macro name in the definition.
159 SourceLocation getLocation() const { return getSourceRange().getBegin(); }
160
161 // Implement isa/cast/dyncast/etc.
162 static bool classof(const PreprocessedEntity *PE) {
163 return PE->getKind() == MacroDefinitionKind;
164 }
165 };
166
167 /// Records the location of a macro expansion.
168 class MacroExpansion : public PreprocessedEntity {
169 /// The definition of this macro or the name of the macro if it is
170 /// a builtin macro.
171 llvm::PointerUnion<IdentifierInfo *, MacroDefinitionRecord *> NameOrDef;
172
173 public:
174 MacroExpansion(IdentifierInfo *BuiltinName, SourceRange Range)
175 : PreprocessedEntity(MacroExpansionKind, Range),
176 NameOrDef(BuiltinName) {}
177
178 MacroExpansion(MacroDefinitionRecord *Definition, SourceRange Range)
179 : PreprocessedEntity(MacroExpansionKind, Range), NameOrDef(Definition) {
180 }
181
182 /// True if it is a builtin macro.
183 bool isBuiltinMacro() const { return NameOrDef.is<IdentifierInfo *>(); }
184
185 /// The name of the macro being expanded.
186 const IdentifierInfo *getName() const {
187 if (MacroDefinitionRecord *Def = getDefinition())
188 return Def->getName();
189 return NameOrDef.get<IdentifierInfo *>();
190 }
191
192 /// The definition of the macro being expanded. May return null if
193 /// this is a builtin macro.
194 MacroDefinitionRecord *getDefinition() const {
195 return NameOrDef.dyn_cast<MacroDefinitionRecord *>();
196 }
197
198 // Implement isa/cast/dyncast/etc.
199 static bool classof(const PreprocessedEntity *PE) {
200 return PE->getKind() == MacroExpansionKind;
201 }
202 };
203
204 /// Record the location of an inclusion directive, such as an
205 /// \c \#include or \c \#import statement.
206 class InclusionDirective : public PreprocessingDirective {
207 public:
208 /// The kind of inclusion directives known to the
209 /// preprocessor.
210 enum InclusionKind {
211 /// An \c \#include directive.
212 Include,
213
214 /// An Objective-C \c \#import directive.
215 Import,
216
217 /// A GNU \c \#include_next directive.
218 IncludeNext,
219
220 /// A Clang \c \#__include_macros directive.
221 IncludeMacros
222 };
223
224 private:
225 /// The name of the file that was included, as written in
226 /// the source.
227 StringRef FileName;
228
229 /// Whether the file name was in quotation marks; otherwise, it was
230 /// in angle brackets.
231 LLVM_PREFERRED_TYPE(bool)
232 unsigned InQuotes : 1;
233
234 /// The kind of inclusion directive we have.
235 ///
236 /// This is a value of type InclusionKind.
237 LLVM_PREFERRED_TYPE(InclusionKind)
238 unsigned Kind : 2;
239
240 /// Whether the inclusion directive was automatically turned into
241 /// a module import.
242 LLVM_PREFERRED_TYPE(bool)
243 unsigned ImportedModule : 1;
244
245 /// The file that was included.
246 OptionalFileEntryRef File;
247
248 public:
249 InclusionDirective(PreprocessingRecord &PPRec, InclusionKind Kind,
250 StringRef FileName, bool InQuotes, bool ImportedModule,
251 OptionalFileEntryRef File, SourceRange Range);
252
253 /// Determine what kind of inclusion directive this is.
254 InclusionKind getKind() const { return static_cast<InclusionKind>(Kind); }
255
256 /// Retrieve the included file name as it was written in the source.
257 StringRef getFileName() const { return FileName; }
258
259 /// Determine whether the included file name was written in quotes;
260 /// otherwise, it was written in angle brackets.
261 bool wasInQuotes() const { return InQuotes; }
262
263 /// Determine whether the inclusion directive was automatically
264 /// turned into a module import.
265 bool importedModule() const { return ImportedModule; }
266
267 /// Retrieve the file entry for the actual file that was included
268 /// by this directive.
269 OptionalFileEntryRef getFile() const { return File; }
270
271 // Implement isa/cast/dyncast/etc.
272 static bool classof(const PreprocessedEntity *PE) {
273 return PE->getKind() == InclusionDirectiveKind;
274 }
275 };
276
277 /// An abstract class that should be subclassed by any external source
278 /// of preprocessing record entries.
279 class ExternalPreprocessingRecordSource {
280 public:
281 virtual ~ExternalPreprocessingRecordSource();
282
283 /// Read a preallocated preprocessed entity from the external source.
284 ///
285 /// \returns null if an error occurred that prevented the preprocessed
286 /// entity from being loaded.
287 virtual PreprocessedEntity *ReadPreprocessedEntity(unsigned Index) = 0;
288
289 /// Returns a pair of [Begin, End) indices of preallocated
290 /// preprocessed entities that \p Range encompasses.
291 virtual std::pair<unsigned, unsigned>
292 findPreprocessedEntitiesInRange(SourceRange Range) = 0;
293
294 /// Optionally returns true or false if the preallocated preprocessed
295 /// entity with index \p Index came from file \p FID.
296 virtual std::optional<bool> isPreprocessedEntityInFileID(unsigned Index,
297 FileID FID) {
298 return std::nullopt;
299 }
300
301 /// Read a preallocated skipped range from the external source.
302 virtual SourceRange ReadSkippedRange(unsigned Index) = 0;
303 };
304
305 /// A record of the steps taken while preprocessing a source file,
306 /// including the various preprocessing directives processed, macros
307 /// expanded, etc.
308 class PreprocessingRecord : public PPCallbacks {
309 SourceManager &SourceMgr;
310
311 /// Allocator used to store preprocessing objects.
312 llvm::BumpPtrAllocator BumpAlloc;
313
314 /// The set of preprocessed entities in this record, in order they
315 /// were seen.
316 std::vector<PreprocessedEntity *> PreprocessedEntities;
317
318 /// The set of preprocessed entities in this record that have been
319 /// loaded from external sources.
320 ///
321 /// The entries in this vector are loaded lazily from the external source,
322 /// and are referenced by the iterator using negative indices.
323 std::vector<PreprocessedEntity *> LoadedPreprocessedEntities;
324
325 /// The set of ranges that were skipped by the preprocessor,
326 std::vector<SourceRange> SkippedRanges;
327
328 bool SkippedRangesAllLoaded = true;
329
330 /// Global (loaded or local) ID for a preprocessed entity.
331 /// Negative values are used to indicate preprocessed entities
332 /// loaded from the external source while non-negative values are used to
333 /// indicate preprocessed entities introduced by the current preprocessor.
334 /// Value -1 corresponds to element 0 in the loaded entities vector,
335 /// value -2 corresponds to element 1 in the loaded entities vector, etc.
336 /// Value 0 is an invalid value, the index to local entities is 1-based,
337 /// value 1 corresponds to element 0 in the local entities vector,
338 /// value 2 corresponds to element 1 in the local entities vector, etc.
339 class PPEntityID {
340 friend class PreprocessingRecord;
341
342 int ID = 0;
343
344 explicit PPEntityID(int ID) : ID(ID) {}
345
346 public:
347 PPEntityID() = default;
348 };
349
350 static PPEntityID getPPEntityID(unsigned Index, bool isLoaded) {
351 return isLoaded ? PPEntityID(-int(Index)-1) : PPEntityID(Index+1);
352 }
353
354 /// Mapping from MacroInfo structures to their definitions.
355 llvm::DenseMap<const MacroInfo *, MacroDefinitionRecord *> MacroDefinitions;
356
357 /// External source of preprocessed entities.
358 ExternalPreprocessingRecordSource *ExternalSource = nullptr;
359
360 /// Retrieve the preprocessed entity at the given ID.
361 PreprocessedEntity *getPreprocessedEntity(PPEntityID PPID);
362
363 /// Retrieve the loaded preprocessed entity at the given index.
364 PreprocessedEntity *getLoadedPreprocessedEntity(unsigned Index);
365
366 /// Determine the number of preprocessed entities that were
367 /// loaded (or can be loaded) from an external source.
368 unsigned getNumLoadedPreprocessedEntities() const {
369 return LoadedPreprocessedEntities.size();
370 }
371
372 /// Returns a pair of [Begin, End) indices of local preprocessed
373 /// entities that \p Range encompasses.
374 std::pair<unsigned, unsigned>
375 findLocalPreprocessedEntitiesInRange(SourceRange Range) const;
376 unsigned findBeginLocalPreprocessedEntity(SourceLocation Loc) const;
377 unsigned findEndLocalPreprocessedEntity(SourceLocation Loc) const;
378
379 /// Allocate space for a new set of loaded preprocessed entities.
380 ///
381 /// \returns The index into the set of loaded preprocessed entities, which
382 /// corresponds to the first newly-allocated entity.
383 unsigned allocateLoadedEntities(unsigned NumEntities);
384
385 /// Allocate space for a new set of loaded preprocessed skipped
386 /// ranges.
387 ///
388 /// \returns The index into the set of loaded preprocessed ranges, which
389 /// corresponds to the first newly-allocated range.
390 unsigned allocateSkippedRanges(unsigned NumRanges);
391
392 /// Ensures that all external skipped ranges have been loaded.
393 void ensureSkippedRangesLoaded();
394
395 /// Register a new macro definition.
396 void RegisterMacroDefinition(MacroInfo *Macro, MacroDefinitionRecord *Def);
397
398 public:
399 /// Construct a new preprocessing record.
400 explicit PreprocessingRecord(SourceManager &SM);
401
402 /// Allocate memory in the preprocessing record.
403 void *Allocate(unsigned Size, unsigned Align = 8) {
404 return BumpAlloc.Allocate(Size, Alignment: Align);
405 }
406
407 /// Deallocate memory in the preprocessing record.
408 void Deallocate(void *Ptr) {}
409
410 size_t getTotalMemory() const;
411
412 SourceManager &getSourceManager() const { return SourceMgr; }
413
414 /// Iteration over the preprocessed entities.
415 ///
416 /// In a complete iteration, the iterator walks the range [-M, N),
417 /// where negative values are used to indicate preprocessed entities
418 /// loaded from the external source while non-negative values are used to
419 /// indicate preprocessed entities introduced by the current preprocessor.
420 /// However, to provide iteration in source order (for, e.g., chained
421 /// precompiled headers), dereferencing the iterator flips the negative
422 /// values (corresponding to loaded entities), so that position -M
423 /// corresponds to element 0 in the loaded entities vector, position -M+1
424 /// corresponds to element 1 in the loaded entities vector, etc. This
425 /// gives us a reasonably efficient, source-order walk.
426 ///
427 /// We define this as a wrapping iterator around an int. The
428 /// iterator_adaptor_base class forwards the iterator methods to basic
429 /// integer arithmetic.
430 class iterator : public llvm::iterator_adaptor_base<
431 iterator, int, std::random_access_iterator_tag,
432 PreprocessedEntity *, int, PreprocessedEntity *,
433 PreprocessedEntity *> {
434 friend class PreprocessingRecord;
435
436 PreprocessingRecord *Self;
437
438 iterator(PreprocessingRecord *Self, int Position)
439 : iterator::iterator_adaptor_base(Position), Self(Self) {}
440
441 public:
442 iterator() : iterator(nullptr, 0) {}
443
444 PreprocessedEntity *operator*() const {
445 bool isLoaded = this->I < 0;
446 unsigned Index = isLoaded ?
447 Self->LoadedPreprocessedEntities.size() + this->I : this->I;
448 PPEntityID ID = Self->getPPEntityID(Index, isLoaded);
449 return Self->getPreprocessedEntity(PPID: ID);
450 }
451 PreprocessedEntity *operator->() const { return **this; }
452 };
453
454 /// Begin iterator for all preprocessed entities.
455 iterator begin() {
456 return iterator(this, -(int)LoadedPreprocessedEntities.size());
457 }
458
459 /// End iterator for all preprocessed entities.
460 iterator end() {
461 return iterator(this, PreprocessedEntities.size());
462 }
463
464 /// Begin iterator for local, non-loaded, preprocessed entities.
465 iterator local_begin() {
466 return iterator(this, 0);
467 }
468
469 /// End iterator for local, non-loaded, preprocessed entities.
470 iterator local_end() {
471 return iterator(this, PreprocessedEntities.size());
472 }
473
474 /// iterator range for the given range of loaded
475 /// preprocessed entities.
476 llvm::iterator_range<iterator> getIteratorsForLoadedRange(unsigned start,
477 unsigned count) {
478 unsigned end = start + count;
479 assert(end <= LoadedPreprocessedEntities.size());
480 return llvm::make_range(
481 x: iterator(this, int(start) - LoadedPreprocessedEntities.size()),
482 y: iterator(this, int(end) - LoadedPreprocessedEntities.size()));
483 }
484
485 /// Returns a range of preprocessed entities that source range \p R
486 /// encompasses.
487 ///
488 /// \param R the range to look for preprocessed entities.
489 llvm::iterator_range<iterator>
490 getPreprocessedEntitiesInRange(SourceRange R);
491
492 /// Returns true if the preprocessed entity that \p PPEI iterator
493 /// points to is coming from the file \p FID.
494 ///
495 /// Can be used to avoid implicit deserializations of preallocated
496 /// preprocessed entities if we only care about entities of a specific file
497 /// and not from files \#included in the range given at
498 /// \see getPreprocessedEntitiesInRange.
499 bool isEntityInFileID(iterator PPEI, FileID FID);
500
501 /// Add a new preprocessed entity to this record.
502 PPEntityID addPreprocessedEntity(PreprocessedEntity *Entity);
503
504 /// Set the external source for preprocessed entities.
505 void SetExternalSource(ExternalPreprocessingRecordSource &Source);
506
507 /// Retrieve the external source for preprocessed entities.
508 ExternalPreprocessingRecordSource *getExternalSource() const {
509 return ExternalSource;
510 }
511
512 /// Retrieve the macro definition that corresponds to the given
513 /// \c MacroInfo.
514 MacroDefinitionRecord *findMacroDefinition(const MacroInfo *MI);
515
516 /// Retrieve all ranges that got skipped while preprocessing.
517 const std::vector<SourceRange> &getSkippedRanges() {
518 ensureSkippedRangesLoaded();
519 return SkippedRanges;
520 }
521
522 private:
523 friend class ASTReader;
524 friend class ASTWriter;
525
526 void MacroExpands(const Token &Id, const MacroDefinition &MD,
527 SourceRange Range, const MacroArgs *Args) override;
528 void MacroDefined(const Token &Id, const MacroDirective *MD) override;
529 void MacroUndefined(const Token &Id, const MacroDefinition &MD,
530 const MacroDirective *Undef) override;
531 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
532 StringRef FileName, bool IsAngled,
533 CharSourceRange FilenameRange,
534 OptionalFileEntryRef File, StringRef SearchPath,
535 StringRef RelativePath,
536 const Module *SuggestedModule, bool ModuleImported,
537 SrcMgr::CharacteristicKind FileType) override;
538 void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
539 const MacroDefinition &MD) override;
540 void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
541 const MacroDefinition &MD) override;
542
543 using PPCallbacks::Elifdef;
544 using PPCallbacks::Elifndef;
545 void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
546 const MacroDefinition &MD) override;
547 void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
548 const MacroDefinition &MD) override;
549
550 /// Hook called whenever the 'defined' operator is seen.
551 void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
552 SourceRange Range) override;
553
554 void SourceRangeSkipped(SourceRange Range,
555 SourceLocation EndifLoc) override;
556
557 void addMacroExpansion(const Token &Id, const MacroInfo *MI,
558 SourceRange Range);
559
560 /// Cached result of the last \see getPreprocessedEntitiesInRange
561 /// query.
562 struct {
563 SourceRange Range;
564 std::pair<int, int> Result;
565 } CachedRangeQuery;
566
567 std::pair<int, int> getPreprocessedEntitiesInRangeSlow(SourceRange R);
568 };
569
570} // namespace clang
571
572inline void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
573 unsigned alignment) noexcept {
574 return PR.Allocate(Size: bytes, Align: alignment);
575}
576
577inline void operator delete(void *ptr, clang::PreprocessingRecord &PR,
578 unsigned) noexcept {
579 PR.Deallocate(Ptr: ptr);
580}
581
582#endif // LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
583

source code of clang/include/clang/Lex/PreprocessingRecord.h