Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/MacroInfo.h
Line
Count
Source (jump to first uncovered line)
1
//===- MacroInfo.h - Information about #defined identifiers -----*- 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
/// \file
11
/// Defines the clang::MacroInfo and clang::MacroDirective classes.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_LEX_MACROINFO_H
16
#define LLVM_CLANG_LEX_MACROINFO_H
17
18
#include "clang/Lex/Token.h"
19
#include "clang/Basic/LLVM.h"
20
#include "clang/Basic/SourceLocation.h"
21
#include "llvm/ADT/ArrayRef.h"
22
#include "llvm/ADT/FoldingSet.h"
23
#include "llvm/ADT/PointerIntPair.h"
24
#include "llvm/ADT/SmallVector.h"
25
#include "llvm/Support/Allocator.h"
26
#include <algorithm>
27
#include <cassert>
28
29
namespace clang {
30
31
class DefMacroDirective;
32
class IdentifierInfo;
33
class Module;
34
class Preprocessor;
35
class SourceManager;
36
37
/// Encapsulates the data about a macro definition (e.g. its tokens).
38
///
39
/// There's an instance of this class for every #define.
40
class MacroInfo {
41
  //===--------------------------------------------------------------------===//
42
  // State set when the macro is defined.
43
44
  /// The location the macro is defined.
45
  SourceLocation Location;
46
47
  /// The location of the last token in the macro.
48
  SourceLocation EndLocation;
49
50
  /// The list of arguments for a function-like macro.
51
  ///
52
  /// ParameterList points to the first of NumParameters pointers.
53
  ///
54
  /// This can be empty, for, e.g. "#define X()".  In a C99-style variadic
55
  /// macro, this includes the \c __VA_ARGS__ identifier on the list.
56
  IdentifierInfo **ParameterList = nullptr;
57
58
  /// \see ParameterList
59
  unsigned NumParameters = 0;
60
61
  /// This is the list of tokens that the macro is defined to.
62
  SmallVector<Token, 8> ReplacementTokens;
63
64
  /// Length in characters of the macro definition.
65
  mutable unsigned DefinitionLength;
66
  mutable bool IsDefinitionLengthCached : 1;
67
68
  /// True if this macro is function-like, false if it is object-like.
69
  bool IsFunctionLike : 1;
70
71
  /// True if this macro is of the form "#define X(...)" or
72
  /// "#define X(Y,Z,...)".
73
  ///
74
  /// The __VA_ARGS__ token should be replaced with the contents of "..." in an
75
  /// invocation.
76
  bool IsC99Varargs : 1;
77
78
  /// True if this macro is of the form "#define X(a...)".
79
  ///
80
  /// The "a" identifier in the replacement list will be replaced with all
81
  /// arguments of the macro starting with the specified one.
82
  bool IsGNUVarargs : 1;
83
84
  /// True if this macro requires processing before expansion.
85
  ///
86
  /// This is the case for builtin macros such as __LINE__, so long as they have
87
  /// not been redefined, but not for regular predefined macros from the
88
  /// "<built-in>" memory buffer (see Preprocessing::getPredefinesFileID).
89
  bool IsBuiltinMacro : 1;
90
91
  /// Whether this macro contains the sequence ", ## __VA_ARGS__"
92
  bool HasCommaPasting : 1;
93
94
  //===--------------------------------------------------------------------===//
95
  // State that changes as the macro is used.
96
97
  /// True if we have started an expansion of this macro already.
98
  ///
99
  /// This disables recursive expansion, which would be quite bad for things
100
  /// like \#define A A.
101
  bool IsDisabled : 1;
102
103
  /// True if this macro is either defined in the main file and has
104
  /// been used, or if it is not defined in the main file.
105
  ///
106
  /// This is used to emit -Wunused-macros diagnostics.
107
  bool IsUsed : 1;
108
109
  /// True if this macro can be redefined without emitting a warning.
110
  bool IsAllowRedefinitionsWithoutWarning : 1;
111
112
  /// Must warn if the macro is unused at the end of translation unit.
113
  bool IsWarnIfUnused : 1;
114
115
  /// Whether this macro was used as header guard.
116
  bool UsedForHeaderGuard : 1;
117
118
  // Only the Preprocessor gets to create and destroy these.
119
  MacroInfo(SourceLocation DefLoc);
120
11.3M
  ~MacroInfo() = default;
121
122
public:
123
  /// Return the location that the macro was defined at.
124
63.1M
  SourceLocation getDefinitionLoc() const { return Location; }
125
126
  /// Set the location of the last token in the macro.
127
23.4M
  void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
128
129
  /// Return the location of the last token in the macro.
130
1.33M
  SourceLocation getDefinitionEndLoc() const { return EndLocation; }
131
132
  /// Get length in characters of the macro definition.
133
11.7M
  unsigned getDefinitionLength(const SourceManager &SM) const {
134
11.7M
    if (IsDefinitionLengthCached)
135
11.3M
      return DefinitionLength;
136
467k
    return getDefinitionLengthSlow(SM);
137
467k
  }
138
139
  /// Return true if the specified macro definition is equal to
140
  /// this macro in spelling, arguments, and whitespace.
141
  ///
142
  /// \param Syntactically if true, the macro definitions can be identical even
143
  /// if they use different identifiers for the function macro parameters.
144
  /// Otherwise the comparison is lexical and this implements the rules in
145
  /// C99 6.10.3.
146
  bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
147
                     bool Syntactically) const;
148
149
  /// Set or clear the isBuiltinMacro flag.
150
998k
  void setIsBuiltinMacro(bool Val = true) { IsBuiltinMacro = Val; }
151
152
  /// Set the value of the IsUsed flag.
153
17.0M
  void setIsUsed(bool Val) { IsUsed = Val; }
154
155
  /// Set the value of the IsAllowRedefinitionsWithoutWarning flag.
156
3
  void setIsAllowRedefinitionsWithoutWarning(bool Val) {
157
3
    IsAllowRedefinitionsWithoutWarning = Val;
158
3
  }
159
160
  /// Set the value of the IsWarnIfUnused flag.
161
17
  void setIsWarnIfUnused(bool val) { IsWarnIfUnused = val; }
162
163
  /// Set the specified list of identifiers as the parameter list for
164
  /// this macro.
165
  void setParameterList(ArrayRef<IdentifierInfo *> List,
166
3.25M
                       llvm::BumpPtrAllocator &PPAllocator) {
167
3.25M
    assert(ParameterList == nullptr && NumParameters == 0 &&
168
3.25M
           "Parameter list already set!");
169
3.25M
    if (List.empty())
170
10
      return;
171
3.25M
172
3.25M
    NumParameters = List.size();
173
3.25M
    ParameterList = PPAllocator.Allocate<IdentifierInfo *>(List.size());
174
3.25M
    std::copy(List.begin(), List.end(), ParameterList);
175
3.25M
  }
176
177
  /// Parameters - The list of parameters for a function-like macro.  This can
178
  /// be empty, for, e.g. "#define X()".
179
  using param_iterator = IdentifierInfo *const *;
180
49
  bool param_empty() const { return NumParameters == 0; }
181
25.9M
  param_iterator param_begin() const { return ParameterList; }
182
18.8M
  param_iterator param_end() const { return ParameterList + NumParameters; }
183
17.1M
  unsigned getNumParams() const { return NumParameters; }
184
9.77k
  ArrayRef<const IdentifierInfo *> params() const {
185
9.77k
    return ArrayRef<const IdentifierInfo *>(ParameterList, NumParameters);
186
9.77k
  }
187
188
  /// Return the parameter number of the specified identifier,
189
  /// or -1 if the identifier is not a formal parameter identifier.
190
17.6M
  int getParameterNum(const IdentifierInfo *Arg) const {
191
42.0M
    for (param_iterator I = param_begin(), E = param_end(); I != E; 
++I24.3M
)
192
31.5M
      if (*I == Arg)
193
7.22M
        return I - param_begin();
194
17.6M
    
return -110.4M
;
195
17.6M
  }
196
197
  /// Function/Object-likeness.  Keep track of whether this macro has formal
198
  /// parameters.
199
3.27M
  void setIsFunctionLike() { IsFunctionLike = true; }
200
46.7M
  bool isFunctionLike() const { return IsFunctionLike; }
201
26.6M
  bool isObjectLike() const { return !IsFunctionLike; }
202
203
  /// Varargs querying methods.  This can only be set for function-like macros.
204
66.2k
  void setIsC99Varargs() { IsC99Varargs = true; }
205
74
  void setIsGNUVarargs() { IsGNUVarargs = true; }
206
3.90M
  bool isC99Varargs() const { return IsC99Varargs; }
207
634k
  bool isGNUVarargs() const { return IsGNUVarargs; }
208
8.51M
  bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
209
210
  /// Return true if this macro requires processing before expansion.
211
  ///
212
  /// This is true only for builtin macro, such as \__LINE__, whose values
213
  /// are not given by fixed textual expansions.  Regular predefined macros
214
  /// from the "<built-in>" buffer are not reported as builtins by this
215
  /// function.
216
20.8M
  bool isBuiltinMacro() const { return IsBuiltinMacro; }
217
218
16.0k
  bool hasCommaPasting() const { return HasCommaPasting; }
219
465
  void setHasCommaPasting() { HasCommaPasting = true; }
220
221
  /// Return false if this macro is defined in the main file and has
222
  /// not yet been used.
223
1.18M
  bool isUsed() const { return IsUsed; }
224
225
  /// Return true if this macro can be redefined without warning.
226
312k
  bool isAllowRedefinitionsWithoutWarning() const {
227
312k
    return IsAllowRedefinitionsWithoutWarning;
228
312k
  }
229
230
  /// Return true if we should emit a warning if the macro is unused.
231
17.9M
  bool isWarnIfUnused() const { return IsWarnIfUnused; }
232
233
  /// Return the number of tokens that this macro expands to.
234
55.7M
  unsigned getNumTokens() const { return ReplacementTokens.size(); }
235
236
54.6M
  const Token &getReplacementToken(unsigned Tok) const {
237
54.6M
    assert(Tok < ReplacementTokens.size() && "Invalid token #");
238
54.6M
    return ReplacementTokens[Tok];
239
54.6M
  }
240
241
  using tokens_iterator = SmallVectorImpl<Token>::const_iterator;
242
243
23.9M
  tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); }
