1//===--- Utils.h - Misc utilities for the front-end -------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header contains miscellaneous utilities for various front-end actions. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_FRONTEND_UTILS_H 15#define LLVM_CLANG_FRONTEND_UTILS_H 16 17#include "clang/Basic/Diagnostic.h" 18#include "clang/Basic/VirtualFileSystem.h" 19#include "llvm/ADT/IntrusiveRefCntPtr.h" 20#include "llvm/ADT/StringRef.h" 21#include "llvm/ADT/StringSet.h" 22#include "llvm/Option/OptSpecifier.h" 23#include <utility> 24 25namespace llvm { 26class raw_fd_ostream; 27class Triple; 28 29namespace opt { 30class ArgList; 31} 32} 33 34namespace clang { 35class ASTConsumer; 36class ASTReader; 37class CompilerInstance; 38class CompilerInvocation; 39class Decl; 40class DependencyOutputOptions; 41class DiagnosticsEngine; 42class DiagnosticOptions; 43class ExternalSemaSource; 44class FileManager; 45class HeaderSearch; 46class HeaderSearchOptions; 47class IdentifierTable; 48class LangOptions; 49class PCHContainerReader; 50class Preprocessor; 51class PreprocessorOptions; 52class PreprocessorOutputOptions; 53class SourceManager; 54class Stmt; 55class TargetInfo; 56class FrontendOptions; 57 58/// Apply the header search options to get given HeaderSearch object. 59void ApplyHeaderSearchOptions(HeaderSearch &HS, 60 const HeaderSearchOptions &HSOpts, 61 const LangOptions &Lang, 62 const llvm::Triple &triple); 63 64/// InitializePreprocessor - Initialize the preprocessor getting it and the 65/// environment ready to process a single file. 66void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, 67 const PCHContainerReader &PCHContainerRdr, 68 const FrontendOptions &FEOpts); 69 70/// DoPrintPreprocessedInput - Implement -E mode. 71void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream* OS, 72 const PreprocessorOutputOptions &Opts); 73 74/// An interface for collecting the dependencies of a compilation. Users should 75/// use \c attachToPreprocessor and \c attachToASTReader to get all of the 76/// dependencies. 77/// FIXME: Migrate DependencyFileGen and DependencyGraphGen to use this 78/// interface. 79class DependencyCollector { 80public: 81 virtual void attachToPreprocessor(Preprocessor &PP); 82 virtual void attachToASTReader(ASTReader &R); 83 llvm::ArrayRef<std::string> getDependencies() const { return Dependencies; } 84 85 /// Called when a new file is seen. Return true if \p Filename should be added 86 /// to the list of dependencies. 87 /// 88 /// The default implementation ignores <built-in> and system files. 89 virtual bool sawDependency(StringRef Filename, bool FromModule, 90 bool IsSystem, bool IsModuleFile, bool IsMissing); 91 /// Called when the end of the main file is reached. 92 virtual void finishedMainFile() { } 93 /// Return true if system files should be passed to sawDependency(). 94 virtual bool needSystemDependencies() { return false; } 95 virtual ~DependencyCollector(); 96 97public: // implementation detail 98 /// Add a dependency \p Filename if it has not been seen before and 99 /// sawDependency() returns true. 100 void maybeAddDependency(StringRef Filename, bool FromModule, bool IsSystem, 101 bool IsModuleFile, bool IsMissing); 102private: 103 llvm::StringSet<> Seen; 104 std::vector<std::string> Dependencies; 105}; 106 107/// Builds a depdenency file when attached to a Preprocessor (for includes) and 108/// ASTReader (for module imports), and writes it out at the end of processing 109/// a source file. Users should attach to the ast reader whenever a module is 110/// loaded. 111class DependencyFileGenerator { 112 void *Impl; // Opaque implementation 113 DependencyFileGenerator(void *Impl); 114public: 115 static DependencyFileGenerator *CreateAndAttachToPreprocessor( 116 Preprocessor &PP, const DependencyOutputOptions &Opts); 117 void AttachToASTReader(ASTReader &R); 118}; 119 120/// Collects the dependencies for imported modules into a directory. Users 121/// should attach to the AST reader whenever a module is loaded. 122class ModuleDependencyCollector : public DependencyCollector { 123 std::string DestDir; 124 bool HasErrors = false; 125 llvm::StringSet<> Seen; 126 vfs::YAMLVFSWriter VFSWriter; 127 128 llvm::StringMap<std::string> SymLinkMap; 129 130 bool getRealPath(StringRef SrcPath, SmallVectorImpl<char> &Result); 131 std::error_code copyToRoot(StringRef Src, StringRef Dst = ""); 132public: 133 StringRef getDest() { return DestDir; } 134 bool insertSeen(StringRef Filename) { return Seen.insert(Filename).second; } 135 void addFile(StringRef Filename, StringRef FileDst = ""); 136 void addFileMapping(StringRef VPath, StringRef RPath) { 137 VFSWriter.addFileMapping(VPath, RPath); 138 } 139 140 void attachToPreprocessor(Preprocessor &PP) override; 141 void attachToASTReader(ASTReader &R) override; 142 143 void writeFileMap(); 144 bool hasErrors() { return HasErrors; } 145 ModuleDependencyCollector(std::string DestDir) 146 : DestDir(std::move(DestDir)) {} 147 ~ModuleDependencyCollector() { writeFileMap(); } 148}; 149 150/// AttachDependencyGraphGen - Create a dependency graph generator, and attach 151/// it to the given preprocessor. 152void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, 153 StringRef SysRoot); 154 155/// AttachHeaderIncludeGen - Create a header include list generator, and attach 156/// it to the given preprocessor. 157/// 158/// \param DepOpts - Options controlling the output. 159/// \param ShowAllHeaders - If true, show all header information instead of just 160/// headers following the predefines buffer. This is useful for making sure 161/// includes mentioned on the command line are also reported, but differs from 162/// the default behavior used by -H. 163/// \param OutputPath - If non-empty, a path to write the header include 164/// information to, instead of writing to stderr. 165/// \param ShowDepth - Whether to indent to show the nesting of the includes. 166/// \param MSStyle - Whether to print in cl.exe /showIncludes style. 167void AttachHeaderIncludeGen(Preprocessor &PP, 168 const DependencyOutputOptions &DepOpts, 169 bool ShowAllHeaders = false, 170 StringRef OutputPath = "", 171 bool ShowDepth = true, bool MSStyle = false); 172 173/// Cache tokens for use with PCH. Note that this requires a seekable stream. 174void CacheTokens(Preprocessor &PP, raw_pwrite_stream *OS); 175 176/// The ChainedIncludesSource class converts headers to chained PCHs in 177/// memory, mainly for testing. 178IntrusiveRefCntPtr<ExternalSemaSource> 179createChainedIncludesSource(CompilerInstance &CI, 180 IntrusiveRefCntPtr<ExternalSemaSource> &Reader); 181 182/// createInvocationFromCommandLine - Construct a compiler invocation object for 183/// a command line argument vector. 184/// 185/// \return A CompilerInvocation, or 0 if none was built for the given 186/// argument vector. 187std::unique_ptr<CompilerInvocation> createInvocationFromCommandLine( 188 ArrayRef<const char *> Args, 189 IntrusiveRefCntPtr<DiagnosticsEngine> Diags = 190 IntrusiveRefCntPtr<DiagnosticsEngine>(), 191 IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr); 192 193/// Return the value of the last argument as an integer, or a default. If Diags 194/// is non-null, emits an error if the argument is given, but non-integral. 195int getLastArgIntValue(const llvm::opt::ArgList &Args, 196 llvm::opt::OptSpecifier Id, int Default, 197 DiagnosticsEngine *Diags = nullptr); 198 199inline int getLastArgIntValue(const llvm::opt::ArgList &Args, 200 llvm::opt::OptSpecifier Id, int Default, 201 DiagnosticsEngine &Diags) { 202 return getLastArgIntValue(Args, Id, Default, &Diags); 203} 204 205uint64_t getLastArgUInt64Value(const llvm::opt::ArgList &Args, 206 llvm::opt::OptSpecifier Id, uint64_t Default, 207 DiagnosticsEngine *Diags = nullptr); 208 209inline uint64_t getLastArgUInt64Value(const llvm::opt::ArgList &Args, 210 llvm::opt::OptSpecifier Id, 211 uint64_t Default, 212 DiagnosticsEngine &Diags) { 213 return getLastArgUInt64Value(Args, Id, Default, &Diags); 214} 215 216// When Clang->getFrontendOpts().DisableFree is set we don't delete some of the 217// global objects, but we don't want LeakDetectors to complain, so we bury them 218// in a globally visible array. 219void BuryPointer(const void *Ptr); 220template <typename T> void BuryPointer(std::unique_ptr<T> Ptr) { 221 BuryPointer(Ptr.release()); 222} 223 224} // end namespace clang 225 226#endif 227