Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Utils.h - Misc utilities for the front-end ---------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This header contains miscellaneous utilities for various front-end actions.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_FRONTEND_UTILS_H

#define LLVM_CLANG_FRONTEND_UTILS_H

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/LLVM.h"

#include "clang/Driver/OptionUtils.h"

#include "clang/Frontend/DependencyOutputOptions.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/StringSet.h"

#include "llvm/Support/FileCollector.h"

#include "llvm/Support/VirtualFileSystem.h"

#include <cstdint>

#include <memory>

#include <string>

#include <system_error>

#include <utility>

#include <vector>

namespace clang {

class ASTReader;

class CompilerInstance;

class CompilerInvocation;

class DiagnosticsEngine;

class ExternalSemaSource;

class FrontendOptions;

class PCHContainerReader;

class Preprocessor;

class PreprocessorOptions;

class PreprocessorOutputOptions;

/// InitializePreprocessor - Initialize the preprocessor getting it and the

/// environment ready to process a single file.

void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts,

                            const PCHContainerReader &PCHContainerRdr,

                            const FrontendOptions &FEOpts);

/// DoPrintPreprocessedInput - Implement -E mode.

void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,

                              const PreprocessorOutputOptions &Opts);

/// An interface for collecting the dependencies of a compilation. Users should

/// use \c attachToPreprocessor and \c attachToASTReader to get all of the

/// dependencies.

/// FIXME: Migrate DependencyGraphGen to use this interface.

class DependencyCollector {

public:

  virtual ~DependencyCollector();

  virtual void attachToPreprocessor(Preprocessor &PP);

  virtual void attachToASTReader(ASTReader &R);

  ArrayRef<std::string> getDependencies() const { return Dependencies; }

  /// Called when a new file is seen. Return true if \p Filename should be added

  /// to the list of dependencies.

  ///

  /// The default implementation ignores <built-in> and system files.

  virtual bool sawDependency(StringRef Filename, bool FromModule,

                             bool IsSystem, bool IsModuleFile, bool IsMissing);

  /// Called when the end of the main file is reached.

  virtual void finishedMainFile(DiagnosticsEngine &Diags) {}

  /// Return true if system files should be passed to sawDependency().

  virtual bool needSystemDependencies() { return false; }

  /// Add a dependency \p Filename if it has not been seen before and

  /// sawDependency() returns true.

  virtual void maybeAddDependency(StringRef Filename, bool FromModule,

                                  bool IsSystem, bool IsModuleFile,

                                  bool IsMissing);

protected:

  /// Return true if the filename was added to the list of dependencies, false

  /// otherwise.

  bool addDependency(StringRef Filename);

private:

  llvm::StringSet<> Seen;

  std::vector<std::string> Dependencies;

};

/// Builds a dependency file when attached to a Preprocessor (for includes) and

/// ASTReader (for module imports), and writes it out at the end of processing

/// a source file.  Users should attach to the ast reader whenever a module is

/// loaded.

class DependencyFileGenerator : public DependencyCollector {

public:

  DependencyFileGenerator(const DependencyOutputOptions &Opts);

  void attachToPreprocessor(Preprocessor &PP) override;

  void finishedMainFile(DiagnosticsEngine &Diags) override;

  bool needSystemDependencies() final { return IncludeSystemHeaders; }

  bool sawDependency(StringRef Filename, bool FromModule, bool IsSystem,

                     bool IsModuleFile, bool IsMissing) final;

protected:

  void outputDependencyFile(llvm::raw_ostream &OS);

private:

  void outputDependencyFile(DiagnosticsEngine &Diags);

  std::string OutputFile;

  std::vector<std::string> Targets;

  bool IncludeSystemHeaders;

  bool PhonyTarget;

  bool AddMissingHeaderDeps;

  bool SeenMissingHeader;

  bool IncludeModuleFiles;

  DependencyOutputFormat OutputFormat;

  unsigned InputFileIndex;

};

/// Collects the dependencies for imported modules into a directory.  Users

/// should attach to the AST reader whenever a module is loaded.

class ModuleDependencyCollector : public DependencyCollector {

  std::string DestDir;

  bool HasErrors = false;

  llvm::StringSet<> Seen;

  llvm::vfs::YAMLVFSWriter VFSWriter;

  llvm::FileCollector::PathCanonicalizer Canonicalizer;

