Repair some fallout from pcwalton's last few build changes.

6 files changed, 973 insertions, 0 deletions

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 <cctype>
+#include <cstring>
+#include <limits>
+
+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<uint32_t>::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<macho::SymbolTableEntry> &Res) const;
+  void moveToNextSymbol(DataRefImpl &DRI) const;
+  void getSection(DataRefImpl DRI, InMemoryStruct<macho::Section> &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<macho::SymtabLoadCommand> 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<macho::SymbolTableEntry> &Res) const {
+  InMemoryStruct<macho::SymtabLoadCommand> 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<macho::SymbolTableEntry> Entry;
+  getSymbolTableEntry(DRI, Entry);
+  return MachOObj->getStringAtIndex(Entry->StringIndex);
+}
+
+uint64_t MachOObjectFile::getSymbolAddress(DataRefImpl DRI) const {
+  InMemoryStruct<macho::SymbolTableEntry> Entry;
+  getSymbolTableEntry(DRI, Entry);
+  return Entry->Value;
+}
+
+uint64_t MachOObjectFile::getSymbolSize(DataRefImpl DRI) const {
+  return UnknownAddressOrSize;
+}
+
+char MachOObjectFile::getSymbolNMTypeChar(DataRefImpl DRI) const {
+  InMemoryStruct<macho::SymbolTableEntry> 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<macho::SymbolTableEntry> 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<macho::SegmentLoadCommand> SegmentLoadCmd;
+      MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
+      if (DRI.d.b < SegmentLoadCmd->NumSections)
+        return;
+    } else if (LCI.Command.Type == macho::LCT_Segment64) {
+      InMemoryStruct<macho::Segment64LoadCommand> 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<macho::Section> &Res) const {
+  InMemoryStruct<macho::SegmentLoadCommand> 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<macho::SegmentLoadCommand> SLC;
+  LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
+  MachOObj->ReadSegmentLoadCommand(LCI, SLC);
+  InMemoryStruct<macho::Section> 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<macho::Section> Sect;
+  getSection(DRI, Sect);
+  return Sect->Address;
+}
+
+uint64_t MachOObjectFile::getSectionSize(DataRefImpl DRI) const {
+  InMemoryStruct<macho::Section> Sect;
+  getSection(DRI, Sect);
+  return Sect->Size;
+}
+
+StringRef MachOObjectFile::getSectionContents(DataRefImpl DRI) const {
+  InMemoryStruct<macho::Section> Sect;
+  getSection(DRI, Sect);
+  return MachOObj->getData(Sect->Offset, Sect->Size);
+}
+
+bool MachOObjectFile::isSectionText(DataRefImpl DRI) const {
+  InMemoryStruct<macho::SegmentLoadCommand> 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<ObjectFile::section_iterator*>(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 <cstdlib>
+
+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<ObjectFile*>(OF);
+    }
+
+    inline LLVMObjectFileRef wrap(const ObjectFile *OF) {
+      return reinterpret_cast<LLVMObjectFileRef>(const_cast<ObjectFile*>(OF));
+    }
+
+    inline ObjectFile::section_iterator *unwrap(LLVMSectionIteratorRef SI) {
+      return reinterpret_cast<ObjectFile::section_iterator*>(SI);
+    }
+
+    inline LLVMSectionIteratorRef
+    wrap(const ObjectFile::section_iterator *SI) {
+      return reinterpret_cast<LLVMSectionIteratorRef>
+        (const_cast<ObjectFile::section_iterator*>(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
+