- const Type *getTypeByName(const std::string &Name) const;
-
-
- //===--------------------------------------------------------------------===//
- // Methods for direct access to the globals list, functions list, and symbol
- // table.
- //
-
- /// Get the underlying elements of the Module...
- inline const GlobalListType &getGlobalList() const { return GlobalList; }
- inline GlobalListType &getGlobalList() { return GlobalList; }
- inline const FunctionListType &getFunctionList() const { return FunctionList;}
- inline FunctionListType &getFunctionList() { return FunctionList;}
-
- /// getSymbolTable() - Get access to the symbol table for the module, where
- /// global variables and functions are identified.
- ///
- inline SymbolTable &getSymbolTable() { return *SymTab; }
- inline const SymbolTable &getSymbolTable() const { return *SymTab; }
-
-
- //===--------------------------------------------------------------------===//
- // Module iterator forwarding functions
- //
- inline giterator gbegin() { return GlobalList.begin(); }
- inline const_giterator gbegin() const { return GlobalList.begin(); }
- inline giterator gend () { return GlobalList.end(); }
- inline const_giterator gend () const { return GlobalList.end(); }
-
- inline reverse_giterator grbegin() { return GlobalList.rbegin(); }
- inline const_reverse_giterator grbegin() const { return GlobalList.rbegin(); }
- inline reverse_giterator grend () { return GlobalList.rend(); }
- inline const_reverse_giterator grend () const { return GlobalList.rend(); }
-
- inline unsigned gsize() const { return GlobalList.size(); }
- inline bool gempty() const { return GlobalList.empty(); }
- inline const GlobalVariable &gfront() const { return GlobalList.front(); }
- inline GlobalVariable &gfront() { return GlobalList.front(); }
- inline const GlobalVariable &gback() const { return GlobalList.back(); }
- inline GlobalVariable &gback() { return GlobalList.back(); }
-
-
-
- inline iterator begin() { return FunctionList.begin(); }
- inline const_iterator begin() const { return FunctionList.begin(); }
- inline iterator end () { return FunctionList.end(); }
- inline const_iterator end () const { return FunctionList.end(); }
-
- inline reverse_iterator rbegin() { return FunctionList.rbegin(); }
- inline const_reverse_iterator rbegin() const { return FunctionList.rbegin(); }
- inline reverse_iterator rend () { return FunctionList.rend(); }
- inline const_reverse_iterator rend () const { return FunctionList.rend(); }
-
- inline unsigned size() const { return FunctionList.size(); }
- inline bool empty() const { return FunctionList.empty(); }
- inline const Function &front() const { return FunctionList.front(); }
- inline Function &front() { return FunctionList.front(); }
- inline const Function &back() const { return FunctionList.back(); }
- inline Function &back() { return FunctionList.back(); }
-
- void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
+ const Type *getTypeByName(StringRef Name) const;
+
+/// @}
+/// @name Materialization
+/// @{
+
+ /// setMaterializer - Sets the GVMaterializer to GVM. This module must not
+ /// yet have a Materializer. To reset the materializer for a module that
+ /// already has one, call MaterializeAllPermanently first. Destroying this
+ /// module will destroy its materializer without materializing any more
+ /// GlobalValues. Without destroying the Module, there is no way to detach or
+ /// destroy a materializer without materializing all the GVs it controls, to
+ /// avoid leaving orphan unmaterialized GVs.
+ void setMaterializer(GVMaterializer *GVM);
+ /// getMaterializer - Retrieves the GVMaterializer, if any, for this Module.
+ GVMaterializer *getMaterializer() const { return Materializer.get(); }
+
+ /// isMaterializable - True if the definition of GV has yet to be materialized
+ /// from the GVMaterializer.
+ bool isMaterializable(const GlobalValue *GV) const;
+ /// isDematerializable - Returns true if this GV was loaded from this Module's
+ /// GVMaterializer and the GVMaterializer knows how to dematerialize the GV.
+ bool isDematerializable(const GlobalValue *GV) const;
+
+ /// Materialize - Make sure the GlobalValue is fully read. If the module is
+ /// corrupt, this returns true and fills in the optional string with
+ /// information about the problem. If successful, this returns false.
+ bool Materialize(GlobalValue *GV, std::string *ErrInfo = 0);
+ /// Dematerialize - If the GlobalValue is read in, and if the GVMaterializer
+ /// supports it, release the memory for the function, and set it up to be
+ /// materialized lazily. If !isDematerializable(), this method is a noop.
+ void Dematerialize(GlobalValue *GV);
+
+ /// MaterializeAll - Make sure all GlobalValues in this Module are fully read.
+ /// If the module is corrupt, this returns true and fills in the optional
+ /// string with information about the problem. If successful, this returns
+ /// false.
+ bool MaterializeAll(std::string *ErrInfo = 0);
+
+ /// MaterializeAllPermanently - Make sure all GlobalValues in this Module are
+ /// fully read and clear the Materializer. If the module is corrupt, this
+ /// returns true, fills in the optional string with information about the
+ /// problem, and DOES NOT clear the old Materializer. If successful, this
+ /// returns false.
+ bool MaterializeAllPermanently(std::string *ErrInfo = 0);
+
+/// @}
+/// @name Direct access to the globals list, functions list, and symbol table
+/// @{
+
+ /// Get the Module's list of global variables (constant).
+ const GlobalListType &getGlobalList() const { return GlobalList; }
+ /// Get the Module's list of global variables.
+ GlobalListType &getGlobalList() { return GlobalList; }
+ static iplist<GlobalVariable> Module::*getSublistAccess(GlobalVariable*) {
+ return &Module::GlobalList;
+ }
+ /// Get the Module's list of functions (constant).
+ const FunctionListType &getFunctionList() const { return FunctionList; }
+ /// Get the Module's list of functions.
+ FunctionListType &getFunctionList() { return FunctionList; }
+ static iplist<Function> Module::*getSublistAccess(Function*) {
+ return &Module::FunctionList;
+ }
+ /// Get the Module's list of aliases (constant).
+ const AliasListType &getAliasList() const { return AliasList; }
+ /// Get the Module's list of aliases.
+ AliasListType &getAliasList() { return AliasList; }
+ static iplist<GlobalAlias> Module::*getSublistAccess(GlobalAlias*) {
+ return &Module::AliasList;
+ }
+ /// Get the Module's list of named metadata (constant).
+ const NamedMDListType &getNamedMDList() const { return NamedMDList; }
+ /// Get the Module's list of named metadata.
+ NamedMDListType &getNamedMDList() { return NamedMDList; }
+ static iplist<NamedMDNode> Module::*getSublistAccess(NamedMDNode *) {
+ return &Module::NamedMDList;
+ }
+ /// Get the symbol table of global variable and function identifiers
+ const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
+ /// Get the Module's symbol table of global variable and function identifiers.
+ ValueSymbolTable &getValueSymbolTable() { return *ValSymTab; }
+ /// Get the symbol table of types
+ const TypeSymbolTable &getTypeSymbolTable() const { return *TypeSymTab; }
+ /// Get the Module's symbol table of types
+ TypeSymbolTable &getTypeSymbolTable() { return *TypeSymTab; }
+ /// Get the symbol table of named metadata
+ const MDSymbolTable &getMDSymbolTable() const { return *NamedMDSymTab; }
+ /// Get the Module's symbol table of named metadata
+ MDSymbolTable &getMDSymbolTable() { return *NamedMDSymTab; }
+
+/// @}
+/// @name Global Variable Iteration
+/// @{
+
+ /// Get an iterator to the first global variable
+ global_iterator global_begin() { return GlobalList.begin(); }
+ /// Get a constant iterator to the first global variable
+ const_global_iterator global_begin() const { return GlobalList.begin(); }
+ /// Get an iterator to the last global variable
+ global_iterator global_end () { return GlobalList.end(); }
+ /// Get a constant iterator to the last global variable
+ const_global_iterator global_end () const { return GlobalList.end(); }
+ /// Determine if the list of globals is empty.
+ bool global_empty() const { return GlobalList.empty(); }
+
+/// @}
+/// @name Function Iteration
+/// @{
+
+ /// Get an iterator to the first function.
+ iterator begin() { return FunctionList.begin(); }
+ /// Get a constant iterator to the first function.
+ const_iterator begin() const { return FunctionList.begin(); }
+ /// Get an iterator to the last function.
+ iterator end () { return FunctionList.end(); }
+ /// Get a constant iterator to the last function.
+ const_iterator end () const { return FunctionList.end(); }
+ /// Determine how many functions are in the Module's list of functions.
+ size_t size() const { return FunctionList.size(); }
+ /// Determine if the list of functions is empty.
+ bool empty() const { return FunctionList.empty(); }
+
+/// @}
+/// @name Dependent Library Iteration
+/// @{
+
+ /// @brief Get a constant iterator to beginning of dependent library list.
+ inline lib_iterator lib_begin() const { return LibraryList.begin(); }
+ /// @brief Get a constant iterator to end of dependent library list.
+ inline lib_iterator lib_end() const { return LibraryList.end(); }
+ /// @brief Returns the number of items in the list of libraries.
+ inline size_t lib_size() const { return LibraryList.size(); }
+ /// @brief Add a library to the list of dependent libraries
+ void addLibrary(StringRef Lib);
+ /// @brief Remove a library from the list of dependent libraries
+ void removeLibrary(StringRef Lib);
+ /// @brief Get all the libraries
+ inline const LibraryListType& getLibraries() const { return LibraryList; }
+
+/// @}
+/// @name Alias Iteration
+/// @{
+
+ /// Get an iterator to the first alias.
+ alias_iterator alias_begin() { return AliasList.begin(); }
+ /// Get a constant iterator to the first alias.
+ const_alias_iterator alias_begin() const { return AliasList.begin(); }
+ /// Get an iterator to the last alias.
+ alias_iterator alias_end () { return AliasList.end(); }
+ /// Get a constant iterator to the last alias.
+ const_alias_iterator alias_end () const { return AliasList.end(); }
+ /// Determine how many aliases are in the Module's list of aliases.
+ size_t alias_size () const { return AliasList.size(); }
+ /// Determine if the list of aliases is empty.
+ bool alias_empty() const { return AliasList.empty(); }
+
+
+/// @}
+/// @name Named Metadata Iteration
+/// @{
+
+ /// Get an iterator to the first named metadata.
+ named_metadata_iterator named_metadata_begin() { return NamedMDList.begin(); }
+ /// Get a constant iterator to the first named metadata.
+ const_named_metadata_iterator named_metadata_begin() const {
+ return NamedMDList.begin();
+ }
+
+ /// Get an iterator to the last named metadata.
+ named_metadata_iterator named_metadata_end() { return NamedMDList.end(); }
+ /// Get a constant iterator to the last named metadata.
+ const_named_metadata_iterator named_metadata_end() const {
+ return NamedMDList.end();
+ }
+
+ /// Determine how many NamedMDNodes are in the Module's list of named metadata.
+ size_t named_metadata_size() const { return NamedMDList.size(); }
+ /// Determine if the list of named metadata is empty.
+ bool named_metadata_empty() const { return NamedMDList.empty(); }
+
+
+/// @}
+/// @name Utility functions for printing and dumping Module objects
+/// @{
+
+ /// Print the module to an output stream with AssemblyAnnotationWriter.
+ void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const;
+
+ /// Dump the module to stderr (for debugging).