1 //===- FunctionIndexObjectFile.cpp - Function index file implementation ---===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Part of the FunctionIndexObjectFile class implementation.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Object/FunctionIndexObjectFile.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/Bitcode/ReaderWriter.h"
17 #include "llvm/IR/FunctionInfo.h"
18 #include "llvm/MC/MCStreamer.h"
19 #include "llvm/Object/ObjectFile.h"
20 #include "llvm/Support/MemoryBuffer.h"
21 #include "llvm/Support/raw_ostream.h"
23 using namespace object;
25 FunctionIndexObjectFile::FunctionIndexObjectFile(
26 MemoryBufferRef Object, std::unique_ptr<FunctionInfoIndex> I)
27 : SymbolicFile(Binary::ID_FunctionIndex, Object), Index(std::move(I)) {}
29 FunctionIndexObjectFile::~FunctionIndexObjectFile() {}
31 std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() {
32 return std::move(Index);
35 ErrorOr<MemoryBufferRef>
36 FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
37 for (const SectionRef &Sec : Obj.sections()) {
39 if (std::error_code EC = Sec.getName(SecName))
41 if (SecName == ".llvmbc") {
42 StringRef SecContents;
43 if (std::error_code EC = Sec.getContents(SecContents))
45 return MemoryBufferRef(SecContents, Obj.getFileName());
49 return object_error::bitcode_section_not_found;
52 ErrorOr<MemoryBufferRef>
53 FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
54 sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
56 case sys::fs::file_magic::bitcode:
58 case sys::fs::file_magic::elf_relocatable:
59 case sys::fs::file_magic::macho_object:
60 case sys::fs::file_magic::coff_object: {
61 ErrorOr<std::unique_ptr<ObjectFile>> ObjFile =
62 ObjectFile::createObjectFile(Object, Type);
64 return ObjFile.getError();
65 return findBitcodeInObject(*ObjFile->get());
68 return object_error::invalid_file_type;
72 // Looks for function index in the given memory buffer.
73 // returns true if found, else false.
74 bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
75 MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler) {
76 ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
80 return hasFunctionSummary(BCOrErr.get(), DiagnosticHandler);
83 // Parse function index in the given memory buffer.
84 // Return new FunctionIndexObjectFile instance containing parsed
85 // function summary/index.
86 ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
87 FunctionIndexObjectFile::create(MemoryBufferRef Object,
88 DiagnosticHandlerFunction DiagnosticHandler,
89 const Module *ExportingModule, bool IsLazy) {
90 std::unique_ptr<FunctionInfoIndex> Index;
92 ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
94 return BCOrErr.getError();
96 ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = getFunctionInfoIndex(
97 BCOrErr.get(), DiagnosticHandler, ExportingModule, IsLazy);
99 if (std::error_code EC = IOrErr.getError())
102 Index = std::move(IOrErr.get());
104 return llvm::make_unique<FunctionIndexObjectFile>(Object, std::move(Index));
107 // Parse the function summary information for function with the
108 // given name out of the given buffer. Parsed information is
109 // stored on the index object saved in this object.
110 std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer(
111 MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler,
112 StringRef FunctionName) {
113 sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
115 case sys::fs::file_magic::bitcode: {
116 return readFunctionSummary(Object, DiagnosticHandler, FunctionName,
120 return object_error::invalid_file_type;
124 // Parse the function index out of an IR file and return the function
125 // index object if found, or nullptr if not.
126 ErrorOr<std::unique_ptr<FunctionInfoIndex>>
127 llvm::getFunctionIndexForFile(StringRef Path,
128 DiagnosticHandlerFunction DiagnosticHandler,
129 const Module *ExportingModule) {
130 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
131 MemoryBuffer::getFileOrSTDIN(Path);
132 std::error_code EC = FileOrErr.getError();
135 MemoryBufferRef BufferRef = (FileOrErr.get())->getMemBufferRef();
136 ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
137 object::FunctionIndexObjectFile::create(BufferRef, DiagnosticHandler,
139 EC = ObjOrErr.getError();
143 object::FunctionIndexObjectFile &Obj = **ObjOrErr;
144 return Obj.takeIndex();