1 //===- FunctionIndexObjectFile.h - Function 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 FunctionIndexObjectFile template class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H 15 #define LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H 16 17 #include "llvm/IR/DiagnosticInfo.h" 18 #include "llvm/Object/SymbolicFile.h" 19 20 namespace llvm { 21 class FunctionInfoIndex; 22 class Module; 23 24 namespace object { 25 class ObjectFile; 26 27 /// This class is used to read just the function 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 FunctionInfoIndex 30 /// object. 31 class FunctionIndexObjectFile : public SymbolicFile { 32 std::unique_ptr<FunctionInfoIndex> Index; 33 34 public: 35 FunctionIndexObjectFile(MemoryBufferRef Object, 36 std::unique_ptr<FunctionInfoIndex> I); 37 ~FunctionIndexObjectFile() override; 38 39 // TODO: Walk through FunctionMap entries for function 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 FunctionInfoIndex &getIndex() const { 63 return const_cast<FunctionIndexObjectFile *>(this)->getIndex(); 64 } getIndex()65 FunctionInfoIndex &getIndex() { return *Index; } 66 std::unique_ptr<FunctionInfoIndex> takeIndex(); 67 classof(const Binary * v)68 static inline bool classof(const Binary *v) { return v->isFunctionIndex(); } 69 70 /// \brief Finds and returns bitcode embedded in the given object file, or an 71 /// error code if not found. 72 static ErrorOr<MemoryBufferRef> findBitcodeInObject(const ObjectFile &Obj); 73 74 /// \brief Finds and returns bitcode in the given memory buffer (which may 75 /// be either a bitcode file or a native object file with embedded bitcode), 76 /// or an error code if not found. 77 static ErrorOr<MemoryBufferRef> 78 findBitcodeInMemBuffer(MemoryBufferRef Object); 79 80 /// \brief Looks for function summary in the given memory buffer, 81 /// returns true if found, else false. 82 static bool 83 hasFunctionSummaryInMemBuffer(MemoryBufferRef Object, 84 DiagnosticHandlerFunction DiagnosticHandler); 85 86 /// \brief Parse function index in the given memory buffer. 87 /// Return new FunctionIndexObjectFile instance containing parsed function 88 /// summary/index. 89 static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>> 90 create(MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler, 91 bool IsLazy = false); 92 93 /// \brief Parse the function summary information for function with the 94 /// given name out of the given buffer. Parsed information is 95 /// stored on the index object saved in this object. 96 std::error_code 97 findFunctionSummaryInMemBuffer(MemoryBufferRef Object, 98 DiagnosticHandlerFunction DiagnosticHandler, 99 StringRef FunctionName); 100 }; 101 } 102 103 /// Parse the function index out of an IR file and return the function 104 /// index object if found, or nullptr if not. 105 ErrorOr<std::unique_ptr<FunctionInfoIndex>> 106 getFunctionIndexForFile(StringRef Path, 107 DiagnosticHandlerFunction DiagnosticHandler); 108 } 109 110 #endif 111