From 7ac885ee8cb18fc2cb974cff06190532680cf29b Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 21 Mar 2011 23:06:42 -0700 Subject: Repair some fallout from pcwalton's last few build changes. --- src/rustllvm/MachOObjectFile.cpp | 330 ++++++++++++++++++++++++ src/rustllvm/Object.cpp | 59 +++++ src/rustllvm/README | 3 + src/rustllvm/RustWrapper.cpp | 31 +++ src/rustllvm/include/llvm-c/Object.h | 77 ++++++ src/rustllvm/rustllvm.def | 473 +++++++++++++++++++++++++++++++++++ 6 files changed, 973 insertions(+) create mode 100644 src/rustllvm/MachOObjectFile.cpp create mode 100644 src/rustllvm/Object.cpp create mode 100644 src/rustllvm/README create mode 100644 src/rustllvm/RustWrapper.cpp create mode 100644 src/rustllvm/include/llvm-c/Object.h create mode 100644 src/rustllvm/rustllvm.def (limited to 'src/rustllvm') diff --git a/src/rustllvm/MachOObjectFile.cpp b/src/rustllvm/MachOObjectFile.cpp new file mode 100644 index 00000000..4a003249 --- /dev/null +++ b/src/rustllvm/MachOObjectFile.cpp @@ -0,0 +1,330 @@ +//===- MachOObjectFile.cpp - Mach-O object file binding ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the MachOObjectFile class, which binds the MachOObject +// class to the generic ObjectFile wrapper. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/Triple.h" +#include "llvm/Object/MachOFormat.h" +#include "llvm/Object/MachOObject.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Support/MemoryBuffer.h" + +#include +#include +#include + +using namespace llvm; +using namespace object; + +namespace llvm { + +typedef MachOObject::LoadCommandInfo LoadCommandInfo; + +class MachOObjectFile : public ObjectFile { +public: + MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO) + : ObjectFile(Object), + MachOObj(MOO), + RegisteredStringTable(std::numeric_limits::max()) {} + + virtual symbol_iterator begin_symbols() const; + virtual symbol_iterator end_symbols() const; + virtual section_iterator begin_sections() const; + virtual section_iterator end_sections() const; + + virtual uint8_t getBytesInAddress() const; + virtual StringRef getFileFormatName() const; + virtual unsigned getArch() const; + +protected: + virtual SymbolRef getSymbolNext(DataRefImpl Symb) const; + virtual StringRef getSymbolName(DataRefImpl Symb) const; + virtual uint64_t getSymbolAddress(DataRefImpl Symb) const; + virtual uint64_t getSymbolSize(DataRefImpl Symb) const; + virtual char getSymbolNMTypeChar(DataRefImpl Symb) const; + virtual bool isSymbolInternal(DataRefImpl Symb) const; + + virtual SectionRef getSectionNext(DataRefImpl Sec) const; + virtual StringRef getSectionName(DataRefImpl Sec) const; + virtual uint64_t getSectionAddress(DataRefImpl Sec) const; + virtual uint64_t getSectionSize(DataRefImpl Sec) const; + virtual StringRef getSectionContents(DataRefImpl Sec) const; + virtual bool isSectionText(DataRefImpl Sec) const; + +private: + MachOObject *MachOObj; + mutable uint32_t RegisteredStringTable; + + void moveToNextSection(DataRefImpl &DRI) const; + void getSymbolTableEntry(DataRefImpl DRI, + InMemoryStruct &Res) const; + void moveToNextSymbol(DataRefImpl &DRI) const; + void getSection(DataRefImpl DRI, InMemoryStruct &Res) const; +}; + +ObjectFile *ObjectFile::createMachOObjectFile(MemoryBuffer *Buffer) { + std::string Err; + MachOObject *MachOObj = MachOObject::LoadFromBuffer(Buffer, &Err); + if (!MachOObj) + return NULL; + return new MachOObjectFile(Buffer, MachOObj); +} + +/*===-- Symbols -----------------------------------------------------------===*/ + +void MachOObjectFile::moveToNextSymbol(DataRefImpl &DRI) const { + uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands; + while (DRI.d.a < LoadCommandCount) { + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + if (LCI.Command.Type == macho::LCT_Symtab) { + InMemoryStruct SymtabLoadCmd; + MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd); + if (DRI.d.b < SymtabLoadCmd->NumSymbolTableEntries) + return; + } + + DRI.d.a++; + DRI.d.b = 0; + } +} + +void MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI, + InMemoryStruct &Res) const { + InMemoryStruct SymtabLoadCmd; + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd); + + if (RegisteredStringTable != DRI.d.a) { + MachOObj->RegisterStringTable(*SymtabLoadCmd); + RegisteredStringTable = DRI.d.a; + } + + MachOObj->ReadSymbolTableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b, + Res); +} + + +SymbolRef MachOObjectFile::getSymbolNext(DataRefImpl DRI) const { + DRI.d.b++; + moveToNextSymbol(DRI); + return SymbolRef(DRI, this); +} + +StringRef MachOObjectFile::getSymbolName(DataRefImpl DRI) const { + InMemoryStruct Entry; + getSymbolTableEntry(DRI, Entry); + return MachOObj->getStringAtIndex(Entry->StringIndex); +} + +uint64_t MachOObjectFile::getSymbolAddress(DataRefImpl DRI) const { + InMemoryStruct Entry; + getSymbolTableEntry(DRI, Entry); + return Entry->Value; +} + +uint64_t MachOObjectFile::getSymbolSize(DataRefImpl DRI) const { + return UnknownAddressOrSize; +} + +char MachOObjectFile::getSymbolNMTypeChar(DataRefImpl DRI) const { + InMemoryStruct Entry; + getSymbolTableEntry(DRI, Entry); + + char Char; + switch (Entry->Type & macho::STF_TypeMask) { + case macho::STT_Undefined: + Char = 'u'; + break; + case macho::STT_Absolute: + case macho::STT_Section: + Char = 's'; + break; + default: + Char = '?'; + break; + } + + if (Entry->Flags & (macho::STF_External | macho::STF_PrivateExtern)) + Char = toupper(Char); + return Char; +} + +bool MachOObjectFile::isSymbolInternal(DataRefImpl DRI) const { + InMemoryStruct Entry; + getSymbolTableEntry(DRI, Entry); + return Entry->Flags & macho::STF_StabsEntryMask; +} + +ObjectFile::symbol_iterator MachOObjectFile::begin_symbols() const { + // DRI.d.a = segment number; DRI.d.b = symbol index. + DataRefImpl DRI; + DRI.d.a = DRI.d.b = 0; + moveToNextSymbol(DRI); + return symbol_iterator(SymbolRef(DRI, this)); +} + +ObjectFile::symbol_iterator MachOObjectFile::end_symbols() const { + DataRefImpl DRI; + DRI.d.a = MachOObj->getHeader().NumLoadCommands; + DRI.d.b = 0; + return symbol_iterator(SymbolRef(DRI, this)); +} + + +/*===-- Sections ----------------------------------------------------------===*/ + +void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const { + uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands; + while (DRI.d.a < LoadCommandCount) { + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + if (LCI.Command.Type == macho::LCT_Segment) { + InMemoryStruct SegmentLoadCmd; + MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd); + if (DRI.d.b < SegmentLoadCmd->NumSections) + return; + } else if (LCI.Command.Type == macho::LCT_Segment64) { + InMemoryStruct Segment64LoadCmd; + MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd); + if (DRI.d.b < Segment64LoadCmd->NumSections) + return; + } + + DRI.d.a++; + DRI.d.b = 0; + } +} + +SectionRef MachOObjectFile::getSectionNext(DataRefImpl DRI) const { + DRI.d.b++; + moveToNextSection(DRI); + return SectionRef(DRI, this); +} + +void +MachOObjectFile::getSection(DataRefImpl DRI, + InMemoryStruct &Res) const { + InMemoryStruct SLC; + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + MachOObj->ReadSegmentLoadCommand(LCI, SLC); + MachOObj->ReadSection(LCI, DRI.d.b, Res); +} + +StringRef MachOObjectFile::getSectionName(DataRefImpl DRI) const { + InMemoryStruct SLC; + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + MachOObj->ReadSegmentLoadCommand(LCI, SLC); + InMemoryStruct Sect; + MachOObj->ReadSection(LCI, DRI.d.b, Sect); + + static char Result[34]; + strcpy(Result, SLC->Name); + strcat(Result, ","); + strcat(Result, Sect->Name); + return StringRef(Result); +} + +uint64_t MachOObjectFile::getSectionAddress(DataRefImpl DRI) const { + InMemoryStruct Sect; + getSection(DRI, Sect); + return Sect->Address; +} + +uint64_t MachOObjectFile::getSectionSize(DataRefImpl DRI) const { + InMemoryStruct Sect; + getSection(DRI, Sect); + return Sect->Size; +} + +StringRef MachOObjectFile::getSectionContents(DataRefImpl DRI) const { + InMemoryStruct Sect; + getSection(DRI, Sect); + return MachOObj->getData(Sect->Offset, Sect->Size); +} + +bool MachOObjectFile::isSectionText(DataRefImpl DRI) const { + InMemoryStruct SLC; + LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a); + MachOObj->ReadSegmentLoadCommand(LCI, SLC); + return !strcmp(SLC->Name, "__TEXT"); +} + +ObjectFile::section_iterator MachOObjectFile::begin_sections() const { + DataRefImpl DRI; + DRI.d.a = DRI.d.b = 0; + moveToNextSection(DRI); + return section_iterator(SectionRef(DRI, this)); +} + +ObjectFile::section_iterator MachOObjectFile::end_sections() const { + DataRefImpl DRI; + DRI.d.a = MachOObj->getHeader().NumLoadCommands; + DRI.d.b = 0; + return section_iterator(SectionRef(DRI, this)); +} + +/*===-- Miscellaneous -----------------------------------------------------===*/ + +uint8_t MachOObjectFile::getBytesInAddress() const { + return MachOObj->is64Bit() ? 8 : 4; +} + +StringRef MachOObjectFile::getFileFormatName() const { + if (!MachOObj->is64Bit()) { + switch (MachOObj->getHeader().CPUType) { + case 0x00000007: + return "MACHO32-i386"; + case 0x01000007: + return "MACHO32-x86-64"; + case 0x0000000c: + return "MACHO32-arm"; + case 0x00000012: + return "MACHO32-ppc"; + case 0x01000012: + return "MACHO32-ppc64"; + } + } + + switch (MachOObj->getHeader().CPUType) { + case 0x00000007: + return "MACHO64-i386"; + case 0x01000007: + return "MACHO64-x86-64"; + case 0x0000000c: + return "MACHO64-arm"; + case 0x00000012: + return "MACHO64-ppc"; + case 0x01000012: + return "MACHO64-ppc64"; + default: + return "MACHO64-unknown"; + } +} + +unsigned MachOObjectFile::getArch() const { + switch (MachOObj->getHeader().CPUType) { + case 0x00000007: + return Triple::x86; + case 0x01000007: + return Triple::x86_64; + case 0x0000000c: + return Triple::arm; + case 0x00000012: + return Triple::ppc; + case 0x01000012: + return Triple::ppc64; + default: + return Triple::UnknownArch; + } +} + +} // end namespace llvm + diff --git a/src/rustllvm/Object.cpp b/src/rustllvm/Object.cpp new file mode 100644 index 00000000..603e72b9 --- /dev/null +++ b/src/rustllvm/Object.cpp @@ -0,0 +1,59 @@ +//===- Object.cpp - C bindings to the object file library--------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the C bindings to the file-format-independent object +// library. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Object/ObjectFile.h" +#include "llvm-c/Object.h" + +using namespace llvm; +using namespace object; + +LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf) { + return wrap(ObjectFile::createObjectFile(unwrap(MemBuf))); +} + +void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile) { + delete unwrap(ObjectFile); +} + +LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile) { + ObjectFile::section_iterator SI = unwrap(ObjectFile)->begin_sections(); + return wrap(new ObjectFile::section_iterator(SI)); +} + +void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI) { + delete unwrap(SI); +} + +bool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile, + LLVMSectionIteratorRef SI) { + return *unwrap(SI) == unwrap(ObjectFile)->end_sections(); +} + +void LLVMMoveToNextSection(LLVMSectionIteratorRef SI) { + // We can't use unwrap() here because the argument to ++ must be an lvalue. + ++*reinterpret_cast(SI); +} + +const char *LLVMGetSectionName(LLVMSectionIteratorRef SI) { + return (*unwrap(SI))->getName().data(); +} + +uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI) { + return (*unwrap(SI))->getSize(); +} + +const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI) { + return (*unwrap(SI))->getContents().data(); +} + diff --git a/src/rustllvm/README b/src/rustllvm/README new file mode 100644 index 00000000..31495f22 --- /dev/null +++ b/src/rustllvm/README @@ -0,0 +1,3 @@ +This directory currently contains some LLVM support code. This will generally +be sent upstream to LLVM in time; for now it lives here. + diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp new file mode 100644 index 00000000..a604e4c2 --- /dev/null +++ b/src/rustllvm/RustWrapper.cpp @@ -0,0 +1,31 @@ +//===- RustWrapper.cpp - Rust wrapper for core functions --------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines alternate interfaces to core functions that are more +// readily callable by Rust's FFI. +// +//===----------------------------------------------------------------------===// + +#include "llvm-c/Core.h" +#include "llvm-c/Object.h" +#include + +static char *LLVMRustError; + +extern "C" LLVMMemoryBufferRef +LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) { + LLVMMemoryBufferRef MemBuf = NULL; + LLVMCreateMemoryBufferWithContentsOfFile(Path, &MemBuf, &LLVMRustError); + return MemBuf; +} + +extern "C" const char *LLVMRustGetLastError(void) { + return LLVMRustError; +} + diff --git a/src/rustllvm/include/llvm-c/Object.h b/src/rustllvm/include/llvm-c/Object.h new file mode 100644 index 00000000..1103d7dd --- /dev/null +++ b/src/rustllvm/include/llvm-c/Object.h @@ -0,0 +1,77 @@ +/*===-- llvm-c/Object.h - Object Lib C Iface --------------------*- C++ -*-===*/ +/* */ +/* The LLVM Compiler Infrastructure */ +/* */ +/* This file is distributed under the University of Illinois Open Source */ +/* License. See LICENSE.TXT for details. */ +/* */ +/*===----------------------------------------------------------------------===*/ +/* */ +/* This header declares the C interface to libLLVMObject.a, which */ +/* implements object file reading and writing. */ +/* */ +/* Many exotic languages can interoperate with C code but have a harder time */ +/* with C++ due to name mangling. So in addition to C, this interface enables */ +/* tools written in such languages. */ +/* */ +/*===----------------------------------------------------------------------===*/ + +#ifndef LLVM_C_OBJECT_H +#define LLVM_C_OBJECT_H + +#include "llvm-c/Core.h" +#include "llvm/Config/llvm-config.h" + +#ifdef __cplusplus +#include "llvm/Object/ObjectFile.h" + +extern "C" { +#endif + + +typedef struct LLVMOpaqueObjectFile *LLVMObjectFileRef; + +typedef struct LLVMOpaqueSectionIterator *LLVMSectionIteratorRef; + +LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf); +void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile); + +LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile); +void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI); +bool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile, + LLVMSectionIteratorRef SI); +void LLVMMoveToNextSection(LLVMSectionIteratorRef SI); +const char *LLVMGetSectionName(LLVMSectionIteratorRef SI); +uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI); +const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI); + + +#ifdef __cplusplus +} + +namespace llvm { + namespace object { + inline ObjectFile *unwrap(LLVMObjectFileRef OF) { + return reinterpret_cast(OF); + } + + inline LLVMObjectFileRef wrap(const ObjectFile *OF) { + return reinterpret_cast(const_cast(OF)); + } + + inline ObjectFile::section_iterator *unwrap(LLVMSectionIteratorRef SI) { + return reinterpret_cast(SI); + } + + inline LLVMSectionIteratorRef + wrap(const ObjectFile::section_iterator *SI) { + return reinterpret_cast + (const_cast(SI)); + } + } +} + +#endif /* defined(__cplusplus) */ + +#endif + diff --git a/src/rustllvm/rustllvm.def b/src/rustllvm/rustllvm.def new file mode 100644 index 00000000..c1b521b5 --- /dev/null +++ b/src/rustllvm/rustllvm.def @@ -0,0 +1,473 @@ +LIBRARY RUSTLLVM +EXPORTS + LLVMRustCreateMemoryBufferWithContentsOfFile + LLVMRustGetLastError + LLVMCreateObjectFile + LLVMDisposeObjectFile + LLVMGetSections + LLVMDisposeSectionIterator + LLVMIsSectionIteratorAtEnd + LLVMMoveToNextSection + LLVMGetSectionName + LLVMGetSectionSize + LLVMGetSectionContents + LLVMABIAlignmentOfType + LLVMABISizeOfType + LLVMAddAlias + LLVMAddAttribute + LLVMAddCase + LLVMAddDestination + LLVMAddFunction + LLVMAddFunctionAttr + LLVMAddGlobal + LLVMAddGlobalInAddressSpace + LLVMAddGlobalMapping + LLVMAddIncoming + LLVMAddInstrAttribute + LLVMAddModule + LLVMAddModuleProvider + LLVMAddTargetData + LLVMAddTypeName + LLVMAlignOf + LLVMAppendBasicBlock + LLVMAppendBasicBlockInContext + LLVMArrayType + LLVMBasicBlockAsValue + LLVMBlockAddress + LLVMBuildAShr + LLVMBuildAdd + LLVMBuildAggregateRet + LLVMBuildAlloca + LLVMBuildAnd + LLVMBuildArrayAlloca + LLVMBuildArrayMalloc + LLVMBuildBinOp + LLVMBuildBitCast + LLVMBuildBr + LLVMBuildCall + LLVMBuildCast + LLVMBuildCondBr + LLVMBuildExactSDiv + LLVMBuildExtractElement + LLVMBuildExtractValue + LLVMBuildFAdd + LLVMBuildFCmp + LLVMBuildFDiv + LLVMBuildFMul + LLVMBuildFNeg + LLVMBuildFPCast + LLVMBuildFPExt + LLVMBuildFPToSI + LLVMBuildFPToUI + LLVMBuildFPTrunc + LLVMBuildFRem + LLVMBuildFSub + LLVMBuildFree + LLVMBuildGEP + LLVMBuildGlobalString + LLVMBuildGlobalStringPtr + LLVMBuildICmp + LLVMBuildInBoundsGEP + LLVMBuildIndirectBr + LLVMBuildInsertElement + LLVMBuildInsertValue + LLVMBuildIntCast + LLVMBuildIntToPtr + LLVMBuildInvoke + LLVMBuildIsNotNull + LLVMBuildIsNull + LLVMBuildLShr + LLVMBuildLoad + LLVMBuildMalloc + LLVMBuildMul + LLVMBuildNSWAdd + LLVMBuildNSWMul + LLVMBuildNSWNeg + LLVMBuildNSWSub + LLVMBuildNUWAdd + LLVMBuildNUWMul + LLVMBuildNUWNeg + LLVMBuildNUWSub + LLVMBuildNeg + LLVMBuildNot + LLVMBuildOr + LLVMBuildPhi + LLVMBuildPointerCast + LLVMBuildPtrDiff + LLVMBuildPtrToInt + LLVMBuildRet + LLVMBuildRetVoid + LLVMBuildSDiv + LLVMBuildSExt + LLVMBuildSExtOrBitCast + LLVMBuildSIToFP + LLVMBuildSRem + LLVMBuildSelect + LLVMBuildShl + LLVMBuildShuffleVector + LLVMBuildStore + LLVMBuildStructGEP + LLVMBuildSub + LLVMBuildSwitch + LLVMBuildTrunc + LLVMBuildTruncOrBitCast + LLVMBuildUDiv + LLVMBuildUIToFP + LLVMBuildURem + LLVMBuildUnreachable + LLVMBuildUnwind + LLVMBuildVAArg + LLVMBuildXor + LLVMBuildZExt + LLVMBuildZExtOrBitCast + LLVMByteOrder + LLVMCallFrameAlignmentOfType + LLVMClearInsertionPosition + LLVMConstAShr + LLVMConstAdd + LLVMConstAllOnes + LLVMConstAnd + LLVMConstArray + LLVMConstBitCast + LLVMConstExactSDiv + LLVMConstExtractElement + LLVMConstExtractValue + LLVMConstFAdd + LLVMConstFCmp + LLVMConstFDiv + LLVMConstFMul + LLVMConstFNeg + LLVMConstFPCast + LLVMConstFPExt + LLVMConstFPToSI + LLVMConstFPToUI + LLVMConstFPTrunc + LLVMConstFRem + LLVMConstFSub + LLVMConstGEP + LLVMConstICmp + LLVMConstInBoundsGEP + LLVMConstInlineAsm + LLVMConstInsertElement + LLVMConstInsertValue + LLVMConstInt + LLVMConstIntCast + LLVMConstIntGetSExtValue + LLVMConstIntGetZExtValue + LLVMConstIntOfArbitraryPrecision + LLVMConstIntOfString + LLVMConstIntOfStringAndSize + LLVMConstIntToPtr + LLVMConstLShr + LLVMConstMul + LLVMConstNSWAdd + LLVMConstNSWMul + LLVMConstNSWNeg + LLVMConstNSWSub + LLVMConstNUWAdd + LLVMConstNUWMul + LLVMConstNUWNeg + LLVMConstNUWSub + LLVMConstNeg + LLVMConstNot + LLVMConstNull + LLVMConstOr + LLVMConstPointerCast + LLVMConstPointerNull + LLVMConstPtrToInt + LLVMConstReal + LLVMConstRealOfString + LLVMConstRealOfStringAndSize + LLVMConstSDiv + LLVMConstSExt + LLVMConstSExtOrBitCast + LLVMConstSIToFP + LLVMConstSRem + LLVMConstSelect + LLVMConstShl + LLVMConstShuffleVector + LLVMConstString + LLVMConstStringInContext + LLVMConstStruct + LLVMConstStructInContext + LLVMConstSub + LLVMConstTrunc + LLVMConstTruncOrBitCast + LLVMConstUDiv + LLVMConstUIToFP + LLVMConstURem + LLVMConstVector + LLVMConstXor + LLVMConstZExt + LLVMConstZExtOrBitCast + LLVMContextCreate + LLVMContextDispose + LLVMCopyStringRepOfTargetData + LLVMCountBasicBlocks + LLVMCountIncoming + LLVMCountParamTypes + LLVMCountParams + LLVMCountStructElementTypes + LLVMCreateBuilder + LLVMCreateBuilderInContext + LLVMCreateExecutionEngine + LLVMCreateExecutionEngineForModule + LLVMCreateFunctionPassManager + LLVMCreateFunctionPassManagerForModule + LLVMCreateGenericValueOfFloat + LLVMCreateGenericValueOfInt + LLVMCreateGenericValueOfPointer + LLVMCreateInterpreter + LLVMCreateInterpreterForModule + LLVMCreateJITCompiler + LLVMCreateJITCompilerForModule + LLVMCreateMemoryBufferWithContentsOfFile + LLVMCreateMemoryBufferWithSTDIN + LLVMCreateModuleProviderForExistingModule + LLVMCreateObjectFile + LLVMCreatePassManager + LLVMCreateTargetData + LLVMCreateTypeHandle + LLVMDeleteBasicBlock + LLVMDeleteFunction + LLVMDeleteGlobal + LLVMDeleteTypeName + LLVMDisposeBuilder + LLVMDisposeExecutionEngine + LLVMDisposeGenericValue + LLVMDisposeMemoryBuffer + LLVMDisposeMessage + LLVMDisposeModule + LLVMDisposeModuleProvider + LLVMDisposeObjectFile + LLVMDisposePassManager + LLVMDisposeSectionIterator + LLVMDisposeTargetData + LLVMDisposeTypeHandle + LLVMDoubleType + LLVMDoubleTypeInContext + LLVMDumpModule + LLVMDumpValue + LLVMElementAtOffset + LLVMFP128Type + LLVMFP128TypeInContext + LLVMFinalizeFunctionPassManager + LLVMFindFunction + LLVMFloatType + LLVMFloatTypeInContext + LLVMFreeMachineCodeForFunction + LLVMFunctionType + LLVMGenericValueIntWidth + LLVMGenericValueToFloat + LLVMGenericValueToInt + LLVMGenericValueToPointer + LLVMGetAlignment + LLVMGetArrayLength + LLVMGetAttribute + LLVMGetBasicBlockParent + LLVMGetBasicBlocks + LLVMGetBitcodeModule + LLVMGetBitcodeModuleInContext + LLVMGetBitcodeModuleProvider + LLVMGetBitcodeModuleProviderInContext + LLVMGetConstOpcode + LLVMGetCurrentDebugLocation + LLVMGetDataLayout + LLVMGetElementType + LLVMGetEntryBasicBlock + LLVMGetExecutionEngineTargetData + LLVMGetFirstBasicBlock + LLVMGetFirstFunction + LLVMGetFirstGlobal + LLVMGetFirstInstruction + LLVMGetFirstParam + LLVMGetFirstUse + LLVMGetFunctionAttr + LLVMGetFunctionCallConv + LLVMGetGC + LLVMGetGlobalContext + LLVMGetGlobalParent + LLVMGetGlobalPassRegistry + LLVMGetIncomingBlock + LLVMGetIncomingValue + LLVMGetInitializer + LLVMGetInsertBlock + LLVMGetInstructionCallConv + LLVMGetInstructionParent + LLVMGetIntTypeWidth + LLVMGetIntrinsicID + LLVMGetLastBasicBlock + LLVMGetLastFunction + LLVMGetLastGlobal + LLVMGetLastInstruction + LLVMGetLastParam + LLVMGetLinkage + LLVMGetMDKindID + LLVMGetMDKindIDInContext + LLVMGetMetadata + LLVMGetModuleContext + LLVMGetNamedFunction + LLVMGetNamedGlobal + LLVMGetNextBasicBlock + LLVMGetNextFunction + LLVMGetNextGlobal + LLVMGetNextInstruction + LLVMGetNextParam + LLVMGetNextUse + LLVMGetNumOperands + LLVMGetOperand + LLVMGetParam + LLVMGetParamParent + LLVMGetParamTypes + LLVMGetParams + LLVMGetPointerAddressSpace + LLVMGetPointerToGlobal + LLVMGetPreviousBasicBlock + LLVMGetPreviousFunction + LLVMGetPreviousGlobal + LLVMGetPreviousInstruction + LLVMGetPreviousParam + LLVMGetReturnType + LLVMGetSection + LLVMGetSectionContents + LLVMGetSectionName + LLVMGetSectionSize + LLVMGetSections + LLVMGetStructElementTypes + LLVMGetTarget + LLVMGetTypeByName + LLVMGetTypeContext + LLVMGetTypeKind + LLVMGetTypeName + LLVMGetUndef + LLVMGetUsedValue + LLVMGetUser + LLVMGetValueName + LLVMGetVectorSize + LLVMGetVisibility + LLVMHasMetadata + LLVMInitializeAnalysis + LLVMInitializeCodeGen + LLVMInitializeCore + LLVMInitializeFunctionPassManager + LLVMInitializeIPA + LLVMInitializeIPO + LLVMInitializeInstCombine + LLVMInitializeInstrumentation + LLVMInitializeScalarOpts + LLVMInitializeTarget + LLVMInitializeTransformUtils + LLVMInsertBasicBlock + LLVMInsertBasicBlockInContext + LLVMInsertIntoBuilder + LLVMInsertIntoBuilderWithName + LLVMInt16Type + LLVMInt16TypeInContext + LLVMInt1Type + LLVMInt1TypeInContext + LLVMInt32Type + LLVMInt32TypeInContext + LLVMInt64Type + LLVMInt64TypeInContext + LLVMInt8Type + LLVMInt8TypeInContext + LLVMIntPtrType + LLVMIntType + LLVMIntTypeInContext + LLVMInvalidateStructLayout + LLVMIsConstant + LLVMIsDeclaration + LLVMIsFunctionVarArg + LLVMIsGlobalConstant + LLVMIsNull + LLVMIsPackedStruct + LLVMIsSectionIteratorAtEnd + LLVMIsTailCall + LLVMIsThreadLocal + LLVMIsUndef + LLVMLabelType + LLVMLabelTypeInContext + LLVMLinkInInterpreter + LLVMLinkInJIT + LLVMMDNode + LLVMMDNodeInContext + LLVMMDString + LLVMMDStringInContext + LLVMModuleCreateWithName + LLVMModuleCreateWithNameInContext + LLVMMoveBasicBlockAfter + LLVMMoveBasicBlockBefore + LLVMMoveToNextSection + LLVMOffsetOfElement + LLVMOpaqueType + LLVMOpaqueTypeInContext + LLVMPPCFP128Type + LLVMPPCFP128TypeInContext + LLVMParseBitcode + LLVMParseBitcodeInContext + LLVMPointerSize + LLVMPointerType + LLVMPositionBuilder + LLVMPositionBuilderAtEnd + LLVMPositionBuilderBefore + LLVMPreferredAlignmentOfGlobal + LLVMPreferredAlignmentOfType + LLVMRecompileAndRelinkFunction + LLVMRefineType + LLVMRemoveAttribute + LLVMRemoveFunctionAttr + LLVMRemoveInstrAttribute + LLVMRemoveModule + LLVMRemoveModuleProvider + LLVMReplaceAllUsesWith + LLVMResolveTypeHandle + LLVMRunFunction + LLVMRunFunctionAsMain + LLVMRunFunctionPassManager + LLVMRunPassManager + LLVMRunStaticConstructors + LLVMRunStaticDestructors + LLVMSetAlignment + LLVMSetCurrentDebugLocation + LLVMSetDataLayout + LLVMSetFunctionCallConv + LLVMSetGC + LLVMSetGlobalConstant + LLVMSetInitializer + LLVMSetInstDebugLocation + LLVMSetInstrParamAlignment + LLVMSetInstructionCallConv + LLVMSetLinkage + LLVMSetMetadata + LLVMSetModuleInlineAsm + LLVMSetOperand + LLVMSetParamAlignment + LLVMSetSection + LLVMSetTailCall + LLVMSetTarget + LLVMSetThreadLocal + LLVMSetValueName + LLVMSetVisibility + LLVMSizeOf + LLVMSizeOfTypeInBits + LLVMStoreSizeOfType + LLVMStructType + LLVMStructTypeInContext + LLVMTypeOf + LLVMValueAsBasicBlock + LLVMValueIsBasicBlock + LLVMVectorType + LLVMVerifyFunction + LLVMVerifyModule + LLVMViewFunctionCFG + LLVMViewFunctionCFGOnly + LLVMVoidType + LLVMVoidTypeInContext + LLVMWriteBitcodeToFD + LLVMWriteBitcodeToFile + LLVMWriteBitcodeToFileHandle + LLVMX86FP80Type + LLVMX86FP80TypeInContext + LLVMX86MMXType + LLVMX86MMXTypeInContext + -- cgit v1.2.3