  std::error_code copyToRoot(StringRef Src, StringRef Dst = {});

public:

  ModuleDependencyCollector(std::string DestDir)

      : DestDir(std::move(DestDir)) {}

  ~ModuleDependencyCollector() override { writeFileMap(); }

  StringRef getDest() { return DestDir; }

  virtual bool insertSeen(StringRef Filename) { return Seen.insert(Filename).second; }

  virtual void addFile(StringRef Filename, StringRef FileDst = {});

  virtual void addFileMapping(StringRef VPath, StringRef RPath) {

    VFSWriter.addFileMapping(VPath, RPath);

  }

  void attachToPreprocessor(Preprocessor &PP) override;

  void attachToASTReader(ASTReader &R) override;

  virtual void writeFileMap();

  virtual bool hasErrors() { return HasErrors; }

};

/// AttachDependencyGraphGen - Create a dependency graph generator, and attach

/// it to the given preprocessor.

void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,

                              StringRef SysRoot);

/// AttachHeaderIncludeGen - Create a header include list generator, and attach

/// it to the given preprocessor.

///

/// \param DepOpts - Options controlling the output.

/// \param ShowAllHeaders - If true, show all header information instead of just

/// headers following the predefines buffer. This is useful for making sure

/// includes mentioned on the command line are also reported, but differs from

/// the default behavior used by -H.

/// \param OutputPath - If non-empty, a path to write the header include

/// information to, instead of writing to stderr.

/// \param ShowDepth - Whether to indent to show the nesting of the includes.

/// \param MSStyle - Whether to print in cl.exe /showIncludes style.

void AttachHeaderIncludeGen(Preprocessor &PP,

                            const DependencyOutputOptions &DepOpts,

                            bool ShowAllHeaders = false,

                            StringRef OutputPath = {},

                            bool ShowDepth = true, bool MSStyle = false);

/// The ChainedIncludesSource class converts headers to chained PCHs in

/// memory, mainly for testing.

IntrusiveRefCntPtr<ExternalSemaSource>

createChainedIncludesSource(CompilerInstance &CI,

                            IntrusiveRefCntPtr<ExternalSemaSource> &Reader);

/// Optional inputs to createInvocation.

struct CreateInvocationOptions {

  /// Receives diagnostics encountered while parsing command-line flags.

  /// If not provided, these are printed to stderr.

  IntrusiveRefCntPtr<DiagnosticsEngine> Diags = nullptr;

  /// Used e.g. to probe for system headers locations.

  /// If not provided, the real filesystem is used.

  /// FIXME: the driver does perform some non-virtualized IO.

  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr;

  /// Whether to attempt to produce a non-null (possibly incorrect) invocation

  /// if any errors were encountered.

  /// By default, always return null on errors.

  bool RecoverOnError = false;

  /// Allow the driver to probe the filesystem for PCH files.

  /// This is used to replace -include with -include-pch in the cc1 args.

  /// FIXME: ProbePrecompiled=true is a poor, historical default.

  /// It misbehaves if the PCH file is from GCC, has the wrong version, etc.

  bool ProbePrecompiled = false;

  /// If set, the target is populated with the cc1 args produced by the driver.

  /// This may be populated even if createInvocation returns nullptr.

  std::vector<std::string> *CC1Args = nullptr;

};

/// Interpret clang arguments in preparation to parse a file.

///

/// This simulates a number of steps Clang takes when its driver is invoked:

/// - choosing actions (e.g compile + link) to run

/// - probing the system for settings like standard library locations

/// - spawning a cc1 subprocess to compile code, with more explicit arguments

/// - in the cc1 process, assembling those arguments into a CompilerInvocation

///   which is used to configure the parser

///

/// This simulation is lossy, e.g. in some situations one driver run would

/// result in multiple parses. (Multi-arch, CUDA, ...).

/// This function tries to select a reasonable invocation that tools should use.

///

/// Args[0] should be the driver name, such as "clang" or "/usr/bin/g++".

/// Absolute path is preferred - this affects searching for system headers.

///

/// May return nullptr if an invocation could not be determined.

/// See CreateInvocationOptions::ShouldRecoverOnErrors to try harder!

std::unique_ptr<CompilerInvocation>

createInvocation(ArrayRef<const char *> Args,

                 CreateInvocationOptions Opts = {});

} // namespace clang

#endif // LLVM_CLANG_FRONTEND_UTILS_H