lib/Object/Object.cpp

   1 //===- Object.cpp - C bindings to the object file library--------*- C++ -*-===//
   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 defines the C bindings to the file-format-independent object
  11 // library.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Object/ObjectFile.h"
  16 #include "llvm-c/Object.h"
  17
  18 using namespace llvm;
  19 using namespace object;
  20
  21 // ObjectFile creation
  22 LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf) {
  23   return wrap(ObjectFile::createObjectFile(unwrap(MemBuf)));
  24 }
  25
  26 void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile) {
  27   delete unwrap(ObjectFile);
  28 }
  29
  30 // ObjectFile Section iterators
  31 LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile) {
  32   section_iterator SI = unwrap(ObjectFile)->begin_sections();
  33   return wrap(new section_iterator(SI));
  34 }
  35
  36 void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI) {
  37   delete unwrap(SI);
  38 }
  39
  40 LLVMBool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile,
  41                                 LLVMSectionIteratorRef SI) {
  42   return (*unwrap(SI) == unwrap(ObjectFile)->end_sections()) ? 1 : 0;
  43 }
  44
  45 void LLVMMoveToNextSection(LLVMSectionIteratorRef SI) {
  46   error_code ec;
  47   unwrap(SI)->increment(ec);
  48   if (ec) report_fatal_error("LLVMMoveToNextSection failed: " + ec.message());
  49 }
  50
  51 void LLVMMoveToContainingSection(LLVMSectionIteratorRef Sect,
  52                                  LLVMSymbolIteratorRef Sym) {
  53   if (error_code ec = (*unwrap(Sym))->getSection(*unwrap(Sect)))
  54     report_fatal_error(ec.message());
  55 }
  56
  57 // ObjectFile Symbol iterators
  58 LLVMSymbolIteratorRef LLVMGetSymbols(LLVMObjectFileRef ObjectFile) {
  59   symbol_iterator SI = unwrap(ObjectFile)->begin_symbols();
  60   return wrap(new symbol_iterator(SI));
  61 }
  62
  63 void LLVMDisposeSymbolIterator(LLVMSymbolIteratorRef SI) {
  64   delete unwrap(SI);
  65 }
  66
  67 LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef ObjectFile,
  68                                 LLVMSymbolIteratorRef SI) {
  69   return (*unwrap(SI) == unwrap(ObjectFile)->end_symbols()) ? 1 : 0;
  70 }
  71
  72 void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI) {
  73   error_code ec;
  74   unwrap(SI)->increment(ec);
  75   if (ec) report_fatal_error("LLVMMoveToNextSymbol failed: " + ec.message());
  76 }
  77
  78 // SectionRef accessors
  79 const char *LLVMGetSectionName(LLVMSectionIteratorRef SI) {
  80   StringRef ret;
  81   if (error_code ec = (*unwrap(SI))->getName(ret))
  82    report_fatal_error(ec.message());
  83   return ret.data();
  84 }
  85
  86 uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI) {
  87   uint64_t ret;
  88   if (error_code ec = (*unwrap(SI))->getSize(ret))
  89     report_fatal_error(ec.message());
  90   return ret;
  91 }
  92
  93 const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI) {
  94   StringRef ret;
  95   if (error_code ec = (*unwrap(SI))->getContents(ret))
  96     report_fatal_error(ec.message());
  97   return ret.data();
  98 }
  99
 100 uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI) {
 101   uint64_t ret;
 102   if (error_code ec = (*unwrap(SI))->getAddress(ret))
 103     report_fatal_error(ec.message());
 104   return ret;
 105 }
 106
 107 LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
 108                                  LLVMSymbolIteratorRef Sym) {
 109   bool ret;
 110   if (error_code ec = (*unwrap(SI))->containsSymbol(**unwrap(Sym), ret))
 111     report_fatal_error(ec.message());
 112   return ret;
 113 }
 114
 115 // Section Relocation iterators
 116 LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section) {
 117   relocation_iterator SI = (*unwrap(Section))->begin_relocations();
 118   return wrap(new relocation_iterator(SI));
 119 }
 120
 121 void LLVMDisposeRelocationIterator(LLVMRelocationIteratorRef SI) {
 122   delete unwrap(SI);
 123 }
 124
 125 LLVMBool LLVMIsRelocationIteratorAtEnd(LLVMSectionIteratorRef Section,
 126                                        LLVMRelocationIteratorRef SI) {
 127   return (*unwrap(SI) == (*unwrap(Section))->end_relocations()) ? 1 : 0;
 128 }
 129
 130 void LLVMMoveToNextRelocation(LLVMRelocationIteratorRef SI) {
 131   error_code ec;
 132   unwrap(SI)->increment(ec);
 133   if (ec) report_fatal_error("LLVMMoveToNextRelocation failed: " +
 134                              ec.message());
 135 }
 136
 137
 138 // SymbolRef accessors
 139 const char *LLVMGetSymbolName(LLVMSymbolIteratorRef SI) {
 140   StringRef ret;
 141   if (error_code ec = (*unwrap(SI))->getName(ret))
 142     report_fatal_error(ec.message());
 143   return ret.data();
 144 }
 145
 146 uint64_t LLVMGetSymbolAddress(LLVMSymbolIteratorRef SI) {
 147   uint64_t ret;
 148   if (error_code ec = (*unwrap(SI))->getAddress(ret))
 149     report_fatal_error(ec.message());
 150   return ret;
 151 }
 152
 153 uint64_t LLVMGetSymbolOffset(LLVMSymbolIteratorRef SI) {
 154   uint64_t ret;
 155   if (error_code ec = (*unwrap(SI))->getOffset(ret))
 156     report_fatal_error(ec.message());
 157   return ret;
 158 }
 159
 160 uint64_t LLVMGetSymbolSize(LLVMSymbolIteratorRef SI) {
 161   uint64_t ret;
 162   if (error_code ec = (*unwrap(SI))->getSize(ret))
 163     report_fatal_error(ec.message());
 164   return ret;
 165 }
 166
 167 // RelocationRef accessors
 168 uint64_t LLVMGetRelocationAddress(LLVMRelocationIteratorRef RI) {
 169   uint64_t ret;
 170   if (error_code ec = (*unwrap(RI))->getAddress(ret))
 171     report_fatal_error(ec.message());
 172   return ret;
 173 }
 174
 175 LLVMSymbolIteratorRef LLVMGetRelocationSymbol(LLVMRelocationIteratorRef RI) {
 176   SymbolRef ret;
 177   if (error_code ec = (*unwrap(RI))->getSymbol(ret))
 178     report_fatal_error(ec.message());
 179
 180   return wrap(new symbol_iterator(ret));
 181 }
 182
 183 uint64_t LLVMGetRelocationType(LLVMRelocationIteratorRef RI) {
 184   uint64_t ret;
 185   if (error_code ec = (*unwrap(RI))->getType(ret))
 186     report_fatal_error(ec.message());
 187   return ret;
 188 }
 189
 190 // NOTE: Caller takes ownership of returned string.
 191 const char *LLVMGetRelocationTypeName(LLVMRelocationIteratorRef RI) {
 192   SmallVector<char, 0> ret;
 193   if (error_code ec = (*unwrap(RI))->getTypeName(ret))
 194     report_fatal_error(ec.message());
 195
 196   char *str = static_cast<char*>(malloc(ret.size()));
 197   std::copy(ret.begin(), ret.end(), str);
 198   return str;
 199 }
 200
 201 // NOTE: Caller takes ownership of returned string.
 202 const char *LLVMGetRelocationValueString(LLVMRelocationIteratorRef RI) {
 203   SmallVector<char, 0> ret;
 204   if (error_code ec = (*unwrap(RI))->getValueString(ret))
 205     report_fatal_error(ec.message());
 206
 207   char *str = static_cast<char*>(malloc(ret.size()));
 208   std::copy(ret.begin(), ret.end(), str);
 209   return str;
 210 }
 211