Coverage Report

Created: 2017-10-03 07:32

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