14#ifndef LLVM_CLANG_SERIALIZATION_ASTWRITER_H
15#define LLVM_CLANG_SERIALIZATION_ASTWRITER_H
29#include "llvm/ADT/ArrayRef.h"
30#include "llvm/ADT/DenseMap.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/MapVector.h"
33#include "llvm/ADT/STLExtras.h"
34#include "llvm/ADT/SetVector.h"
35#include "llvm/ADT/SmallVector.h"
36#include "llvm/ADT/StringRef.h"
37#include "llvm/Bitstream/BitstreamWriter.h"
55class FPOptionsOverride;
58class HeaderSearchOptions;
59class IdentifierResolver;
61class MacroDefinitionRecord;
64class InMemoryModuleCache;
65class ModuleFileExtension;
66class ModuleFileExtensionWriter;
68class ObjCInterfaceDecl;
69class PreprocessingRecord;
111 llvm::BitstreamWriter &Stream;
129 Module *WritingModule =
nullptr;
132 std::pair<uint64_t, uint64_t> UnhashedControlBlockRange;
134 uint64_t ASTBlockHashOffset = 0;
136 uint64_t SignatureOffset = 0;
139 uint64_t ASTBlockStartOffset = 0;
142 std::pair<uint64_t, uint64_t> ASTBlockRange;
145 std::string BaseDirectory;
151 bool IncludeTimestamps;
156 bool BuildingImplicitModule =
false;
160 bool WritingAST =
false;
164 bool DoneWritingDeclsAndTypes =
false;
167 bool ASTHasCompilerErrors =
false;
171 bool GeneratingReducedBMI =
false;
175 llvm::DenseMap<const FileEntry *, uint32_t> InputFileIDs;
180 DeclOrType(
Decl *D) : Stored(D), IsType(
false) {}
181 DeclOrType(
QualType T) : Stored(
T.getAsOpaquePtr()), IsType(
true) {}
183 bool isType()
const {
return IsType; }
184 bool isDecl()
const {
return !IsType; }
187 assert(isType() &&
"Not a type!");
191 Decl *getDecl()
const {
192 assert(isDecl() &&
"Not a decl!");
193 return static_cast<Decl *
>(Stored);
202 std::queue<DeclOrType> DeclTypesToEmit;
226 llvm::DenseMap<const Decl *, LocalDeclID> DeclIDs;
230 std::vector<serialization::DeclOffset> DeclOffsets;
234 uint64_t DeclTypesBlockStartOffset = 0;
238 struct DeclIDInFileInfo {
239 LocDeclIDsTy DeclIDs;
243 unsigned FirstDeclIndex;
245 using FileDeclIDsTy =
246 llvm::DenseMap<FileID, std::unique_ptr<DeclIDInFileInfo>>;
250 FileDeclIDsTy FileDeclIDs;
252 void associateDeclWithFile(
const Decl *D, LocalDeclID);
273 std::vector<serialization::UnderalignedInt64> TypeOffsets;
287 llvm::MapVector<const IdentifierInfo *, serialization::IdentID> IdentifierIDs;
296 llvm::DenseMap<MacroInfo *, serialization::MacroID> MacroIDs;
298 struct MacroInfoToEmitData {
299 const IdentifierInfo *Name;
305 std::vector<MacroInfoToEmitData> MacroInfosToEmit;
307 llvm::DenseMap<const IdentifierInfo *, uint32_t>
308 IdentMacroDirectivesOffsetMap;
318 llvm::DenseMap<Stmt *, uint64_t> SubStmtEntries;
324 std::vector<uint32_t> IdentifierOffsets;
341 llvm::MapVector<Selector, serialization::SelectorID> SelectorIDs;
345 std::vector<uint32_t> SelectorOffsets;
349 llvm::DenseMap<
const MacroDefinitionRecord *,
354 llvm::DenseMap<const Decl *, unsigned> AnonymousDeclarationNumbers;
366 const Attr *Attribute;
370 DeclUpdate(
unsigned Kind) :
Kind(
Kind), Dcl(nullptr) {}
371 DeclUpdate(
unsigned Kind,
const Decl *Dcl) :
Kind(
Kind), Dcl(Dcl) {}
372 DeclUpdate(
unsigned Kind, QualType Type)
374 DeclUpdate(
unsigned Kind, SourceLocation Loc)
375 :
Kind(
Kind), Loc(Loc.getRawEncoding()) {}
376 DeclUpdate(
unsigned Kind,
unsigned Val) :
Kind(
Kind), Val(Val) {}
377 DeclUpdate(
unsigned Kind, Module *M) :
Kind(
Kind), Mod(M) {}
378 DeclUpdate(
unsigned Kind,
const Attr *Attribute)
379 :
Kind(
Kind), Attribute(Attribute) {}
381 unsigned getKind()
const {
return Kind; }
382 const Decl *getDecl()
const {
return Dcl; }
385 SourceLocation getLoc()
const {
389 unsigned getNumber()
const {
return Val; }
390 Module *getModule()
const {
return Mod; }
391 const Attr *getAttr()
const {
return Attribute; }
394 using UpdateRecord = SmallVector<DeclUpdate, 1>;
395 using DeclUpdateMap = llvm::MapVector<const Decl *, UpdateRecord>;
399 DeclUpdateMap DeclUpdates;
404 DeclUpdateMap DeclUpdatesFromGMF;
406 using FirstLatestDeclMap = llvm::DenseMap<Decl *, Decl *>;
410 FirstLatestDeclMap FirstLatestDecls;
438 SmallVector<const Decl *, 16> DeclsToEmitEvenIfUnreferenced;
442 llvm::SetVector<ObjCInterfaceDecl *> ObjCClassesWithCategories;
450 llvm::DenseMap<const Decl *, const Decl *> FirstLocalDeclCache;
453 llvm::DenseMap<SwitchCase *, unsigned> SwitchCaseIDs;
456 unsigned NumStatements = 0;
459 unsigned NumMacros = 0;
463 unsigned NumLexicalDeclContexts = 0;
467 unsigned NumVisibleDeclContexts = 0;
471 llvm::DenseMap<const Module *, unsigned> SubmoduleIDs;
474 std::vector<std::unique_ptr<ModuleFileExtensionWriter>>
475 ModuleFileExtensionWriters;
478 llvm::BitVector IsSLocAffecting;
481 std::vector<FileID> NonAffectingFileIDs;
482 std::vector<unsigned> NonAffectingFileIDAdjustments;
485 std::vector<SourceRange> NonAffectingRanges;
486 std::vector<SourceLocation::UIntTy> NonAffectingOffsetAdjustments;
491 void computeNonAffectingInputFiles();
495 FileID getAdjustedFileID(FileID FID)
const;
498 unsigned getAdjustedNumCreatedFIDs(FileID FID)
const;
501 SourceLocation getAdjustedLocation(SourceLocation Loc)
const;
504 SourceRange getAdjustedRange(SourceRange Range)
const;
513 unsigned getSubmoduleID(Module *Mod);
516 void WriteSubStmt(Stmt *S);
518 void WriteBlockInfoBlock();
519 void WriteControlBlock(Preprocessor &PP, ASTContext &Context,
523 void writeUnhashedControlBlock(Preprocessor &PP, ASTContext &Context);
524 ASTFileSignature backpatchSignature();
527 std::pair<ASTFileSignature, ASTFileSignature> createSignature()
const;
529 void WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts);
530 void WriteSourceManagerBlock(SourceManager &SourceMgr,
531 const Preprocessor &PP);
532 void WritePreprocessor(
const Preprocessor &PP,
bool IsModule);
533 void WriteHeaderSearch(
const HeaderSearch &HS);
534 void WritePreprocessorDetail(PreprocessingRecord &PPRec,
535 uint64_t MacroOffsetsBase);
536 void WriteSubmodules(Module *WritingModule);
538 void WritePragmaDiagnosticMappings(
const DiagnosticsEngine &
Diag,
541 unsigned TypeExtQualAbbrev = 0;
542 void WriteTypeAbbrevs();
543 void WriteType(QualType
T);
545 bool isLookupResultExternal(StoredDeclsList &
Result, DeclContext *DC);
546 bool isLookupResultEntirelyExternalOrUnreachable(StoredDeclsList &
Result,
549 void GenerateNameLookupTable(
const DeclContext *DC,
551 uint64_t WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC);
552 uint64_t WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC);
553 void WriteTypeDeclOffsets();
554 void WriteFileDeclIDsMap();
555 void WriteComments();
556 void WriteSelectors(Sema &SemaRef);
557 void WriteReferencedSelectorsPool(Sema &SemaRef);
558 void WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver,
560 void WriteDeclAndTypes(ASTContext &Context);
561 void PrepareWritingSpecialDecls(Sema &SemaRef);
562 void WriteSpecialDeclRecords(Sema &SemaRef);
564 void WriteDeclContextVisibleUpdate(
const DeclContext *DC);
565 void WriteFPPragmaOptions(
const FPOptionsOverride &Opts);
566 void WriteOpenCLExtensions(Sema &SemaRef);
567 void WriteCUDAPragmas(Sema &SemaRef);
568 void WriteObjCCategories();
569 void WriteLateParsedTemplates(Sema &SemaRef);
570 void WriteOptimizePragmaOptions(Sema &SemaRef);
571 void WriteMSStructPragmaOptions(Sema &SemaRef);
572 void WriteMSPointersToMembersPragmaOptions(Sema &SemaRef);
573 void WritePackPragmaOptions(Sema &SemaRef);
574 void WriteFloatControlPragmaOptions(Sema &SemaRef);
575 void WriteModuleFileExtension(Sema &SemaRef,
576 ModuleFileExtensionWriter &Writer);
578 unsigned DeclParmVarAbbrev = 0;
579 unsigned DeclContextLexicalAbbrev = 0;
580 unsigned DeclContextVisibleLookupAbbrev = 0;
581 unsigned UpdateVisibleAbbrev = 0;
582 unsigned DeclRecordAbbrev = 0;
583 unsigned DeclTypedefAbbrev = 0;
584 unsigned DeclVarAbbrev = 0;
585 unsigned DeclFieldAbbrev = 0;
586 unsigned DeclEnumAbbrev = 0;
587 unsigned DeclObjCIvarAbbrev = 0;
588 unsigned DeclCXXMethodAbbrev = 0;
589 unsigned DeclDependentNonTemplateCXXMethodAbbrev = 0;
590 unsigned DeclTemplateCXXMethodAbbrev = 0;
591 unsigned DeclMemberSpecializedCXXMethodAbbrev = 0;
592 unsigned DeclTemplateSpecializedCXXMethodAbbrev = 0;
593 unsigned DeclDependentSpecializationCXXMethodAbbrev = 0;
594 unsigned DeclTemplateTypeParmAbbrev = 0;
595 unsigned DeclUsingShadowAbbrev = 0;
597 unsigned DeclRefExprAbbrev = 0;
598 unsigned CharacterLiteralAbbrev = 0;
599 unsigned IntegerLiteralAbbrev = 0;
600 unsigned ExprImplicitCastAbbrev = 0;
601 unsigned BinaryOperatorAbbrev = 0;
602 unsigned CompoundAssignOperatorAbbrev = 0;
603 unsigned CallExprAbbrev = 0;
604 unsigned CXXOperatorCallExprAbbrev = 0;
605 unsigned CXXMemberCallExprAbbrev = 0;
607 unsigned CompoundStmtAbbrev = 0;
609 void WriteDeclAbbrevs();
610 void WriteDecl(ASTContext &Context, Decl *D);
612 ASTFileSignature WriteASTCore(Sema &SemaRef, StringRef isysroot,
613 Module *WritingModule);
618 ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
619 InMemoryModuleCache &ModuleCache,
620 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
621 bool IncludeTimestamps =
true,
bool BuildingImplicitModule =
false,
622 bool GeneratingReducedBMI =
false);
626 assert(Context &&
"requested AST context when not writing AST");
652 Module *WritingModule, StringRef isysroot,
653 bool ShouldCacheASTInMemory =
false);
667 LocSeq *
Seq =
nullptr);
671 LocSeq *
Seq =
nullptr);
709 auto I = DeclIDs.find(D);
710 return (I == DeclIDs.end() ||
777 return TypeExtQualAbbrev;
790 return DeclCXXMethodAbbrev;
792 return DeclTemplateCXXMethodAbbrev;
794 return DeclMemberSpecializedCXXMethodAbbrev;
796 return DeclTemplateSpecializedCXXMethodAbbrev;
798 return DeclDependentNonTemplateCXXMethodAbbrev;
800 return DeclDependentSpecializationCXXMethodAbbrev;
802 llvm_unreachable(
"Unknwon Template Kind!");
805 return DeclTemplateTypeParmAbbrev;
815 return CompoundAssignOperatorAbbrev;
836 void ReaderInitialized(
ASTReader *Reader)
override;
846 void CompletedTagDefinition(
const TagDecl *D)
override;
849 void AddedCXXTemplateSpecialization(
852 void AddedCXXTemplateSpecialization(
857 void ResolvedExceptionSpec(
const FunctionDecl *FD)
override;
861 Expr *ThisArg)
override;
862 void CompletedImplicitDefinition(
const FunctionDecl *D)
override;
863 void InstantiationRequested(
const ValueDecl *D)
override;
864 void VariableDefinitionInstantiated(
const VarDecl *D)
override;
865 void FunctionDefinitionInstantiated(
const FunctionDecl *D)
override;
866 void DefaultArgumentInstantiated(
const ParmVarDecl *D)
override;
867 void DefaultMemberInitializerInstantiated(
const FieldDecl *D)
override;
870 void DeclarationMarkedUsed(
const Decl *D)
override;
871 void DeclarationMarkedOpenMPThreadPrivate(
const Decl *D)
override;
872 void DeclarationMarkedOpenMPDeclareTarget(
const Decl *D,
874 void DeclarationMarkedOpenMPAllocate(
const Decl *D,
const Attr *A)
override;
875 void RedefinedHiddenDefinition(
const NamedDecl *D,
Module *M)
override;
876 void AddedAttributeToRecord(
const Attr *
Attr,
878 void EnteringModulePurview()
override;
879 void AddedManglingNumber(
const Decl *D,
unsigned)
override;
880 void AddedStaticLocalNumbers(
const Decl *D,
unsigned)
override;
889 std::string OutputFile;
890 std::string isysroot;
892 std::shared_ptr<PCHBuffer> Buffer;
893 llvm::BitstreamWriter Stream;
895 bool AllowASTWithErrors;
896 bool ShouldCacheASTInMemory;
915 StringRef OutputFile, StringRef isysroot,
916 std::shared_ptr<PCHBuffer> Buffer,
917 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
918 bool AllowASTWithErrors =
false,
bool IncludeTimestamps =
true,
919 bool BuildingImplicitModule =
false,
920 bool ShouldCacheASTInMemory =
false,
921 bool GeneratingReducedBMI =
false);
937 StringRef OutputFile);
951 constexpr static uint32_t BitIndexUpbound = 32u;
962 return CurrentBitIndex + BitsWidth < BitIndexUpbound;
966 UnderlyingValue =
Value;
972 assert(BitsWidth < BitIndexUpbound);
973 assert((
Value < (1u << BitsWidth)) &&
"Passing narrower bit width!");
975 "Inserting too much bits into a value!");
977 UnderlyingValue |=
Value << CurrentBitIndex;
978 CurrentBitIndex += BitsWidth;
981 operator uint32_t() {
return UnderlyingValue; }
984 uint32_t UnderlyingValue = 0;
985 uint32_t CurrentBitIndex = 0;
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
Defines the clang::SourceLocation class and associated facilities.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Reads an AST files chain containing the contents of a translation unit.
An object for streaming information to a record.
Writes an AST file containing the contents of a translation unit.
serialization::MacroID getMacroID(MacroInfo *MI)
Determine the ID of an already-emitted macro.
ASTFileSignature WriteAST(Sema &SemaRef, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
serialization::TypeID getTypeID(QualType T) const
Determine the type ID of an already-emitted type.
unsigned getDeclParmVarAbbrev() const
void AddEmittedDeclRef(const Decl *D, RecordDataImpl &Record)
void AddSourceRange(SourceRange Range, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source range.
unsigned getBinaryOperatorAbbrev() const
unsigned getDeclTemplateTypeParmAbbrev() const
bool isWritingStdCXXNamedModules() const
ArrayRef< uint64_t > RecordDataRef
void EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, StringRef Path)
Emit the current record with the given path as a blob.
void AddFileID(FileID FID, RecordDataImpl &Record)
Emit a FileID.
unsigned getDeclObjCIvarAbbrev() const
unsigned getExprImplicitCastAbbrev() const
unsigned getDeclTypedefAbbrev() const
unsigned getSwitchCaseID(SwitchCase *S)
Retrieve the ID for the given switch-case statement.
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
SmallVectorImpl< uint64_t > RecordDataImpl
unsigned getDeclUsingShadowAbbrev() const
unsigned getTypeExtQualAbbrev() const
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
bool isGeneratingReducedBMI() const
uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name)
unsigned getDeclVarAbbrev() const
unsigned getDeclEnumAbbrev() const
void AddAlignPackInfo(const Sema::AlignPackInfo &Info, RecordDataImpl &Record)
Emit a AlignPackInfo.
bool IsLocalDecl(const Decl *D)
Is this a local declaration (that is, one that will be written to our AST file)? This is the case for...
unsigned getDeclRefExprAbbrev() const
unsigned getCXXOperatorCallExprAbbrev()
bool wasDeclEmitted(const Decl *D) const
Whether or not the declaration got emitted.
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
time_t getTimestampForOutput(const FileEntry *E) const
Get a timestamp for output into the AST file.
void ClearSwitchCaseIDs()
LocalDeclID GetDeclRef(const Decl *D)
Force a declaration to be emitted and get its local ID to the module file been writing.
LocalDeclID getDeclID(const Decl *D)
Determine the local declaration ID of an already-emitted declaration.
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
serialization::TypeID GetOrCreateTypeID(QualType T)
Force a type to be emitted and get its ID.
serialization::MacroID getMacroRef(MacroInfo *MI, const IdentifierInfo *Name)
Get the unique number used to refer to the given macro.
void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source location.
void AddTypeRef(QualType T, RecordDataImpl &Record)
Emit a reference to a type.
ASTContext & getASTContext() const
unsigned getCXXMemberCallExprAbbrev()
ASTReader * getChain() const
unsigned getCompoundAssignOperatorAbbrev() const
bool getDoneWritingDeclsAndTypes() const
unsigned RecordSwitchCaseID(SwitchCase *S)
Record an ID for the given switch-case statement.
unsigned getCharacterLiteralAbbrev() const
unsigned getDeclCXXMethodAbbrev(FunctionDecl::TemplatedKind Kind) const
unsigned getCompoundStmtAbbrev() const
unsigned getLocalOrImportedSubmoduleID(const Module *Mod)
Retrieve or create a submodule ID for this module, or return 0 if the submodule is neither local (a s...
const Decl * getFirstLocalDecl(const Decl *D)
Find the first local declaration of a given local redeclarable decl.
void AddToken(const Token &Tok, RecordDataImpl &Record)
Emit a token.
serialization::SelectorID getSelectorRef(Selector Sel)
Get the unique number used to refer to the given selector.
ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl< char > &Buffer, InMemoryModuleCache &ModuleCache, ArrayRef< std::shared_ptr< ModuleFileExtension > > Extensions, bool IncludeTimestamps=true, bool BuildingImplicitModule=false, bool GeneratingReducedBMI=false)
Create a new precompiled header writer that outputs to the given bitstream.
SmallVector< uint64_t, 64 > RecordData
unsigned getAnonymousDeclarationNumber(const NamedDecl *D)
unsigned getDeclFieldAbbrev() const
serialization::IdentID getIdentifierRef(const IdentifierInfo *II)
Get the unique number used to refer to the given identifier.
const LangOptions & getLangOpts() const
void SetSelectorOffset(Selector Sel, uint32_t Offset)
Note that the selector Sel occurs at the given offset within the method pool/selector table.
bool PreparePathForOutput(SmallVectorImpl< char > &Path)
Convert a path from this build process into one that is appropriate for emission in the module file.
unsigned getCallExprAbbrev() const
void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset)
Note that the identifier II occurs at the given offset within the identifier table.
unsigned getDeclRecordAbbrev() const
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
unsigned getIntegerLiteralAbbrev() const
Attr - This represents one attribute.
A simple helper class to pack several bits in order into (a) 32 bit integer(s).
bool canWriteNextNBits(uint32_t BitsWidth) const
BitsPacker operator=(BitsPacker &&)=delete
BitsPacker(BitsPacker &&)=delete
void addBits(uint32_t Value, uint32_t BitsWidth)
void reset(uint32_t Value)
BitsPacker(const BitsPacker &)=delete
BitsPacker operator=(const BitsPacker &)=delete
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Decl - This represents one declaration (or definition), e.g.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Concrete class used by the front-end to report problems and issues.
This represents one expression.
Represents a member of a struct/union/class.
Cached information about one file (either on disk or in the virtual file system).
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a function declaration or definition.
TemplatedKind
The kind of templated function a FunctionDecl can be.
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
Declaration of a template function.
One of these records is kept for each identifier that is lexed.
In-memory cache for modules.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Record the location of a macro definition.
Encapsulates the data about a macro definition (e.g.
Describes a module or submodule.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
This represents a decl that may have a name.
Represent a C++ namespace.
ObjCCategoryDecl - Represents a category declaration.
Represents an ObjC class declaration.
AST and semantic-analysis consumer that generates a precompiled header from the parsed source code.
ASTMutationListener * GetASTMutationListener() override
If the consumer is interested in entities getting modified after their initial creation,...
PCHBuffer * getBufferPtr()
Preprocessor & getPreprocessor()
virtual Module * getEmittingModule(ASTContext &Ctx)
SmallVectorImpl< char > & getPCH() const
void InitializeSema(Sema &S) override
Initialize the semantic consumer with the Sema instance being used to perform semantic analysis on th...
StringRef getOutputFile() const
ASTDeserializationListener * GetASTDeserializationListener() override
If the consumer is interested in entities being deserialized from AST files, it should return a point...
const ASTWriter & getWriter() const
void HandleTranslationUnit(ASTContext &Ctx) override
HandleTranslationUnit - This method is called when the ASTs for entire translation unit have been par...
bool hasEmittedPCH() const
DiagnosticsEngine & getDiagnostics() const
Represents a parameter to a function.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
A (possibly-)qualified type.
static QualType getFromOpaquePtr(const void *Ptr)
Represents a struct/union/class.
void HandleTranslationUnit(ASTContext &Ctx) override
HandleTranslationUnit - This method is called when the ASTs for entire translation unit have been par...
virtual Module * getEmittingModule(ASTContext &Ctx) override
Smart pointer class that efficiently represents Objective-C method names.
An abstract interface that should be implemented by clients that read ASTs and then require further s...
Sema - This implements semantic analysis and AST building for C.
DiagnosticsEngine & getDiagnostics() const
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
static SourceLocation getFromRawEncoding(UIntTy Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
A trivial tuple used to represent a source range.
Represents the declaration of a struct/union/class/enum.
Token - This structure provides full information about a lexed token.
The top declaration context.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
Declaration of a variable template.
Represents a variable template specialization, which refers to a variable template with a given set o...
A type index; the type ID with the qualifier bits removed.
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
uint32_t TypeID
An ID number that refers to a type in an AST file.
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
uint32_t MacroID
An ID number that refers to a macro in an AST file.
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
@ Result
The result type of a method or function.
bool CanElideDeclDef(const Decl *D)
If we can elide the definition of.
const FunctionProtoType * T
The signature of a module, which is a hash of the AST content.
A structure for putting "fast"-unqualified QualTypes into a DenseMap.