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