244
11.7M
  tokens_iterator tokens_end() const { return ReplacementTokens.end(); }
245
397k
  bool tokens_empty() const { return ReplacementTokens.empty(); }
246
398k
  ArrayRef<Token> tokens() const { return ReplacementTokens; }
247
248
  /// Add the specified token to the replacement text for the macro.
249
115M
  void AddTokenToBody(const Token &Tok) {
250
115M
    assert(
251
115M
        !IsDefinitionLengthCached &&
252
115M
        "Changing replacement tokens after definition length got calculated");
253
115M
    ReplacementTokens.push_back(Tok);
254
115M
  }
255
256
  /// Return true if this macro is enabled.
257
  ///
258
  /// In other words, that we are not currently in an expansion of this macro.
259
20.6M
  bool isEnabled() const { return !IsDisabled; }
260
261
11.7M
  void EnableMacro() {
262
11.7M
    assert(IsDisabled && "Cannot enable an already-enabled macro!");
263
11.7M
    IsDisabled = false;
264
11.7M
  }
265
266
11.7M
  void DisableMacro() {
267
11.7M
    assert(!IsDisabled && "Cannot disable an already-disabled macro!");
268
11.7M
    IsDisabled = true;
269
11.7M
  }
270
271
  /// Determine whether this macro was used for a header guard.
