contrib/llvm/tools/clang/include/clang/Serialization/ModuleManager.h

   1 //===--- ModuleManager.cpp - Module Manager ---------------------*- 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 file defines the ModuleManager class, which manages a set of loaded
  11 //  modules for the ASTReader.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_SERIALIZATION_MODULE_MANAGER_H
  16 #define LLVM_CLANG_SERIALIZATION_MODULE_MANAGER_H
  17
  18 #include "clang/Serialization/Module.h"
  19 #include "clang/Basic/FileManager.h"
  20 #include "llvm/ADT/DenseMap.h"
  21
  22 namespace clang {
  23
  24 namespace serialization {
  25
  26 /// \brief Manages the set of modules loaded by an AST reader.
  27 class ModuleManager {
  28   /// \brief The chain of AST files. The first entry is the one named by the
  29   /// user, the last one is the one that doesn't depend on anything further.
  30   llvm::SmallVector<ModuleFile*, 2> Chain;
  31
  32   /// \brief All loaded modules, indexed by name.
  33   llvm::DenseMap<const FileEntry *, ModuleFile *> Modules;
  34
  35   /// \brief FileManager that handles translating between filenames and
  36   /// FileEntry *.
  37   FileManager FileMgr;
  38
  39   /// \brief A lookup of in-memory (virtual file) buffers
  40   llvm::DenseMap<const FileEntry *, llvm::MemoryBuffer *> InMemoryBuffers;
  41
  42 public:
  43   typedef SmallVector<ModuleFile*, 2>::iterator ModuleIterator;
  44   typedef SmallVector<ModuleFile*, 2>::const_iterator ModuleConstIterator;
  45   typedef SmallVector<ModuleFile*, 2>::reverse_iterator ModuleReverseIterator;
  46   typedef std::pair<uint32_t, StringRef> ModuleOffset;
  47
  48   ModuleManager(const FileSystemOptions &FSO);
  49   ~ModuleManager();
  50
  51   /// \brief Forward iterator to traverse all loaded modules.  This is reverse
  52   /// source-order.
  53   ModuleIterator begin() { return Chain.begin(); }
  54   /// \brief Forward iterator end-point to traverse all loaded modules
  55   ModuleIterator end() { return Chain.end(); }
  56
  57   /// \brief Const forward iterator to traverse all loaded modules.  This is
  58   /// in reverse source-order.
  59   ModuleConstIterator begin() const { return Chain.begin(); }
  60   /// \brief Const forward iterator end-point to traverse all loaded modules
  61   ModuleConstIterator end() const { return Chain.end(); }
  62
  63   /// \brief Reverse iterator to traverse all loaded modules.  This is in
  64   /// source order.
  65   ModuleReverseIterator rbegin() { return Chain.rbegin(); }
  66   /// \brief Reverse iterator end-point to traverse all loaded modules.
  67   ModuleReverseIterator rend() { return Chain.rend(); }
  68
  69   /// \brief Returns the primary module associated with the manager, that is,
  70   /// the first module loaded
  71   ModuleFile &getPrimaryModule() { return *Chain[0]; }
  72
  73   /// \brief Returns the primary module associated with the manager, that is,
  74   /// the first module loaded.
  75   ModuleFile &getPrimaryModule() const { return *Chain[0]; }
  76
  77   /// \brief Returns the module associated with the given index
  78   ModuleFile &operator[](unsigned Index) const { return *Chain[Index]; }
  79
  80   /// \brief Returns the module associated with the given name
  81   ModuleFile *lookup(StringRef Name);
  82
  83   /// \brief Returns the in-memory (virtual file) buffer with the given name
  84   llvm::MemoryBuffer *lookupBuffer(StringRef Name);
  85
  86   /// \brief Number of modules loaded
  87   unsigned size() const { return Chain.size(); }
  88   /// \brief Attempts to create a new module and add it to the list of known
  89   /// modules.
  90   ///
  91   /// \param FileName The file name of the module to be loaded.
  92   ///
  93   /// \param Type The kind of module being loaded.
  94   ///
  95   /// \param ImportedBy The module that is importing this module, or NULL if
  96   /// this module is imported directly by the user.
  97   ///
  98   /// \param Generation The generation in which this module was loaded.
  99   ///
 100   /// \param ErrorStr Will be set to a non-empty string if any errors occurred
 101   /// while trying to load the module.
 102   ///
 103   /// \return A pointer to the module that corresponds to this file name,
 104   /// and a boolean indicating whether the module was newly added.
 105   std::pair<ModuleFile *, bool>
 106   addModule(StringRef FileName, ModuleKind Type, ModuleFile *ImportedBy,
 107             unsigned Generation, std::string &ErrorStr);
 108
 109   /// \brief Add an in-memory buffer the list of known buffers
 110   void addInMemoryBuffer(StringRef FileName, llvm::MemoryBuffer *Buffer);
 111
 112   /// \brief Visit each of the modules.
 113   ///
 114   /// This routine visits each of the modules, starting with the
 115   /// "root" modules that no other loaded modules depend on, and
 116   /// proceeding to the leaf modules, visiting each module only once
 117   /// during the traversal.
 118   ///
 119   /// This traversal is intended to support various "lookup"
 120   /// operations that can find data in any of the loaded modules.
 121   ///
 122   /// \param Visitor A visitor function that will be invoked with each
 123   /// module and the given user data pointer. The return value must be
 124   /// convertible to bool; when false, the visitation continues to
 125   /// modules that the current module depends on. When true, the
 126   /// visitation skips any modules that the current module depends on.
 127   ///
 128   /// \param UserData User data associated with the visitor object, which
 129   /// will be passed along to the visitor.
 130   void visit(bool (*Visitor)(ModuleFile &M, void *UserData), void *UserData);
 131
 132   /// \brief Visit each of the modules with a depth-first traversal.
 133   ///
 134   /// This routine visits each of the modules known to the module
 135   /// manager using a depth-first search, starting with the first
 136   /// loaded module. The traversal invokes the callback both before
 137   /// traversing the children (preorder traversal) and after
 138   /// traversing the children (postorder traversal).
 139   ///
 140   /// \param Visitor A visitor function that will be invoked with each
 141   /// module and given a \c Preorder flag that indicates whether we're
 142   /// visiting the module before or after visiting its children.  The
 143   /// visitor may return true at any time to abort the depth-first
 144   /// visitation.
 145   ///
 146   /// \param UserData User data ssociated with the visitor object,
 147   /// which will be passed along to the user.
 148   void visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder,
 149                                        void *UserData),
 150                        void *UserData);
 151
 152   /// \brief View the graphviz representation of the module graph.
 153   void viewGraph();
 154 };
 155
 156 } } // end namespace clang::serialization
 157
 158 #endif