include/llvm-c/Object.h

   1 /*===-- llvm-c/Object.h - Object Lib C Iface --------------------*- 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 header declares the C interface to libLLVMObject.a, which             */
  11 /* implements object file reading and writing.                                */
  12 /*                                                                            */
  13 /* Many exotic languages can interoperate with C code but have a harder time  */
  14 /* with C++ due to name mangling. So in addition to C, this interface enables */
  15 /* tools written in such languages.                                           */
  16 /*                                                                            */
  17 /*===----------------------------------------------------------------------===*/
  18
  19 #ifndef LLVM_C_OBJECT_H
  20 #define LLVM_C_OBJECT_H
  21
  22 #include "llvm-c/Core.h"
  23 #include "llvm/Config/llvm-config.h"
  24
  25 #ifdef __cplusplus
  26 #include "llvm/Object/ObjectFile.h"
  27
  28 extern "C" {
  29 #endif
  30
  31 // Opaque type wrappers
  32 typedef struct LLVMOpaqueObjectFile *LLVMObjectFileRef;
  33 typedef struct LLVMOpaqueSectionIterator *LLVMSectionIteratorRef;
  34 typedef struct LLVMOpauqeSymbolIterator *LLVMSymbolIteratorRef;
  35
  36 // ObjectFile creation
  37 LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf);
  38 void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile);
  39
  40 // ObjectFile Section iterators
  41 LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile);
  42 void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI);
  43 LLVMBool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile,
  44                                 LLVMSectionIteratorRef SI);
  45 void LLVMMoveToNextSection(LLVMSectionIteratorRef SI);
  46 void LLVMMoveToContainingSection(LLVMSectionIteratorRef Sect,
  47                                  LLVMSymbolIteratorRef Sym);
  48
  49 // ObjectFile Symbol iterators
  50 LLVMSymbolIteratorRef LLVMGetSymbols(LLVMObjectFileRef ObjectFile);
  51 void LLVMDisposeSymbolIterator(LLVMSymbolIteratorRef SI);
  52 LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef ObjectFile,
  53                                 LLVMSymbolIteratorRef SI);
  54 void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI);
  55
  56 // SectionRef accessors
  57 const char *LLVMGetSectionName(LLVMSectionIteratorRef SI);
  58 uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI);
  59 const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI);
  60 uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI);
  61 int LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
  62                                  LLVMSymbolIteratorRef Sym);
  63
  64 // SymbolRef accessors
  65 const char *LLVMGetSymbolName(LLVMSymbolIteratorRef SI);
  66 uint64_t LLVMGetSymbolAddress(LLVMSymbolIteratorRef SI);
  67 uint64_t LLVMGetSymbolOffset(LLVMSymbolIteratorRef SI);
  68 uint64_t LLVMGetSymbolSize(LLVMSymbolIteratorRef SI);
  69
  70 #ifdef __cplusplus
  71 }
  72
  73 namespace llvm {
  74   namespace object {
  75     inline ObjectFile *unwrap(LLVMObjectFileRef OF) {
  76       return reinterpret_cast<ObjectFile*>(OF);
  77     }
  78
  79     inline LLVMObjectFileRef wrap(const ObjectFile *OF) {
  80       return reinterpret_cast<LLVMObjectFileRef>(const_cast<ObjectFile*>(OF));
  81     }
  82
  83     inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
  84       return reinterpret_cast<section_iterator*>(SI);
  85     }
  86
  87     inline LLVMSectionIteratorRef
  88     wrap(const section_iterator *SI) {
  89       return reinterpret_cast<LLVMSectionIteratorRef>
  90         (const_cast<section_iterator*>(SI));
  91     }
  92
  93     inline symbol_iterator *unwrap(LLVMSymbolIteratorRef SI) {
  94       return reinterpret_cast<symbol_iterator*>(SI);
  95     }
  96
  97     inline LLVMSymbolIteratorRef
  98     wrap(const symbol_iterator *SI) {
  99       return reinterpret_cast<LLVMSymbolIteratorRef>
 100         (const_cast<symbol_iterator*>(SI));
 101     }
 102   }
 103 }
 104
 105 #endif /* defined(__cplusplus) */
 106
 107 #endif
 108