272
867k
  bool isUsedForHeaderGuard() const { return UsedForHeaderGuard; }
273
274
430k
  void setUsedForHeaderGuard(bool Val) { UsedForHeaderGuard = Val; }
275
276
  void dump() const;
277
278
private:
279
  friend class Preprocessor;
280
281
  unsigned getDefinitionLengthSlow(const SourceManager &SM) const;
282
};
283
284
/// Encapsulates changes to the "macros namespace" (the location where
285
/// the macro name became active, the location where it was undefined, etc.).
286
///
287
/// MacroDirectives, associated with an identifier, are used to model the macro
288
/// history. Usually a macro definition (MacroInfo) is where a macro name
289
/// becomes active (MacroDirective) but #pragma push_macro / pop_macro can
290
/// create additional DefMacroDirectives for the same MacroInfo.
291
class MacroDirective {
292
public:
293
  enum Kind {
294
    MD_Define,
295
    MD_Undefine,
296
    MD_Visibility
297
  };
298
299
protected:
300
  /// Previous macro directive for the same identifier, or nullptr.
301
  MacroDirective *Previous = nullptr;
302
303
  SourceLocation Loc;
304
305
  /// MacroDirective kind.
306
  unsigned MDKind : 2;
307
308
  /// True if the macro directive was loaded from a PCH file.
309
  unsigned IsFromPCH : 1;
310
311
  // Used by VisibilityMacroDirective ----------------------------------------//
312
313
  /// Whether the macro has public visibility (when described in a
314
  /// module).
315
  unsigned IsPublic : 1;
316
317
  MacroDirective(Kind K, SourceLocation Loc)
318
24.5M
      : Loc(Loc), MDKind(K), IsFromPCH(false), IsPublic(true) {}
319
320
public:
321
136M
  Kind getKind() const { return Kind(MDKind); }
322
323
1.50M
  SourceLocation getLocation() const { return Loc; }
324
325
  /// Set previous definition of the macro with the same name.
326
24.5M
  void setPrevious(MacroDirective *Prev) { Previous = Prev; }
327
328
  /// Get previous definition of the macro with the same name.
329
0
  const MacroDirective *getPrevious() const { return Previous; }
330
331
  /// Get previous definition of the macro with the same name.
332
865k
  MacroDirective *getPrevious() { return Previous; }
333
334
  /// Return true if the macro directive was loaded from a PCH file.
335
  bool isFromPCH() const { return IsFromPCH; }
336
337
  void setIsFromPCH() { IsFromPCH = true; }
338
339
0
  class DefInfo {
340
    DefMacroDirective *DefDirective = nullptr;
341
    SourceLocation UndefLoc;
342
    bool IsPublic = true;
343
344
  public:
345
2.57k
    DefInfo() = default;
346
    DefInfo(DefMacroDirective *DefDirective, SourceLocation UndefLoc,
347
            bool isPublic)
348
75.7M
        : DefDirective(DefDirective), UndefLoc(UndefLoc), IsPublic(isPublic) {}
349
350
0
    const DefMacroDirective *getDirective() const { return DefDirective; }
351
15
    DefMacroDirective *getDirective() { return DefDirective; }
352
353
    inline SourceLocation getLocation() const;
354
    inline MacroInfo *getMacroInfo();
355
356
1.54M
    const MacroInfo *getMacroInfo() const {
357
1.54M
      return const_cast<DefInfo *>(this)->getMacroInfo();
358
1.54M
    }
359
360
254
    SourceLocation getUndefLocation() const { return UndefLoc; }
361
25.0M
    bool isUndefined() const { return UndefLoc.isValid(); }
362
363
    bool isPublic() const { return IsPublic; }
364
365
76.2M
    bool isValid() const { return DefDirective != nullptr; }
366
51.0M
    bool isInvalid() const { return !isValid(); }
367
368
25.1M
    explicit operator bool() const { return isValid(); }
369
370
    inline DefInfo getPreviousDefinition();
371
372
0
    const DefInfo getPreviousDefinition() const {
373
0
      return const_cast<DefInfo *>(this)->getPreviousDefinition();
374
0
    }
375
  };
376
377
  /// Traverses the macro directives history and returns the next
378
  /// macro definition directive along with info about its undefined location
379
  /// (if there is one) and if it is public or private.
380
  DefInfo getDefinition();
381
26.4M
  const DefInfo getDefinition() const {
382
26.4M
    return const_cast<MacroDirective *>(this)->getDefinition();
383
26.4M
  }
384
385
24.9M
  bool isDefined() const {
386
24.9M
    if (const DefInfo Def = getDefinition())
387
24.9M
      return !Def.isUndefined();
388
191
    return false;
389
191
  }
390
391
1.37M
  const MacroInfo *getMacroInfo() const {
392
1.37M
    return getDefinition().getMacroInfo();
393
1.37M
  }
394
49.2M
  MacroInfo *getMacroInfo() { return getDefinition().getMacroInfo(); }
395
396
  /// Find macro definition active in the specified source location. If
397
  /// this macro was not defined there, return NULL.
398
  const DefInfo findDirectiveAtLoc(SourceLocation L,
399
                                   const SourceManager &SM) const;
400
401
  void dump() const;
402
403
  static bool classof(const MacroDirective *) { return true; }
404
};
405
406
/// A directive for a defined macro or a macro imported from a module.
407
class DefMacroDirective : public MacroDirective {
408
  MacroInfo *Info;
409
410
public:
411
  DefMacroDirective(MacroInfo *MI, SourceLocation Loc)
412
24.4M
      : MacroDirective(MD_Define, Loc), Info(MI) {
413
24.4M
    assert(MI && "MacroInfo is null");
414
24.4M
  }
415
  explicit DefMacroDirective(MacroInfo *MI)
416
      : DefMacroDirective(MI, MI->getDefinitionLoc()) {}
417
418
  /// The data for the macro definition.
419
0
  const MacroInfo *getInfo() const { return Info; }
420
51.6M
  MacroInfo *getInfo() { return Info; }
421
422
106M
  static bool classof(const MacroDirective *MD) {
423
106M
    return MD->getKind() == MD_Define;
424
106M
  }
425
426
0
  static bool classof(const DefMacroDirective *) { return true; }
427
};
428
429
/// A directive for an undefined macro.
430
class UndefMacroDirective : public MacroDirective {
431
public:
432
  explicit UndefMacroDirective(SourceLocation UndefLoc)
433
127k
      : MacroDirective(MD_Undefine, UndefLoc) {
434
127k
    assert(UndefLoc.isValid() && "Invalid UndefLoc!");
435
127k
  }
436
437
128k
  static bool classof(const MacroDirective *MD) {
438
128k
    return MD->getKind() == MD_Undefine;
439
128k
  }
440
441
0
  static bool classof(const UndefMacroDirective *) { return true; }
442
};
443
444
/// A directive for setting the module visibility of a macro.
445
class VisibilityMacroDirective : public MacroDirective {
446
public:
447
  explicit VisibilityMacroDirective(SourceLocation Loc, bool Public)
448
174
      : MacroDirective(MD_Visibility, Loc) {
449
174
    IsPublic = Public;
450
174
  }
451
452
  /// Determine whether this macro is part of the public API of its
453
  /// module.
454
645
  bool isPublic() const { return IsPublic; }
455
456
29.7M
  static bool classof(const MacroDirective *MD) {
457
29.7M
    return MD->getKind() == MD_Visibility;
458
29.7M
  }
459
460
0
  static bool classof(const VisibilityMacroDirective *) { return true; }
461
};
462
463
110k
inline SourceLocation MacroDirective::DefInfo::getLocation() const {
464
110k
  if (isInvalid())
465
0
    return {};
466
110k
  return DefDirective->getLocation();
467
110k
}
468
469
50.9M
inline MacroInfo *MacroDirective::DefInfo::getMacroInfo() {
470
50.9M
  if (isInvalid())
471
0
    return nullptr;
472
50.9M
  return DefDirective->getInfo();
473
50.9M
}
474
475
inline MacroDirective::DefInfo
476
2.44k
MacroDirective::DefInfo::getPreviousDefinition() {
477
2.44k
  if (isInvalid() || DefDirective->getPrevious() == nullptr)
478
2.28k
    return {};
479
162
  return DefDirective->getPrevious()->getDefinition();
480
162
}
481
482
/// Represents a macro directive exported by a module.
483
///
484
/// There's an instance of this class for every macro #define or #undef that is
485
/// the final directive for a macro name within a module. These entities also
486
/// represent the macro override graph.
487
///
488
/// These are stored in a FoldingSet in the preprocessor.
489
class ModuleMacro : public llvm::FoldingSetNode {
490
  friend class Preprocessor;
491
492
  /// The name defined by the macro.
493
  IdentifierInfo *II;
494
495
  /// The body of the #define, or nullptr if this is a #undef.
496
  MacroInfo *Macro;
497
498
  /// The module that exports this macro.
499
  Module *OwningModule;
500
501
  /// The number of module macros that override this one.
502
  unsigned NumOverriddenBy = 0;
503
504
  /// The number of modules whose macros are directly overridden by this one.
505
  unsigned NumOverrides;
506
507
  ModuleMacro(Module *OwningModule, IdentifierInfo *II, MacroInfo *Macro,
508
              ArrayRef<ModuleMacro *> Overrides)
509
      : II(II), Macro(Macro), OwningModule(OwningModule),
510
14.9k
        NumOverrides(Overrides.size()) {
511
14.9k
    std::copy(Overrides.begin(), Overrides.end(),
512
14.9k
              reinterpret_cast<ModuleMacro **>(this + 1));
513
14.9k
  }
514
515
public:
516
  static ModuleMacro *create(Preprocessor &PP, Module *OwningModule,
517
                             IdentifierInfo *II, MacroInfo *Macro,
518
                             ArrayRef<ModuleMacro *> Overrides);
519
520
36.6k
  void Profile(llvm::FoldingSetNodeID &ID) const {
521
36.6k
    return Profile(ID, OwningModule, II);
522
36.6k
  }
523
524
  static void Profile(llvm::FoldingSetNodeID &ID, Module *OwningModule,
525
51.8k
                      IdentifierInfo *II) {
526
51.8k
    ID.AddPointer(OwningModule);
527
51.8k
    ID.AddPointer(II);
528
51.8k
  }
529
530
  /// Get the name of the macro.
531
  IdentifierInfo *getName() const { return II; }
532
533
  /// Get the ID of the module that exports this macro.
534
16.5k
  Module *getOwningModule() const { return OwningModule; }
535
536
  /// Get definition for this exported #define, or nullptr if this
537
  /// represents a #undef.
538
18.0k
  MacroInfo *getMacroInfo() const { return Macro; }
539
540
  /// Iterators over the overridden module IDs.
541
  /// \{
542
  using overrides_iterator = ModuleMacro *const *;
543
544
57.6k
  overrides_iterator overrides_begin() const {
545
57.6k
    return reinterpret_cast<overrides_iterator>(this + 1);
546
57.6k
  }
547
548
28.8k
  overrides_iterator overrides_end() const {
549
28.8k
    return overrides_begin() + NumOverrides;
550
28.8k
  }
551
552
28.8k
  ArrayRef<ModuleMacro *> overrides() const {
553
28.8k
    return llvm::makeArrayRef(overrides_begin(), overrides_end());
554
28.8k
  }
555
  /// \}
556
557
  /// Get the number of macros that override this one.
558
178
  unsigned getNumOverridingMacros() const { return NumOverriddenBy; }
559
};
560
561
/// A description of the current definition of a macro.
562
///
563
/// The definition of a macro comprises a set of (at least one) defining
564
/// entities, which are either local MacroDirectives or imported ModuleMacros.
565
class MacroDefinition {
566
  llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
567
  ArrayRef<ModuleMacro *> ModuleMacros;
568
569
public:
570
2.50M
  MacroDefinition() = default;
571
  MacroDefinition(DefMacroDirective *MD, ArrayRef<ModuleMacro *> MMs,
572
                  bool IsAmbiguous)
573
29.7M
      : LatestLocalAndAmbiguous(MD, IsAmbiguous), ModuleMacros(MMs) {}
574
575
  /// Determine whether there is a definition of this macro.
576
31.8M
  explicit operator bool() const {
577
31.8M
    return getLocalDirective() || 
!ModuleMacros.empty()2.56M
;
578
31.8M
  }
579
580
  /// Get the MacroInfo that should be used for this definition.
581
48.7M
  MacroInfo *getMacroInfo() const {
582
48.7M
    if (!ModuleMacros.empty())
583
1.93k
      return ModuleMacros.back()->getMacroInfo();
584
48.7M
    if (auto *MD = getLocalDirective())
585
47.5M
      return MD->getMacroInfo();
586
1.20M
    return nullptr;
587
1.20M
  }
588
589
  /// \c true if the definition is ambiguous, \c false otherwise.
590
15.7M
  bool isAmbiguous() const { return LatestLocalAndAmbiguous.getInt(); }
591
592
  /// Get the latest non-imported, non-\#undef'd macro definition
593
  /// for this macro.
594
80.6M
  DefMacroDirective *getLocalDirective() const {
595
80.6M
    return LatestLocalAndAmbiguous.getPointer();
596
80.6M
  }
597
598
  /// Get the active module macros for this macro.
599
113
  ArrayRef<ModuleMacro *> getModuleMacros() const { return ModuleMacros; }
600
601
113
  template <typename Fn> void forAllDefinitions(Fn F) const {
602
113
    if (auto *MD = getLocalDirective())
603
57
      F(MD->getMacroInfo());
604
113
    for (auto *MM : getModuleMacros())
605
97
      F(MM->getMacroInfo());
606
113
  }
PPMacroExpansion.cpp:void clang::MacroDefinition::forAllDefinitions<clang::Preprocessor::HandleMacroExpandedIdentifier(clang::Token&, clang::MacroDefinition const&)::$_1>(clang::Preprocessor::HandleMacroExpandedIdentifier(clang::Token&, clang::MacroDefinition const&)::$_1) const
Line
Count
Source
601
45
  template <typename Fn> void forAllDefinitions(Fn F) const {
602
45
    if (auto *MD = getLocalDirective())
603
13
      F(MD->getMacroInfo());
604
45
    for (auto *MM : getModuleMacros())
605
77
      F(MM->getMacroInfo());
606
45
  }
PreprocessingRecord.cpp:void clang::MacroDefinition::forAllDefinitions<clang::PreprocessingRecord::MacroUndefined(clang::Token const&, clang::MacroDefinition const&, clang::MacroDirective const*)::$_0>(clang::PreprocessingRecord::MacroUndefined(clang::Token const&, clang::MacroDefinition const&, clang::MacroDirective const*)::$_0) const
Line
Count
Source
601
68
  template <typename Fn> void forAllDefinitions(Fn F) const {
602
68
    if (auto *MD = getLocalDirective())
603
44
      F(MD->getMacroInfo());
604
68
    for (auto *MM : getModuleMacros())
605
20
      F(MM->getMacroInfo());
606
68
  }
607
};
608
609
} // namespace clang
610
611
#endif // LLVM_CLANG_LEX_MACROINFO_H