1 //===- ModuleSummaryIndexObjectFile.h - Summary index file implementation -=// 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 ModuleSummaryIndexObjectFile template class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_OBJECT_MODULESUMMARYINDEXOBJECTFILE_H 15 #define LLVM_OBJECT_MODULESUMMARYINDEXOBJECTFILE_H 16 17 #include "llvm/IR/DiagnosticInfo.h" 18 #include "llvm/Object/SymbolicFile.h" 19 20 namespace llvm { 21 class ModuleSummaryIndex; 22 class Module; 23 24 namespace object { 25 class ObjectFile; 26 27 /// This class is used to read just the module summary index related 28 /// sections out of the given object (which may contain a single module's 29 /// bitcode or be a combined index bitcode file). It builds a ModuleSummaryIndex 30 /// object. 31 class ModuleSummaryIndexObjectFile : public SymbolicFile { 32 std::unique_ptr<ModuleSummaryIndex> Index; 33 34 public: 35 ModuleSummaryIndexObjectFile(MemoryBufferRef Object, 36 std::unique_ptr<ModuleSummaryIndex> I); 37 ~ModuleSummaryIndexObjectFile() override; 38 39 // TODO: Walk through GlobalValueMap entries for symbols. 40 // However, currently these interfaces are not used by any consumers. moveSymbolNext(DataRefImpl & Symb)41 void moveSymbolNext(DataRefImpl &Symb) const override { 42 llvm_unreachable("not implemented"); 43 } printSymbolName(raw_ostream & OS,DataRefImpl Symb)44 std::error_code printSymbolName(raw_ostream &OS, 45 DataRefImpl Symb) const override { 46 llvm_unreachable("not implemented"); 47 return std::error_code(); 48 } getSymbolFlags(DataRefImpl Symb)49 uint32_t getSymbolFlags(DataRefImpl Symb) const override { 50 llvm_unreachable("not implemented"); 51 return 0; 52 } symbol_begin_impl()53 basic_symbol_iterator symbol_begin_impl() const override { 54 llvm_unreachable("not implemented"); 55 return basic_symbol_iterator(BasicSymbolRef()); 56 } symbol_end_impl()57 basic_symbol_iterator symbol_end_impl() const override { 58 llvm_unreachable("not implemented"); 59 return basic_symbol_iterator(BasicSymbolRef()); 60 } 61 getIndex()62 const ModuleSummaryIndex &getIndex() const { 63 return const_cast<ModuleSummaryIndexObjectFile *>(this)->getIndex(); 64 } getIndex()65 ModuleSummaryIndex &getIndex() { return *Index; } 66 std::unique_ptr<ModuleSummaryIndex> takeIndex(); 67 classof(const Binary * v)68 static inline bool classof(const Binary *v) { 69 return v->isModuleSummaryIndex(); 70 } 71 72 /// \brief Finds and returns bitcode embedded in the given object file, or an 73 /// error code if not found. 74 static ErrorOr<MemoryBufferRef> findBitcodeInObject(const ObjectFile &Obj); 75 76 /// \brief Finds and returns bitcode in the given memory buffer (which may 77 /// be either a bitcode file or a native object file with embedded bitcode), 78 /// or an error code if not found. 79 static ErrorOr<MemoryBufferRef> 80 findBitcodeInMemBuffer(MemoryBufferRef Object); 81 82 /// \brief Looks for summary sections in the given memory buffer, 83 /// returns true if found, else false. 84 static bool hasGlobalValueSummaryInMemBuffer( 85 MemoryBufferRef Object, 86 const DiagnosticHandlerFunction &DiagnosticHandler); 87 88 /// \brief Parse module summary index in the given memory buffer. 89 /// Return new ModuleSummaryIndexObjectFile instance containing parsed module 90 /// summary/index. 91 static ErrorOr<std::unique_ptr<ModuleSummaryIndexObjectFile>> 92 create(MemoryBufferRef Object, 93 const DiagnosticHandlerFunction &DiagnosticHandler); 94 }; 95 } 96 97 /// Parse the module summary index out of an IR file and return the module 98 /// summary index object if found, or nullptr if not. 99 ErrorOr<std::unique_ptr<ModuleSummaryIndex>> getModuleSummaryIndexForFile( 100 StringRef Path, const DiagnosticHandlerFunction &DiagnosticHandler); 101 } 102 103 #endif 104