diff options
Diffstat (limited to 'include/clang/Frontend')
| -rw-r--r-- | include/clang/Frontend/ASTConsumers.h | 107 | ||||
| -rw-r--r-- | include/clang/Frontend/Analyses.def | 77 | ||||
| -rw-r--r-- | include/clang/Frontend/AnalysisConsumer.h | 78 | ||||
| -rw-r--r-- | include/clang/Frontend/CompileOptions.h | 62 | ||||
| -rw-r--r-- | include/clang/Frontend/DocumentXML.h | 128 | ||||
| -rw-r--r-- | include/clang/Frontend/FixItRewriter.h | 95 | ||||
| -rw-r--r-- | include/clang/Frontend/FrontendDiagnostic.h | 27 | ||||
| -rw-r--r-- | include/clang/Frontend/InitHeaderSearch.h | 74 | ||||
| -rw-r--r-- | include/clang/Frontend/InitPreprocessor.h | 70 | ||||
| -rw-r--r-- | include/clang/Frontend/ManagerRegistry.h | 53 | ||||
| -rw-r--r-- | include/clang/Frontend/PCHBitCodes.h | 660 | ||||
| -rw-r--r-- | include/clang/Frontend/PCHReader.h | 567 | ||||
| -rw-r--r-- | include/clang/Frontend/PCHWriter.h | 278 | ||||
| -rw-r--r-- | include/clang/Frontend/PathDiagnosticClients.h | 34 | ||||
| -rw-r--r-- | include/clang/Frontend/TextDiagnosticBuffer.h | 48 | ||||
| -rw-r--r-- | include/clang/Frontend/TextDiagnosticPrinter.h | 85 | ||||
| -rw-r--r-- | include/clang/Frontend/Utils.h | 79 |
17 files changed, 2522 insertions, 0 deletions
diff --git a/include/clang/Frontend/ASTConsumers.h b/include/clang/Frontend/ASTConsumers.h new file mode 100644 index 0000000..04365d7 --- /dev/null +++ b/include/clang/Frontend/ASTConsumers.h @@ -0,0 +1,107 @@ +//===--- ASTConsumers.h - ASTConsumer implementations -----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// AST Consumers. +// +//===----------------------------------------------------------------------===// + +#ifndef DRIVER_ASTCONSUMERS_H +#define DRIVER_ASTCONSUMERS_H + +#include "llvm/Support/raw_ostream.h" +#include <string> +#include <iosfwd> + +namespace llvm { + class Module; + namespace sys { class Path; } +} +namespace clang { + +class ASTConsumer; +class Diagnostic; +class FileManager; +class Preprocessor; +class PreprocessorFactory; +struct CompileOptions; +class LangOptions; + +// AST pretty-printer: prints out the AST in a format that is close to the +// original C code. The output is intended to be in a format such that +// clang could re-parse the output back into the same AST, but the +// implementation is still incomplete. +ASTConsumer *CreateASTPrinter(llvm::raw_ostream* OS); + +// AST XML-printer: prints out the AST in a XML format +// The output is intended to be in a format such that +// clang or any other tool could re-parse the output back into the same AST, +// but the implementation is still incomplete. +ASTConsumer *CreateASTPrinterXML(llvm::raw_ostream* OS); + +// AST dumper: dumps the raw AST in human-readable form to stderr; this is +// intended for debugging. +ASTConsumer *CreateASTDumper(); + +// Graphical AST viewer: for each function definition, creates a graph of +// the AST and displays it with the graph viewer "dotty". Also outputs +// function declarations to stderr. +ASTConsumer *CreateASTViewer(); + +// DeclContext printer: prints out the DeclContext tree in human-readable form +// to stderr; this is intended for debugging. +ASTConsumer *CreateDeclContextPrinter(); + +// ObjC rewriter: attempts tp rewrite ObjC constructs into pure C code. +// This is considered experimental, and only works with Apple's ObjC runtime. +ASTConsumer *CreateObjCRewriter(const std::string& InFile, + llvm::raw_ostream* OS, + Diagnostic &Diags, + const LangOptions &LOpts, + bool SilenceRewriteMacroWarning); + +// LLVM code generator: uses the code generation backend to generate LLVM +// assembly. This runs optimizations depending on the CompileOptions +// parameter. The output depends on the Action parameter. +enum BackendAction { + Backend_EmitAssembly, // Emit native assembly + Backend_EmitBC, // Emit LLVM bitcode file + Backend_EmitLL, // Emit human-readable LLVM assembly + Backend_EmitNothing // Don't emit anything (benchmarking mode) +}; +ASTConsumer *CreateBackendConsumer(BackendAction Action, + Diagnostic &Diags, + const LangOptions &Features, + const CompileOptions &CompileOpts, + const std::string &ModuleID, + llvm::raw_ostream *OS); + +// HTML printer: uses the rewriter to convert source code to HTML with +// syntax highlighting suitable for viewing in a web-browser. +ASTConsumer* CreateHTMLPrinter(llvm::raw_ostream *OS, Diagnostic &D, + Preprocessor *PP, PreprocessorFactory *PPF); + +// PCH generator: generates a precompiled header file; this file can be +// used later with the PCHReader (clang-cc option -include-pch) +// to speed up compile times. +ASTConsumer *CreatePCHGenerator(const Preprocessor &PP, + llvm::raw_ostream *OS); + +// Block rewriter: rewrites code using the Apple blocks extension to pure +// C code. Output is always sent to stdout. +ASTConsumer *CreateBlockRewriter(const std::string &InFile, + Diagnostic &Diags, + const LangOptions &LangOpts); + +// Inheritance viewer: for C++ code, creates a graph of the inheritance +// tree for the given class and displays it with "dotty". +ASTConsumer *CreateInheritanceViewer(const std::string& clsname); + +} // end clang namespace + +#endif diff --git a/include/clang/Frontend/Analyses.def b/include/clang/Frontend/Analyses.def new file mode 100644 index 0000000..3492d09 --- /dev/null +++ b/include/clang/Frontend/Analyses.def @@ -0,0 +1,77 @@ +//===-- Analyses.def - Metadata about Static Analyses -----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the set of static analyses used by AnalysisConsumer. +// +//===----------------------------------------------------------------------===// + +#ifndef ANALYSIS +#define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) +#endif + +ANALYSIS(CFGDump, "cfg-dump", + "Display Control-Flow Graphs", Code) + +ANALYSIS(CFGView, "cfg-view", + "View Control-Flow Graphs using GraphViz", Code) + +ANALYSIS(DisplayLiveVariables, "dump-live-variables", + "Print results of live variable analysis", Code) + +ANALYSIS(WarnDeadStores, "warn-dead-stores", + "Warn about stores to dead variables", Code) + +ANALYSIS(WarnUninitVals, "warn-uninit-values", + "Warn about uses of uninitialized variables", Code) + +ANALYSIS(WarnObjCMethSigs, "warn-objc-methodsigs", + "Warn about Objective-C method signatures with type incompatibilities", + ObjCImplementation) + +ANALYSIS(WarnObjCDealloc, "warn-objc-missing-dealloc", + "Warn about Objective-C classes that lack a correct implementation of -dealloc", + ObjCImplementation) + +ANALYSIS(WarnObjCUnusedIvars, "warn-objc-unused-ivars", + "Warn about private ivars that are never used", ObjCImplementation) + +ANALYSIS(CheckerSimple, "checker-simple", + "Perform simple path-sensitive checks.", Code) + +ANALYSIS(CheckerCFRef, "checker-cfref", + "Run the [Core] Foundation reference count checker", Code) + + +#ifndef ANALYSIS_STORE +#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) +#endif + +ANALYSIS_STORE(BasicStore, "basic", "Use basic analyzer store", CreateBasicStoreManager) +ANALYSIS_STORE(RegionStore, "region", "Use region-based analyzer store", CreateRegionStoreManager) + +#ifndef ANALYSIS_CONSTRAINTS +#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) +#endif + +ANALYSIS_CONSTRAINTS(BasicConstraints, "basic", "Use basic constraint tracking", CreateBasicConstraintManager) +ANALYSIS_CONSTRAINTS(RangeConstraints, "range", "Use constraint tracking of concrete value ranges", CreateRangeConstraintManager) + +#ifndef ANALYSIS_DIAGNOSTICS +#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN, AUTOCREATE) +#endif + +ANALYSIS_DIAGNOSTICS(HTML, "html", "Output analysis results using HTML", CreateHTMLDiagnosticClient, false) +ANALYSIS_DIAGNOSTICS(PLIST, "plist", "Output analysis results using Plists", CreatePlistDiagnosticClient, true) + +#undef ANALYSIS +#undef ANALYSIS_STORE +#undef ANALYSIS_CONSTRAINTS +#undef ANALYSIS_DIAGNOSTICS +#undef ANALYSIS_STORE + diff --git a/include/clang/Frontend/AnalysisConsumer.h b/include/clang/Frontend/AnalysisConsumer.h new file mode 100644 index 0000000..0e4b09b --- /dev/null +++ b/include/clang/Frontend/AnalysisConsumer.h @@ -0,0 +1,78 @@ +//===--- AnalysisConsumer.h - Front-end hooks for the analysis engine------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This header contains the functions necessary for a front-end to run various +// analyses. +// +//===----------------------------------------------------------------------===// + +#include <string> +#include <vector> + +namespace clang { +class ASTConsumer; +class Diagnostic; +class Preprocessor; +class PreprocessorFactory; +class LangOptions; + +/// Analysis - Set of available source code analyses. +enum Analyses { +#define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) NAME, +#include "clang/Frontend/Analyses.def" +NumAnalyses +}; + +/// AnalysisStores - Set of available analysis store models. +enum AnalysisStores { +#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) NAME##Model, +#include "clang/Frontend/Analyses.def" +NumStores +}; + +/// AnalysisConstraints - Set of available constraint models. +enum AnalysisConstraints { +#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model, +#include "clang/Frontend/Analyses.def" +NumConstraints +}; + +/// AnalysisDiagClients - Set of available diagnostic clients for rendering +/// analysis results. +enum AnalysisDiagClients { +#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) PD_##NAME, +#include "clang/Frontend/Analyses.def" +NUM_ANALYSIS_DIAG_CLIENTS +}; + +struct AnalyzerOptions { + std::vector<Analyses> AnalysisList; + AnalysisStores AnalysisStoreOpt; + AnalysisConstraints AnalysisConstraintsOpt; + AnalysisDiagClients AnalysisDiagOpt; + bool VisualizeEGDot; + bool VisualizeEGUbi; + bool AnalyzeAll; + bool AnalyzerDisplayProgress; + bool PurgeDead; + bool EagerlyAssume; + std::string AnalyzeSpecificFunction; + bool TrimGraph; +}; + +/// CreateAnalysisConsumer - Creates an ASTConsumer to run various code +/// analysis passes. (The set of analyses run is controlled by command-line +/// options.) +ASTConsumer* CreateAnalysisConsumer(Diagnostic &diags, Preprocessor *pp, + PreprocessorFactory *ppf, + const LangOptions &lopts, + const std::string &output, + const AnalyzerOptions& Opts); + +} diff --git a/include/clang/Frontend/CompileOptions.h b/include/clang/Frontend/CompileOptions.h new file mode 100644 index 0000000..1af5e48 --- /dev/null +++ b/include/clang/Frontend/CompileOptions.h @@ -0,0 +1,62 @@ +//===--- CompileOptions.h ---------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the CompileOptions interface. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_COMPILEOPTIONS_H +#define LLVM_CLANG_FRONTEND_COMPILEOPTIONS_H + +#include <string> +#include <vector> + +namespace clang { + +/// CompileOptions - Track various options which control how the code +/// is optimized and passed to the backend. +class CompileOptions { +public: + unsigned OptimizationLevel : 3; /// The -O[0-4] option specified. + unsigned OptimizeSize : 1; /// If -Os is specified. + unsigned DebugInfo : 1; /// Should generate deubg info (-g). + unsigned UnitAtATime : 1; /// Unused. For mirroring GCC + /// optimization selection. + unsigned InlineFunctions : 1; /// Should functions be inlined? + unsigned SimplifyLibCalls : 1; /// Should standard library calls be + /// treated specially. + unsigned UnrollLoops : 1; /// Control whether loops are unrolled. + unsigned VerifyModule : 1; /// Control whether the module + /// should be run through the LLVM Verifier. + unsigned TimePasses : 1; /// Set when -ftime-report is enabled. + unsigned NoCommon : 1; /// Set when -fno-common or C++ is enabled. + + /// CPU - An optional CPU to target. + std::string CPU; + + /// Features - A list of subtarget features to pass to the code + /// generator. + std::vector<std::string> Features; + +public: + CompileOptions() { + OptimizationLevel = 0; + OptimizeSize = 0; + DebugInfo = 0; + UnitAtATime = 1; + InlineFunctions = SimplifyLibCalls = UnrollLoops = 0; + VerifyModule = 1; + TimePasses = 0; + NoCommon = 0; + } +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/DocumentXML.h b/include/clang/Frontend/DocumentXML.h new file mode 100644 index 0000000..99db717 --- /dev/null +++ b/include/clang/Frontend/DocumentXML.h @@ -0,0 +1,128 @@ +//===--- DocumentXML.h - XML document for ASTs ------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the XML document class, which provides the means to +// dump out the AST in a XML form that exposes type details and other fields. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_DOCUMENTXML_H +#define LLVM_CLANG_FRONTEND_DOCUMENTXML_H + +#include <string> +#include <map> +#include "clang/AST/Type.h" +#include "clang/AST/TypeOrdering.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/ADT/DenseMap.h" + +namespace clang { + +//--------------------------------------------------------- forwards +class DeclContext; +class Decl; +class NamedDecl; +class FunctionDecl; +class ASTContext; + +//--------------------------------------------------------- +namespace XML +{ + // id maps: + template<class T> + struct IdMap : llvm::DenseMap<T, unsigned> {}; + + template<> + struct IdMap<QualType> : std::map<QualType, unsigned, QualTypeOrdering> {}; + + template<> + struct IdMap<std::string> : std::map<std::string, unsigned> {}; +} + +//--------------------------------------------------------- +class DocumentXML +{ +public: + DocumentXML(const std::string& rootName, llvm::raw_ostream& out); + ~DocumentXML(); + + void initialize(ASTContext &Context); + void PrintDecl(Decl *D); + void PrintStmt(const Stmt *S); // defined in StmtXML.cpp + + void finalize(); + + + DocumentXML& addSubNode(const std::string& name); // also enters the sub node, returns *this + DocumentXML& toParent(); // returns *this + + template<class T> + void addAttribute(const char* pName, const T& value); + + void addTypeAttribute(const QualType& pType); + void addRefAttribute(const NamedDecl* D); + + enum tContextUsage { CONTEXT_AS_CONTEXT, CONTEXT_AS_ID }; + void addContextAttribute(const DeclContext *DC, tContextUsage usage = CONTEXT_AS_CONTEXT); + void addSourceFileAttribute(const std::string& fileName); + + PresumedLoc addLocation(const SourceLocation& Loc); + void addLocationRange(const SourceRange& R); + + static std::string escapeString(const char* pStr, std::string::size_type len); + +private: + DocumentXML(const DocumentXML&); // not defined + DocumentXML& operator=(const DocumentXML&); // not defined + + struct NodeXML; + + NodeXML* Root; + NodeXML* CurrentNode; // always after Root + llvm::raw_ostream& Out; + ASTContext *Ctx; + int CurrentIndent; + bool HasCurrentNodeSubNodes; + + + XML::IdMap<QualType> Types; + XML::IdMap<const DeclContext*> Contexts; + XML::IdMap<const Type*> BasicTypes; + XML::IdMap<std::string> SourceFiles; + XML::IdMap<const NamedDecl*> Decls; + + void addContextsRecursively(const DeclContext *DC); + void addBasicTypeRecursively(const Type* pType); + void addTypeRecursively(const QualType& pType); + + void PrintFunctionDecl(FunctionDecl *FD); + void addDeclIdAttribute(const NamedDecl* D); + void addTypeIdAttribute(const Type* pType); + void Indent(); +}; + +//--------------------------------------------------------- inlines + +inline void DocumentXML::initialize(ASTContext &Context) +{ + Ctx = &Context; +} + +//--------------------------------------------------------- +template<class T> +inline void DocumentXML::addAttribute(const char* pName, const T& value) +{ + Out << ' ' << pName << "=\"" << value << "\""; +} + +//--------------------------------------------------------- + +} //namespace clang + +#endif //LLVM_CLANG_DOCUMENTXML_H diff --git a/include/clang/Frontend/FixItRewriter.h b/include/clang/Frontend/FixItRewriter.h new file mode 100644 index 0000000..7fcd682 --- /dev/null +++ b/include/clang/Frontend/FixItRewriter.h @@ -0,0 +1,95 @@ +//===--- FixItRewriter.h - Fix-It Rewriter Diagnostic Client ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This is a diagnostic client adaptor that performs rewrites as +// suggested by code modification hints attached to diagnostics. It +// then forwards any diagnostics to the adapted diagnostic client. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_FRONTEND_FIX_IT_REWRITER_H +#define LLVM_CLANG_FRONTEND_FIX_IT_REWRITER_H + +#include "clang/Basic/Diagnostic.h" +#include "clang/Rewrite/Rewriter.h" +#include "llvm/ADT/SmallVector.h" + +namespace clang { + +class SourceManager; +class FileEntry; + +/// \brief Stores a source location in the form that it shows up on +/// the Clang command line, e.g., file:line:column. +/// +/// FIXME: Would prefer to use real SourceLocations, but I don't see a +/// good way to resolve them during parsing. +struct RequestedSourceLocation { + const FileEntry *File; + unsigned Line; + unsigned Column; +}; + +class FixItRewriter : public DiagnosticClient { + /// \brief The diagnostics machinery. + Diagnostic &Diags; + + /// \brief The rewriter used to perform the various code + /// modifications. + Rewriter Rewrite; + + /// \brief The diagnostic client that performs the actual formatting + /// of error messages. + DiagnosticClient *Client; + + /// \brief The number of rewriter failures. + unsigned NumFailures; + + /// \brief Locations at which we should perform fix-its. + /// + /// When empty, perform fix-it modifications everywhere. + llvm::SmallVector<RequestedSourceLocation, 4> FixItLocations; + +public: + /// \brief Initialize a new fix-it rewriter. + FixItRewriter(Diagnostic &Diags, SourceManager &SourceMgr, + const LangOptions &LangOpts); + + /// \brief Destroy the fix-it rewriter. + ~FixItRewriter(); + + /// \brief Add a location where fix-it modifications should be + /// performed. + void addFixItLocation(RequestedSourceLocation Loc) { + FixItLocations.push_back(Loc); + } + + /// \brief Write the modified source file. + /// + /// \returns true if there was an error, false otherwise. + bool WriteFixedFile(const std::string &InFileName, + const std::string &OutFileName = std::string()); + + /// IncludeInDiagnosticCounts - This method (whose default implementation + /// returns true) indicates whether the diagnostics handled by this + /// DiagnosticClient should be included in the number of diagnostics + /// reported by Diagnostic. + virtual bool IncludeInDiagnosticCounts() const; + + /// HandleDiagnostic - Handle this diagnostic, reporting it to the user or + /// capturing it to a log as needed. + virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, + const DiagnosticInfo &Info); + + /// \brief Emit a diagnostic via the adapted diagnostic client. + void Diag(FullSourceLoc Loc, unsigned DiagID); +}; + +} + +#endif // LLVM_CLANG_FRONTEND_FIX_IT_REWRITER_H diff --git a/include/clang/Frontend/FrontendDiagnostic.h b/include/clang/Frontend/FrontendDiagnostic.h new file mode 100644 index 0000000..02432ca --- /dev/null +++ b/include/clang/Frontend/FrontendDiagnostic.h @@ -0,0 +1,27 @@ +//===--- DiagnosticFrontend.h - Diagnostics for frontend --------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTENDDIAGNOSTIC_H +#define LLVM_CLANG_FRONTENDDIAGNOSTIC_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { + namespace diag { + enum { +#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP) ENUM, +#define FRONTENDSTART +#include "clang/Basic/DiagnosticFrontendKinds.inc" +#undef DIAG + NUM_BUILTIN_FRONTEND_DIAGNOSTICS + }; + } // end namespace diag +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/InitHeaderSearch.h b/include/clang/Frontend/InitHeaderSearch.h new file mode 100644 index 0000000..5151666 --- /dev/null +++ b/include/clang/Frontend/InitHeaderSearch.h @@ -0,0 +1,74 @@ +//===--- InitHeaderSearch.h - Initialize header search paths ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the InitHeaderSearch class. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_INIT_HEADER_SEARCH_H_ +#define LLVM_CLANG_FRONTEND_INIT_HEADER_SEARCH_H_ + +#include <string> +#include <vector> + +#include "clang/Lex/DirectoryLookup.h" + +namespace clang { + +class HeaderSearch; +class LangOptions; + +/// InitHeaderSearch - This class makes it easier to set the search paths of +/// a HeaderSearch object. InitHeaderSearch stores several search path lists +/// internally, which can be sent to a HeaderSearch object in one swoop. +class InitHeaderSearch { + std::vector<DirectoryLookup> IncludeGroup[4]; + HeaderSearch& Headers; + bool Verbose; + std::string isysroot; + +public: + /// InitHeaderSearch::IncludeDirGroup - Identifies the several search path + /// lists stored internally. + enum IncludeDirGroup { + Quoted = 0, //< `#include ""` paths. Thing `gcc -iquote`. + Angled, //< Paths for both `#include ""` and `#include <>`. (`-I`) + System, //< Like Angled, but marks system directories. + After //< Like System, but searched after the system directories. + }; + + InitHeaderSearch(HeaderSearch &HS, + bool verbose = false, const std::string &iSysroot = "") + : Headers(HS), Verbose(verbose), isysroot(iSysroot) {} + + /// AddPath - Add the specified path to the specified group list. + void AddPath(const std::string &Path, IncludeDirGroup Group, + bool isCXXAware, bool isUserSupplied, + bool isFramework, bool IgnoreSysRoot = false); + + /// AddEnvVarPaths - Add a list of paths from an environment variable to a + /// header search list. + void AddEnvVarPaths(const char *Name); + + /// AddDefaultEnvVarPaths - Adds list of paths from default environment + /// variables such as CPATH. + void AddDefaultEnvVarPaths(const LangOptions &Lang); + + /// AddDefaultSystemIncludePaths - Adds the default system include paths so + /// that e.g. stdio.h is found. + void AddDefaultSystemIncludePaths(const LangOptions &Lang); + + /// Realize - Merges all search path lists into one list and send it to + /// HeaderSearch. + void Realize(); +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/InitPreprocessor.h b/include/clang/Frontend/InitPreprocessor.h new file mode 100644 index 0000000..eb03602 --- /dev/null +++ b/include/clang/Frontend/InitPreprocessor.h @@ -0,0 +1,70 @@ +//===--- InitPreprocessor.h - InitializePreprocessor function. --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the clang::InitializePreprocessor function. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_INIT_PREPROCESSOR_H_ +#define LLVM_CLANG_FRONTEND_INIT_PREPROCESSOR_H_ + +#include <string> +#include <vector> + +namespace clang { + +class Preprocessor; +class LangOptions; + +/// PreprocessorInitOptions - This class is used for passing the various +/// options used in preprocessor initialization to InitializePreprocessor(). +class PreprocessorInitOptions { + std::vector<std::pair<std::string, bool/*isUndef*/> > Macros; + std::vector<std::pair<std::string, bool/*isPTH*/> > Includes; + std::vector<std::string> MacroIncludes; + +public: + + void addMacroDef(const std::string &Name) { + Macros.push_back(std::make_pair(Name, false)); + } + void addMacroUndef(const std::string &Name) { + Macros.push_back(std::make_pair(Name, true)); + } + void addInclude(const std::string &Name, bool isPTH = false) { + Includes.push_back(std::make_pair(Name, isPTH)); + } + void addMacroInclude(const std::string &Name) { + MacroIncludes.push_back(Name); + } + + typedef std::vector<std::pair<std::string, + bool> >::const_iterator macro_iterator; + macro_iterator macro_begin() const { return Macros.begin(); } + macro_iterator macro_end() const { return Macros.end(); } + + typedef std::vector<std::pair<std::string, + bool> >::const_iterator include_iterator; + include_iterator include_begin() const { return Includes.begin(); } + include_iterator include_end() const { return Includes.end(); } + + typedef std::vector<std::string>::const_iterator imacro_iterator; + imacro_iterator imacro_begin() const { return MacroIncludes.begin(); } + imacro_iterator imacro_end() const { return MacroIncludes.end(); } +}; + +/// InitializePreprocessor - Initialize the preprocessor getting it and the +/// environment ready to process a single file. This returns true on error. +/// +bool InitializePreprocessor(Preprocessor &PP, + const PreprocessorInitOptions& InitOptions); + +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/ManagerRegistry.h b/include/clang/Frontend/ManagerRegistry.h new file mode 100644 index 0000000..ecab67a --- /dev/null +++ b/include/clang/Frontend/ManagerRegistry.h @@ -0,0 +1,53 @@ +//===-- ManagerRegistry.h - Pluggable analyzer module registry --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the ManagerRegistry and Register* classes. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_MANAGER_REGISTRY_H +#define LLVM_CLANG_FRONTEND_MANAGER_REGISTRY_H + +#include "clang/Analysis/PathSensitive/GRState.h" + +namespace clang { + +/// ManagerRegistry - This class records manager creators registered at +/// runtime. The information is communicated to AnalysisManager through static +/// members. Better design is expected. + +class ManagerRegistry { +public: + static StoreManagerCreator StoreMgrCreator; + static ConstraintManagerCreator ConstraintMgrCreator; +}; + +/// RegisterConstraintManager - This class is used to setup the constraint +/// manager of the static analyzer. The constructor takes a creator function +/// pointer for creating the constraint manager. +/// +/// It is used like this: +/// +/// class MyConstraintManager {}; +/// ConstraintManager* CreateMyConstraintManager(GRStateManager& statemgr) { +/// return new MyConstraintManager(statemgr); +/// } +/// RegisterConstraintManager X(CreateMyConstraintManager); + +class RegisterConstraintManager { +public: + RegisterConstraintManager(ConstraintManagerCreator CMC) { + assert(ManagerRegistry::ConstraintMgrCreator == 0 + && "ConstraintMgrCreator already set!"); + ManagerRegistry::ConstraintMgrCreator = CMC; + } +}; + +} +#endif diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h new file mode 100644 index 0000000..0862cd6 --- /dev/null +++ b/include/clang/Frontend/PCHBitCodes.h @@ -0,0 +1,660 @@ +//===- PCHBitCodes.h - Enum values for the PCH bitcode format ---*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This header defines Bitcode enum values for Clang precompiled header files. +// +// The enum values defined in this file should be considered permanent. If +// new features are added, they should have values added at the end of the +// respective lists. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_FRONTEND_PCHBITCODES_H +#define LLVM_CLANG_FRONTEND_PCHBITCODES_H + +#include "llvm/Bitcode/BitCodes.h" +#include "llvm/Support/DataTypes.h" + +namespace clang { + namespace pch { + /// \brief PCH major version number supported by this version of + /// Clang. + /// + /// Whenever the PCH format changes in a way that makes it + /// incompatible with previous versions (such that a reader + /// designed for the previous version could not support reading + /// the new version), this number should be increased. + const unsigned VERSION_MAJOR = 1; + + /// \brief PCH minor version number supported by this version of + /// Clang. + /// + /// Whenever the PCH format changes in a way that is still + /// compatible with previous versions (such that a reader designed + /// for the previous version could still support reading the new + /// version by ignoring new kinds of subblocks), this number + /// should be increased. + const unsigned VERSION_MINOR = 0; + + /// \brief An ID number that refers to a declaration in a PCH file. + /// + /// The ID numbers of types are consecutive (in order of + /// discovery) and start at 2. 0 is reserved for NULL, and 1 is + /// reserved for the translation unit declaration. + typedef uint32_t DeclID; + + /// \brief An ID number that refers to a type in a PCH file. + /// + /// The ID of a type is partitioned into two parts: the lower + /// three bits are used to store the const/volatile/restrict + /// qualifiers (as with QualType) and the upper bits provide a + /// type index. The type index values are partitioned into two + /// sets. The values below NUM_PREDEF_TYPE_IDs are predefined type + /// IDs (based on the PREDEF_TYPE_*_ID constants), with 0 as a + /// placeholder for "no type". Values from NUM_PREDEF_TYPE_IDs are + /// other types that have serialized representations. + typedef uint32_t TypeID; + + /// \brief An ID number that refers to an identifier in a PCH + /// file. + typedef uint32_t IdentID; + + typedef uint32_t SelectorID; + + /// \brief Describes the various kinds of blocks that occur within + /// a PCH file. + enum BlockIDs { + /// \brief The PCH block, which acts as a container around the + /// full PCH block. + PCH_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID, + + /// \brief The block containing information about the source + /// manager. + SOURCE_MANAGER_BLOCK_ID, + + /// \brief The block containing information about the + /// preprocessor. + PREPROCESSOR_BLOCK_ID, + + /// \brief The block containing the definitions of all of the + /// types used within the PCH file. + TYPES_BLOCK_ID, + + /// \brief The block containing the definitions of all of the + /// declarations stored in the PCH file. + DECLS_BLOCK_ID + }; + + /// \brief Record types that occur within the PCH block itself. + enum PCHRecordTypes { + /// \brief Offset of each type within the types block. + /// + /// The TYPE_OFFSET constant describes the record that occurs + /// within the block identified by TYPE_OFFSETS_BLOCK_ID within + /// the PCH file. The record itself is an array of offsets that + /// point into the types block (identified by TYPES_BLOCK_ID in + /// the PCH file). The index into the array is based on the ID + /// of a type. For a given type ID @c T, the lower three bits of + /// @c T are its qualifiers (const, volatile, restrict), as in + /// the QualType class. The upper bits, after being shifted and + /// subtracting NUM_PREDEF_TYPE_IDS, are used to index into the + /// TYPE_OFFSET block to determine the offset of that type's + /// corresponding record within the TYPES_BLOCK_ID block. + TYPE_OFFSET = 1, + + /// \brief Record code for the offsets of each decl. + /// + /// The DECL_OFFSET constant describes the record that occurs + /// within the block identifier by DECL_OFFSETS_BLOCK_ID within + /// the PCH file. The record itself is an array of offsets that + /// point into the declarations block (identified by + /// DECLS_BLOCK_ID). The declaration ID is an index into this + /// record, after subtracting one to account for the use of + /// declaration ID 0 for a NULL declaration pointer. Index 0 is + /// reserved for the translation unit declaration. + DECL_OFFSET = 2, + + /// \brief Record code for the language options table. + /// + /// The record with this code contains the contents of the + /// LangOptions structure. We serialize the entire contents of + /// the structure, and let the reader decide which options are + /// actually important to check. + LANGUAGE_OPTIONS = 3, + + /// \brief PCH metadata, including the PCH file version number + /// and the target triple used to build the PCH file. + METADATA = 4, + + /// \brief Record code for the table of offsets of each + /// identifier ID. + /// + /// The offset table contains offsets into the blob stored in + /// the IDENTIFIER_TABLE record. Each offset points to the + /// NULL-terminated string that corresponds to that identifier. + IDENTIFIER_OFFSET = 5, + + /// \brief Record code for the identifier table. + /// + /// The identifier table is a simple blob that contains + /// NULL-terminated strings for all of the identifiers + /// referenced by the PCH file. The IDENTIFIER_OFFSET table + /// contains the mapping from identifier IDs to the characters + /// in this blob. Note that the starting offsets of all of the + /// identifiers are odd, so that, when the identifier offset + /// table is loaded in, we can use the low bit to distinguish + /// between offsets (for unresolved identifier IDs) and + /// IdentifierInfo pointers (for already-resolved identifier + /// IDs). + IDENTIFIER_TABLE = 6, + + /// \brief Record code for the array of external definitions. + /// + /// The PCH file contains a list of all of the unnamed external + /// definitions present within the parsed headers, stored as an + /// array of declaration IDs. These external definitions will be + /// reported to the AST consumer after the PCH file has been + /// read, since their presence can affect the semantics of the + /// program (e.g., for code generation). + EXTERNAL_DEFINITIONS = 7, + + /// \brief Record code for the set of non-builtin, special + /// types. + /// + /// This record contains the type IDs for the various type nodes + /// that are constructed during semantic analysis (e.g., + /// __builtin_va_list). The SPECIAL_TYPE_* constants provide + /// offsets into this record. + SPECIAL_TYPES = 8, + + /// \brief Record code for the extra statistics we gather while + /// generating a PCH file. + STATISTICS = 9, + + /// \brief Record code for the array of tentative definitions. + TENTATIVE_DEFINITIONS = 10, + + /// \brief Record code for the array of locally-scoped external + /// declarations. + LOCALLY_SCOPED_EXTERNAL_DECLS = 11, + + /// \brief Record code for the table of offsets into the + /// Objective-C method pool. + SELECTOR_OFFSETS = 12, + + /// \brief Record code for the Objective-C method pool, + METHOD_POOL = 13, + + /// \brief The value of the next __COUNTER__ to dispense. + /// [PP_COUNTER_VALUE, Val] + PP_COUNTER_VALUE = 14, + + /// \brief Record code for the table of offsets into the block + /// of source-location information. + SOURCE_LOCATION_OFFSETS = 15, + + /// \brief Record code for the set of source location entries + /// that need to be preloaded by the PCH reader. + /// + /// This set contains the source location entry for the + /// predefines buffer and for any file entries that need to be + /// preloaded. + SOURCE_LOCATION_PRELOADS = 16, + + /// \brief Record code for the stat() cache. + STAT_CACHE = 17, + + /// \brief Record code for the set of ext_vector type names. + EXT_VECTOR_DECLS = 18, + + /// \brief Record code for the set of Objective-C category + /// implementations. + OBJC_CATEGORY_IMPLEMENTATIONS = 19, + + /// \brief Record code for the original file that was used to + /// generate the precompiled header. + ORIGINAL_FILE_NAME = 20 + }; + + /// \brief Record types used within a source manager block. + enum SourceManagerRecordTypes { + /// \brief Describes a source location entry (SLocEntry) for a + /// file. + SM_SLOC_FILE_ENTRY = 1, + /// \brief Describes a source location entry (SLocEntry) for a + /// buffer. + SM_SLOC_BUFFER_ENTRY = 2, + /// \brief Describes a blob that contains the data for a buffer + /// entry. This kind of record always directly follows a + /// SM_SLOC_BUFFER_ENTRY record. + SM_SLOC_BUFFER_BLOB = 3, + /// \brief Describes a source location entry (SLocEntry) for a + /// macro instantiation. + SM_SLOC_INSTANTIATION_ENTRY = 4, + /// \brief Describes the SourceManager's line table, with + /// information about #line directives. + SM_LINE_TABLE = 5, + /// \brief Describes one header file info [isImport, DirInfo, NumIncludes] + /// ControllingMacro is optional. + SM_HEADER_FILE_INFO = 6 + }; + + /// \brief Record types used within a preprocessor block. + enum PreprocessorRecordTypes { + // The macros in the PP section are a PP_MACRO_* instance followed by a + // list of PP_TOKEN instances for each token in the definition. + + /// \brief An object-like macro definition. + /// [PP_MACRO_OBJECT_LIKE, IdentInfoID, SLoc, IsUsed] + PP_MACRO_OBJECT_LIKE = 1, + + /// \brief A function-like macro definition. + /// [PP_MACRO_FUNCTION_LIKE, <ObjectLikeStuff>, IsC99Varargs, IsGNUVarars, + /// NumArgs, ArgIdentInfoID* ] + PP_MACRO_FUNCTION_LIKE = 2, + + /// \brief Describes one token. + /// [PP_TOKEN, SLoc, Length, IdentInfoID, Kind, Flags] + PP_TOKEN = 3 + }; + + /// \defgroup PCHAST Precompiled header AST constants + /// + /// The constants in this group describe various components of the + /// abstract syntax tree within a precompiled header. + /// + /// @{ + + /// \brief Predefined type IDs. + /// + /// These type IDs correspond to predefined types in the AST + /// context, such as built-in types (int) and special place-holder + /// types (the <overload> and <dependent> type markers). Such + /// types are never actually serialized, since they will be built + /// by the AST context when it is created. + enum PredefinedTypeIDs { + /// \brief The NULL type. + PREDEF_TYPE_NULL_ID = 0, + /// \brief The void type. + PREDEF_TYPE_VOID_ID = 1, + /// \brief The 'bool' or '_Bool' type. + PREDEF_TYPE_BOOL_ID = 2, + /// \brief The 'char' type, when it is unsigned. + PREDEF_TYPE_CHAR_U_ID = 3, + /// \brief The 'unsigned char' type. + PREDEF_TYPE_UCHAR_ID = 4, + /// \brief The 'unsigned short' type. + PREDEF_TYPE_USHORT_ID = 5, + /// \brief The 'unsigned int' type. + PREDEF_TYPE_UINT_ID = 6, + /// \brief The 'unsigned long' type. + PREDEF_TYPE_ULONG_ID = 7, + /// \brief The 'unsigned long long' type. + PREDEF_TYPE_ULONGLONG_ID = 8, + /// \brief The 'char' type, when it is signed. + PREDEF_TYPE_CHAR_S_ID = 9, + /// \brief The 'signed char' type. + PREDEF_TYPE_SCHAR_ID = 10, + /// \brief The C++ 'wchar_t' type. + PREDEF_TYPE_WCHAR_ID = 11, + /// \brief The (signed) 'short' type. + PREDEF_TYPE_SHORT_ID = 12, + /// \brief The (signed) 'int' type. + PREDEF_TYPE_INT_ID = 13, + /// \brief The (signed) 'long' type. + PREDEF_TYPE_LONG_ID = 14, + /// \brief The (signed) 'long long' type. + PREDEF_TYPE_LONGLONG_ID = 15, + /// \brief The 'float' type. + PREDEF_TYPE_FLOAT_ID = 16, + /// \brief The 'double' type. + PREDEF_TYPE_DOUBLE_ID = 17, + /// \brief The 'long double' type. + PREDEF_TYPE_LONGDOUBLE_ID = 18, + /// \brief The placeholder type for overloaded function sets. + PREDEF_TYPE_OVERLOAD_ID = 19, + /// \brief The placeholder type for dependent types. + PREDEF_TYPE_DEPENDENT_ID = 20, + /// \brief The '__uint128_t' type. + PREDEF_TYPE_UINT128_ID = 21, + /// \brief The '__int128_t' type. + PREDEF_TYPE_INT128_ID = 22, + /// \brief The type of 'nullptr'. + PREDEF_TYPE_NULLPTR_ID = 23 + }; + + /// \brief The number of predefined type IDs that are reserved for + /// the PREDEF_TYPE_* constants. + /// + /// Type IDs for non-predefined types will start at + /// NUM_PREDEF_TYPE_IDs. + const unsigned NUM_PREDEF_TYPE_IDS = 100; + + /// \brief Record codes for each kind of type. + /// + /// These constants describe the records that can occur within a + /// block identified by TYPES_BLOCK_ID in the PCH file. Each + /// constant describes a record for a specific type class in the + /// AST. + enum TypeCode { + /// \brief An ExtQualType record. + TYPE_EXT_QUAL = 1, + /// \brief A FixedWidthIntType record. + TYPE_FIXED_WIDTH_INT = 2, + /// \brief A ComplexType record. + TYPE_COMPLEX = 3, + /// \brief A PointerType record. + TYPE_POINTER = 4, + /// \brief A BlockPointerType record. + TYPE_BLOCK_POINTER = 5, + /// \brief An LValueReferenceType record. + TYPE_LVALUE_REFERENCE = 6, + /// \brief An RValueReferenceType record. + TYPE_RVALUE_REFERENCE = 7, + /// \brief A MemberPointerType record. + TYPE_MEMBER_POINTER = 8, + /// \brief A ConstantArrayType record. + TYPE_CONSTANT_ARRAY = 9, + /// \brief An IncompleteArrayType record. + TYPE_INCOMPLETE_ARRAY = 10, + /// \brief A VariableArrayType record. + TYPE_VARIABLE_ARRAY = 11, + /// \brief A VectorType record. + TYPE_VECTOR = 12, + /// \brief An ExtVectorType record. + TYPE_EXT_VECTOR = 13, + /// \brief A FunctionNoProtoType record. + TYPE_FUNCTION_NO_PROTO = 14, + /// \brief A FunctionProtoType record. + TYPE_FUNCTION_PROTO = 15, + /// \brief A TypedefType record. + TYPE_TYPEDEF = 16, + /// \brief A TypeOfExprType record. + TYPE_TYPEOF_EXPR = 17, + /// \brief A TypeOfType record. + TYPE_TYPEOF = 18, + /// \brief A RecordType record. + TYPE_RECORD = 19, + /// \brief An EnumType record. + TYPE_ENUM = 20, + /// \brief An ObjCInterfaceType record. + TYPE_OBJC_INTERFACE = 21, + /// \brief An ObjCQualifiedInterfaceType record. + TYPE_OBJC_QUALIFIED_INTERFACE = 22, + /// \brief An ObjCQualifiedIdType record. + TYPE_OBJC_QUALIFIED_ID = 23 + }; + + /// \brief The type IDs for special types constructed by semantic + /// analysis. + /// + /// The constants in this enumeration are indices into the + /// SPECIAL_TYPES record. + enum SpecialTypeIDs { + /// \brief __builtin_va_list + SPECIAL_TYPE_BUILTIN_VA_LIST = 0, + /// \brief Objective-C "id" type + SPECIAL_TYPE_OBJC_ID = 1, + /// \brief Objective-C selector type + SPECIAL_TYPE_OBJC_SELECTOR = 2, + /// \brief Objective-C Protocol type + SPECIAL_TYPE_OBJC_PROTOCOL = 3, + /// \brief Objective-C Class type + SPECIAL_TYPE_OBJC_CLASS = 4, + /// \brief CFConstantString type + SPECIAL_TYPE_CF_CONSTANT_STRING = 5, + /// \brief Objective-C fast enumeration state type + SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE = 6 + }; + + /// \brief Record codes for each kind of declaration. + /// + /// These constants describe the records that can occur within a + /// declarations block (identified by DECLS_BLOCK_ID). Each + /// constant describes a record for a specific declaration class + /// in the AST. + enum DeclCode { + /// \brief Attributes attached to a declaration. + DECL_ATTR = 1, + /// \brief A TranslationUnitDecl record. + DECL_TRANSLATION_UNIT, + /// \brief A TypedefDecl record. + DECL_TYPEDEF, + /// \brief An EnumDecl record. + DECL_ENUM, + /// \brief A RecordDecl record. + DECL_RECORD, + /// \brief An EnumConstantDecl record. + DECL_ENUM_CONSTANT, + /// \brief A FunctionDecl record. + DECL_FUNCTION, + /// \brief A ObjCMethodDecl record. + DECL_OBJC_METHOD, + /// \brief A ObjCInterfaceDecl record. + DECL_OBJC_INTERFACE, + /// \brief A ObjCProtocolDecl record. + DECL_OBJC_PROTOCOL, + /// \brief A ObjCIvarDecl record. + DECL_OBJC_IVAR, + /// \brief A ObjCAtDefsFieldDecl record. + DECL_OBJC_AT_DEFS_FIELD, + /// \brief A ObjCClassDecl record. + DECL_OBJC_CLASS, + /// \brief A ObjCForwardProtocolDecl record. + DECL_OBJC_FORWARD_PROTOCOL, + /// \brief A ObjCCategoryDecl record. + DECL_OBJC_CATEGORY, + /// \brief A ObjCCategoryImplDecl record. + DECL_OBJC_CATEGORY_IMPL, + /// \brief A ObjCImplementationDecl record. + DECL_OBJC_IMPLEMENTATION, + /// \brief A ObjCCompatibleAliasDecl record. + DECL_OBJC_COMPATIBLE_ALIAS, + /// \brief A ObjCPropertyDecl record. + DECL_OBJC_PROPERTY, + /// \brief A ObjCPropertyImplDecl record. + DECL_OBJC_PROPERTY_IMPL, + /// \brief A FieldDecl record. + DECL_FIELD, + /// \brief A VarDecl record. + DECL_VAR, + /// \brief An ImplicitParamDecl record. + DECL_IMPLICIT_PARAM, + /// \brief A ParmVarDecl record. + DECL_PARM_VAR, + /// \brief An OriginalParmVarDecl record. + DECL_ORIGINAL_PARM_VAR, + /// \brief A FileScopeAsmDecl record. + DECL_FILE_SCOPE_ASM, + /// \brief A BlockDecl record. + DECL_BLOCK, + /// \brief A record that stores the set of declarations that are + /// lexically stored within a given DeclContext. + /// + /// The record itself is an array of declaration IDs, in the + /// order in which those declarations were added to the + /// declaration context. This data is used when iterating over + /// the contents of a DeclContext, e.g., via + /// DeclContext::decls_begin()/DeclContext::decls_end(). + DECL_CONTEXT_LEXICAL, + /// \brief A record that stores the set of declarations that are + /// visible from a given DeclContext. + /// + /// The record itself stores a set of mappings, each of which + /// associates a declaration name with one or more declaration + /// IDs. This data is used when performing qualified name lookup + /// into a DeclContext via DeclContext::lookup. + DECL_CONTEXT_VISIBLE + }; + + /// \brief Record codes for each kind of statement or expression. + /// + /// These constants describe the records that describe statements + /// or expressions. These records can occur within either the type + /// or declaration blocks, so they begin with record values of + /// 50. Each constant describes a record for a specific + /// statement or expression class in the AST. + enum StmtCode { + /// \brief A marker record that indicates that we are at the end + /// of an expression. + STMT_STOP = 50, + /// \brief A NULL expression. + STMT_NULL_PTR, + /// \brief A NullStmt record. + STMT_NULL, + /// \brief A CompoundStmt record. + STMT_COMPOUND, + /// \brief A CaseStmt record. + STMT_CASE, + /// \brief A DefaultStmt record. + STMT_DEFAULT, + /// \brief A LabelStmt record. + STMT_LABEL, + /// \brief An IfStmt record. + STMT_IF, + /// \brief A SwitchStmt record. + STMT_SWITCH, + /// \brief A WhileStmt record. + STMT_WHILE, + /// \brief A DoStmt record. + STMT_DO, + /// \brief A ForStmt record. + STMT_FOR, + /// \brief A GotoStmt record. + STMT_GOTO, + /// \brief An IndirectGotoStmt record. + STMT_INDIRECT_GOTO, + /// \brief A ContinueStmt record. + STMT_CONTINUE, + /// \brief A BreakStmt record. + STMT_BREAK, + /// \brief A ReturnStmt record. + STMT_RETURN, + /// \brief A DeclStmt record. + STMT_DECL, + /// \brief An AsmStmt record. + STMT_ASM, + /// \brief A PredefinedExpr record. + EXPR_PREDEFINED, + /// \brief A DeclRefExpr record. + EXPR_DECL_REF, + /// \brief An IntegerLiteral record. + EXPR_INTEGER_LITERAL, + /// \brief A FloatingLiteral record. + EXPR_FLOATING_LITERAL, + /// \brief An ImaginaryLiteral record. + EXPR_IMAGINARY_LITERAL, + /// \brief A StringLiteral record. + EXPR_STRING_LITERAL, + /// \brief A CharacterLiteral record. + EXPR_CHARACTER_LITERAL, + /// \brief A ParenExpr record. + EXPR_PAREN, + /// \brief A UnaryOperator record. + EXPR_UNARY_OPERATOR, + /// \brief A SizefAlignOfExpr record. + EXPR_SIZEOF_ALIGN_OF, + /// \brief An ArraySubscriptExpr record. + EXPR_ARRAY_SUBSCRIPT, + /// \brief A CallExpr record. + EXPR_CALL, + /// \brief A MemberExpr record. + EXPR_MEMBER, + /// \brief A BinaryOperator record. + EXPR_BINARY_OPERATOR, + /// \brief A CompoundAssignOperator record. + EXPR_COMPOUND_ASSIGN_OPERATOR, + /// \brief A ConditionOperator record. + EXPR_CONDITIONAL_OPERATOR, + /// \brief An ImplicitCastExpr record. + EXPR_IMPLICIT_CAST, + /// \brief A CStyleCastExpr record. + EXPR_CSTYLE_CAST, + /// \brief A CompoundLiteralExpr record. + EXPR_COMPOUND_LITERAL, + /// \brief An ExtVectorElementExpr record. + EXPR_EXT_VECTOR_ELEMENT, + /// \brief An InitListExpr record. + EXPR_INIT_LIST, + /// \brief A DesignatedInitExpr record. + EXPR_DESIGNATED_INIT, + /// \brief An ImplicitValueInitExpr record. + EXPR_IMPLICIT_VALUE_INIT, + /// \brief A VAArgExpr record. + EXPR_VA_ARG, + /// \brief An AddrLabelExpr record. + EXPR_ADDR_LABEL, + /// \brief A StmtExpr record. + EXPR_STMT, + /// \brief A TypesCompatibleExpr record. + EXPR_TYPES_COMPATIBLE, + /// \brief A ChooseExpr record. + EXPR_CHOOSE, + /// \brief A GNUNullExpr record. + EXPR_GNU_NULL, + /// \brief A ShuffleVectorExpr record. + EXPR_SHUFFLE_VECTOR, + /// \brief BlockExpr + EXPR_BLOCK, + /// \brief A BlockDeclRef record. + EXPR_BLOCK_DECL_REF, + + // Objective-C + + /// \brief An ObjCStringLiteral record. + EXPR_OBJC_STRING_LITERAL, + /// \brief An ObjCEncodeExpr record. + EXPR_OBJC_ENCODE, + /// \brief An ObjCSelectorExpr record. + EXPR_OBJC_SELECTOR_EXPR, + /// \brief An ObjCProtocolExpr record. + EXPR_OBJC_PROTOCOL_EXPR, + /// \brief An ObjCIvarRefExpr record. + EXPR_OBJC_IVAR_REF_EXPR, + /// \brief An ObjCPropertyRefExpr record. + EXPR_OBJC_PROPERTY_REF_EXPR, + /// \brief An ObjCKVCRefExpr record. + EXPR_OBJC_KVC_REF_EXPR, + /// \brief An ObjCMessageExpr record. + EXPR_OBJC_MESSAGE_EXPR, + /// \brief An ObjCSuperExpr record. + EXPR_OBJC_SUPER_EXPR, + + /// \brief An ObjCForCollectionStmt record. + STMT_OBJC_FOR_COLLECTION, + /// \brief An ObjCAtCatchStmt record. + STMT_OBJC_CATCH, + /// \brief An ObjCAtFinallyStmt record. + STMT_OBJC_FINALLY, + /// \brief An ObjCAtTryStmt record. + STMT_OBJC_AT_TRY, + /// \brief An ObjCAtSynchronizedStmt record. + STMT_OBJC_AT_SYNCHRONIZED, + /// \brief An ObjCAtThrowStmt record. + STMT_OBJC_AT_THROW + }; + + /// \brief The kinds of designators that can occur in a + /// DesignatedInitExpr. + enum DesignatorTypes { + /// \brief Field designator where only the field name is known. + DESIG_FIELD_NAME = 0, + /// \brief Field designator where the field has been resolved to + /// a declaration. + DESIG_FIELD_DECL = 1, + /// \brief Array designator. + DESIG_ARRAY = 2, + /// \brief GNU array range designator. + DESIG_ARRAY_RANGE = 3 + }; + + /// @} + } +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/PCHReader.h b/include/clang/Frontend/PCHReader.h new file mode 100644 index 0000000..1e00ae3 --- /dev/null +++ b/include/clang/Frontend/PCHReader.h @@ -0,0 +1,567 @@ +//===--- PCHReader.h - Precompiled Headers Reader ---------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the PCHReader class, which reads a precompiled header. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_PCH_READER_H +#define LLVM_CLANG_FRONTEND_PCH_READER_H + +#include "clang/Frontend/PCHBitCodes.h" +#include "clang/AST/DeclarationName.h" +#include "clang/Sema/ExternalSemaSource.h" +#include "clang/AST/DeclObjC.h" +#include "clang/AST/Type.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/SourceManager.h" +#include "llvm/ADT/APFloat.h" +#include "llvm/ADT/APInt.h" +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Bitcode/BitstreamReader.h" +#include "llvm/Support/DataTypes.h" +#include <map> +#include <string> +#include <utility> +#include <vector> + +namespace llvm { + class MemoryBuffer; +} + +namespace clang { + +class AddrLabelExpr; +class ASTConsumer; +class ASTContext; +class Attr; +class Decl; +class DeclContext; +class GotoStmt; +class LabelStmt; +class NamedDecl; +class Preprocessor; +class Sema; +class SwitchCase; + +/// \brief Reads a precompiled head containing the contents of a +/// translation unit. +/// +/// The PCHReader class reads a bitstream (produced by the PCHWriter +/// class) containing the serialized representation of a given +/// abstract syntax tree and its supporting data structures. An +/// instance of the PCHReader can be attached to an ASTContext object, +/// which will provide access to the contents of the PCH file. +/// +/// The PCH reader provides lazy de-serialization of declarations, as +/// required when traversing the AST. Only those AST nodes that are +/// actually required will be de-serialized. +class PCHReader + : public ExternalSemaSource, + public IdentifierInfoLookup, + public ExternalIdentifierLookup, + public ExternalSLocEntrySource { +public: + enum PCHReadResult { Success, Failure, IgnorePCH }; + +private: + /// \brief The semantic analysis object that will be processing the + /// PCH file and the translation unit that uses it. + Sema *SemaObj; + + /// \brief The preprocessor that will be loading the source file. + Preprocessor &PP; + + /// \brief The AST context into which we'll read the PCH file. + ASTContext *Context; + + /// \brief The AST consumer. + ASTConsumer *Consumer; + + /// \brief The bitstream reader from which we'll read the PCH file. + llvm::BitstreamReader StreamFile; + llvm::BitstreamCursor Stream; + + /// DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block. It + /// has read all the abbreviations at the start of the block and is ready to + /// jump around with these in context. + llvm::BitstreamCursor DeclsCursor; + + /// \brief The file name of the PCH file. + std::string FileName; + + /// \brief The memory buffer that stores the data associated with + /// this PCH file. + llvm::OwningPtr<llvm::MemoryBuffer> Buffer; + + /// \brief Offset type for all of the source location entries in the + /// PCH file. + const uint32_t *SLocOffsets; + + /// \brief The number of source location entries in the PCH file. + unsigned TotalNumSLocEntries; + + /// \brief Cursor used to read source location entries. + llvm::BitstreamCursor SLocEntryCursor; + + /// \brief Offset of each type within the bitstream, indexed by the + /// type ID, or the representation of a Type*. + const uint32_t *TypeOffsets; + + /// \brief Types that have already been loaded from the PCH file. + /// + /// When the pointer at index I is non-NULL, the type with + /// ID = (I + 1) << 3 has already been loaded from the PCH file. + std::vector<Type *> TypesLoaded; + + /// \brief Offset of each declaration within the bitstream, indexed + /// by the declaration ID (-1). + const uint32_t *DeclOffsets; + + /// \brief Declarations that have already been loaded from the PCH file. + /// + /// When the pointer at index I is non-NULL, the declaration with ID + /// = I + 1 has already been loaded. + std::vector<Decl *> DeclsLoaded; + + typedef llvm::DenseMap<const DeclContext *, std::pair<uint64_t, uint64_t> > + DeclContextOffsetsMap; + + /// \brief Offsets of the lexical and visible declarations for each + /// DeclContext. + DeclContextOffsetsMap DeclContextOffsets; + + /// \brief Actual data for the on-disk hash table. + /// + // This pointer points into a memory buffer, where the on-disk hash + // table for identifiers actually lives. + const char *IdentifierTableData; + + /// \brief A pointer to an on-disk hash table of opaque type + /// IdentifierHashTable. + void *IdentifierLookupTable; + + /// \brief Offsets into the identifier table data. + /// + /// This array is indexed by the identifier ID (-1), and provides + /// the offset into IdentifierTableData where the string data is + /// stored. + const uint32_t *IdentifierOffsets; + + /// \brief A vector containing identifiers that have already been + /// loaded. + /// + /// If the pointer at index I is non-NULL, then it refers to the + /// IdentifierInfo for the identifier with ID=I+1 that has already + /// been loaded. + std::vector<IdentifierInfo *> IdentifiersLoaded; + + /// \brief A pointer to an on-disk hash table of opaque type + /// PCHMethodPoolLookupTable. + /// + /// This hash table provides the instance and factory methods + /// associated with every selector known in the PCH file. + void *MethodPoolLookupTable; + + /// \brief A pointer to the character data that comprises the method + /// pool. + /// + /// The SelectorOffsets table refers into this memory. + const unsigned char *MethodPoolLookupTableData; + + /// \brief The number of selectors stored in the method pool itself. + unsigned TotalSelectorsInMethodPool; + + /// \brief Offsets into the method pool lookup table's data array + /// where each selector resides. + const uint32_t *SelectorOffsets; + + /// \brief The total number of selectors stored in the PCH file. + unsigned TotalNumSelectors; + + /// \brief A vector containing selectors that have already been loaded. + /// + /// This vector is indexed by the Selector ID (-1). NULL selector + /// entries indicate that the particular selector ID has not yet + /// been loaded. + llvm::SmallVector<Selector, 16> SelectorsLoaded; + + /// \brief The set of external definitions stored in the the PCH + /// file. + llvm::SmallVector<uint64_t, 16> ExternalDefinitions; + + /// \brief The set of tentative definitions stored in the the PCH + /// file. + llvm::SmallVector<uint64_t, 16> TentativeDefinitions; + + /// \brief The set of locally-scoped external declarations stored in + /// the the PCH file. + llvm::SmallVector<uint64_t, 16> LocallyScopedExternalDecls; + + /// \brief The set of ext_vector type declarations stored in the the + /// PCH file. + llvm::SmallVector<uint64_t, 4> ExtVectorDecls; + + /// \brief The set of Objective-C category definitions stored in the + /// the PCH file. + llvm::SmallVector<uint64_t, 4> ObjCCategoryImpls; + + /// \brief The original file name that was used to build the PCH + /// file. + std::string OriginalFileName; + + /// \brief Mapping from switch-case IDs in the PCH file to + /// switch-case statements. + std::map<unsigned, SwitchCase *> SwitchCaseStmts; + + /// \brief Mapping from label statement IDs in the PCH file to label + /// statements. + std::map<unsigned, LabelStmt *> LabelStmts; + + /// \brief Mapping from label IDs to the set of "goto" statements + /// that point to that label before the label itself has been + /// de-serialized. + std::multimap<unsigned, GotoStmt *> UnresolvedGotoStmts; + + /// \brief Mapping from label IDs to the set of address label + /// expressions that point to that label before the label itself has + /// been de-serialized. + std::multimap<unsigned, AddrLabelExpr *> UnresolvedAddrLabelExprs; + + /// \brief The number of stat() calls that hit/missed the stat + /// cache. + unsigned NumStatHits, NumStatMisses; + + /// \brief The number of source location entries de-serialized from + /// the PCH file. + unsigned NumSLocEntriesRead; + + /// \brief The number of statements (and expressions) de-serialized + /// from the PCH file. + unsigned NumStatementsRead; + + /// \brief The total number of statements (and expressions) stored + /// in the PCH file. + unsigned TotalNumStatements; + + /// \brief The number of macros de-serialized from the PCH file. + unsigned NumMacrosRead; + + /// \brief The number of method pool entries that have been read. + unsigned NumMethodPoolSelectorsRead; + + /// \brief The number of times we have looked into the global method + /// pool and not found anything. + unsigned NumMethodPoolMisses; + + /// \brief The total number of macros stored in the PCH file. + unsigned TotalNumMacros; + + /// Number of lexical decl contexts read/total. + unsigned NumLexicalDeclContextsRead, TotalLexicalDeclContexts; + + /// Number of visible decl contexts read/total. + unsigned NumVisibleDeclContextsRead, TotalVisibleDeclContexts; + + /// \brief FIXME: document! + llvm::SmallVector<uint64_t, 4> SpecialTypes; + + /// \brief Contains declarations and definitions that will be + /// "interesting" to the ASTConsumer, when we get that AST consumer. + /// + /// "Interesting" declarations are those that have data that may + /// need to be emitted, such as inline function definitions or + /// Objective-C protocols. + llvm::SmallVector<Decl *, 16> InterestingDecls; + + /// \brief The file ID for the predefines buffer in the PCH file. + FileID PCHPredefinesBufferID; + + /// \brief Pointer to the beginning of the predefines buffer in the + /// PCH file. + const char *PCHPredefines; + + /// \brief Length of the predefines buffer in the PCH file. + unsigned PCHPredefinesLen; + + /// \brief Suggested contents of the predefines buffer, after this + /// PCH file has been processed. + /// + /// In most cases, this string will be empty, because the predefines + /// buffer computed to build the PCH file will be identical to the + /// predefines buffer computed from the command line. However, when + /// there are differences that the PCH reader can work around, this + /// predefines buffer may contain additional definitions. + std::string SuggestedPredefines; + + PCHReadResult ReadPCHBlock(); + bool CheckPredefinesBuffer(const char *PCHPredef, + unsigned PCHPredefLen, + FileID PCHBufferID); + PCHReadResult ReadSourceManagerBlock(); + PCHReadResult ReadSLocEntryRecord(unsigned ID); + + bool ParseLanguageOptions(const llvm::SmallVectorImpl<uint64_t> &Record); + QualType ReadTypeRecord(uint64_t Offset); + void LoadedDecl(unsigned Index, Decl *D); + Decl *ReadDeclRecord(uint64_t Offset, unsigned Index); + + /// \brief Produce an error diagnostic and return true. + /// + /// This routine should only be used for fatal errors that have to + /// do with non-routine failures (e.g., corrupted PCH file). + bool Error(const char *Msg); + + PCHReader(const PCHReader&); // do not implement + PCHReader &operator=(const PCHReader &); // do not implement + +public: + typedef llvm::SmallVector<uint64_t, 64> RecordData; + + explicit PCHReader(Preprocessor &PP, ASTContext *Context); + ~PCHReader(); + + /// \brief Load the precompiled header designated by the given file + /// name. + PCHReadResult ReadPCH(const std::string &FileName); + + /// \brief Retrieve the name of the original source file name + const std::string &getOriginalSourceFile() { return OriginalFileName; } + + /// \brief Retrieve the name of the original source file name + /// directly from the PCH file, without actually loading the PCH + /// file. + static std::string getOriginalSourceFile(const std::string &PCHFileName); + + /// \brief Returns the suggested contents of the predefines buffer, + /// which contains a (typically-empty) subset of the predefines + /// build prior to including the precompiled header. + const std::string &getSuggestedPredefines() { return SuggestedPredefines; } + + /// \brief Resolve a type ID into a type, potentially building a new + /// type. + virtual QualType GetType(pch::TypeID ID); + + /// \brief Resolve a declaration ID into a declaration, potentially + /// building a new declaration. + virtual Decl *GetDecl(pch::DeclID ID); + + /// \brief Resolve the offset of a statement into a statement. + /// + /// This operation will read a new statement from the external + /// source each time it is called, and is meant to be used via a + /// LazyOffsetPtr (which is used by Decls for the body of functions, etc). + virtual Stmt *GetDeclStmt(uint64_t Offset); + + /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the + /// specified cursor. Read the abbreviations that are at the top of the block + /// and then leave the cursor pointing into the block. + bool ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID); + + /// \brief Read all of the declarations lexically stored in a + /// declaration context. + /// + /// \param DC The declaration context whose declarations will be + /// read. + /// + /// \param Decls Vector that will contain the declarations loaded + /// from the external source. The caller is responsible for merging + /// these declarations with any declarations already stored in the + /// declaration context. + /// + /// \returns true if there was an error while reading the + /// declarations for this declaration context. + virtual bool ReadDeclsLexicallyInContext(DeclContext *DC, + llvm::SmallVectorImpl<pch::DeclID> &Decls); + + /// \brief Read all of the declarations visible from a declaration + /// context. + /// + /// \param DC The declaration context whose visible declarations + /// will be read. + /// + /// \param Decls A vector of visible declaration structures, + /// providing the mapping from each name visible in the declaration + /// context to the declaration IDs of declarations with that name. + /// + /// \returns true if there was an error while reading the + /// declarations for this declaration context. + /// + /// FIXME: Using this intermediate data structure results in an + /// extraneous copying of the data. Could we pass in a reference to + /// the StoredDeclsMap instead? + virtual bool ReadDeclsVisibleInContext(DeclContext *DC, + llvm::SmallVectorImpl<VisibleDeclaration> & Decls); + + /// \brief Function that will be invoked when we begin parsing a new + /// translation unit involving this external AST source. + /// + /// This function will provide all of the external definitions to + /// the ASTConsumer. + virtual void StartTranslationUnit(ASTConsumer *Consumer); + + /// \brief Print some statistics about PCH usage. + virtual void PrintStats(); + + /// \brief Initialize the semantic source with the Sema instance + /// being used to perform semantic analysis on the abstract syntax + /// tree. + virtual void InitializeSema(Sema &S); + + /// \brief Retrieve the IdentifierInfo for the named identifier. + /// + /// This routine builds a new IdentifierInfo for the given + /// identifier. If any declarations with this name are visible from + /// translation unit scope, their declarations will be deserialized + /// and introduced into the declaration chain of the + /// identifier. FIXME: if this identifier names a macro, deserialize + /// the macro. + virtual IdentifierInfo* get(const char *NameStart, const char *NameEnd); + + /// \brief Load the contents of the global method pool for a given + /// selector. + /// + /// \returns a pair of Objective-C methods lists containing the + /// instance and factory methods, respectively, with this selector. + virtual std::pair<ObjCMethodList, ObjCMethodList> + ReadMethodPool(Selector Sel); + + void SetIdentifierInfo(unsigned ID, IdentifierInfo *II); + + /// \brief Report a diagnostic. + DiagnosticBuilder Diag(unsigned DiagID); + + /// \brief Report a diagnostic. + DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID); + + IdentifierInfo *DecodeIdentifierInfo(unsigned Idx); + + IdentifierInfo *GetIdentifierInfo(const RecordData &Record, unsigned &Idx) { + return DecodeIdentifierInfo(Record[Idx++]); + } + + virtual IdentifierInfo *GetIdentifier(unsigned ID) { + return DecodeIdentifierInfo(ID); + } + + /// \brief Read the source location entry with index ID. + virtual void ReadSLocEntry(unsigned ID); + + Selector DecodeSelector(unsigned Idx); + + Selector GetSelector(const RecordData &Record, unsigned &Idx) { + return DecodeSelector(Record[Idx++]); + } + DeclarationName ReadDeclarationName(const RecordData &Record, unsigned &Idx); + + /// \brief Read an integral value + llvm::APInt ReadAPInt(const RecordData &Record, unsigned &Idx); + + /// \brief Read a signed integral value + llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx); + + /// \brief Read a floating-point value + llvm::APFloat ReadAPFloat(const RecordData &Record, unsigned &Idx); + + // \brief Read a string + std::string ReadString(const RecordData &Record, unsigned &Idx); + + /// \brief Reads attributes from the current stream position. + Attr *ReadAttributes(); + + /// \brief ReadDeclExpr - Reads an expression from the current decl cursor. + Expr *ReadDeclExpr(); + + /// \brief ReadTypeExpr - Reads an expression from the current type cursor. + Expr *ReadTypeExpr(); + + /// \brief Reads a statement from the specified cursor. + Stmt *ReadStmt(llvm::BitstreamCursor &Cursor); + + /// \brief Read a statement from the current DeclCursor. + Stmt *ReadDeclStmt() { + return ReadStmt(DeclsCursor); + } + + /// \brief Reads the macro record located at the given offset. + void ReadMacroRecord(uint64_t Offset); + + /// \brief Retrieve the AST context that this PCH reader + /// supplements. + ASTContext *getContext() { return Context; } + + // \brief Contains declarations that were loaded before we have + // access to a Sema object. + llvm::SmallVector<NamedDecl *, 16> PreloadedDecls; + + /// \brief Retrieve the semantic analysis object used to analyze the + /// translation unit in which the precompiled header is being + /// imported. + Sema *getSema() { return SemaObj; } + + /// \brief Retrieve the stream that this PCH reader is reading from. + llvm::BitstreamCursor &getStream() { return Stream; } + llvm::BitstreamCursor &getDeclsCursor() { return DeclsCursor; } + + /// \brief Retrieve the identifier table associated with the + /// preprocessor. + IdentifierTable &getIdentifierTable(); + + /// \brief Record that the given ID maps to the given switch-case + /// statement. + void RecordSwitchCaseID(SwitchCase *SC, unsigned ID); + + /// \brief Retrieve the switch-case statement with the given ID. + SwitchCase *getSwitchCaseWithID(unsigned ID); + + /// \brief Record that the given label statement has been + /// deserialized and has the given ID. + void RecordLabelStmt(LabelStmt *S, unsigned ID); + + /// \brief Set the label of the given statement to the label + /// identified by ID. + /// + /// Depending on the order in which the label and other statements + /// referencing that label occur, this operation may complete + /// immediately (updating the statement) or it may queue the + /// statement to be back-patched later. + void SetLabelOf(GotoStmt *S, unsigned ID); + + /// \brief Set the label of the given expression to the label + /// identified by ID. + /// + /// Depending on the order in which the label and other statements + /// referencing that label occur, this operation may complete + /// immediately (updating the statement) or it may queue the + /// statement to be back-patched later. + void SetLabelOf(AddrLabelExpr *S, unsigned ID); +}; + +/// \brief Helper class that saves the current stream position and +/// then restores it when destroyed. +struct SavedStreamPosition { + explicit SavedStreamPosition(llvm::BitstreamCursor &Cursor) + : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) { } + + ~SavedStreamPosition() { + Cursor.JumpToBit(Offset); + } + +private: + llvm::BitstreamCursor &Cursor; + uint64_t Offset; +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/PCHWriter.h b/include/clang/Frontend/PCHWriter.h new file mode 100644 index 0000000..5cb9395 --- /dev/null +++ b/include/clang/Frontend/PCHWriter.h @@ -0,0 +1,278 @@ +//===--- PCHWriter.h - Precompiled Headers Writer ---------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the PCHWriter class, which writes a precompiled +// header containing a serialized representation of a translation +// unit. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_FRONTEND_PCH_WRITER_H +#define LLVM_CLANG_FRONTEND_PCH_WRITER_H + +#include "clang/AST/Decl.h" +#include "clang/AST/DeclarationName.h" +#include "clang/Frontend/PCHBitCodes.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallVector.h" +#include <map> +#include <queue> + +namespace llvm { + class APFloat; + class APInt; + class BitstreamWriter; +} + +namespace clang { + +class ASTContext; +class LabelStmt; +class MemorizeStatCalls; +class Preprocessor; +class Sema; +class SourceManager; +class SwitchCase; +class TargetInfo; + +/// \brief Writes a precompiled header containing the contents of a +/// translation unit. +/// +/// The PCHWriter class produces a bitstream containing the serialized +/// representation of a given abstract syntax tree and its supporting +/// data structures. This bitstream can be de-serialized via an +/// instance of the PCHReader class. +class PCHWriter { +public: + typedef llvm::SmallVector<uint64_t, 64> RecordData; + +private: + /// \brief The bitstream writer used to emit this precompiled header. + llvm::BitstreamWriter &Stream; + + /// \brief Map that provides the ID numbers of each declaration within + /// the output stream. + /// + /// The ID numbers of declarations are consecutive (in order of + /// discovery) and start at 2. 1 is reserved for the translation + /// unit, while 0 is reserved for NULL. + llvm::DenseMap<const Decl *, pch::DeclID> DeclIDs; + + /// \brief Offset of each declaration in the bitstream, indexed by + /// the declaration's ID. + std::vector<uint32_t> DeclOffsets; + + /// \brief Queue containing the declarations that we still need to + /// emit. + std::queue<Decl *> DeclsToEmit; + + /// \brief Map that provides the ID numbers of each type within the + /// output stream. + /// + /// The ID numbers of types are consecutive (in order of discovery) + /// and start at 1. 0 is reserved for NULL. When types are actually + /// stored in the stream, the ID number is shifted by 3 bits to + /// allow for the const/volatile/restrict qualifiers. + llvm::DenseMap<const Type *, pch::TypeID> TypeIDs; + + /// \brief Offset of each type in the bitstream, indexed by + /// the type's ID. + std::vector<uint32_t> TypeOffsets; + + /// \brief The type ID that will be assigned to the next new type. + pch::TypeID NextTypeID; + + /// \brief Queue containing the types that we still need to + /// emit. + std::queue<const Type *> TypesToEmit; + + /// \brief Map that provides the ID numbers of each identifier in + /// the output stream. + /// + /// The ID numbers for identifiers are consecutive (in order of + /// discovery), starting at 1. An ID of zero refers to a NULL + /// IdentifierInfo. + llvm::DenseMap<const IdentifierInfo *, pch::IdentID> IdentifierIDs; + + /// \brief Offsets of each of the identifier IDs into the identifier + /// table. + std::vector<uint32_t> IdentifierOffsets; + + /// \brief Map that provides the ID numbers of each Selector. + llvm::DenseMap<Selector, pch::SelectorID> SelectorIDs; + + /// \brief Offset of each selector within the method pool/selector + /// table, indexed by the Selector ID (-1). + std::vector<uint32_t> SelectorOffsets; + + /// \brief A vector of all Selectors (ordered by ID). + std::vector<Selector> SelVector; + + /// \brief Offsets of each of the macro identifiers into the + /// bitstream. + /// + /// For each identifier that is associated with a macro, this map + /// provides the offset into the bitstream where that macro is + /// defined. + llvm::DenseMap<const IdentifierInfo *, uint64_t> MacroOffsets; + + /// \brief Declarations encountered that might be external + /// definitions. + /// + /// We keep track of external definitions (as well as tentative + /// definitions) as we are emitting declarations to the PCH + /// file. The PCH file contains a separate record for these external + /// definitions, which are provided to the AST consumer by the PCH + /// reader. This is behavior is required to properly cope with, + /// e.g., tentative variable definitions that occur within + /// headers. The declarations themselves are stored as declaration + /// IDs, since they will be written out to an EXTERNAL_DEFINITIONS + /// record. + llvm::SmallVector<uint64_t, 16> ExternalDefinitions; + + /// \brief Statements that we've encountered while serializing a + /// declaration or type. + llvm::SmallVector<Stmt *, 8> StmtsToEmit; + + /// \brief Mapping from SwitchCase statements to IDs. + std::map<SwitchCase *, unsigned> SwitchCaseIDs; + + /// \brief Mapping from LabelStmt statements to IDs. + std::map<LabelStmt *, unsigned> LabelIDs; + + /// \brief The number of statements written to the PCH file. + unsigned NumStatements; + + /// \brief The number of macros written to the PCH file. + unsigned NumMacros; + + /// \brief The number of lexical declcontexts written to the PCH + /// file. + unsigned NumLexicalDeclContexts; + + /// \brief The number of visible declcontexts written to the PCH + /// file. + unsigned NumVisibleDeclContexts; + + void WriteBlockInfoBlock(); + void WriteMetadata(ASTContext &Context); + void WriteLanguageOptions(const LangOptions &LangOpts); + void WriteStatCache(MemorizeStatCalls &StatCalls); + void WriteSourceManagerBlock(SourceManager &SourceMgr, + const Preprocessor &PP); + void WritePreprocessor(const Preprocessor &PP); + void WriteType(const Type *T); + void WriteTypesBlock(ASTContext &Context); + uint64_t WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC); + uint64_t WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC); + + void WriteDeclsBlock(ASTContext &Context); + void WriteMethodPool(Sema &SemaRef); + void WriteIdentifierTable(Preprocessor &PP); + void WriteAttributeRecord(const Attr *Attr); + + unsigned ParmVarDeclAbbrev; + void WriteDeclsBlockAbbrevs(); + +public: + /// \brief Create a new precompiled header writer that outputs to + /// the given bitstream. + PCHWriter(llvm::BitstreamWriter &Stream); + + /// \brief Write a precompiled header for the given semantic analysis. + void WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls); + + /// \brief Emit a source location. + void AddSourceLocation(SourceLocation Loc, RecordData &Record); + + /// \brief Emit an integral value. + void AddAPInt(const llvm::APInt &Value, RecordData &Record); + + /// \brief Emit a signed integral value. + void AddAPSInt(const llvm::APSInt &Value, RecordData &Record); + + /// \brief Emit a floating-point value. + void AddAPFloat(const llvm::APFloat &Value, RecordData &Record); + + /// \brief Emit a reference to an identifier + void AddIdentifierRef(const IdentifierInfo *II, RecordData &Record); + + /// \brief Emit a Selector (which is a smart pointer reference) + void AddSelectorRef(const Selector, RecordData &Record); + + /// \brief Get the unique number used to refer to the given + /// identifier. + pch::IdentID getIdentifierRef(const IdentifierInfo *II); + + /// \brief Retrieve the offset of the macro definition for the given + /// identifier. + /// + /// The identifier must refer to a macro. + uint64_t getMacroOffset(const IdentifierInfo *II) { + assert(MacroOffsets.find(II) != MacroOffsets.end() && + "Identifier does not name a macro"); + return MacroOffsets[II]; + } + + /// \brief Emit a reference to a type. + void AddTypeRef(QualType T, RecordData &Record); + + /// \brief Emit a reference to a declaration. + void AddDeclRef(const Decl *D, RecordData &Record); + + /// \brief Determine the declaration ID of an already-emitted + /// declaration. + pch::DeclID getDeclID(const Decl *D); + + /// \brief Emit a declaration name. + void AddDeclarationName(DeclarationName Name, RecordData &Record); + + /// \brief Add a string to the given record. + void AddString(const std::string &Str, RecordData &Record); + + /// \brief Note that the identifier II occurs at the given offset + /// within the identifier table. + void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset); + + /// \brief Note that the selector Sel occurs at the given offset + /// within the method pool/selector table. + void SetSelectorOffset(Selector Sel, uint32_t Offset); + + /// \brief Add the given statement or expression to the queue of + /// statements to emit. + /// + /// This routine should be used when emitting types and declarations + /// that have expressions as part of their formulation. Once the + /// type or declaration has been written, call FlushStmts() to write + /// the corresponding statements just after the type or + /// declaration. + void AddStmt(Stmt *S) { StmtsToEmit.push_back(S); } + + /// \brief Write the given subexpression to the bitstream. + void WriteSubStmt(Stmt *S); + + /// \brief Flush all of the statements and expressions that have + /// been added to the queue via AddStmt(). + void FlushStmts(); + + /// \brief Record an ID for the given switch-case statement. + unsigned RecordSwitchCaseID(SwitchCase *S); + + /// \brief Retrieve the ID for the given switch-case statement. + unsigned getSwitchCaseID(SwitchCase *S); + + /// \brief Retrieve the ID for the given label statement, which may + /// or may not have been emitted yet. + unsigned GetLabelID(LabelStmt *S); + + unsigned getParmVarDeclAbbrev() const { return ParmVarDeclAbbrev; } +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Frontend/PathDiagnosticClients.h b/include/clang/Frontend/PathDiagnosticClients.h new file mode 100644 index 0000000..028cd85 --- /dev/null +++ b/include/clang/Frontend/PathDiagnosticClients.h @@ -0,0 +1,34 @@ +//===--- PathDiagnosticClients.h - Path Diagnostic Clients ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the interface to create different path diagostic clients. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_PATH_DIAGNOSTIC_CLIENTS_H +#define LLVM_CLANG_FRONTEND_PATH_DIAGNOSTIC_CLiENTS_H + +#include <string> + +namespace clang { + +class PathDiagnosticClient; +class Preprocessor; +class PreprocessorFactory; + +PathDiagnosticClient* CreateHTMLDiagnosticClient(const std::string& prefix, + Preprocessor* PP = 0, + PreprocessorFactory* PPF = 0); + +PathDiagnosticClient* CreatePlistDiagnosticClient(const std::string& prefix, + Preprocessor* PP, + PreprocessorFactory* PPF); +} + +#endif diff --git a/include/clang/Frontend/TextDiagnosticBuffer.h b/include/clang/Frontend/TextDiagnosticBuffer.h new file mode 100644 index 0000000..4e907e1 --- /dev/null +++ b/include/clang/Frontend/TextDiagnosticBuffer.h @@ -0,0 +1,48 @@ +//===--- TextDiagnosticBuffer.h - Buffer Text Diagnostics -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This is a concrete diagnostic client, which buffers the diagnostic messages. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_TEXT_DIAGNOSTIC_BUFFER_H_ +#define LLVM_CLANG_FRONTEND_TEXT_DIAGNOSTIC_BUFFER_H_ + +#include "clang/Basic/Diagnostic.h" +#include <vector> + +namespace clang { + +class Preprocessor; +class SourceManager; + +class TextDiagnosticBuffer : public DiagnosticClient { +public: + typedef std::vector<std::pair<SourceLocation, std::string> > DiagList; + typedef DiagList::iterator iterator; + typedef DiagList::const_iterator const_iterator; +private: + DiagList Errors, Warnings, Notes; +public: + const_iterator err_begin() const { return Errors.begin(); } + const_iterator err_end() const { return Errors.end(); } + + const_iterator warn_begin() const { return Warnings.begin(); } + const_iterator warn_end() const { return Warnings.end(); } + + const_iterator note_begin() const { return Notes.begin(); } + const_iterator note_end() const { return Notes.end(); } + + virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, + const DiagnosticInfo &Info); +}; + +} // end namspace clang + +#endif diff --git a/include/clang/Frontend/TextDiagnosticPrinter.h b/include/clang/Frontend/TextDiagnosticPrinter.h new file mode 100644 index 0000000..3c9dcb8 --- /dev/null +++ b/include/clang/Frontend/TextDiagnosticPrinter.h @@ -0,0 +1,85 @@ +//===--- TextDiagnosticPrinter.h - Text Diagnostic Client -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This is a concrete diagnostic client, which prints the diagnostics to +// standard error. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_TEXT_DIAGNOSTIC_PRINTER_H_ +#define LLVM_CLANG_FRONTEND_TEXT_DIAGNOSTIC_PRINTER_H_ + +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/SourceLocation.h" + +namespace llvm { + class raw_ostream; +} + +namespace clang { +class SourceManager; +class LangOptions; + +class TextDiagnosticPrinter : public DiagnosticClient { + llvm::raw_ostream &OS; + const LangOptions *LangOpts; + SourceLocation LastWarningLoc; + FullSourceLoc LastLoc; + bool LastCaretDiagnosticWasNote; + + bool ShowColumn; + bool CaretDiagnostics; + bool ShowLocation; + bool PrintRangeInfo; + bool PrintDiagnosticOption; + bool PrintFixItInfo; + unsigned MessageLength; + +public: + TextDiagnosticPrinter(llvm::raw_ostream &os, + bool showColumn = true, + bool caretDiagnistics = true, bool showLocation = true, + bool printRangeInfo = true, + bool printDiagnosticOption = true, + bool printFixItInfo = true, + unsigned messageLength = 0) + : OS(os), LangOpts(0), + LastCaretDiagnosticWasNote(false), ShowColumn(showColumn), + CaretDiagnostics(caretDiagnistics), ShowLocation(showLocation), + PrintRangeInfo(printRangeInfo), + PrintDiagnosticOption(printDiagnosticOption), + PrintFixItInfo(printFixItInfo), + MessageLength(messageLength) {} + + void setLangOptions(const LangOptions *LO) { + LangOpts = LO; + } + + void PrintIncludeStack(SourceLocation Loc, const SourceManager &SM); + + void HighlightRange(const SourceRange &R, + const SourceManager &SrcMgr, + unsigned LineNo, FileID FID, + std::string &CaretLine, + const std::string &SourceLine); + + void EmitCaretDiagnostic(SourceLocation Loc, + SourceRange *Ranges, unsigned NumRanges, + SourceManager &SM, + const CodeModificationHint *Hints, + unsigned NumHints, + unsigned Columns); + + virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, + const DiagnosticInfo &Info); +}; + +} // end namspace clang + +#endif diff --git a/include/clang/Frontend/Utils.h b/include/clang/Frontend/Utils.h new file mode 100644 index 0000000..41eb31a --- /dev/null +++ b/include/clang/Frontend/Utils.h @@ -0,0 +1,79 @@ +//===--- Utils.h - Misc utilities for the front-end------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This header contains miscellaneous utilities for various front-end actions. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_FRONTEND_UTILS_H +#define LLVM_CLANG_FRONTEND_UTILS_H + +#include <vector> +#include <string> + +namespace llvm { +class raw_ostream; +class raw_fd_ostream; +} + +namespace clang { +class Preprocessor; +class MinimalAction; +class TargetInfo; +class Diagnostic; +class ASTConsumer; +class IdentifierTable; +class SourceManager; +class PreprocessorFactory; +class LangOptions; + +/// ProcessWarningOptions - Initialize the diagnostic client and process the +/// warning options specified on the command line. +bool ProcessWarningOptions(Diagnostic &Diags, + std::vector<std::string> &Warnings, + bool Pedantic, bool PedanticErrors, + bool NoWarnings); + +/// DoPrintPreprocessedInput - Implement -E -dM mode. +void DoPrintMacros(Preprocessor &PP, llvm::raw_ostream* OS); + +/// DoPrintPreprocessedInput - Implement -E mode. +void DoPrintPreprocessedInput(Preprocessor &PP, llvm::raw_ostream* OS, + bool EnableCommentOutput, + bool EnableMacroCommentOutput, + bool DisableLineMarkers, + bool DumpDefines); + +/// RewriteMacrosInInput - Implement -rewrite-macros mode. +void RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream* OS); + +/// RewriteMacrosInInput - A simple test for the TokenRewriter class. +void DoRewriteTest(Preprocessor &PP, llvm::raw_ostream* OS); + +/// CreatePrintParserActionsAction - Return the actions implementation that +/// implements the -parse-print-callbacks option. +MinimalAction *CreatePrintParserActionsAction(Preprocessor &PP, + llvm::raw_ostream* OS); + +/// CheckDiagnostics - Gather the expected diagnostics and check them. +bool CheckDiagnostics(Preprocessor &PP); + +/// AttachDependencyFileGen - Create a dependency file generator, and attach +/// it to the given preprocessor. This takes ownership of the output stream. +void AttachDependencyFileGen(Preprocessor *PP, llvm::raw_ostream *OS, + std::vector<std::string> &Targets, + bool IncludeSystemHeaders, bool PhonyTarget); + +/// CacheTokens - Cache tokens for use with PCH. Note that this requires +/// a seekable stream. +void CacheTokens(Preprocessor& PP, llvm::raw_fd_ostream* OS); + +} // end namespace clang + +#endif |
