LCOV - code coverage report
Current view: top level - lib/Object - Object.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 7 110 6.4 %
Date: 2017-09-14 15:23:50 Functions: 1 28 3.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13