1 //===- Object.cpp - C bindings to the object file library--------*- C++ -*-===//
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 // This file defines the C bindings to the file-format-independent object
13 //===----------------------------------------------------------------------===//
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm-c/Object.h"
17 #include "llvm/Object/ObjectFile.h"
20 using namespace object;
22 inline OwningBinary<ObjectFile> *unwrap(LLVMObjectFileRef OF) {
23 return reinterpret_cast<OwningBinary<ObjectFile> *>(OF);
26 inline LLVMObjectFileRef wrap(const OwningBinary<ObjectFile> *OF) {
27 return reinterpret_cast<LLVMObjectFileRef>(
28 const_cast<OwningBinary<ObjectFile> *>(OF));
31 inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
32 return reinterpret_cast<section_iterator*>(SI);
35 inline LLVMSectionIteratorRef
36 wrap(const section_iterator *SI) {
37 return reinterpret_cast<LLVMSectionIteratorRef>
38 (const_cast<section_iterator*>(SI));
41 inline symbol_iterator *unwrap(LLVMSymbolIteratorRef SI) {
42 return reinterpret_cast<symbol_iterator*>(SI);
45 inline LLVMSymbolIteratorRef
46 wrap(const symbol_iterator *SI) {
47 return reinterpret_cast<LLVMSymbolIteratorRef>
48 (const_cast<symbol_iterator*>(SI));
51 inline relocation_iterator *unwrap(LLVMRelocationIteratorRef SI) {
52 return reinterpret_cast<relocation_iterator*>(SI);
55 inline LLVMRelocationIteratorRef
56 wrap(const relocation_iterator *SI) {
57 return reinterpret_cast<LLVMRelocationIteratorRef>
58 (const_cast<relocation_iterator*>(SI));
61 // ObjectFile creation
62 LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf) {
63 std::unique_ptr<MemoryBuffer> Buf(unwrap(MemBuf));
64 ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr(
65 ObjectFile::createObjectFile(Buf->getMemBufferRef()));
66 std::unique_ptr<ObjectFile> Obj;
68 Obj = std::move(ObjOrErr.get());
69 auto *Ret = new OwningBinary<ObjectFile>(std::move(Obj), std::move(Buf));
73 void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile) {
74 delete unwrap(ObjectFile);
77 // ObjectFile Section iterators
78 LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef OF) {
79 OwningBinary<ObjectFile> *OB = unwrap(OF);
80 section_iterator SI = OB->getBinary()->section_begin();
81 return wrap(new section_iterator(SI));
84 void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI) {
88 LLVMBool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef OF,
89 LLVMSectionIteratorRef SI) {
90 OwningBinary<ObjectFile> *OB = unwrap(OF);
91 return (*unwrap(SI) == OB->getBinary()->section_end()) ? 1 : 0;
94 void LLVMMoveToNextSection(LLVMSectionIteratorRef SI) {
98 void LLVMMoveToContainingSection(LLVMSectionIteratorRef Sect,
99 LLVMSymbolIteratorRef Sym) {
100 if (std::error_code ec = (*unwrap(Sym))->getSection(*unwrap(Sect)))
101 report_fatal_error(ec.message());
104 // ObjectFile Symbol iterators
105 LLVMSymbolIteratorRef LLVMGetSymbols(LLVMObjectFileRef OF) {
106 OwningBinary<ObjectFile> *OB = unwrap(OF);
107 symbol_iterator SI = OB->getBinary()->symbol_begin();
108 return wrap(new symbol_iterator(SI));
111 void LLVMDisposeSymbolIterator(LLVMSymbolIteratorRef SI) {
115 LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef OF,
116 LLVMSymbolIteratorRef SI) {
117 OwningBinary<ObjectFile> *OB = unwrap(OF);
118 return (*unwrap(SI) == OB->getBinary()->symbol_end()) ? 1 : 0;
121 void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI) {
125 // SectionRef accessors
126 const char *LLVMGetSectionName(LLVMSectionIteratorRef SI) {
128 if (std::error_code ec = (*unwrap(SI))->getName(ret))
129 report_fatal_error(ec.message());
133 uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI) {
135 if (std::error_code ec = (*unwrap(SI))->getSize(ret))
136 report_fatal_error(ec.message());
140 const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI) {
142 if (std::error_code ec = (*unwrap(SI))->getContents(ret))
143 report_fatal_error(ec.message());
147 uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI) {
149 if (std::error_code ec = (*unwrap(SI))->getAddress(ret))
150 report_fatal_error(ec.message());
154 LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
155 LLVMSymbolIteratorRef Sym) {
157 if (std::error_code ec = (*unwrap(SI))->containsSymbol(**unwrap(Sym), ret))
158 report_fatal_error(ec.message());
162 // Section Relocation iterators
163 LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section) {
164 relocation_iterator SI = (*unwrap(Section))->relocation_begin();
165 return wrap(new relocation_iterator(SI));
168 void LLVMDisposeRelocationIterator(LLVMRelocationIteratorRef SI) {
172 LLVMBool LLVMIsRelocationIteratorAtEnd(LLVMSectionIteratorRef Section,
173 LLVMRelocationIteratorRef SI) {
174 return (*unwrap(SI) == (*unwrap(Section))->relocation_end()) ? 1 : 0;
177 void LLVMMoveToNextRelocation(LLVMRelocationIteratorRef SI) {
182 // SymbolRef accessors
183 const char *LLVMGetSymbolName(LLVMSymbolIteratorRef SI) {
185 if (std::error_code ec = (*unwrap(SI))->getName(ret))
186 report_fatal_error(ec.message());
190 uint64_t LLVMGetSymbolAddress(LLVMSymbolIteratorRef SI) {
192 if (std::error_code ec = (*unwrap(SI))->getAddress(ret))
193 report_fatal_error(ec.message());
197 uint64_t LLVMGetSymbolSize(LLVMSymbolIteratorRef SI) {
199 if (std::error_code ec = (*unwrap(SI))->getSize(ret))
200 report_fatal_error(ec.message());
204 // RelocationRef accessors
205 uint64_t LLVMGetRelocationAddress(LLVMRelocationIteratorRef RI) {
207 if (std::error_code ec = (*unwrap(RI))->getAddress(ret))
208 report_fatal_error(ec.message());
212 uint64_t LLVMGetRelocationOffset(LLVMRelocationIteratorRef RI) {
214 if (std::error_code ec = (*unwrap(RI))->getOffset(ret))
215 report_fatal_error(ec.message());
219 LLVMSymbolIteratorRef LLVMGetRelocationSymbol(LLVMRelocationIteratorRef RI) {
220 symbol_iterator ret = (*unwrap(RI))->getSymbol();
221 return wrap(new symbol_iterator(ret));
224 uint64_t LLVMGetRelocationType(LLVMRelocationIteratorRef RI) {
226 if (std::error_code ec = (*unwrap(RI))->getType(ret))
227 report_fatal_error(ec.message());
231 // NOTE: Caller takes ownership of returned string.
232 const char *LLVMGetRelocationTypeName(LLVMRelocationIteratorRef RI) {
233 SmallVector<char, 0> ret;
234 if (std::error_code ec = (*unwrap(RI))->getTypeName(ret))
235 report_fatal_error(ec.message());
237 char *str = static_cast<char*>(malloc(ret.size()));
238 std::copy(ret.begin(), ret.end(), str);
242 // NOTE: Caller takes ownership of returned string.
243 const char *LLVMGetRelocationValueString(LLVMRelocationIteratorRef RI) {
244 SmallVector<char, 0> ret;
245 if (std::error_code ec = (*unwrap(RI))->getValueString(ret))
246 report_fatal_error(ec.message());
248 char *str = static_cast<char*>(malloc(ret.size()));
249 std::copy(ret.begin(), ret.end(), str);