LCOV - code coverage report
Current view: top level - include/llvm/LTO/legacy - LTOModule.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 8 8 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===//
       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 declares the LTOModule class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_LTO_LTOMODULE_H
      15             : #define LLVM_LTO_LTOMODULE_H
      16             : 
      17             : #include "llvm-c/lto.h"
      18             : #include "llvm/ADT/StringMap.h"
      19             : #include "llvm/ADT/StringSet.h"
      20             : #include "llvm/IR/Module.h"
      21             : #include "llvm/Object/IRObjectFile.h"
      22             : #include "llvm/Object/ModuleSymbolTable.h"
      23             : #include "llvm/Target/TargetMachine.h"
      24             : #include <string>
      25             : #include <vector>
      26             : 
      27             : // Forward references to llvm classes.
      28             : namespace llvm {
      29             :   class Function;
      30             :   class GlobalValue;
      31             :   class MemoryBuffer;
      32             :   class TargetOptions;
      33             :   class Value;
      34             : 
      35             : //===----------------------------------------------------------------------===//
      36             : /// C++ class which implements the opaque lto_module_t type.
      37             : ///
      38             : struct LTOModule {
      39             : private:
      40          35 :   struct NameAndAttributes {
      41             :     StringRef name;
      42             :     uint32_t           attributes = 0;
      43             :     bool               isFunction = 0;
      44             :     const GlobalValue *symbol = 0;
      45             :   };
      46             : 
      47             :   std::unique_ptr<LLVMContext> OwnedContext;
      48             : 
      49             :   std::string LinkerOpts;
      50             : 
      51             :   std::unique_ptr<Module> Mod;
      52             :   MemoryBufferRef MBRef;
      53             :   ModuleSymbolTable SymTab;
      54             :   std::unique_ptr<TargetMachine> _target;
      55             :   std::vector<NameAndAttributes> _symbols;
      56             : 
      57             :   // _defines and _undefines only needed to disambiguate tentative definitions
      58             :   StringSet<>                             _defines;
      59             :   StringMap<NameAndAttributes> _undefines;
      60             :   std::vector<StringRef> _asm_undefines;
      61             : 
      62             :   LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef,
      63             :             TargetMachine *TM);
      64             : 
      65             : public:
      66             :   ~LTOModule();
      67             : 
      68             :   /// Returns 'true' if the file or memory contents is LLVM bitcode.
      69             :   static bool isBitcodeFile(const void *mem, size_t length);
      70             :   static bool isBitcodeFile(StringRef path);
      71             : 
      72             :   /// Returns 'true' if the Module is produced for ThinLTO.
      73             :   bool isThinLTO();
      74             : 
      75             :   /// Returns 'true' if the memory buffer is LLVM bitcode for the specified
      76             :   /// triple.
      77             :   static bool isBitcodeForTarget(MemoryBuffer *memBuffer,
      78             :                                  StringRef triplePrefix);
      79             : 
      80             :   /// Returns a string representing the producer identification stored in the
      81             :   /// bitcode, or "" if the bitcode does not contains any.
      82             :   ///
      83             :   static std::string getProducerString(MemoryBuffer *Buffer);
      84             : 
      85             :   /// Create a MemoryBuffer from a memory range with an optional name.
      86             :   static std::unique_ptr<MemoryBuffer>
      87             :   makeBuffer(const void *mem, size_t length, StringRef name = "");
      88             : 
      89             :   /// Create an LTOModule. N.B. These methods take ownership of the buffer. The
      90             :   /// caller must have initialized the Targets, the TargetMCs, the AsmPrinters,
      91             :   /// and the AsmParsers by calling:
      92             :   ///
      93             :   /// InitializeAllTargets();
      94             :   /// InitializeAllTargetMCs();
      95             :   /// InitializeAllAsmPrinters();
      96             :   /// InitializeAllAsmParsers();
      97             :   static ErrorOr<std::unique_ptr<LTOModule>>
      98             :   createFromFile(LLVMContext &Context, StringRef path,
      99             :                  const TargetOptions &options);
     100             :   static ErrorOr<std::unique_ptr<LTOModule>>
     101             :   createFromOpenFile(LLVMContext &Context, int fd, StringRef path, size_t size,
     102             :                      const TargetOptions &options);
     103             :   static ErrorOr<std::unique_ptr<LTOModule>>
     104             :   createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path,
     105             :                           size_t map_size, off_t offset,
     106             :                           const TargetOptions &options);
     107             :   static ErrorOr<std::unique_ptr<LTOModule>>
     108             :   createFromBuffer(LLVMContext &Context, const void *mem, size_t length,
     109             :                    const TargetOptions &options, StringRef path = "");
     110             :   static ErrorOr<std::unique_ptr<LTOModule>>
     111             :   createInLocalContext(std::unique_ptr<LLVMContext> Context, const void *mem,
     112             :                        size_t length, const TargetOptions &options,
     113             :                        StringRef path);
     114             : 
     115             :   const Module &getModule() const { return *Mod; }
     116         104 :   Module &getModule() { return *Mod; }
     117             : 
     118          92 :   std::unique_ptr<Module> takeModule() { return std::move(Mod); }
     119             : 
     120             :   /// Return the Module's target triple.
     121             :   const std::string &getTargetTriple() {
     122             :     return getModule().getTargetTriple();
     123             :   }
     124             : 
     125             :   /// Set the Module's target triple.
     126             :   void setTargetTriple(StringRef Triple) {
     127             :     getModule().setTargetTriple(Triple);
     128             :   }
     129             : 
     130             :   /// Get the number of symbols
     131             :   uint32_t getSymbolCount() {
     132          95 :     return _symbols.size();
     133             :   }
     134             : 
     135             :   /// Get the attributes for a symbol at the specified index.
     136             :   lto_symbol_attributes getSymbolAttributes(uint32_t index) {
     137          22 :     if (index < _symbols.size())
     138          22 :       return lto_symbol_attributes(_symbols[index].attributes);
     139             :     return lto_symbol_attributes(0);
     140             :   }
     141             : 
     142             :   /// Get the name of the symbol at the specified index.
     143             :   StringRef getSymbolName(uint32_t index) {
     144         266 :     if (index < _symbols.size())
     145         266 :       return _symbols[index].name;
     146             :     return StringRef();
     147             :   }
     148             : 
     149             :   const GlobalValue *getSymbolGV(uint32_t index) {
     150             :     if (index < _symbols.size())
     151             :       return _symbols[index].symbol;
     152             :     return nullptr;
     153             :   }
     154             : 
     155             :   StringRef getLinkerOpts() { return LinkerOpts; }
     156             : 
     157             :   const std::vector<StringRef> &getAsmUndefinedRefs() { return _asm_undefines; }
     158             : 
     159             : private:
     160             :   /// Parse metadata from the module
     161             :   // FIXME: it only parses "llvm.linker.options" metadata at the moment
     162             :   void parseMetadata();
     163             : 
     164             :   /// Parse the symbols from the module and model-level ASM and add them to
     165             :   /// either the defined or undefined lists.
     166             :   void parseSymbols();
     167             : 
     168             :   /// Add a symbol which isn't defined just yet to a list to be resolved later.
     169             :   void addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,
     170             :                                    bool isFunc);
     171             : 
     172             :   /// Add a defined symbol to the list.
     173             :   void addDefinedSymbol(StringRef Name, const GlobalValue *def,
     174             :                         bool isFunction);
     175             : 
     176             :   /// Add a data symbol as defined to the list.
     177             :   void addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym);
     178             :   void addDefinedDataSymbol(StringRef Name, const GlobalValue *v);
     179             : 
     180             :   /// Add a function symbol as defined to the list.
     181             :   void addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym);
     182             :   void addDefinedFunctionSymbol(StringRef Name, const Function *F);
     183             : 
     184             :   /// Add a global symbol from module-level ASM to the defined list.
     185             :   void addAsmGlobalSymbol(StringRef, lto_symbol_attributes scope);
     186             : 
     187             :   /// Add a global symbol from module-level ASM to the undefined list.
     188             :   void addAsmGlobalSymbolUndef(StringRef);
     189             : 
     190             :   /// Parse i386/ppc ObjC class data structure.
     191             :   void addObjCClass(const GlobalVariable *clgv);
     192             : 
     193             :   /// Parse i386/ppc ObjC category data structure.
     194             :   void addObjCCategory(const GlobalVariable *clgv);
     195             : 
     196             :   /// Parse i386/ppc ObjC class list data structure.
     197             :   void addObjCClassRef(const GlobalVariable *clgv);
     198             : 
     199             :   /// Get string that the data pointer points to.
     200             :   bool objcClassNameFromExpression(const Constant *c, std::string &name);
     201             : 
     202             :   /// Create an LTOModule (private version).
     203             :   static ErrorOr<std::unique_ptr<LTOModule>>
     204             :   makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
     205             :                 LLVMContext &Context, bool ShouldBeLazy);
     206             : };
     207             : }
     208             : #endif

Generated by: LCOV version 1.13