From 6ed6a91a6434a944010d8f2c6752e70a372b5296 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 1 Feb 2020 22:50:57 +0000
Subject: [PATCH] Begin LLVM C API integration

---
 bin/llvm/windows/LLVM-C.lib                   |  Bin 0 -> 274018 bytes
 build.bat                                     |    7 +-
 examples/llvm-demo/demo.odin                  |   11 +
 src/build_settings.cpp                        |    2 +
 src/llvm-c/Analysis.h                         |   65 +
 src/llvm-c/BitReader.h                        |   85 +
 src/llvm-c/BitWriter.h                        |   59 +
 src/llvm-c/Comdat.h                           |   75 +
 src/llvm-c/Config/AsmParsers.def              |   44 +
 src/llvm-c/Config/AsmPrinters.def             |   46 +
 src/llvm-c/Config/Disassemblers.def           |   45 +
 src/llvm-c/Config/Targets.def                 |   45 +
 src/llvm-c/Config/abi-breaking.h              |   62 +
 src/llvm-c/Config/llvm-config.h               |   85 +
 src/llvm-c/Core.h                             | 4079 +++++++++++++++++
 src/llvm-c/DataTypes.h                        |   90 +
 src/llvm-c/DebugInfo.h                        | 1315 ++++++
 src/llvm-c/Disassembler.h                     |  113 +
 src/llvm-c/DisassemblerTypes.h                |  160 +
 src/llvm-c/Error.h                            |   69 +
 src/llvm-c/ErrorHandling.h                    |   49 +
 src/llvm-c/ExecutionEngine.h                  |  200 +
 src/llvm-c/IRReader.h                         |   40 +
 src/llvm-c/Initialization.h                   |   56 +
 src/llvm-c/LinkTimeOptimizer.h                |   68 +
 src/llvm-c/Linker.h                           |   41 +
 src/llvm-c/Object.h                           |  233 +
 src/llvm-c/OrcBindings.h                      |  172 +
 src/llvm-c/Remarks.h                          |  329 ++
 src/llvm-c/Support.h                          |   65 +
 src/llvm-c/Target.h                           |  295 ++
 src/llvm-c/TargetMachine.h                    |  163 +
 src/llvm-c/Transforms/AggressiveInstCombine.h |   43 +
 src/llvm-c/Transforms/Coroutines.h            |   55 +
 src/llvm-c/Transforms/IPO.h                   |   84 +
 src/llvm-c/Transforms/InstCombine.h           |   43 +
 src/llvm-c/Transforms/PassManagerBuilder.h    |   90 +
 src/llvm-c/Transforms/Scalar.h                |  167 +
 src/llvm-c/Transforms/Utils.h                 |   53 +
 src/llvm-c/Transforms/Vectorize.h             |   50 +
 src/llvm-c/Types.h                            |  179 +
 src/llvm-c/lto.h                              |  899 ++++
 src/llvm_backend.cpp                          |  831 ++++
 src/main.cpp                                  |   20 +
 src/types.cpp                                 |    3 +
 45 files changed, 10683 insertions(+), 2 deletions(-)
 create mode 100644 bin/llvm/windows/LLVM-C.lib
 create mode 100644 examples/llvm-demo/demo.odin
 create mode 100644 src/llvm-c/Analysis.h
 create mode 100644 src/llvm-c/BitReader.h
 create mode 100644 src/llvm-c/BitWriter.h
 create mode 100644 src/llvm-c/Comdat.h
 create mode 100644 src/llvm-c/Config/AsmParsers.def
 create mode 100644 src/llvm-c/Config/AsmPrinters.def
 create mode 100644 src/llvm-c/Config/Disassemblers.def
 create mode 100644 src/llvm-c/Config/Targets.def
 create mode 100644 src/llvm-c/Config/abi-breaking.h
 create mode 100644 src/llvm-c/Config/llvm-config.h
 create mode 100644 src/llvm-c/Core.h
 create mode 100644 src/llvm-c/DataTypes.h
 create mode 100644 src/llvm-c/DebugInfo.h
 create mode 100644 src/llvm-c/Disassembler.h
 create mode 100644 src/llvm-c/DisassemblerTypes.h
 create mode 100644 src/llvm-c/Error.h
 create mode 100644 src/llvm-c/ErrorHandling.h
 create mode 100644 src/llvm-c/ExecutionEngine.h
 create mode 100644 src/llvm-c/IRReader.h
 create mode 100644 src/llvm-c/Initialization.h
 create mode 100644 src/llvm-c/LinkTimeOptimizer.h
 create mode 100644 src/llvm-c/Linker.h
 create mode 100644 src/llvm-c/Object.h
 create mode 100644 src/llvm-c/OrcBindings.h
 create mode 100644 src/llvm-c/Remarks.h
 create mode 100644 src/llvm-c/Support.h
 create mode 100644 src/llvm-c/Target.h
 create mode 100644 src/llvm-c/TargetMachine.h
 create mode 100644 src/llvm-c/Transforms/AggressiveInstCombine.h
 create mode 100644 src/llvm-c/Transforms/Coroutines.h
 create mode 100644 src/llvm-c/Transforms/IPO.h
 create mode 100644 src/llvm-c/Transforms/InstCombine.h
 create mode 100644 src/llvm-c/Transforms/PassManagerBuilder.h
 create mode 100644 src/llvm-c/Transforms/Scalar.h
 create mode 100644 src/llvm-c/Transforms/Utils.h
 create mode 100644 src/llvm-c/Transforms/Vectorize.h
 create mode 100644 src/llvm-c/Types.h
 create mode 100644 src/llvm-c/lto.h
 create mode 100644 src/llvm_backend.cpp

diff --git a/bin/llvm/windows/LLVM-C.lib b/bin/llvm/windows/LLVM-C.lib
new file mode 100644
index 0000000000000000000000000000000000000000..2353c6a39e4b0149ce2c9166eb52ed706efb0ac0
GIT binary patch
literal 274018
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

literal 0
HcmV?d00001

diff --git a/build.bat b/build.bat
index 013a199a7..58799c454 100644
--- a/build.bat
+++ b/build.bat
@@ -30,7 +30,8 @@ set compiler_warnings= ^
 
 set compiler_includes=
 set libs= ^
-	kernel32.lib
+	kernel32.lib ^
+	bin\llvm\windows\LLVM-C.lib
 
 set linker_flags= -incremental:no -opt:ref -subsystem:console
 
@@ -48,7 +49,9 @@ del *.ilk > NUL 2> NUL
 
 cl %compiler_settings% "src\main.cpp" ^
 	/link %linker_settings% -OUT:%exe_name% ^
-	&& odin run examples/demo/demo.odin
+	&& odin build examples/llvm-demo/demo.odin -llvm-api
+
+	rem && link -nologo llvm_demo.obj kernel32.lib -OUT:llvm_demo.exe
 
 del *.obj > NUL 2> NUL
 
diff --git a/examples/llvm-demo/demo.odin b/examples/llvm-demo/demo.odin
new file mode 100644
index 000000000..481970ab5
--- /dev/null
+++ b/examples/llvm-demo/demo.odin
@@ -0,0 +1,11 @@
+package demo
+
+import "core:os"
+
+main :: proc() {
+	x := 1;
+	y := 2;
+	z := x + y;
+	w := z - 2;
+	// os.write_string(os.stdout, "Hellope\n");
+}
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 5a1ec0f30..f34f21dc6 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -127,6 +127,8 @@ struct BuildContext {
 	bool   vet;
 	bool   cross_compiling;
 
+	bool   use_llvm_api;
+
 	QueryDataSetSettings query_data_set_settings;
 
 	gbAffinity affinity;
diff --git a/src/llvm-c/Analysis.h b/src/llvm-c/Analysis.h
new file mode 100644
index 000000000..cb9e8ece3
--- /dev/null
+++ b/src/llvm-c/Analysis.h
@@ -0,0 +1,65 @@
+/*===-- llvm-c/Analysis.h - Analysis Library C Interface --------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMAnalysis.a, which           *|
+|* implements various analyses of the LLVM IR.                                *|
+|*                                                                            *|
+|* 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_ANALYSIS_H
+#define LLVM_C_ANALYSIS_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCAnalysis Analysis
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+typedef enum {
+  LLVMAbortProcessAction, /* verifier will print to stderr and abort() */
+  LLVMPrintMessageAction, /* verifier will print to stderr and return 1 */
+  LLVMReturnStatusAction  /* verifier will just return 1 */
+} LLVMVerifierFailureAction;
+
+
+/* Verifies that a module is valid, taking the specified action if not.
+   Optionally returns a human-readable description of any invalid constructs.
+   OutMessage must be disposed with LLVMDisposeMessage. */
+LLVMBool LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action,
+                          char **OutMessage);
+
+/* Verifies that a single function is valid, taking the specified action. Useful
+   for debugging. */
+LLVMBool LLVMVerifyFunction(LLVMValueRef Fn, LLVMVerifierFailureAction Action);
+
+/* Open up a ghostview window that displays the CFG of the current function.
+   Useful for debugging. */
+void LLVMViewFunctionCFG(LLVMValueRef Fn);
+void LLVMViewFunctionCFGOnly(LLVMValueRef Fn);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/BitReader.h b/src/llvm-c/BitReader.h
new file mode 100644
index 000000000..b307ee979
--- /dev/null
+++ b/src/llvm-c/BitReader.h
@@ -0,0 +1,85 @@
+/*===-- llvm-c/BitReader.h - BitReader Library C Interface ------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMBitReader.a, which          *|
+|* implements input of the LLVM bitcode format.                               *|
+|*                                                                            *|
+|* 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_BITREADER_H
+#define LLVM_C_BITREADER_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCBitReader Bit Reader
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+/* Builds a module from the bitcode in the specified memory buffer, returning a
+   reference to the module via the OutModule parameter. Returns 0 on success.
+   Optionally returns a human-readable error message via OutMessage.
+
+   This is deprecated. Use LLVMParseBitcode2. */
+LLVMBool LLVMParseBitcode(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutModule,
+                          char **OutMessage);
+
+/* Builds a module from the bitcode in the specified memory buffer, returning a
+   reference to the module via the OutModule parameter. Returns 0 on success. */
+LLVMBool LLVMParseBitcode2(LLVMMemoryBufferRef MemBuf,
+                           LLVMModuleRef *OutModule);
+
+/* This is deprecated. Use LLVMParseBitcodeInContext2. */
+LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef,
+                                   LLVMMemoryBufferRef MemBuf,
+                                   LLVMModuleRef *OutModule, char **OutMessage);
+
+LLVMBool LLVMParseBitcodeInContext2(LLVMContextRef ContextRef,
+                                    LLVMMemoryBufferRef MemBuf,
+                                    LLVMModuleRef *OutModule);
+
+/** Reads a module from the specified path, returning via the OutMP parameter
+    a module provider which performs lazy deserialization. Returns 0 on success.
+    Optionally returns a human-readable error message via OutMessage.
+    This is deprecated. Use LLVMGetBitcodeModuleInContext2. */
+LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef,
+                                       LLVMMemoryBufferRef MemBuf,
+                                       LLVMModuleRef *OutM, char **OutMessage);
+
+/** Reads a module from the specified path, returning via the OutMP parameter a
+ * module provider which performs lazy deserialization. Returns 0 on success. */
+LLVMBool LLVMGetBitcodeModuleInContext2(LLVMContextRef ContextRef,
+                                        LLVMMemoryBufferRef MemBuf,
+                                        LLVMModuleRef *OutM);
+
+/* This is deprecated. Use LLVMGetBitcodeModule2. */
+LLVMBool LLVMGetBitcodeModule(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
+                              char **OutMessage);
+
+LLVMBool LLVMGetBitcodeModule2(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/BitWriter.h b/src/llvm-c/BitWriter.h
new file mode 100644
index 000000000..187051555
--- /dev/null
+++ b/src/llvm-c/BitWriter.h
@@ -0,0 +1,59 @@
+/*===-- llvm-c/BitWriter.h - BitWriter Library C Interface ------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMBitWriter.a, which          *|
+|* implements output of the LLVM bitcode format.                              *|
+|*                                                                            *|
+|* 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_BITWRITER_H
+#define LLVM_C_BITWRITER_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCBitWriter Bit Writer
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+/*===-- Operations on modules ---------------------------------------------===*/
+
+/** Writes a module to the specified path. Returns 0 on success. */
+int LLVMWriteBitcodeToFile(LLVMModuleRef M, const char *Path);
+
+/** Writes a module to an open file descriptor. Returns 0 on success. */
+int LLVMWriteBitcodeToFD(LLVMModuleRef M, int FD, int ShouldClose,
+                         int Unbuffered);
+
+/** Deprecated for LLVMWriteBitcodeToFD. Writes a module to an open file
+    descriptor. Returns 0 on success. Closes the Handle. */
+int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int Handle);
+
+/** Writes a module to a new memory buffer and returns it. */
+LLVMMemoryBufferRef LLVMWriteBitcodeToMemoryBuffer(LLVMModuleRef M);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Comdat.h b/src/llvm-c/Comdat.h
new file mode 100644
index 000000000..81fee3fc9
--- /dev/null
+++ b/src/llvm-c/Comdat.h
@@ -0,0 +1,75 @@
+/*===-- llvm-c/Comdat.h - Module Comdat C Interface -------------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to COMDAT.                               *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_COMDAT_H
+#define LLVM_C_COMDAT_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  LLVMAnyComdatSelectionKind,        ///< The linker may choose any COMDAT.
+  LLVMExactMatchComdatSelectionKind, ///< The data referenced by the COMDAT must
+                                     ///< be the same.
+  LLVMLargestComdatSelectionKind,    ///< The linker will choose the largest
+                                     ///< COMDAT.
+  LLVMNoDuplicatesComdatSelectionKind, ///< No other Module may specify this
+                                       ///< COMDAT.
+  LLVMSameSizeComdatSelectionKind ///< The data referenced by the COMDAT must be
+                                  ///< the same size.
+} LLVMComdatSelectionKind;
+
+/**
+ * Return the Comdat in the module with the specified name. It is created
+ * if it didn't already exist.
+ *
+ * @see llvm::Module::getOrInsertComdat()
+ */
+LLVMComdatRef LLVMGetOrInsertComdat(LLVMModuleRef M, const char *Name);
+
+/**
+ * Get the Comdat assigned to the given global object.
+ *
+ * @see llvm::GlobalObject::getComdat()
+ */
+LLVMComdatRef LLVMGetComdat(LLVMValueRef V);
+
+/**
+ * Assign the Comdat to the given global object.
+ *
+ * @see llvm::GlobalObject::setComdat()
+ */
+void LLVMSetComdat(LLVMValueRef V, LLVMComdatRef C);
+
+/*
+ * Get the conflict resolution selection kind for the Comdat.
+ *
+ * @see llvm::Comdat::getSelectionKind()
+ */
+LLVMComdatSelectionKind LLVMGetComdatSelectionKind(LLVMComdatRef C);
+
+/*
+ * Set the conflict resolution selection kind for the Comdat.
+ *
+ * @see llvm::Comdat::setSelectionKind()
+ */
+void LLVMSetComdatSelectionKind(LLVMComdatRef C, LLVMComdatSelectionKind Kind);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Config/AsmParsers.def b/src/llvm-c/Config/AsmParsers.def
new file mode 100644
index 000000000..7aaab6e50
--- /dev/null
+++ b/src/llvm-c/Config/AsmParsers.def
@@ -0,0 +1,44 @@
+/*===- llvm/Config/AsmParsers.def - LLVM Assembly Parsers -------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file enumerates all of the assembly-language parsers                  *|
+|* supported by this build of LLVM. Clients of this file should define        *|
+|* the LLVM_ASM_PARSER macro to be a function-like macro with a               *|
+|* single parameter (the name of the target whose assembly can be             *|
+|* generated); including this file will then enumerate all of the             *|
+|* targets with assembly parsers.                                             *|
+|*                                                                            *|
+|* The set of targets supported by LLVM is generated at configuration         *|
+|* time, at which point this header is generated. Do not modify this          *|
+|* header directly.                                                           *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_ASM_PARSER
+#  error Please define the macro LLVM_ASM_PARSER(TargetName)
+#endif
+
+LLVM_ASM_PARSER(AArch64)
+LLVM_ASM_PARSER(AMDGPU)
+LLVM_ASM_PARSER(ARM)
+LLVM_ASM_PARSER(BPF)
+LLVM_ASM_PARSER(Hexagon)
+LLVM_ASM_PARSER(Lanai)
+LLVM_ASM_PARSER(Mips)
+LLVM_ASM_PARSER(MSP430)
+LLVM_ASM_PARSER(PowerPC)
+LLVM_ASM_PARSER(RISCV)
+LLVM_ASM_PARSER(Sparc)
+LLVM_ASM_PARSER(SystemZ)
+LLVM_ASM_PARSER(WebAssembly)
+LLVM_ASM_PARSER(X86)
+LLVM_ASM_PARSER(AVR)
+
+
+#undef LLVM_ASM_PARSER
diff --git a/src/llvm-c/Config/AsmPrinters.def b/src/llvm-c/Config/AsmPrinters.def
new file mode 100644
index 000000000..3ecc3644f
--- /dev/null
+++ b/src/llvm-c/Config/AsmPrinters.def
@@ -0,0 +1,46 @@
+/*===- llvm/Config/AsmPrinters.def - LLVM Assembly Printers -----*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file enumerates all of the assembly-language printers                 *|
+|* supported by this build of LLVM. Clients of this file should define        *|
+|* the LLVM_ASM_PRINTER macro to be a function-like macro with a              *|
+|* single parameter (the name of the target whose assembly can be             *|
+|* generated); including this file will then enumerate all of the             *|
+|* targets with assembly printers.                                            *|
+|*                                                                            *|
+|* The set of targets supported by LLVM is generated at configuration         *|
+|* time, at which point this header is generated. Do not modify this          *|
+|* header directly.                                                           *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_ASM_PRINTER
+#  error Please define the macro LLVM_ASM_PRINTER(TargetName)
+#endif
+
+LLVM_ASM_PRINTER(AArch64)
+LLVM_ASM_PRINTER(AMDGPU)
+LLVM_ASM_PRINTER(ARM)
+LLVM_ASM_PRINTER(BPF)
+LLVM_ASM_PRINTER(Hexagon)
+LLVM_ASM_PRINTER(Lanai)
+LLVM_ASM_PRINTER(Mips)
+LLVM_ASM_PRINTER(MSP430)
+LLVM_ASM_PRINTER(NVPTX)
+LLVM_ASM_PRINTER(PowerPC)
+LLVM_ASM_PRINTER(RISCV)
+LLVM_ASM_PRINTER(Sparc)
+LLVM_ASM_PRINTER(SystemZ)
+LLVM_ASM_PRINTER(WebAssembly)
+LLVM_ASM_PRINTER(X86)
+LLVM_ASM_PRINTER(XCore)
+LLVM_ASM_PRINTER(AVR)
+
+
+#undef LLVM_ASM_PRINTER
diff --git a/src/llvm-c/Config/Disassemblers.def b/src/llvm-c/Config/Disassemblers.def
new file mode 100644
index 000000000..4485af241
--- /dev/null
+++ b/src/llvm-c/Config/Disassemblers.def
@@ -0,0 +1,45 @@
+/*===- llvm/Config/Disassemblers.def - LLVM Assembly Parsers ----*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file enumerates all of the assembly-language parsers                  *|
+|* supported by this build of LLVM. Clients of this file should define        *|
+|* the LLVM_DISASSEMBLER macro to be a function-like macro with a             *|
+|* single parameter (the name of the target whose assembly can be             *|
+|* generated); including this file will then enumerate all of the             *|
+|* targets with assembly parsers.                                             *|
+|*                                                                            *|
+|* The set of targets supported by LLVM is generated at configuration         *|
+|* time, at which point this header is generated. Do not modify this          *|
+|* header directly.                                                           *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_DISASSEMBLER
+#  error Please define the macro LLVM_DISASSEMBLER(TargetName)
+#endif
+
+LLVM_DISASSEMBLER(AArch64)
+LLVM_DISASSEMBLER(AMDGPU)
+LLVM_DISASSEMBLER(ARM)
+LLVM_DISASSEMBLER(BPF)
+LLVM_DISASSEMBLER(Hexagon)
+LLVM_DISASSEMBLER(Lanai)
+LLVM_DISASSEMBLER(Mips)
+LLVM_DISASSEMBLER(MSP430)
+LLVM_DISASSEMBLER(PowerPC)
+LLVM_DISASSEMBLER(RISCV)
+LLVM_DISASSEMBLER(Sparc)
+LLVM_DISASSEMBLER(SystemZ)
+LLVM_DISASSEMBLER(WebAssembly)
+LLVM_DISASSEMBLER(X86)
+LLVM_DISASSEMBLER(XCore)
+LLVM_DISASSEMBLER(AVR)
+
+
+#undef LLVM_DISASSEMBLER
diff --git a/src/llvm-c/Config/Targets.def b/src/llvm-c/Config/Targets.def
new file mode 100644
index 000000000..4962add96
--- /dev/null
+++ b/src/llvm-c/Config/Targets.def
@@ -0,0 +1,45 @@
+/*===- llvm/Config/Targets.def - LLVM Target Architectures ------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file enumerates all of the target architectures supported by          *|
+|* this build of LLVM. Clients of this file should define the                 *|
+|* LLVM_TARGET macro to be a function-like macro with a single                *|
+|* parameter (the name of the target); including this file will then          *|
+|* enumerate all of the targets.                                              *|
+|*                                                                            *|
+|* The set of targets supported by LLVM is generated at configuration         *|
+|* time, at which point this header is generated. Do not modify this          *|
+|* header directly.                                                           *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_TARGET
+#  error Please define the macro LLVM_TARGET(TargetName)
+#endif
+
+LLVM_TARGET(AArch64)
+LLVM_TARGET(AMDGPU)
+LLVM_TARGET(ARM)
+LLVM_TARGET(BPF)
+LLVM_TARGET(Hexagon)
+LLVM_TARGET(Lanai)
+LLVM_TARGET(Mips)
+LLVM_TARGET(MSP430)
+LLVM_TARGET(NVPTX)
+LLVM_TARGET(PowerPC)
+LLVM_TARGET(RISCV)
+LLVM_TARGET(Sparc)
+LLVM_TARGET(SystemZ)
+LLVM_TARGET(WebAssembly)
+LLVM_TARGET(X86)
+LLVM_TARGET(XCore)
+LLVM_TARGET(AVR)
+
+
+#undef LLVM_TARGET
diff --git a/src/llvm-c/Config/abi-breaking.h b/src/llvm-c/Config/abi-breaking.h
new file mode 100644
index 000000000..fd32bf381
--- /dev/null
+++ b/src/llvm-c/Config/abi-breaking.h
@@ -0,0 +1,62 @@
+/*===------- llvm/Config/abi-breaking.h - llvm configuration -------*- C -*-===*/
+/*                                                                            */
+/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
+/* Exceptions.                                                                */
+/* See https://llvm.org/LICENSE.txt for license information.                  */
+/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                                                                            */
+/*===----------------------------------------------------------------------===*/
+
+/* This file controls the C++ ABI break introduced in LLVM public header. */
+
+#ifndef LLVM_ABI_BREAKING_CHECKS_H
+#define LLVM_ABI_BREAKING_CHECKS_H
+
+/* Define to enable checks that alter the LLVM C++ ABI */
+#define LLVM_ENABLE_ABI_BREAKING_CHECKS 0
+
+/* Define to enable reverse iteration of unordered llvm containers */
+#define LLVM_ENABLE_REVERSE_ITERATION 0
+
+/* Allow selectively disabling link-time mismatch checking so that header-only
+   ADT content from LLVM can be used without linking libSupport. */
+#if !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+
+// ABI_BREAKING_CHECKS protection: provides link-time failure when clients build
+// mismatch with LLVM
+#if defined(_MSC_VER)
+// Use pragma with MSVC
+#define LLVM_XSTR(s) LLVM_STR(s)
+#define LLVM_STR(s) #s
+#pragma detect_mismatch("LLVM_ENABLE_ABI_BREAKING_CHECKS", LLVM_XSTR(LLVM_ENABLE_ABI_BREAKING_CHECKS))
+#undef LLVM_XSTR
+#undef LLVM_STR
+#elif defined(_WIN32) || defined(__CYGWIN__) // Win32 w/o #pragma detect_mismatch
+// FIXME: Implement checks without weak.
+#elif defined(__cplusplus)
+#if !(defined(_AIX) && defined(__GNUC__) && !defined(__clang__))
+#define LLVM_HIDDEN_VISIBILITY __attribute__ ((visibility("hidden")))
+#else
+// GCC on AIX does not support visibility attributes. Symbols are not
+// exported by default on AIX.
+#define LLVM_HIDDEN_VISIBILITY
+#endif
+namespace llvm {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
+extern int EnableABIBreakingChecks;
+LLVM_HIDDEN_VISIBILITY
+__attribute__((weak)) int *VerifyEnableABIBreakingChecks =
+    &EnableABIBreakingChecks;
+#else
+extern int DisableABIBreakingChecks;
+LLVM_HIDDEN_VISIBILITY
+__attribute__((weak)) int *VerifyDisableABIBreakingChecks =
+    &DisableABIBreakingChecks;
+#endif
+}
+#undef LLVM_HIDDEN_VISIBILITY
+#endif // _MSC_VER
+
+#endif // LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+
+#endif
diff --git a/src/llvm-c/Config/llvm-config.h b/src/llvm-c/Config/llvm-config.h
new file mode 100644
index 000000000..cdc6d47e7
--- /dev/null
+++ b/src/llvm-c/Config/llvm-config.h
@@ -0,0 +1,85 @@
+/*===------- llvm/Config/llvm-config.h - llvm configuration -------*- C -*-===*/
+/*                                                                            */
+/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
+/* Exceptions.                                                                */
+/* See https://llvm.org/LICENSE.txt for license information.                  */
+/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                                                                            */
+/*===----------------------------------------------------------------------===*/
+
+/* This file enumerates variables from the LLVM configuration so that they
+   can be in exported headers and won't override package specific directives.
+   This is a C header that can be included in the llvm-c headers. */
+
+#ifndef LLVM_CONFIG_H
+#define LLVM_CONFIG_H
+
+/* Define if LLVM_ENABLE_DUMP is enabled */
+/* #undef LLVM_ENABLE_DUMP */
+
+/* Define if we link Polly to the tools */
+/* #undef LINK_POLLY_INTO_TOOLS */
+
+/* Target triple LLVM will generate code for by default */
+#define LLVM_DEFAULT_TARGET_TRIPLE "x86_64-pc-windows-msvc"
+
+/* Define if threads enabled */
+#define LLVM_ENABLE_THREADS 1
+
+/* Has gcc/MSVC atomic intrinsics */
+#define LLVM_HAS_ATOMICS 1
+
+/* Host triple LLVM will be executed on */
+#define LLVM_HOST_TRIPLE "x86_64-pc-windows-msvc"
+
+/* LLVM architecture name for the native architecture, if available */
+#define LLVM_NATIVE_ARCH X86
+
+/* LLVM name for the native AsmParser init function, if available */
+#define LLVM_NATIVE_ASMPARSER LLVMInitializeX86AsmParser
+
+/* LLVM name for the native AsmPrinter init function, if available */
+#define LLVM_NATIVE_ASMPRINTER LLVMInitializeX86AsmPrinter
+
+/* LLVM name for the native Disassembler init function, if available */
+#define LLVM_NATIVE_DISASSEMBLER LLVMInitializeX86Disassembler
+
+/* LLVM name for the native Target init function, if available */
+#define LLVM_NATIVE_TARGET LLVMInitializeX86Target
+
+/* LLVM name for the native TargetInfo init function, if available */
+#define LLVM_NATIVE_TARGETINFO LLVMInitializeX86TargetInfo
+
+/* LLVM name for the native target MC init function, if available */
+#define LLVM_NATIVE_TARGETMC LLVMInitializeX86TargetMC
+
+/* Define if this is Unixish platform */
+/* #undef LLVM_ON_UNIX */
+
+/* Define if we have the Intel JIT API runtime support library */
+#define LLVM_USE_INTEL_JITEVENTS 0
+
+/* Define if we have the oprofile JIT-support library */
+#define LLVM_USE_OPROFILE 0
+
+/* Define if we have the perf JIT-support library */
+#define LLVM_USE_PERF 0
+
+/* Major version of the LLVM API */
+#define LLVM_VERSION_MAJOR 9
+
+/* Minor version of the LLVM API */
+#define LLVM_VERSION_MINOR 0
+
+/* Patch version of the LLVM API */
+#define LLVM_VERSION_PATCH 0
+
+/* LLVM version string */
+#define LLVM_VERSION_STRING "9.0.0"
+
+/* Whether LLVM records statistics for use with GetStatistics(),
+ * PrintStatistics() or PrintStatisticsJSON()
+ */
+#define LLVM_FORCE_ENABLE_STATS 0
+
+#endif
diff --git a/src/llvm-c/Core.h b/src/llvm-c/Core.h
new file mode 100644
index 000000000..51f160818
--- /dev/null
+++ b/src/llvm-c/Core.h
@@ -0,0 +1,4079 @@
+/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMCore.a, which implements    *|
+|* the LLVM intermediate representation.                                      *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_CORE_H
+#define LLVM_C_CORE_H
+
+#include "llvm-c/ErrorHandling.h"
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMC LLVM-C: C interface to LLVM
+ *
+ * This module exposes parts of the LLVM library as a C API.
+ *
+ * @{
+ */
+
+/**
+ * @defgroup LLVMCTransforms Transforms
+ */
+
+/**
+ * @defgroup LLVMCCore Core
+ *
+ * This modules provide an interface to libLLVMCore, which implements
+ * the LLVM intermediate representation as well as other related types
+ * and utilities.
+ *
+ * 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.
+ *
+ * @{
+ */
+
+/**
+ * @defgroup LLVMCCoreTypes Types and Enumerations
+ *
+ * @{
+ */
+
+/// External users depend on the following values being stable. It is not safe
+/// to reorder them.
+typedef enum {
+  /* Terminator Instructions */
+  LLVMRet            = 1,
+  LLVMBr             = 2,
+  LLVMSwitch         = 3,
+  LLVMIndirectBr     = 4,
+  LLVMInvoke         = 5,
+  /* removed 6 due to API changes */
+  LLVMUnreachable    = 7,
+  LLVMCallBr         = 67,
+
+  /* Standard Unary Operators */
+  LLVMFNeg           = 66,
+
+  /* Standard Binary Operators */
+  LLVMAdd            = 8,
+  LLVMFAdd           = 9,
+  LLVMSub            = 10,
+  LLVMFSub           = 11,
+  LLVMMul            = 12,
+  LLVMFMul           = 13,
+  LLVMUDiv           = 14,
+  LLVMSDiv           = 15,
+  LLVMFDiv           = 16,
+  LLVMURem           = 17,
+  LLVMSRem           = 18,
+  LLVMFRem           = 19,
+
+  /* Logical Operators */
+  LLVMShl            = 20,
+  LLVMLShr           = 21,
+  LLVMAShr           = 22,
+  LLVMAnd            = 23,
+  LLVMOr             = 24,
+  LLVMXor            = 25,
+
+  /* Memory Operators */
+  LLVMAlloca         = 26,
+  LLVMLoad           = 27,
+  LLVMStore          = 28,
+  LLVMGetElementPtr  = 29,
+
+  /* Cast Operators */
+  LLVMTrunc          = 30,
+  LLVMZExt           = 31,
+  LLVMSExt           = 32,
+  LLVMFPToUI         = 33,
+  LLVMFPToSI         = 34,
+  LLVMUIToFP         = 35,
+  LLVMSIToFP         = 36,
+  LLVMFPTrunc        = 37,
+  LLVMFPExt          = 38,
+  LLVMPtrToInt       = 39,
+  LLVMIntToPtr       = 40,
+  LLVMBitCast        = 41,
+  LLVMAddrSpaceCast  = 60,
+
+  /* Other Operators */
+  LLVMICmp           = 42,
+  LLVMFCmp           = 43,
+  LLVMPHI            = 44,
+  LLVMCall           = 45,
+  LLVMSelect         = 46,
+  LLVMUserOp1        = 47,
+  LLVMUserOp2        = 48,
+  LLVMVAArg          = 49,
+  LLVMExtractElement = 50,
+  LLVMInsertElement  = 51,
+  LLVMShuffleVector  = 52,
+  LLVMExtractValue   = 53,
+  LLVMInsertValue    = 54,
+
+  /* Atomic operators */
+  LLVMFence          = 55,
+  LLVMAtomicCmpXchg  = 56,
+  LLVMAtomicRMW      = 57,
+
+  /* Exception Handling Operators */
+  LLVMResume         = 58,
+  LLVMLandingPad     = 59,
+  LLVMCleanupRet     = 61,
+  LLVMCatchRet       = 62,
+  LLVMCatchPad       = 63,
+  LLVMCleanupPad     = 64,
+  LLVMCatchSwitch    = 65
+} LLVMOpcode;
+
+typedef enum {
+  LLVMVoidTypeKind,        /**< type with no size */
+  LLVMHalfTypeKind,        /**< 16 bit floating point type */
+  LLVMFloatTypeKind,       /**< 32 bit floating point type */
+  LLVMDoubleTypeKind,      /**< 64 bit floating point type */
+  LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
+  LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
+  LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
+  LLVMLabelTypeKind,       /**< Labels */
+  LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
+  LLVMFunctionTypeKind,    /**< Functions */
+  LLVMStructTypeKind,      /**< Structures */
+  LLVMArrayTypeKind,       /**< Arrays */
+  LLVMPointerTypeKind,     /**< Pointers */
+  LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
+  LLVMMetadataTypeKind,    /**< Metadata */
+  LLVMX86_MMXTypeKind,     /**< X86 MMX */
+  LLVMTokenTypeKind        /**< Tokens */
+} LLVMTypeKind;
+
+typedef enum {
+  LLVMExternalLinkage,    /**< Externally visible function */
+  LLVMAvailableExternallyLinkage,
+  LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
+  LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
+                            equivalent. */
+  LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */
+  LLVMWeakAnyLinkage,     /**< Keep one copy of function when linking (weak) */
+  LLVMWeakODRLinkage,     /**< Same, but only replaced by something
+                            equivalent. */
+  LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
+  LLVMInternalLinkage,    /**< Rename collisions when linking (static
+                               functions) */
+  LLVMPrivateLinkage,     /**< Like Internal, but omit from symbol table */
+  LLVMDLLImportLinkage,   /**< Obsolete */
+  LLVMDLLExportLinkage,   /**< Obsolete */
+  LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
+  LLVMGhostLinkage,       /**< Obsolete */
+  LLVMCommonLinkage,      /**< Tentative definitions */
+  LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
+  LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */
+} LLVMLinkage;
+
+typedef enum {
+  LLVMDefaultVisibility,  /**< The GV is visible */
+  LLVMHiddenVisibility,   /**< The GV is hidden */
+  LLVMProtectedVisibility /**< The GV is protected */
+} LLVMVisibility;
+
+typedef enum {
+  LLVMNoUnnamedAddr,    /**< Address of the GV is significant. */
+  LLVMLocalUnnamedAddr, /**< Address of the GV is locally insignificant. */
+  LLVMGlobalUnnamedAddr /**< Address of the GV is globally insignificant. */
+} LLVMUnnamedAddr;
+
+typedef enum {
+  LLVMDefaultStorageClass   = 0,
+  LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */
+  LLVMDLLExportStorageClass = 2  /**< Function to be accessible from DLL. */
+} LLVMDLLStorageClass;
+
+typedef enum {
+  LLVMCCallConv             = 0,
+  LLVMFastCallConv          = 8,
+  LLVMColdCallConv          = 9,
+  LLVMGHCCallConv           = 10,
+  LLVMHiPECallConv          = 11,
+  LLVMWebKitJSCallConv      = 12,
+  LLVMAnyRegCallConv        = 13,
+  LLVMPreserveMostCallConv  = 14,
+  LLVMPreserveAllCallConv   = 15,
+  LLVMSwiftCallConv         = 16,
+  LLVMCXXFASTTLSCallConv    = 17,
+  LLVMX86StdcallCallConv    = 64,
+  LLVMX86FastcallCallConv   = 65,
+  LLVMARMAPCSCallConv       = 66,
+  LLVMARMAAPCSCallConv      = 67,
+  LLVMARMAAPCSVFPCallConv   = 68,
+  LLVMMSP430INTRCallConv    = 69,
+  LLVMX86ThisCallCallConv   = 70,
+  LLVMPTXKernelCallConv     = 71,
+  LLVMPTXDeviceCallConv     = 72,
+  LLVMSPIRFUNCCallConv      = 75,
+  LLVMSPIRKERNELCallConv    = 76,
+  LLVMIntelOCLBICallConv    = 77,
+  LLVMX8664SysVCallConv     = 78,
+  LLVMWin64CallConv         = 79,
+  LLVMX86VectorCallCallConv = 80,
+  LLVMHHVMCallConv          = 81,
+  LLVMHHVMCCallConv         = 82,
+  LLVMX86INTRCallConv       = 83,
+  LLVMAVRINTRCallConv       = 84,
+  LLVMAVRSIGNALCallConv     = 85,
+  LLVMAVRBUILTINCallConv    = 86,
+  LLVMAMDGPUVSCallConv      = 87,
+  LLVMAMDGPUGSCallConv      = 88,
+  LLVMAMDGPUPSCallConv      = 89,
+  LLVMAMDGPUCSCallConv      = 90,
+  LLVMAMDGPUKERNELCallConv  = 91,
+  LLVMX86RegCallCallConv    = 92,
+  LLVMAMDGPUHSCallConv      = 93,
+  LLVMMSP430BUILTINCallConv = 94,
+  LLVMAMDGPULSCallConv      = 95,
+  LLVMAMDGPUESCallConv      = 96
+} LLVMCallConv;
+
+typedef enum {
+  LLVMArgumentValueKind,
+  LLVMBasicBlockValueKind,
+  LLVMMemoryUseValueKind,
+  LLVMMemoryDefValueKind,
+  LLVMMemoryPhiValueKind,
+
+  LLVMFunctionValueKind,
+  LLVMGlobalAliasValueKind,
+  LLVMGlobalIFuncValueKind,
+  LLVMGlobalVariableValueKind,
+  LLVMBlockAddressValueKind,
+  LLVMConstantExprValueKind,
+  LLVMConstantArrayValueKind,
+  LLVMConstantStructValueKind,
+  LLVMConstantVectorValueKind,
+
+  LLVMUndefValueValueKind,
+  LLVMConstantAggregateZeroValueKind,
+  LLVMConstantDataArrayValueKind,
+  LLVMConstantDataVectorValueKind,
+  LLVMConstantIntValueKind,
+  LLVMConstantFPValueKind,
+  LLVMConstantPointerNullValueKind,
+  LLVMConstantTokenNoneValueKind,
+
+  LLVMMetadataAsValueValueKind,
+  LLVMInlineAsmValueKind,
+
+  LLVMInstructionValueKind,
+} LLVMValueKind;
+
+typedef enum {
+  LLVMIntEQ = 32, /**< equal */
+  LLVMIntNE,      /**< not equal */
+  LLVMIntUGT,     /**< unsigned greater than */
+  LLVMIntUGE,     /**< unsigned greater or equal */
+  LLVMIntULT,     /**< unsigned less than */
+  LLVMIntULE,     /**< unsigned less or equal */
+  LLVMIntSGT,     /**< signed greater than */
+  LLVMIntSGE,     /**< signed greater or equal */
+  LLVMIntSLT,     /**< signed less than */
+  LLVMIntSLE      /**< signed less or equal */
+} LLVMIntPredicate;
+
+typedef enum {
+  LLVMRealPredicateFalse, /**< Always false (always folded) */
+  LLVMRealOEQ,            /**< True if ordered and equal */
+  LLVMRealOGT,            /**< True if ordered and greater than */
+  LLVMRealOGE,            /**< True if ordered and greater than or equal */
+  LLVMRealOLT,            /**< True if ordered and less than */
+  LLVMRealOLE,            /**< True if ordered and less than or equal */
+  LLVMRealONE,            /**< True if ordered and operands are unequal */
+  LLVMRealORD,            /**< True if ordered (no nans) */
+  LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
+  LLVMRealUEQ,            /**< True if unordered or equal */
+  LLVMRealUGT,            /**< True if unordered or greater than */
+  LLVMRealUGE,            /**< True if unordered, greater than, or equal */
+  LLVMRealULT,            /**< True if unordered or less than */
+  LLVMRealULE,            /**< True if unordered, less than, or equal */
+  LLVMRealUNE,            /**< True if unordered or not equal */
+  LLVMRealPredicateTrue   /**< Always true (always folded) */
+} LLVMRealPredicate;
+
+typedef enum {
+  LLVMLandingPadCatch,    /**< A catch clause   */
+  LLVMLandingPadFilter    /**< A filter clause  */
+} LLVMLandingPadClauseTy;
+
+typedef enum {
+  LLVMNotThreadLocal = 0,
+  LLVMGeneralDynamicTLSModel,
+  LLVMLocalDynamicTLSModel,
+  LLVMInitialExecTLSModel,
+  LLVMLocalExecTLSModel
+} LLVMThreadLocalMode;
+
+typedef enum {
+  LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */
+  LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees
+                                     somewhat sane results, lock free. */
+  LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the
+                                     operations affecting a specific address,
+                                     a consistent ordering exists */
+  LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort
+                                   necessary to acquire a lock to access other
+                                   memory with normal loads and stores. */
+  LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with
+                                   a barrier of the sort necessary to release
+                                   a lock. */
+  LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a
+                                          Release barrier (for fences and
+                                          operations which both read and write
+                                           memory). */
+  LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics
+                                                 for loads and Release
+                                                 semantics for stores.
+                                                 Additionally, it guarantees
+                                                 that a total ordering exists
+                                                 between all
+                                                 SequentiallyConsistent
+                                                 operations. */
+} LLVMAtomicOrdering;
+
+typedef enum {
+    LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */
+    LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */
+    LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */
+    LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */
+    LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */
+    LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */
+    LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */
+    LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the
+                             original using a signed comparison and return
+                             the old one */
+    LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the
+                             original using a signed comparison and return
+                             the old one */
+    LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the
+                             original using an unsigned comparison and return
+                             the old one */
+    LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the
+                             original using an unsigned comparison  and return
+                             the old one */
+} LLVMAtomicRMWBinOp;
+
+typedef enum {
+    LLVMDSError,
+    LLVMDSWarning,
+    LLVMDSRemark,
+    LLVMDSNote
+} LLVMDiagnosticSeverity;
+
+typedef enum {
+  LLVMInlineAsmDialectATT,
+  LLVMInlineAsmDialectIntel
+} LLVMInlineAsmDialect;
+
+typedef enum {
+  /**
+   * Emits an error if two values disagree, otherwise the resulting value is
+   * that of the operands.
+   *
+   * @see Module::ModFlagBehavior::Error
+   */
+  LLVMModuleFlagBehaviorError,
+  /**
+   * Emits a warning if two values disagree. The result value will be the
+   * operand for the flag from the first module being linked.
+   *
+   * @see Module::ModFlagBehavior::Warning
+   */
+  LLVMModuleFlagBehaviorWarning,
+  /**
+   * Adds a requirement that another module flag be present and have a
+   * specified value after linking is performed. The value must be a metadata
+   * pair, where the first element of the pair is the ID of the module flag
+   * to be restricted, and the second element of the pair is the value the
+   * module flag should be restricted to. This behavior can be used to
+   * restrict the allowable results (via triggering of an error) of linking
+   * IDs with the **Override** behavior.
+   *
+   * @see Module::ModFlagBehavior::Require
+   */
+  LLVMModuleFlagBehaviorRequire,
+  /**
+   * Uses the specified value, regardless of the behavior or value of the
+   * other module. If both modules specify **Override**, but the values
+   * differ, an error will be emitted.
+   *
+   * @see Module::ModFlagBehavior::Override
+   */
+  LLVMModuleFlagBehaviorOverride,
+  /**
+   * Appends the two values, which are required to be metadata nodes.
+   *
+   * @see Module::ModFlagBehavior::Append
+   */
+  LLVMModuleFlagBehaviorAppend,
+  /**
+   * Appends the two values, which are required to be metadata
+   * nodes. However, duplicate entries in the second list are dropped
+   * during the append operation.
+   *
+   * @see Module::ModFlagBehavior::AppendUnique
+   */
+  LLVMModuleFlagBehaviorAppendUnique,
+} LLVMModuleFlagBehavior;
+
+/**
+ * Attribute index are either LLVMAttributeReturnIndex,
+ * LLVMAttributeFunctionIndex or a parameter number from 1 to N.
+ */
+enum {
+  LLVMAttributeReturnIndex = 0U,
+  // ISO C restricts enumerator values to range of 'int'
+  // (4294967295 is too large)
+  // LLVMAttributeFunctionIndex = ~0U,
+  LLVMAttributeFunctionIndex = -1,
+};
+
+typedef unsigned LLVMAttributeIndex;
+
+/**
+ * @}
+ */
+
+void LLVMInitializeCore(LLVMPassRegistryRef R);
+
+/** Deallocate and destroy all ManagedStatic variables.
+    @see llvm::llvm_shutdown
+    @see ManagedStatic */
+void LLVMShutdown(void);
+
+/*===-- Error handling ----------------------------------------------------===*/
+
+char *LLVMCreateMessage(const char *Message);
+void LLVMDisposeMessage(char *Message);
+
+/**
+ * @defgroup LLVMCCoreContext Contexts
+ *
+ * Contexts are execution states for the core LLVM IR system.
+ *
+ * Most types are tied to a context instance. Multiple contexts can
+ * exist simultaneously. A single context is not thread safe. However,
+ * different contexts can execute on different threads simultaneously.
+ *
+ * @{
+ */
+
+typedef void (*LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *);
+typedef void (*LLVMYieldCallback)(LLVMContextRef, void *);
+
+/**
+ * Create a new context.
+ *
+ * Every call to this function should be paired with a call to
+ * LLVMContextDispose() or the context will leak memory.
+ */
+LLVMContextRef LLVMContextCreate(void);
+
+/**
+ * Obtain the global context instance.
+ */
+LLVMContextRef LLVMGetGlobalContext(void);
+
+/**
+ * Set the diagnostic handler for this context.
+ */
+void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
+                                     LLVMDiagnosticHandler Handler,
+                                     void *DiagnosticContext);
+
+/**
+ * Get the diagnostic handler of this context.
+ */
+LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C);
+
+/**
+ * Get the diagnostic context of this context.
+ */
+void *LLVMContextGetDiagnosticContext(LLVMContextRef C);
+
+/**
+ * Set the yield callback function for this context.
+ *
+ * @see LLVMContext::setYieldCallback()
+ */
+void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
+                                 void *OpaqueHandle);
+
+/**
+ * Retrieve whether the given context is set to discard all value names.
+ *
+ * @see LLVMContext::shouldDiscardValueNames()
+ */
+LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C);
+
+/**
+ * Set whether the given context discards all value names.
+ *
+ * If true, only the names of GlobalValue objects will be available in the IR.
+ * This can be used to save memory and runtime, especially in release mode.
+ *
+ * @see LLVMContext::setDiscardValueNames()
+ */
+void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard);
+
+/**
+ * Destroy a context instance.
+ *
+ * This should be called for every call to LLVMContextCreate() or memory
+ * will be leaked.
+ */
+void LLVMContextDispose(LLVMContextRef C);
+
+/**
+ * Return a string representation of the DiagnosticInfo. Use
+ * LLVMDisposeMessage to free the string.
+ *
+ * @see DiagnosticInfo::print()
+ */
+char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI);
+
+/**
+ * Return an enum LLVMDiagnosticSeverity.
+ *
+ * @see DiagnosticInfo::getSeverity()
+ */
+LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI);
+
+unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
+                                  unsigned SLen);
+unsigned LLVMGetMDKindID(const char *Name, unsigned SLen);
+
+/**
+ * Return an unique id given the name of a enum attribute,
+ * or 0 if no attribute by that name exists.
+ *
+ * See http://llvm.org/docs/LangRef.html#parameter-attributes
+ * and http://llvm.org/docs/LangRef.html#function-attributes
+ * for the list of available attributes.
+ *
+ * NB: Attribute names and/or id are subject to change without
+ * going through the C API deprecation cycle.
+ */
+unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen);
+unsigned LLVMGetLastEnumAttributeKind(void);
+
+/**
+ * Create an enum attribute.
+ */
+LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
+                                         uint64_t Val);
+
+/**
+ * Get the unique id corresponding to the enum attribute
+ * passed as argument.
+ */
+unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A);
+
+/**
+ * Get the enum attribute's value. 0 is returned if none exists.
+ */
+uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A);
+
+/**
+ * Create a string attribute.
+ */
+LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C,
+                                           const char *K, unsigned KLength,
+                                           const char *V, unsigned VLength);
+
+/**
+ * Get the string attribute's kind.
+ */
+const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length);
+
+/**
+ * Get the string attribute's value.
+ */
+const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length);
+
+/**
+ * Check for the different types of attributes.
+ */
+LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A);
+LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreModule Modules
+ *
+ * Modules represent the top-level structure in an LLVM program. An LLVM
+ * module is effectively a translation unit or a collection of
+ * translation units merged together.
+ *
+ * @{
+ */
+
+/**
+ * Create a new, empty module in the global context.
+ *
+ * This is equivalent to calling LLVMModuleCreateWithNameInContext with
+ * LLVMGetGlobalContext() as the context parameter.
+ *
+ * Every invocation should be paired with LLVMDisposeModule() or memory
+ * will be leaked.
+ */
+LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
+
+/**
+ * Create a new, empty module in a specific context.
+ *
+ * Every invocation should be paired with LLVMDisposeModule() or memory
+ * will be leaked.
+ */
+LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
+                                                LLVMContextRef C);
+/**
+ * Return an exact copy of the specified module.
+ */
+LLVMModuleRef LLVMCloneModule(LLVMModuleRef M);
+
+/**
+ * Destroy a module instance.
+ *
+ * This must be called for every created module or memory will be
+ * leaked.
+ */
+void LLVMDisposeModule(LLVMModuleRef M);
+
+/**
+ * Obtain the identifier of a module.
+ *
+ * @param M Module to obtain identifier of
+ * @param Len Out parameter which holds the length of the returned string.
+ * @return The identifier of M.
+ * @see Module::getModuleIdentifier()
+ */
+const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len);
+
+/**
+ * Set the identifier of a module to a string Ident with length Len.
+ *
+ * @param M The module to set identifier
+ * @param Ident The string to set M's identifier to
+ * @param Len Length of Ident
+ * @see Module::setModuleIdentifier()
+ */
+void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len);
+
+/**
+ * Obtain the module's original source file name.
+ *
+ * @param M Module to obtain the name of
+ * @param Len Out parameter which holds the length of the returned string
+ * @return The original source file name of M
+ * @see Module::getSourceFileName()
+ */
+const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len);
+
+/**
+ * Set the original source file name of a module to a string Name with length
+ * Len.
+ *
+ * @param M The module to set the source file name of
+ * @param Name The string to set M's source file name to
+ * @param Len Length of Name
+ * @see Module::setSourceFileName()
+ */
+void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len);
+
+/**
+ * Obtain the data layout for a module.
+ *
+ * @see Module::getDataLayoutStr()
+ *
+ * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect,
+ * but match the name of another method on the module. Prefer the use
+ * of LLVMGetDataLayoutStr, which is not ambiguous.
+ */
+const char *LLVMGetDataLayoutStr(LLVMModuleRef M);
+const char *LLVMGetDataLayout(LLVMModuleRef M);
+
+/**
+ * Set the data layout for a module.
+ *
+ * @see Module::setDataLayout()
+ */
+void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr);
+
+/**
+ * Obtain the target triple for a module.
+ *
+ * @see Module::getTargetTriple()
+ */
+const char *LLVMGetTarget(LLVMModuleRef M);
+
+/**
+ * Set the target triple for a module.
+ *
+ * @see Module::setTargetTriple()
+ */
+void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
+
+/**
+ * Returns the module flags as an array of flag-key-value triples.  The caller
+ * is responsible for freeing this array by calling
+ * \c LLVMDisposeModuleFlagsMetadata.
+ *
+ * @see Module::getModuleFlagsMetadata()
+ */
+LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len);
+
+/**
+ * Destroys module flags metadata entries.
+ */
+void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries);
+
+/**
+ * Returns the flag behavior for a module flag entry at a specific index.
+ *
+ * @see Module::ModuleFlagEntry::Behavior
+ */
+LLVMModuleFlagBehavior
+LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries,
+                                     unsigned Index);
+
+/**
+ * Returns the key for a module flag entry at a specific index.
+ *
+ * @see Module::ModuleFlagEntry::Key
+ */
+const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries,
+                                        unsigned Index, size_t *Len);
+
+/**
+ * Returns the metadata for a module flag entry at a specific index.
+ *
+ * @see Module::ModuleFlagEntry::Val
+ */
+LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries,
+                                                 unsigned Index);
+
+/**
+ * Add a module-level flag to the module-level flags metadata if it doesn't
+ * already exist.
+ *
+ * @see Module::getModuleFlag()
+ */
+LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M,
+                                  const char *Key, size_t KeyLen);
+
+/**
+ * Add a module-level flag to the module-level flags metadata if it doesn't
+ * already exist.
+ *
+ * @see Module::addModuleFlag()
+ */
+void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior,
+                       const char *Key, size_t KeyLen,
+                       LLVMMetadataRef Val);
+
+/**
+ * Dump a representation of a module to stderr.
+ *
+ * @see Module::dump()
+ */
+void LLVMDumpModule(LLVMModuleRef M);
+
+/**
+ * Print a representation of a module to a file. The ErrorMessage needs to be
+ * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
+ *
+ * @see Module::print()
+ */
+LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
+                               char **ErrorMessage);
+
+/**
+ * Return a string representation of the module. Use
+ * LLVMDisposeMessage to free the string.
+ *
+ * @see Module::print()
+ */
+char *LLVMPrintModuleToString(LLVMModuleRef M);
+
+/**
+ * Get inline assembly for a module.
+ *
+ * @see Module::getModuleInlineAsm()
+ */
+const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len);
+
+/**
+ * Set inline assembly for a module.
+ *
+ * @see Module::setModuleInlineAsm()
+ */
+void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len);
+
+/**
+ * Append inline assembly to a module.
+ *
+ * @see Module::appendModuleInlineAsm()
+ */
+void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len);
+
+/**
+ * Create the specified uniqued inline asm string.
+ *
+ * @see InlineAsm::get()
+ */
+LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty,
+                              char *AsmString, size_t AsmStringSize,
+                              char *Constraints, size_t ConstraintsSize,
+                              LLVMBool HasSideEffects, LLVMBool IsAlignStack,
+                              LLVMInlineAsmDialect Dialect);
+
+/**
+ * Obtain the context to which this module is associated.
+ *
+ * @see Module::getContext()
+ */
+LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
+
+/**
+ * Obtain a Type from a module by its registered name.
+ */
+LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
+
+/**
+ * Obtain an iterator to the first NamedMDNode in a Module.
+ *
+ * @see llvm::Module::named_metadata_begin()
+ */
+LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M);
+
+/**
+ * Obtain an iterator to the last NamedMDNode in a Module.
+ *
+ * @see llvm::Module::named_metadata_end()
+ */
+LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M);
+
+/**
+ * Advance a NamedMDNode iterator to the next NamedMDNode.
+ *
+ * Returns NULL if the iterator was already at the end and there are no more
+ * named metadata nodes.
+ */
+LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NamedMDNode);
+
+/**
+ * Decrement a NamedMDNode iterator to the previous NamedMDNode.
+ *
+ * Returns NULL if the iterator was already at the beginning and there are
+ * no previous named metadata nodes.
+ */
+LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NamedMDNode);
+
+/**
+ * Retrieve a NamedMDNode with the given name, returning NULL if no such
+ * node exists.
+ *
+ * @see llvm::Module::getNamedMetadata()
+ */
+LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M,
+                                        const char *Name, size_t NameLen);
+
+/**
+ * Retrieve a NamedMDNode with the given name, creating a new node if no such
+ * node exists.
+ *
+ * @see llvm::Module::getOrInsertNamedMetadata()
+ */
+LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M,
+                                                const char *Name,
+                                                size_t NameLen);
+
+/**
+ * Retrieve the name of a NamedMDNode.
+ *
+ * @see llvm::NamedMDNode::getName()
+ */
+const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NamedMD,
+                                     size_t *NameLen);
+
+/**
+ * Obtain the number of operands for named metadata in a module.
+ *
+ * @see llvm::Module::getNamedMetadata()
+ */
+unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name);
+
+/**
+ * Obtain the named metadata operands for a module.
+ *
+ * The passed LLVMValueRef pointer should refer to an array of
+ * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This
+ * array will be populated with the LLVMValueRef instances. Each
+ * instance corresponds to a llvm::MDNode.
+ *
+ * @see llvm::Module::getNamedMetadata()
+ * @see llvm::MDNode::getOperand()
+ */
+void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name,
+                                  LLVMValueRef *Dest);
+
+/**
+ * Add an operand to named metadata.
+ *
+ * @see llvm::Module::getNamedMetadata()
+ * @see llvm::MDNode::addOperand()
+ */
+void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name,
+                                 LLVMValueRef Val);
+
+/**
+ * Return the directory of the debug location for this value, which must be
+ * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
+ *
+ * @see llvm::Instruction::getDebugLoc()
+ * @see llvm::GlobalVariable::getDebugInfo()
+ * @see llvm::Function::getSubprogram()
+ */
+const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length);
+
+/**
+ * Return the filename of the debug location for this value, which must be
+ * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
+ *
+ * @see llvm::Instruction::getDebugLoc()
+ * @see llvm::GlobalVariable::getDebugInfo()
+ * @see llvm::Function::getSubprogram()
+ */
+const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length);
+
+/**
+ * Return the line number of the debug location for this value, which must be
+ * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
+ *
+ * @see llvm::Instruction::getDebugLoc()
+ * @see llvm::GlobalVariable::getDebugInfo()
+ * @see llvm::Function::getSubprogram()
+ */
+unsigned LLVMGetDebugLocLine(LLVMValueRef Val);
+
+/**
+ * Return the column number of the debug location for this value, which must be
+ * an llvm::Instruction.
+ *
+ * @see llvm::Instruction::getDebugLoc()
+ */
+unsigned LLVMGetDebugLocColumn(LLVMValueRef Val);
+
+/**
+ * Add a function to a module under a specified name.
+ *
+ * @see llvm::Function::Create()
+ */
+LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
+                             LLVMTypeRef FunctionTy);
+
+/**
+ * Obtain a Function value from a Module by its name.
+ *
+ * The returned value corresponds to a llvm::Function value.
+ *
+ * @see llvm::Module::getFunction()
+ */
+LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
+
+/**
+ * Obtain an iterator to the first Function in a Module.
+ *
+ * @see llvm::Module::begin()
+ */
+LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
+
+/**
+ * Obtain an iterator to the last Function in a Module.
+ *
+ * @see llvm::Module::end()
+ */
+LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
+
+/**
+ * Advance a Function iterator to the next Function.
+ *
+ * Returns NULL if the iterator was already at the end and there are no more
+ * functions.
+ */
+LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
+
+/**
+ * Decrement a Function iterator to the previous Function.
+ *
+ * Returns NULL if the iterator was already at the beginning and there are
+ * no previous functions.
+ */
+LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
+
+/** Deprecated: Use LLVMSetModuleInlineAsm2 instead. */
+void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreType Types
+ *
+ * Types represent the type of a value.
+ *
+ * Types are associated with a context instance. The context internally
+ * deduplicates types so there is only 1 instance of a specific type
+ * alive at a time. In other words, a unique type is shared among all
+ * consumers within a context.
+ *
+ * A Type in the C API corresponds to llvm::Type.
+ *
+ * Types have the following hierarchy:
+ *
+ *   types:
+ *     integer type
+ *     real type
+ *     function type
+ *     sequence types:
+ *       array type
+ *       pointer type
+ *       vector type
+ *     void type
+ *     label type
+ *     opaque type
+ *
+ * @{
+ */
+
+/**
+ * Obtain the enumerated type of a Type instance.
+ *
+ * @see llvm::Type:getTypeID()
+ */
+LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
+
+/**
+ * Whether the type has a known size.
+ *
+ * Things that don't have a size are abstract types, labels, and void.a
+ *
+ * @see llvm::Type::isSized()
+ */
+LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty);
+
+/**
+ * Obtain the context to which this type instance is associated.
+ *
+ * @see llvm::Type::getContext()
+ */
+LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
+
+/**
+ * Dump a representation of a type to stderr.
+ *
+ * @see llvm::Type::dump()
+ */
+void LLVMDumpType(LLVMTypeRef Val);
+
+/**
+ * Return a string representation of the type. Use
+ * LLVMDisposeMessage to free the string.
+ *
+ * @see llvm::Type::print()
+ */
+char *LLVMPrintTypeToString(LLVMTypeRef Val);
+
+/**
+ * @defgroup LLVMCCoreTypeInt Integer Types
+ *
+ * Functions in this section operate on integer types.
+ *
+ * @{
+ */
+
+/**
+ * Obtain an integer type from a context with specified bit width.
+ */
+LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C);
+LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
+
+/**
+ * Obtain an integer type from the global context with a specified bit
+ * width.
+ */
+LLVMTypeRef LLVMInt1Type(void);
+LLVMTypeRef LLVMInt8Type(void);
+LLVMTypeRef LLVMInt16Type(void);
+LLVMTypeRef LLVMInt32Type(void);
+LLVMTypeRef LLVMInt64Type(void);
+LLVMTypeRef LLVMInt128Type(void);
+LLVMTypeRef LLVMIntType(unsigned NumBits);
+unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreTypeFloat Floating Point Types
+ *
+ * @{
+ */
+
+/**
+ * Obtain a 16-bit floating point type from a context.
+ */
+LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 32-bit floating point type from a context.
+ */
+LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 64-bit floating point type from a context.
+ */
+LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 80-bit floating point type (X87) from a context.
+ */
+LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 128-bit floating point type (112-bit mantissa) from a
+ * context.
+ */
+LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 128-bit floating point type (two 64-bits) from a context.
+ */
+LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a floating point type from the global context.
+ *
+ * These map to the functions in this group of the same name.
+ */
+LLVMTypeRef LLVMHalfType(void);
+LLVMTypeRef LLVMFloatType(void);
+LLVMTypeRef LLVMDoubleType(void);
+LLVMTypeRef LLVMX86FP80Type(void);
+LLVMTypeRef LLVMFP128Type(void);
+LLVMTypeRef LLVMPPCFP128Type(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreTypeFunction Function Types
+ *
+ * @{
+ */
+
+/**
+ * Obtain a function type consisting of a specified signature.
+ *
+ * The function is defined as a tuple of a return Type, a list of
+ * parameter types, and whether the function is variadic.
+ */
+LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
+                             LLVMTypeRef *ParamTypes, unsigned ParamCount,
+                             LLVMBool IsVarArg);
+
+/**
+ * Returns whether a function type is variadic.
+ */
+LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
+
+/**
+ * Obtain the Type this function Type returns.
+ */
+LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
+
+/**
+ * Obtain the number of parameters this function accepts.
+ */
+unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
+
+/**
+ * Obtain the types of a function's parameters.
+ *
+ * The Dest parameter should point to a pre-allocated array of
+ * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the
+ * first LLVMCountParamTypes() entries in the array will be populated
+ * with LLVMTypeRef instances.
+ *
+ * @param FunctionTy The function type to operate on.
+ * @param Dest Memory address of an array to be filled with result.
+ */
+void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreTypeStruct Structure Types
+ *
+ * These functions relate to LLVMTypeRef instances.
+ *
+ * @see llvm::StructType
+ *
+ * @{
+ */
+
+/**
+ * Create a new structure type in a context.
+ *
+ * A structure is specified by a list of inner elements/types and
+ * whether these can be packed together.
+ *
+ * @see llvm::StructType::create()
+ */
+LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
+                                    unsigned ElementCount, LLVMBool Packed);
+
+/**
+ * Create a new structure type in the global context.
+ *
+ * @see llvm::StructType::create()
+ */
+LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
+                           LLVMBool Packed);
+
+/**
+ * Create an empty structure in a context having a specified name.
+ *
+ * @see llvm::StructType::create()
+ */
+LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
+
+/**
+ * Obtain the name of a structure.
+ *
+ * @see llvm::StructType::getName()
+ */
+const char *LLVMGetStructName(LLVMTypeRef Ty);
+
+/**
+ * Set the contents of a structure type.
+ *
+ * @see llvm::StructType::setBody()
+ */
+void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
+                       unsigned ElementCount, LLVMBool Packed);
+
+/**
+ * Get the number of elements defined inside the structure.
+ *
+ * @see llvm::StructType::getNumElements()
+ */
+unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
+
+/**
+ * Get the elements within a structure.
+ *
+ * The function is passed the address of a pre-allocated array of
+ * LLVMTypeRef at least LLVMCountStructElementTypes() long. After
+ * invocation, this array will be populated with the structure's
+ * elements. The objects in the destination array will have a lifetime
+ * of the structure type itself, which is the lifetime of the context it
+ * is contained in.
+ */
+void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
+
+/**
+ * Get the type of the element at a given index in the structure.
+ *
+ * @see llvm::StructType::getTypeAtIndex()
+ */
+LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i);
+
+/**
+ * Determine whether a structure is packed.
+ *
+ * @see llvm::StructType::isPacked()
+ */
+LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
+
+/**
+ * Determine whether a structure is opaque.
+ *
+ * @see llvm::StructType::isOpaque()
+ */
+LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
+
+/**
+ * Determine whether a structure is literal.
+ *
+ * @see llvm::StructType::isLiteral()
+ */
+LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreTypeSequential Sequential Types
+ *
+ * Sequential types represents "arrays" of types. This is a super class
+ * for array, vector, and pointer types.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the type of elements within a sequential type.
+ *
+ * This works on array, vector, and pointer types.
+ *
+ * @see llvm::SequentialType::getElementType()
+ */
+LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
+
+/**
+ * Returns type's subtypes
+ *
+ * @see llvm::Type::subtypes()
+ */
+void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr);
+
+/**
+ *  Return the number of types in the derived type.
+ *
+ * @see llvm::Type::getNumContainedTypes()
+ */
+unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp);
+
+/**
+ * Create a fixed size array type that refers to a specific type.
+ *
+ * The created type will exist in the context that its element type
+ * exists in.
+ *
+ * @see llvm::ArrayType::get()
+ */
+LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
+
+/**
+ * Obtain the length of an array type.
+ *
+ * This only works on types that represent arrays.
+ *
+ * @see llvm::ArrayType::getNumElements()
+ */
+unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
+
+/**
+ * Create a pointer type that points to a defined type.
+ *
+ * The created type will exist in the context that its pointee type
+ * exists in.
+ *
+ * @see llvm::PointerType::get()
+ */
+LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
+
+/**
+ * Obtain the address space of a pointer type.
+ *
+ * This only works on types that represent pointers.
+ *
+ * @see llvm::PointerType::getAddressSpace()
+ */
+unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
+
+/**
+ * Create a vector type that contains a defined type and has a specific
+ * number of elements.
+ *
+ * The created type will exist in the context thats its element type
+ * exists in.
+ *
+ * @see llvm::VectorType::get()
+ */
+LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
+
+/**
+ * Obtain the number of elements in a vector type.
+ *
+ * This only works on types that represent vectors.
+ *
+ * @see llvm::VectorType::getNumElements()
+ */
+unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreTypeOther Other Types
+ *
+ * @{
+ */
+
+/**
+ * Create a void type in a context.
+ */
+LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
+
+/**
+ * Create a label type in a context.
+ */
+LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
+
+/**
+ * Create a X86 MMX type in a context.
+ */
+LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
+
+/**
+ * Create a token type in a context.
+ */
+LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C);
+
+/**
+ * Create a metadata type in a context.
+ */
+LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C);
+
+/**
+ * These are similar to the above functions except they operate on the
+ * global context.
+ */
+LLVMTypeRef LLVMVoidType(void);
+LLVMTypeRef LLVMLabelType(void);
+LLVMTypeRef LLVMX86MMXType(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValues Values
+ *
+ * The bulk of LLVM's object model consists of values, which comprise a very
+ * rich type hierarchy.
+ *
+ * LLVMValueRef essentially represents llvm::Value. There is a rich
+ * hierarchy of classes within this type. Depending on the instance
+ * obtained, not all APIs are available.
+ *
+ * Callers can determine the type of an LLVMValueRef by calling the
+ * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These
+ * functions are defined by a macro, so it isn't obvious which are
+ * available by looking at the Doxygen source code. Instead, look at the
+ * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list
+ * of value names given. These value names also correspond to classes in
+ * the llvm::Value hierarchy.
+ *
+ * @{
+ */
+
+#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
+  macro(Argument)                           \
+  macro(BasicBlock)                         \
+  macro(InlineAsm)                          \
+  macro(User)                               \
+    macro(Constant)                         \
+      macro(BlockAddress)                   \
+      macro(ConstantAggregateZero)          \
+      macro(ConstantArray)                  \
+      macro(ConstantDataSequential)         \
+        macro(ConstantDataArray)            \
+        macro(ConstantDataVector)           \
+      macro(ConstantExpr)                   \
+      macro(ConstantFP)                     \
+      macro(ConstantInt)                    \
+      macro(ConstantPointerNull)            \
+      macro(ConstantStruct)                 \
+      macro(ConstantTokenNone)              \
+      macro(ConstantVector)                 \
+      macro(GlobalValue)                    \
+        macro(GlobalAlias)                  \
+        macro(GlobalIFunc)                  \
+        macro(GlobalObject)                 \
+          macro(Function)                   \
+          macro(GlobalVariable)             \
+      macro(UndefValue)                     \
+    macro(Instruction)                      \
+      macro(BinaryOperator)                 \
+      macro(CallInst)                       \
+        macro(IntrinsicInst)                \
+          macro(DbgInfoIntrinsic)           \
+            macro(DbgVariableIntrinsic)     \
+              macro(DbgDeclareInst)         \
+            macro(DbgLabelInst)             \
+          macro(MemIntrinsic)               \
+            macro(MemCpyInst)               \
+            macro(MemMoveInst)              \
+            macro(MemSetInst)               \
+      macro(CmpInst)                        \
+        macro(FCmpInst)                     \
+        macro(ICmpInst)                     \
+      macro(ExtractElementInst)             \
+      macro(GetElementPtrInst)              \
+      macro(InsertElementInst)              \
+      macro(InsertValueInst)                \
+      macro(LandingPadInst)                 \
+      macro(PHINode)                        \
+      macro(SelectInst)                     \
+      macro(ShuffleVectorInst)              \
+      macro(StoreInst)                      \
+      macro(BranchInst)                     \
+      macro(IndirectBrInst)                 \
+      macro(InvokeInst)                     \
+      macro(ReturnInst)                     \
+      macro(SwitchInst)                     \
+      macro(UnreachableInst)                \
+      macro(ResumeInst)                     \
+      macro(CleanupReturnInst)              \
+      macro(CatchReturnInst)                \
+      macro(FuncletPadInst)                 \
+        macro(CatchPadInst)                 \
+        macro(CleanupPadInst)               \
+      macro(UnaryInstruction)               \
+        macro(AllocaInst)                   \
+        macro(CastInst)                     \
+          macro(AddrSpaceCastInst)          \
+          macro(BitCastInst)                \
+          macro(FPExtInst)                  \
+          macro(FPToSIInst)                 \
+          macro(FPToUIInst)                 \
+          macro(FPTruncInst)                \
+          macro(IntToPtrInst)               \
+          macro(PtrToIntInst)               \
+          macro(SExtInst)                   \
+          macro(SIToFPInst)                 \
+          macro(TruncInst)                  \
+          macro(UIToFPInst)                 \
+          macro(ZExtInst)                   \
+        macro(ExtractValueInst)             \
+        macro(LoadInst)                     \
+        macro(VAArgInst)
+
+/**
+ * @defgroup LLVMCCoreValueGeneral General APIs
+ *
+ * Functions in this section work on all LLVMValueRef instances,
+ * regardless of their sub-type. They correspond to functions available
+ * on llvm::Value.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the type of a value.
+ *
+ * @see llvm::Value::getType()
+ */
+LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
+
+/**
+ * Obtain the enumerated type of a Value instance.
+ *
+ * @see llvm::Value::getValueID()
+ */
+LLVMValueKind LLVMGetValueKind(LLVMValueRef Val);
+
+/**
+ * Obtain the string name of a value.
+ *
+ * @see llvm::Value::getName()
+ */
+const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length);
+
+/**
+ * Set the string name of a value.
+ *
+ * @see llvm::Value::setName()
+ */
+void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen);
+
+/**
+ * Dump a representation of a value to stderr.
+ *
+ * @see llvm::Value::dump()
+ */
+void LLVMDumpValue(LLVMValueRef Val);
+
+/**
+ * Return a string representation of the value. Use
+ * LLVMDisposeMessage to free the string.
+ *
+ * @see llvm::Value::print()
+ */
+char *LLVMPrintValueToString(LLVMValueRef Val);
+
+/**
+ * Replace all uses of a value with another one.
+ *
+ * @see llvm::Value::replaceAllUsesWith()
+ */
+void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
+
+/**
+ * Determine whether the specified value instance is constant.
+ */
+LLVMBool LLVMIsConstant(LLVMValueRef Val);
+
+/**
+ * Determine whether a value instance is undefined.
+ */
+LLVMBool LLVMIsUndef(LLVMValueRef Val);
+
+/**
+ * Convert value instances between types.
+ *
+ * Internally, an LLVMValueRef is "pinned" to a specific type. This
+ * series of functions allows you to cast an instance to a specific
+ * type.
+ *
+ * If the cast is not valid for the specified type, NULL is returned.
+ *
+ * @see llvm::dyn_cast_or_null<>
+ */
+#define LLVM_DECLARE_VALUE_CAST(name) \
+  LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
+LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
+
+LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val);
+LLVMValueRef LLVMIsAMDString(LLVMValueRef Val);
+
+/** Deprecated: Use LLVMGetValueName2 instead. */
+const char *LLVMGetValueName(LLVMValueRef Val);
+/** Deprecated: Use LLVMSetValueName2 instead. */
+void LLVMSetValueName(LLVMValueRef Val, const char *Name);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueUses Usage
+ *
+ * This module defines functions that allow you to inspect the uses of a
+ * LLVMValueRef.
+ *
+ * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance.
+ * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a
+ * llvm::User and llvm::Value.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the first use of a value.
+ *
+ * Uses are obtained in an iterator fashion. First, call this function
+ * to obtain a reference to the first use. Then, call LLVMGetNextUse()
+ * on that instance and all subsequently obtained instances until
+ * LLVMGetNextUse() returns NULL.
+ *
+ * @see llvm::Value::use_begin()
+ */
+LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
+
+/**
+ * Obtain the next use of a value.
+ *
+ * This effectively advances the iterator. It returns NULL if you are on
+ * the final use and no more are available.
+ */
+LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
+
+/**
+ * Obtain the user value for a user.
+ *
+ * The returned value corresponds to a llvm::User type.
+ *
+ * @see llvm::Use::getUser()
+ */
+LLVMValueRef LLVMGetUser(LLVMUseRef U);
+
+/**
+ * Obtain the value this use corresponds to.
+ *
+ * @see llvm::Use::get().
+ */
+LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueUser User value
+ *
+ * Function in this group pertain to LLVMValueRef instances that descent
+ * from llvm::User. This includes constants, instructions, and
+ * operators.
+ *
+ * @{
+ */
+
+/**
+ * Obtain an operand at a specific index in a llvm::User value.
+ *
+ * @see llvm::User::getOperand()
+ */
+LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
+
+/**
+ * Obtain the use of an operand at a specific index in a llvm::User value.
+ *
+ * @see llvm::User::getOperandUse()
+ */
+LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index);
+
+/**
+ * Set an operand at a specific index in a llvm::User value.
+ *
+ * @see llvm::User::setOperand()
+ */
+void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
+
+/**
+ * Obtain the number of operands in a llvm::User value.
+ *
+ * @see llvm::User::getNumOperands()
+ */
+int LLVMGetNumOperands(LLVMValueRef Val);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueConstant Constants
+ *
+ * This section contains APIs for interacting with LLVMValueRef that
+ * correspond to llvm::Constant instances.
+ *
+ * These functions will work for any LLVMValueRef in the llvm::Constant
+ * class hierarchy.
+ *
+ * @{
+ */
+
+/**
+ * Obtain a constant value referring to the null instance of a type.
+ *
+ * @see llvm::Constant::getNullValue()
+ */
+LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
+
+/**
+ * Obtain a constant value referring to the instance of a type
+ * consisting of all ones.
+ *
+ * This is only valid for integer types.
+ *
+ * @see llvm::Constant::getAllOnesValue()
+ */
+LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty);
+
+/**
+ * Obtain a constant value referring to an undefined value of a type.
+ *
+ * @see llvm::UndefValue::get()
+ */
+LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
+
+/**
+ * Determine whether a value instance is null.
+ *
+ * @see llvm::Constant::isNullValue()
+ */
+LLVMBool LLVMIsNull(LLVMValueRef Val);
+
+/**
+ * Obtain a constant that is a constant pointer pointing to NULL for a
+ * specified type.
+ */
+LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
+
+/**
+ * @defgroup LLVMCCoreValueConstantScalar Scalar constants
+ *
+ * Functions in this group model LLVMValueRef instances that correspond
+ * to constants referring to scalar types.
+ *
+ * For integer types, the LLVMTypeRef parameter should correspond to a
+ * llvm::IntegerType instance and the returned LLVMValueRef will
+ * correspond to a llvm::ConstantInt.
+ *
+ * For floating point types, the LLVMTypeRef returned corresponds to a
+ * llvm::ConstantFP.
+ *
+ * @{
+ */
+
+/**
+ * Obtain a constant value for an integer type.
+ *
+ * The returned value corresponds to a llvm::ConstantInt.
+ *
+ * @see llvm::ConstantInt::get()
+ *
+ * @param IntTy Integer type to obtain value of.
+ * @param N The value the returned instance should refer to.
+ * @param SignExtend Whether to sign extend the produced value.
+ */
+LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
+                          LLVMBool SignExtend);
+
+/**
+ * Obtain a constant value for an integer of arbitrary precision.
+ *
+ * @see llvm::ConstantInt::get()
+ */
+LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
+                                              unsigned NumWords,
+                                              const uint64_t Words[]);
+
+/**
+ * Obtain a constant value for an integer parsed from a string.
+ *
+ * A similar API, LLVMConstIntOfStringAndSize is also available. If the
+ * string's length is available, it is preferred to call that function
+ * instead.
+ *
+ * @see llvm::ConstantInt::get()
+ */
+LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
+                                  uint8_t Radix);
+
+/**
+ * Obtain a constant value for an integer parsed from a string with
+ * specified length.
+ *
+ * @see llvm::ConstantInt::get()
+ */
+LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
+                                         unsigned SLen, uint8_t Radix);
+
+/**
+ * Obtain a constant value referring to a double floating point value.
+ */
+LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
+
+/**
+ * Obtain a constant for a floating point value parsed from a string.
+ *
+ * A similar API, LLVMConstRealOfStringAndSize is also available. It
+ * should be used if the input string's length is known.
+ */
+LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
+
+/**
+ * Obtain a constant for a floating point value parsed from a string.
+ */
+LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
+                                          unsigned SLen);
+
+/**
+ * Obtain the zero extended value for an integer constant value.
+ *
+ * @see llvm::ConstantInt::getZExtValue()
+ */
+unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
+
+/**
+ * Obtain the sign extended value for an integer constant value.
+ *
+ * @see llvm::ConstantInt::getSExtValue()
+ */
+long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
+
+/**
+ * Obtain the double value for an floating point constant value.
+ * losesInfo indicates if some precision was lost in the conversion.
+ *
+ * @see llvm::ConstantFP::getDoubleValue
+ */
+double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueConstantComposite Composite Constants
+ *
+ * Functions in this group operate on composite constants.
+ *
+ * @{
+ */
+
+/**
+ * Create a ConstantDataSequential and initialize it with a string.
+ *
+ * @see llvm::ConstantDataArray::getString()
+ */
+LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
+                                      unsigned Length, LLVMBool DontNullTerminate);
+
+/**
+ * Create a ConstantDataSequential with string content in the global context.
+ *
+ * This is the same as LLVMConstStringInContext except it operates on the
+ * global context.
+ *
+ * @see LLVMConstStringInContext()
+ * @see llvm::ConstantDataArray::getString()
+ */
+LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
+                             LLVMBool DontNullTerminate);
+
+/**
+ * Returns true if the specified constant is an array of i8.
+ *
+ * @see ConstantDataSequential::getAsString()
+ */
+LLVMBool LLVMIsConstantString(LLVMValueRef c);
+
+/**
+ * Get the given constant data sequential as a string.
+ *
+ * @see ConstantDataSequential::getAsString()
+ */
+const char *LLVMGetAsString(LLVMValueRef c, size_t *Length);
+
+/**
+ * Create an anonymous ConstantStruct with the specified values.
+ *
+ * @see llvm::ConstantStruct::getAnon()
+ */
+LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
+                                      LLVMValueRef *ConstantVals,
+                                      unsigned Count, LLVMBool Packed);
+
+/**
+ * Create a ConstantStruct in the global Context.
+ *
+ * This is the same as LLVMConstStructInContext except it operates on the
+ * global Context.
+ *
+ * @see LLVMConstStructInContext()
+ */
+LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
+                             LLVMBool Packed);
+
+/**
+ * Create a ConstantArray from values.
+ *
+ * @see llvm::ConstantArray::get()
+ */
+LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
+                            LLVMValueRef *ConstantVals, unsigned Length);
+
+/**
+ * Create a non-anonymous ConstantStruct from values.
+ *
+ * @see llvm::ConstantStruct::get()
+ */
+LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
+                                  LLVMValueRef *ConstantVals,
+                                  unsigned Count);
+
+/**
+ * Get an element at specified index as a constant.
+ *
+ * @see ConstantDataSequential::getElementAsConstant()
+ */
+LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx);
+
+/**
+ * Create a ConstantVector from values.
+ *
+ * @see llvm::ConstantVector::get()
+ */
+LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
+ *
+ * Functions in this group correspond to APIs on llvm::ConstantExpr.
+ *
+ * @see llvm::ConstantExpr.
+ *
+ * @{
+ */
+LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
+LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
+LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
+LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
+                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
+                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
+LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
+                          LLVMValueRef *ConstantIndices, unsigned NumIndices);
+LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
+                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
+LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
+                                  LLVMValueRef *ConstantIndices,
+                                  unsigned NumIndices);
+LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
+                                   LLVMValueRef *ConstantIndices,
+                                   unsigned NumIndices);
+LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
+                                    LLVMTypeRef ToType);
+LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
+                                    LLVMTypeRef ToType);
+LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
+                                     LLVMTypeRef ToType);
+LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
+                                  LLVMTypeRef ToType);
+LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
+                              LLVMBool isSigned);
+LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
+LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
+                             LLVMValueRef ConstantIfTrue,
+                             LLVMValueRef ConstantIfFalse);
+LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
+                                     LLVMValueRef IndexConstant);
+LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
+                                    LLVMValueRef ElementValueConstant,
+                                    LLVMValueRef IndexConstant);
+LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
+                                    LLVMValueRef VectorBConstant,
+                                    LLVMValueRef MaskConstant);
+LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
+                                   unsigned NumIdx);
+LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
+                                  LLVMValueRef ElementValueConstant,
+                                  unsigned *IdxList, unsigned NumIdx);
+LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
+
+/** Deprecated: Use LLVMGetInlineAsm instead. */
+LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
+                                const char *AsmString, const char *Constraints,
+                                LLVMBool HasSideEffects, LLVMBool IsAlignStack);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueConstantGlobals Global Values
+ *
+ * This group contains functions that operate on global values. Functions in
+ * this group relate to functions in the llvm::GlobalValue class tree.
+ *
+ * @see llvm::GlobalValue
+ *
+ * @{
+ */
+
+LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
+LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
+LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
+void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
+const char *LLVMGetSection(LLVMValueRef Global);
+void LLVMSetSection(LLVMValueRef Global, const char *Section);
+LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
+void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
+LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global);
+void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class);
+LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global);
+void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr);
+
+/**
+ * Returns the "value type" of a global value.  This differs from the formal
+ * type of a global value which is always a pointer type.
+ *
+ * @see llvm::GlobalValue::getValueType()
+ */
+LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global);
+
+/** Deprecated: Use LLVMGetUnnamedAddress instead. */
+LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global);
+/** Deprecated: Use LLVMSetUnnamedAddress instead. */
+void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
+
+/**
+ * @defgroup LLVMCCoreValueWithAlignment Values with alignment
+ *
+ * Functions in this group only apply to values with alignment, i.e.
+ * global variables, load and store instructions.
+ */
+
+/**
+ * Obtain the preferred alignment of the value.
+ * @see llvm::AllocaInst::getAlignment()
+ * @see llvm::LoadInst::getAlignment()
+ * @see llvm::StoreInst::getAlignment()
+ * @see llvm::GlobalValue::getAlignment()
+ */
+unsigned LLVMGetAlignment(LLVMValueRef V);
+
+/**
+ * Set the preferred alignment of the value.
+ * @see llvm::AllocaInst::setAlignment()
+ * @see llvm::LoadInst::setAlignment()
+ * @see llvm::StoreInst::setAlignment()
+ * @see llvm::GlobalValue::setAlignment()
+ */
+void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
+
+/**
+ * Sets a metadata attachment, erasing the existing metadata attachment if
+ * it already exists for the given kind.
+ *
+ * @see llvm::GlobalObject::setMetadata()
+ */
+void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind,
+                           LLVMMetadataRef MD);
+
+/**
+ * Erases a metadata attachment of the given kind if it exists.
+ *
+ * @see llvm::GlobalObject::eraseMetadata()
+ */
+void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind);
+
+/**
+ * Removes all metadata attachments from this value.
+ *
+ * @see llvm::GlobalObject::clearMetadata()
+ */
+void LLVMGlobalClearMetadata(LLVMValueRef Global);
+
+/**
+ * Retrieves an array of metadata entries representing the metadata attached to
+ * this value. The caller is responsible for freeing this array by calling
+ * \c LLVMDisposeValueMetadataEntries.
+ *
+ * @see llvm::GlobalObject::getAllMetadata()
+ */
+LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value,
+                                                  size_t *NumEntries);
+
+/**
+ * Destroys value metadata entries.
+ */
+void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries);
+
+/**
+ * Returns the kind of a value metadata entry at a specific index.
+ */
+unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries,
+                                         unsigned Index);
+
+/**
+ * Returns the underlying metadata node of a value metadata entry at a
+ * specific index.
+ */
+LLVMMetadataRef
+LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries,
+                                    unsigned Index);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
+ *
+ * This group contains functions that operate on global variable values.
+ *
+ * @see llvm::GlobalVariable
+ *
+ * @{
+ */
+LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
+LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
+                                         const char *Name,
+                                         unsigned AddressSpace);
+LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
+LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
+LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
+LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
+LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
+void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
+LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
+void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
+LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
+void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
+LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
+void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
+LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar);
+void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode);
+LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
+void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
+ *
+ * This group contains function that operate on global alias values.
+ *
+ * @see llvm::GlobalAlias
+ *
+ * @{
+ */
+LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
+                          const char *Name);
+
+/**
+ * Obtain a GlobalAlias value from a Module by its name.
+ *
+ * The returned value corresponds to a llvm::GlobalAlias value.
+ *
+ * @see llvm::Module::getNamedAlias()
+ */
+LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M,
+                                     const char *Name, size_t NameLen);
+
+/**
+ * Obtain an iterator to the first GlobalAlias in a Module.
+ *
+ * @see llvm::Module::alias_begin()
+ */
+LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M);
+
+/**
+ * Obtain an iterator to the last GlobalAlias in a Module.
+ *
+ * @see llvm::Module::alias_end()
+ */
+LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M);
+
+/**
+ * Advance a GlobalAlias iterator to the next GlobalAlias.
+ *
+ * Returns NULL if the iterator was already at the end and there are no more
+ * global aliases.
+ */
+LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA);
+
+/**
+ * Decrement a GlobalAlias iterator to the previous GlobalAlias.
+ *
+ * Returns NULL if the iterator was already at the beginning and there are
+ * no previous global aliases.
+ */
+LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA);
+
+/**
+ * Retrieve the target value of an alias.
+ */
+LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias);
+
+/**
+ * Set the target value of an alias.
+ */
+void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueFunction Function values
+ *
+ * Functions in this group operate on LLVMValueRef instances that
+ * correspond to llvm::Function instances.
+ *
+ * @see llvm::Function
+ *
+ * @{
+ */
+
+/**
+ * Remove a function from its containing module and deletes it.
+ *
+ * @see llvm::Function::eraseFromParent()
+ */
+void LLVMDeleteFunction(LLVMValueRef Fn);
+
+/**
+ * Check whether the given function has a personality function.
+ *
+ * @see llvm::Function::hasPersonalityFn()
+ */
+LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn);
+
+/**
+ * Obtain the personality function attached to the function.
+ *
+ * @see llvm::Function::getPersonalityFn()
+ */
+LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn);
+
+/**
+ * Set the personality function attached to the function.
+ *
+ * @see llvm::Function::setPersonalityFn()
+ */
+void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn);
+
+/**
+ * Obtain the intrinsic ID number which matches the given function name.
+ *
+ * @see llvm::Function::lookupIntrinsicID()
+ */
+unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen);
+
+/**
+ * Obtain the ID number from a function instance.
+ *
+ * @see llvm::Function::getIntrinsicID()
+ */
+unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
+
+/**
+ * Create or insert the declaration of an intrinsic.  For overloaded intrinsics,
+ * parameter types must be provided to uniquely identify an overload.
+ *
+ * @see llvm::Intrinsic::getDeclaration()
+ */
+LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod,
+                                         unsigned ID,
+                                         LLVMTypeRef *ParamTypes,
+                                         size_t ParamCount);
+
+/**
+ * Retrieves the type of an intrinsic.  For overloaded intrinsics, parameter
+ * types must be provided to uniquely identify an overload.
+ *
+ * @see llvm::Intrinsic::getType()
+ */
+LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID,
+                                 LLVMTypeRef *ParamTypes, size_t ParamCount);
+
+/**
+ * Retrieves the name of an intrinsic.
+ *
+ * @see llvm::Intrinsic::getName()
+ */
+const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength);
+
+/**
+ * Copies the name of an overloaded intrinsic identified by a given list of
+ * parameter types.
+ *
+ * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the
+ * returned string.
+ *
+ * @see llvm::Intrinsic::getName()
+ */
+const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
+                                            LLVMTypeRef *ParamTypes,
+                                            size_t ParamCount,
+                                            size_t *NameLength);
+
+/**
+ * Obtain if the intrinsic identified by the given ID is overloaded.
+ *
+ * @see llvm::Intrinsic::isOverloaded()
+ */
+LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID);
+
+/**
+ * Obtain the calling function of a function.
+ *
+ * The returned value corresponds to the LLVMCallConv enumeration.
+ *
+ * @see llvm::Function::getCallingConv()
+ */
+unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
+
+/**
+ * Set the calling convention of a function.
+ *
+ * @see llvm::Function::setCallingConv()
+ *
+ * @param Fn Function to operate on
+ * @param CC LLVMCallConv to set calling convention to
+ */
+void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
+
+/**
+ * Obtain the name of the garbage collector to use during code
+ * generation.
+ *
+ * @see llvm::Function::getGC()
+ */
+const char *LLVMGetGC(LLVMValueRef Fn);
+
+/**
+ * Define the garbage collector to use during code generation.
+ *
+ * @see llvm::Function::setGC()
+ */
+void LLVMSetGC(LLVMValueRef Fn, const char *Name);
+
+/**
+ * Add an attribute to a function.
+ *
+ * @see llvm::Function::addAttribute()
+ */
+void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
+                             LLVMAttributeRef A);
+unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx);
+void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
+                              LLVMAttributeRef *Attrs);
+LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
+                                             LLVMAttributeIndex Idx,
+                                             unsigned KindID);
+LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
+                                               LLVMAttributeIndex Idx,
+                                               const char *K, unsigned KLen);
+void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
+                                    unsigned KindID);
+void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
+                                      const char *K, unsigned KLen);
+
+/**
+ * Add a target-dependent attribute to a function
+ * @see llvm::AttrBuilder::addAttribute()
+ */
+void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
+                                        const char *V);
+
+/**
+ * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
+ *
+ * Functions in this group relate to arguments/parameters on functions.
+ *
+ * Functions in this group expect LLVMValueRef instances that correspond
+ * to llvm::Function instances.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the number of parameters in a function.
+ *
+ * @see llvm::Function::arg_size()
+ */
+unsigned LLVMCountParams(LLVMValueRef Fn);
+
+/**
+ * Obtain the parameters in a function.
+ *
+ * The takes a pointer to a pre-allocated array of LLVMValueRef that is
+ * at least LLVMCountParams() long. This array will be filled with
+ * LLVMValueRef instances which correspond to the parameters the
+ * function receives. Each LLVMValueRef corresponds to a llvm::Argument
+ * instance.
+ *
+ * @see llvm::Function::arg_begin()
+ */
+void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
+
+/**
+ * Obtain the parameter at the specified index.
+ *
+ * Parameters are indexed from 0.
+ *
+ * @see llvm::Function::arg_begin()
+ */
+LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
+
+/**
+ * Obtain the function to which this argument belongs.
+ *
+ * Unlike other functions in this group, this one takes an LLVMValueRef
+ * that corresponds to a llvm::Attribute.
+ *
+ * The returned LLVMValueRef is the llvm::Function to which this
+ * argument belongs.
+ */
+LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
+
+/**
+ * Obtain the first parameter to a function.
+ *
+ * @see llvm::Function::arg_begin()
+ */
+LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
+
+/**
+ * Obtain the last parameter to a function.
+ *
+ * @see llvm::Function::arg_end()
+ */
+LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
+
+/**
+ * Obtain the next parameter to a function.
+ *
+ * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
+ * actually a wrapped iterator) and obtains the next parameter from the
+ * underlying iterator.
+ */
+LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
+
+/**
+ * Obtain the previous parameter to a function.
+ *
+ * This is the opposite of LLVMGetNextParam().
+ */
+LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
+
+/**
+ * Set the alignment for a function parameter.
+ *
+ * @see llvm::Argument::addAttr()
+ * @see llvm::AttrBuilder::addAlignmentAttr()
+ */
+void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueGlobalIFunc IFuncs
+ *
+ * Functions in this group relate to indirect functions.
+ *
+ * Functions in this group expect LLVMValueRef instances that correspond
+ * to llvm::GlobalIFunc instances.
+ *
+ * @{
+ */
+
+/**
+ * Add a global indirect function to a module under a specified name.
+ *
+ * @see llvm::GlobalIFunc::create()
+ */
+LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M,
+                                const char *Name, size_t NameLen,
+                                LLVMTypeRef Ty, unsigned AddrSpace,
+                                LLVMValueRef Resolver);
+
+/**
+ * Obtain a GlobalIFunc value from a Module by its name.
+ *
+ * The returned value corresponds to a llvm::GlobalIFunc value.
+ *
+ * @see llvm::Module::getNamedIFunc()
+ */
+LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M,
+                                     const char *Name, size_t NameLen);
+
+/**
+ * Obtain an iterator to the first GlobalIFunc in a Module.
+ *
+ * @see llvm::Module::ifunc_begin()
+ */
+LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M);
+
+/**
+ * Obtain an iterator to the last GlobalIFunc in a Module.
+ *
+ * @see llvm::Module::ifunc_end()
+ */
+LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M);
+
+/**
+ * Advance a GlobalIFunc iterator to the next GlobalIFunc.
+ *
+ * Returns NULL if the iterator was already at the end and there are no more
+ * global aliases.
+ */
+LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc);
+
+/**
+ * Decrement a GlobalIFunc iterator to the previous GlobalIFunc.
+ *
+ * Returns NULL if the iterator was already at the beginning and there are
+ * no previous global aliases.
+ */
+LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc);
+
+/**
+ * Retrieves the resolver function associated with this indirect function, or
+ * NULL if it doesn't not exist.
+ *
+ * @see llvm::GlobalIFunc::getResolver()
+ */
+LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc);
+
+/**
+ * Sets the resolver function associated with this indirect function.
+ *
+ * @see llvm::GlobalIFunc::setResolver()
+ */
+void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver);
+
+/**
+ * Remove a global indirect function from its parent module and delete it.
+ *
+ * @see llvm::GlobalIFunc::eraseFromParent()
+ */
+void LLVMEraseGlobalIFunc(LLVMValueRef IFunc);
+
+/**
+ * Remove a global indirect function from its parent module.
+ *
+ * This unlinks the global indirect function from its containing module but
+ * keeps it alive.
+ *
+ * @see llvm::GlobalIFunc::removeFromParent()
+ */
+void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueMetadata Metadata
+ *
+ * @{
+ */
+
+/**
+ * Create an MDString value from a given string value.
+ *
+ * The MDString value does not take ownership of the given string, it remains
+ * the responsibility of the caller to free it.
+ *
+ * @see llvm::MDString::get()
+ */
+LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str,
+                                       size_t SLen);
+
+/**
+ * Create an MDNode value with the given array of operands.
+ *
+ * @see llvm::MDNode::get()
+ */
+LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs,
+                                     size_t Count);
+
+/**
+ * Obtain a Metadata as a Value.
+ */
+LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD);
+
+/**
+ * Obtain a Value as a Metadata.
+ */
+LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val);
+
+/**
+ * Obtain the underlying string from a MDString value.
+ *
+ * @param V Instance to obtain string from.
+ * @param Length Memory address which will hold length of returned string.
+ * @return String data in MDString.
+ */
+const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length);
+
+/**
+ * Obtain the number of operands from an MDNode value.
+ *
+ * @param V MDNode to get number of operands from.
+ * @return Number of operands of the MDNode.
+ */
+unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V);
+
+/**
+ * Obtain the given MDNode's operands.
+ *
+ * The passed LLVMValueRef pointer should point to enough memory to hold all of
+ * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
+ * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
+ * MDNode's operands.
+ *
+ * @param V MDNode to get the operands from.
+ * @param Dest Destination array for operands.
+ */
+void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest);
+
+/** Deprecated: Use LLVMMDStringInContext2 instead. */
+LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
+                                   unsigned SLen);
+/** Deprecated: Use LLVMMDStringInContext2 instead. */
+LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
+/** Deprecated: Use LLVMMDNodeInContext2 instead. */
+LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
+                                 unsigned Count);
+/** Deprecated: Use LLVMMDNodeInContext2 instead. */
+LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueBasicBlock Basic Block
+ *
+ * A basic block represents a single entry single exit section of code.
+ * Basic blocks contain a list of instructions which form the body of
+ * the block.
+ *
+ * Basic blocks belong to functions. They have the type of label.
+ *
+ * Basic blocks are themselves values. However, the C API models them as
+ * LLVMBasicBlockRef.
+ *
+ * @see llvm::BasicBlock
+ *
+ * @{
+ */
+
+/**
+ * Convert a basic block instance to a value type.
+ */
+LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
+
+/**
+ * Determine whether an LLVMValueRef is itself a basic block.
+ */
+LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
+
+/**
+ * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
+ */
+LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
+
+/**
+ * Obtain the string name of a basic block.
+ */
+const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB);
+
+/**
+ * Obtain the function to which a basic block belongs.
+ *
+ * @see llvm::BasicBlock::getParent()
+ */
+LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
+
+/**
+ * Obtain the terminator instruction for a basic block.
+ *
+ * If the basic block does not have a terminator (it is not well-formed
+ * if it doesn't), then NULL is returned.
+ *
+ * The returned LLVMValueRef corresponds to an llvm::Instruction.
+ *
+ * @see llvm::BasicBlock::getTerminator()
+ */
+LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
+
+/**
+ * Obtain the number of basic blocks in a function.
+ *
+ * @param Fn Function value to operate on.
+ */
+unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
+
+/**
+ * Obtain all of the basic blocks in a function.
+ *
+ * This operates on a function value. The BasicBlocks parameter is a
+ * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
+ * LLVMCountBasicBlocks() in length. This array is populated with
+ * LLVMBasicBlockRef instances.
+ */
+void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
+
+/**
+ * Obtain the first basic block in a function.
+ *
+ * The returned basic block can be used as an iterator. You will likely
+ * eventually call into LLVMGetNextBasicBlock() with it.
+ *
+ * @see llvm::Function::begin()
+ */
+LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
+
+/**
+ * Obtain the last basic block in a function.
+ *
+ * @see llvm::Function::end()
+ */
+LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
+
+/**
+ * Advance a basic block iterator.
+ */
+LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
+
+/**
+ * Go backwards in a basic block iterator.
+ */
+LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
+
+/**
+ * Obtain the basic block that corresponds to the entry point of a
+ * function.
+ *
+ * @see llvm::Function::getEntryBlock()
+ */
+LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
+
+/**
+ * Insert the given basic block after the insertion point of the given builder.
+ *
+ * The insertion point must be valid.
+ *
+ * @see llvm::Function::BasicBlockListType::insertAfter()
+ */
+void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder,
+                                                  LLVMBasicBlockRef BB);
+
+/**
+ * Append the given basic block to the basic block list of the given function.
+ *
+ * @see llvm::Function::BasicBlockListType::push_back()
+ */
+void LLVMAppendExistingBasicBlock(LLVMValueRef Fn,
+                                  LLVMBasicBlockRef BB);
+
+/**
+ * Create a new basic block without inserting it into a function.
+ *
+ * @see llvm::BasicBlock::Create()
+ */
+LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C,
+                                                const char *Name);
+
+/**
+ * Append a basic block to the end of a function.
+ *
+ * @see llvm::BasicBlock::Create()
+ */
+LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
+                                                LLVMValueRef Fn,
+                                                const char *Name);
+
+/**
+ * Append a basic block to the end of a function using the global
+ * context.
+ *
+ * @see llvm::BasicBlock::Create()
+ */
+LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
+
+/**
+ * Insert a basic block in a function before another basic block.
+ *
+ * The function to add to is determined by the function of the
+ * passed basic block.
+ *
+ * @see llvm::BasicBlock::Create()
+ */
+LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
+                                                LLVMBasicBlockRef BB,
+                                                const char *Name);
+
+/**
+ * Insert a basic block in a function using the global context.
+ *
+ * @see llvm::BasicBlock::Create()
+ */
+LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
+                                       const char *Name);
+
+/**
+ * Remove a basic block from a function and delete it.
+ *
+ * This deletes the basic block from its containing function and deletes
+ * the basic block itself.
+ *
+ * @see llvm::BasicBlock::eraseFromParent()
+ */
+void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
+
+/**
+ * Remove a basic block from a function.
+ *
+ * This deletes the basic block from its containing function but keep
+ * the basic block alive.
+ *
+ * @see llvm::BasicBlock::removeFromParent()
+ */
+void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
+
+/**
+ * Move a basic block to before another one.
+ *
+ * @see llvm::BasicBlock::moveBefore()
+ */
+void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
+
+/**
+ * Move a basic block to after another one.
+ *
+ * @see llvm::BasicBlock::moveAfter()
+ */
+void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
+
+/**
+ * Obtain the first instruction in a basic block.
+ *
+ * The returned LLVMValueRef corresponds to a llvm::Instruction
+ * instance.
+ */
+LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
+
+/**
+ * Obtain the last instruction in a basic block.
+ *
+ * The returned LLVMValueRef corresponds to an LLVM:Instruction.
+ */
+LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstruction Instructions
+ *
+ * Functions in this group relate to the inspection and manipulation of
+ * individual instructions.
+ *
+ * In the C++ API, an instruction is modeled by llvm::Instruction. This
+ * class has a large number of descendents. llvm::Instruction is a
+ * llvm::Value and in the C API, instructions are modeled by
+ * LLVMValueRef.
+ *
+ * This group also contains sub-groups which operate on specific
+ * llvm::Instruction types, e.g. llvm::CallInst.
+ *
+ * @{
+ */
+
+/**
+ * Determine whether an instruction has any metadata attached.
+ */
+int LLVMHasMetadata(LLVMValueRef Val);
+
+/**
+ * Return metadata associated with an instruction value.
+ */
+LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
+
+/**
+ * Set metadata associated with an instruction value.
+ */
+void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
+
+/**
+ * Returns the metadata associated with an instruction value, but filters out
+ * all the debug locations.
+ *
+ * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc()
+ */
+LLVMValueMetadataEntry *
+LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr,
+                                               size_t *NumEntries);
+
+/**
+ * Obtain the basic block to which an instruction belongs.
+ *
+ * @see llvm::Instruction::getParent()
+ */
+LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
+
+/**
+ * Obtain the instruction that occurs after the one specified.
+ *
+ * The next instruction will be from the same basic block.
+ *
+ * If this is the last instruction in a basic block, NULL will be
+ * returned.
+ */
+LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
+
+/**
+ * Obtain the instruction that occurred before this one.
+ *
+ * If the instruction is the first instruction in a basic block, NULL
+ * will be returned.
+ */
+LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
+
+/**
+ * Remove and delete an instruction.
+ *
+ * The instruction specified is removed from its containing building
+ * block but is kept alive.
+ *
+ * @see llvm::Instruction::removeFromParent()
+ */
+void LLVMInstructionRemoveFromParent(LLVMValueRef Inst);
+
+/**
+ * Remove and delete an instruction.
+ *
+ * The instruction specified is removed from its containing building
+ * block and then deleted.
+ *
+ * @see llvm::Instruction::eraseFromParent()
+ */
+void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
+
+/**
+ * Obtain the code opcode for an individual instruction.
+ *
+ * @see llvm::Instruction::getOpCode()
+ */
+LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst);
+
+/**
+ * Obtain the predicate of an instruction.
+ *
+ * This is only valid for instructions that correspond to llvm::ICmpInst
+ * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
+ *
+ * @see llvm::ICmpInst::getPredicate()
+ */
+LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
+
+/**
+ * Obtain the float predicate of an instruction.
+ *
+ * This is only valid for instructions that correspond to llvm::FCmpInst
+ * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.
+ *
+ * @see llvm::FCmpInst::getPredicate()
+ */
+LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst);
+
+/**
+ * Create a copy of 'this' instruction that is identical in all ways
+ * except the following:
+ *   * The instruction has no parent
+ *   * The instruction has no name
+ *
+ * @see llvm::Instruction::clone()
+ */
+LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
+
+/**
+ * Determine whether an instruction is a terminator. This routine is named to
+ * be compatible with historical functions that did this by querying the
+ * underlying C++ type.
+ *
+ * @see llvm::Instruction::isTerminator()
+ */
+LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst);
+
+/**
+ * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
+ *
+ * Functions in this group apply to instructions that refer to call
+ * sites and invocations. These correspond to C++ types in the
+ * llvm::CallInst class tree.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the argument count for a call instruction.
+ *
+ * This expects an LLVMValueRef that corresponds to a llvm::CallInst,
+ * llvm::InvokeInst, or llvm:FuncletPadInst.
+ *
+ * @see llvm::CallInst::getNumArgOperands()
+ * @see llvm::InvokeInst::getNumArgOperands()
+ * @see llvm::FuncletPadInst::getNumArgOperands()
+ */
+unsigned LLVMGetNumArgOperands(LLVMValueRef Instr);
+
+/**
+ * Set the calling convention for a call instruction.
+ *
+ * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
+ * llvm::InvokeInst.
+ *
+ * @see llvm::CallInst::setCallingConv()
+ * @see llvm::InvokeInst::setCallingConv()
+ */
+void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
+
+/**
+ * Obtain the calling convention for a call instruction.
+ *
+ * This is the opposite of LLVMSetInstructionCallConv(). Reads its
+ * usage.
+ *
+ * @see LLVMSetInstructionCallConv()
+ */
+unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
+
+void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
+                                unsigned Align);
+
+void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
+                              LLVMAttributeRef A);
+unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx);
+void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
+                               LLVMAttributeRef *Attrs);
+LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
+                                              LLVMAttributeIndex Idx,
+                                              unsigned KindID);
+LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
+                                                LLVMAttributeIndex Idx,
+                                                const char *K, unsigned KLen);
+void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
+                                     unsigned KindID);
+void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
+                                       const char *K, unsigned KLen);
+
+/**
+ * Obtain the function type called by this instruction.
+ *
+ * @see llvm::CallBase::getFunctionType()
+ */
+LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef C);
+
+/**
+ * Obtain the pointer to the function invoked by this instruction.
+ *
+ * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
+ * llvm::InvokeInst.
+ *
+ * @see llvm::CallInst::getCalledValue()
+ * @see llvm::InvokeInst::getCalledValue()
+ */
+LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr);
+
+/**
+ * Obtain whether a call instruction is a tail call.
+ *
+ * This only works on llvm::CallInst instructions.
+ *
+ * @see llvm::CallInst::isTailCall()
+ */
+LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
+
+/**
+ * Set whether a call instruction is a tail call.
+ *
+ * This only works on llvm::CallInst instructions.
+ *
+ * @see llvm::CallInst::setTailCall()
+ */
+void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
+
+/**
+ * Return the normal destination basic block.
+ *
+ * This only works on llvm::InvokeInst instructions.
+ *
+ * @see llvm::InvokeInst::getNormalDest()
+ */
+LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst);
+
+/**
+ * Return the unwind destination basic block.
+ *
+ * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
+ * llvm::CatchSwitchInst instructions.
+ *
+ * @see llvm::InvokeInst::getUnwindDest()
+ * @see llvm::CleanupReturnInst::getUnwindDest()
+ * @see llvm::CatchSwitchInst::getUnwindDest()
+ */
+LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst);
+
+/**
+ * Set the normal destination basic block.
+ *
+ * This only works on llvm::InvokeInst instructions.
+ *
+ * @see llvm::InvokeInst::setNormalDest()
+ */
+void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B);
+
+/**
+ * Set the unwind destination basic block.
+ *
+ * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
+ * llvm::CatchSwitchInst instructions.
+ *
+ * @see llvm::InvokeInst::setUnwindDest()
+ * @see llvm::CleanupReturnInst::setUnwindDest()
+ * @see llvm::CatchSwitchInst::setUnwindDest()
+ */
+void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstructionTerminator Terminators
+ *
+ * Functions in this group only apply to instructions for which
+ * LLVMIsATerminatorInst returns true.
+ *
+ * @{
+ */
+
+/**
+ * Return the number of successors that this terminator has.
+ *
+ * @see llvm::Instruction::getNumSuccessors
+ */
+unsigned LLVMGetNumSuccessors(LLVMValueRef Term);
+
+/**
+ * Return the specified successor.
+ *
+ * @see llvm::Instruction::getSuccessor
+ */
+LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i);
+
+/**
+ * Update the specified successor to point at the provided block.
+ *
+ * @see llvm::Instruction::setSuccessor
+ */
+void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block);
+
+/**
+ * Return if a branch is conditional.
+ *
+ * This only works on llvm::BranchInst instructions.
+ *
+ * @see llvm::BranchInst::isConditional
+ */
+LLVMBool LLVMIsConditional(LLVMValueRef Branch);
+
+/**
+ * Return the condition of a branch instruction.
+ *
+ * This only works on llvm::BranchInst instructions.
+ *
+ * @see llvm::BranchInst::getCondition
+ */
+LLVMValueRef LLVMGetCondition(LLVMValueRef Branch);
+
+/**
+ * Set the condition of a branch instruction.
+ *
+ * This only works on llvm::BranchInst instructions.
+ *
+ * @see llvm::BranchInst::setCondition
+ */
+void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond);
+
+/**
+ * Obtain the default destination basic block of a switch instruction.
+ *
+ * This only works on llvm::SwitchInst instructions.
+ *
+ * @see llvm::SwitchInst::getDefaultDest()
+ */
+LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstructionAlloca Allocas
+ *
+ * Functions in this group only apply to instructions that map to
+ * llvm::AllocaInst instances.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the type that is being allocated by the alloca instruction.
+ */
+LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs
+ *
+ * Functions in this group only apply to instructions that map to
+ * llvm::GetElementPtrInst instances.
+ *
+ * @{
+ */
+
+/**
+ * Check whether the given GEP instruction is inbounds.
+ */
+LLVMBool LLVMIsInBounds(LLVMValueRef GEP);
+
+/**
+ * Set the given GEP instruction to be inbounds or not.
+ */
+void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
+ *
+ * Functions in this group only apply to instructions that map to
+ * llvm::PHINode instances.
+ *
+ * @{
+ */
+
+/**
+ * Add an incoming value to the end of a PHI list.
+ */
+void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
+                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
+
+/**
+ * Obtain the number of incoming basic blocks to a PHI node.
+ */
+unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
+
+/**
+ * Obtain an incoming value to a PHI node as an LLVMValueRef.
+ */
+LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
+
+/**
+ * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
+ */
+LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue
+ * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue
+ *
+ * Functions in this group only apply to instructions that map to
+ * llvm::ExtractValue and llvm::InsertValue instances.
+ *
+ * @{
+ */
+
+/**
+ * Obtain the number of indices.
+ * NB: This also works on GEP.
+ */
+unsigned LLVMGetNumIndices(LLVMValueRef Inst);
+
+/**
+ * Obtain the indices as an array.
+ */
+const unsigned *LLVMGetIndices(LLVMValueRef Inst);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
+ *
+ * An instruction builder represents a point within a basic block and is
+ * the exclusive means of building instructions using the C interface.
+ *
+ * @{
+ */
+
+LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
+LLVMBuilderRef LLVMCreateBuilder(void);
+void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
+                         LLVMValueRef Instr);
+void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
+void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
+LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
+void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
+void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
+void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
+                                   const char *Name);
+void LLVMDisposeBuilder(LLVMBuilderRef Builder);
+
+/* Metadata */
+
+/**
+ * Get location information used by debugging information.
+ *
+ * @see llvm::IRBuilder::getCurrentDebugLocation()
+ */
+LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder);
+
+/**
+ * Set location information used by debugging information.
+ *
+ * To clear the location metadata of the given instruction, pass NULL to \p Loc.
+ *
+ * @see llvm::IRBuilder::SetCurrentDebugLocation()
+ */
+void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc);
+
+/**
+ * Attempts to set the debug location for the given instruction using the
+ * current debug location for the given builder.  If the builder has no current
+ * debug location, this function is a no-op.
+ *
+ * @see llvm::IRBuilder::SetInstDebugLocation()
+ */
+void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
+
+/**
+ * Get the dafult floating-point math metadata for a given builder.
+ *
+ * @see llvm::IRBuilder::getDefaultFPMathTag()
+ */
+LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder);
+
+/**
+ * Set the default floating-point math metadata for the given builder.
+ *
+ * To clear the metadata, pass NULL to \p FPMathTag.
+ *
+ * @see llvm::IRBuilder::setDefaultFPMathTag()
+ */
+void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder,
+                                    LLVMMetadataRef FPMathTag);
+
+/**
+ * Deprecated: Passing the NULL location will crash.
+ * Use LLVMGetCurrentDebugLocation2 instead.
+ */
+void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
+/**
+ * Deprecated: Returning the NULL location will crash.
+ * Use LLVMGetCurrentDebugLocation2 instead.
+ */
+LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
+
+/* Terminators */
+LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
+LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
+LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
+                                   unsigned N);
+LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
+LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
+                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
+LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
+                             LLVMBasicBlockRef Else, unsigned NumCases);
+LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
+                                 unsigned NumDests);
+// LLVMBuildInvoke is deprecated in favor of LLVMBuildInvoke2, in preparation
+// for opaque pointer types.
+LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
+                             LLVMValueRef *Args, unsigned NumArgs,
+                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
+                             const char *Name);
+LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn,
+                              LLVMValueRef *Args, unsigned NumArgs,
+                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
+                              const char *Name);
+LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
+
+/* Exception Handling */
+LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
+LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
+                                 LLVMValueRef PersFn, unsigned NumClauses,
+                                 const char *Name);
+LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
+                                 LLVMBasicBlockRef BB);
+LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
+                               LLVMBasicBlockRef BB);
+LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                               LLVMValueRef *Args, unsigned NumArgs,
+                               const char *Name);
+LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                                 LLVMValueRef *Args, unsigned NumArgs,
+                                 const char *Name);
+LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                                  LLVMBasicBlockRef UnwindBB,
+                                  unsigned NumHandlers, const char *Name);
+
+/* Add a case to the switch instruction */
+void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
+                 LLVMBasicBlockRef Dest);
+
+/* Add a destination to the indirectbr instruction */
+void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
+
+/* Get the number of clauses on the landingpad instruction */
+unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
+
+/* Get the value of the clause at idnex Idx on the landingpad instruction */
+LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
+
+/* Add a catch or filter clause to the landingpad instruction */
+void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
+
+/* Get the 'cleanup' flag in the landingpad instruction */
+LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
+
+/* Set the 'cleanup' flag in the landingpad instruction */
+void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
+
+/* Add a destination to the catchswitch instruction */
+void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest);
+
+/* Get the number of handlers on the catchswitch instruction */
+unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch);
+
+/**
+ * Obtain the basic blocks acting as handlers for a catchswitch instruction.
+ *
+ * The Handlers parameter should point to a pre-allocated array of
+ * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the
+ * first LLVMGetNumHandlers() entries in the array will be populated
+ * with LLVMBasicBlockRef instances.
+ *
+ * @param CatchSwitch The catchswitch instruction to operate on.
+ * @param Handlers Memory address of an array to be filled with basic blocks.
+ */
+void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers);
+
+/* Funclets */
+
+/* Get the number of funcletpad arguments. */
+LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i);
+
+/* Set a funcletpad argument at the given index. */
+void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value);
+
+/**
+ * Get the parent catchswitch instruction of a catchpad instruction.
+ *
+ * This only works on llvm::CatchPadInst instructions.
+ *
+ * @see llvm::CatchPadInst::getCatchSwitch()
+ */
+LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad);
+
+/**
+ * Set the parent catchswitch instruction of a catchpad instruction.
+ *
+ * This only works on llvm::CatchPadInst instructions.
+ *
+ * @see llvm::CatchPadInst::setCatchSwitch()
+ */
+void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch);
+
+/* Arithmetic */
+LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                             const char *Name);
+LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                                const char *Name);
+LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                                const char *Name);
+LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
+                          const char *Name);
+LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
+                            LLVMValueRef LHS, LLVMValueRef RHS,
+                            const char *Name);
+LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
+LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
+                             const char *Name);
+LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
+                             const char *Name);
+LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
+LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
+
+/* Memory */
+LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
+LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
+                                  LLVMValueRef Val, const char *Name);
+
+/**
+ * Creates and inserts a memset to the specified pointer and the
+ * specified value.
+ *
+ * @see llvm::IRRBuilder::CreateMemSet()
+ */
+LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr,
+                             LLVMValueRef Val, LLVMValueRef Len,
+                             unsigned Align);
+/**
+ * Creates and inserts a memcpy between the specified pointers.
+ *
+ * @see llvm::IRRBuilder::CreateMemCpy()
+ */
+LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B,
+                             LLVMValueRef Dst, unsigned DstAlign,
+                             LLVMValueRef Src, unsigned SrcAlign,
+                             LLVMValueRef Size);
+/**
+ * Creates and inserts a memmove between the specified pointers.
+ *
+ * @see llvm::IRRBuilder::CreateMemMove()
+ */
+LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B,
+                              LLVMValueRef Dst, unsigned DstAlign,
+                              LLVMValueRef Src, unsigned SrcAlign,
+                              LLVMValueRef Size);
+
+LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
+LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
+                                  LLVMValueRef Val, const char *Name);
+LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
+// LLVMBuildLoad is deprecated in favor of LLVMBuildLoad2, in preparation for
+// opaque pointer types.
+LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
+                           const char *Name);
+LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty,
+                            LLVMValueRef PointerVal, const char *Name);
+LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
+// LLVMBuildGEP, LLVMBuildInBoundsGEP, and LLVMBuildStructGEP are deprecated in
+// favor of LLVMBuild*GEP2, in preparation for opaque pointer types.
+LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
+                          LLVMValueRef *Indices, unsigned NumIndices,
+                          const char *Name);
+LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
+                                  LLVMValueRef *Indices, unsigned NumIndices,
+                                  const char *Name);
+LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
+                                unsigned Idx, const char *Name);
+LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+                           LLVMValueRef Pointer, LLVMValueRef *Indices,
+                           unsigned NumIndices, const char *Name);
+LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+                                   LLVMValueRef Pointer, LLVMValueRef *Indices,
+                                   unsigned NumIndices, const char *Name);
+LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+                                 LLVMValueRef Pointer, unsigned Idx,
+                                 const char *Name);
+LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
+                                   const char *Name);
+LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
+                                      const char *Name);
+LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
+void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
+LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst);
+void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
+
+/* Casts */
+LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
+                            LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
+                           LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
+                           LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
+                             LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
+                             LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
+                             LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
+                             LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
+                              LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
+                            LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
+                               LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
+                               LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
+                              LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val,
+                                    LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
+                                    LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
+                                    LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
+                                     LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
+                           LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
+                                  LLVMTypeRef DestTy, const char *Name);
+LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val,
+                               LLVMTypeRef DestTy, LLVMBool IsSigned,
+                               const char *Name);
+LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
+                             LLVMTypeRef DestTy, const char *Name);
+
+/** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */
+LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
+                              LLVMTypeRef DestTy, const char *Name);
+
+/* Comparisons */
+LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
+                           LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
+                           LLVMValueRef LHS, LLVMValueRef RHS,
+                           const char *Name);
+
+/* Miscellaneous instructions */
+LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
+// LLVMBuildCall is deprecated in favor of LLVMBuildCall2, in preparation for
+// opaque pointer types.
+LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
+                           LLVMValueRef *Args, unsigned NumArgs,
+                           const char *Name);
+LLVMValueRef LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, LLVMValueRef Fn,
+                            LLVMValueRef *Args, unsigned NumArgs,
+                            const char *Name);
+LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
+                             LLVMValueRef Then, LLVMValueRef Else,
+                             const char *Name);
+LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
+                            const char *Name);
+LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
+                                     LLVMValueRef Index, const char *Name);
+LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
+                                    LLVMValueRef EltVal, LLVMValueRef Index,
+                                    const char *Name);
+LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
+                                    LLVMValueRef V2, LLVMValueRef Mask,
+                                    const char *Name);
+LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
+                                   unsigned Index, const char *Name);
+LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
+                                  LLVMValueRef EltVal, unsigned Index,
+                                  const char *Name);
+
+LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
+                             const char *Name);
+LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
+                                const char *Name);
+LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
+                              LLVMValueRef RHS, const char *Name);
+LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering,
+                            LLVMBool singleThread, const char *Name);
+LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
+                                LLVMValueRef PTR, LLVMValueRef Val,
+                                LLVMAtomicOrdering ordering,
+                                LLVMBool singleThread);
+LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
+                                    LLVMValueRef Cmp, LLVMValueRef New,
+                                    LLVMAtomicOrdering SuccessOrdering,
+                                    LLVMAtomicOrdering FailureOrdering,
+                                    LLVMBool SingleThread);
+
+LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
+void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
+
+LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst);
+void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
+                                   LLVMAtomicOrdering Ordering);
+LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst);
+void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
+                                   LLVMAtomicOrdering Ordering);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreModuleProvider Module Providers
+ *
+ * @{
+ */
+
+/**
+ * Changes the type of M so it can be passed to FunctionPassManagers and the
+ * JIT.  They take ModuleProviders for historical reasons.
+ */
+LLVMModuleProviderRef
+LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
+
+/**
+ * Destroys the module M.
+ */
+void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
+ *
+ * @{
+ */
+
+LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
+                                                  LLVMMemoryBufferRef *OutMemBuf,
+                                                  char **OutMessage);
+LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
+                                         char **OutMessage);
+LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData,
+                                                          size_t InputDataLength,
+                                                          const char *BufferName,
+                                                          LLVMBool RequiresNullTerminator);
+LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData,
+                                                              size_t InputDataLength,
+                                                              const char *BufferName);
+const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf);
+size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
+void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCorePassRegistry Pass Registry
+ *
+ * @{
+ */
+
+/** Return the global pass registry, for use with initialization functions.
+    @see llvm::PassRegistry::getPassRegistry */
+LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCorePassManagers Pass Managers
+ *
+ * @{
+ */
+
+/** Constructs a new whole-module pass pipeline. This type of pipeline is
+    suitable for link-time optimization and whole-module transformations.
+    @see llvm::PassManager::PassManager */
+LLVMPassManagerRef LLVMCreatePassManager(void);
+
+/** Constructs a new function-by-function pass pipeline over the module
+    provider. It does not take ownership of the module provider. This type of
+    pipeline is suitable for code generation and JIT compilation tasks.
+    @see llvm::FunctionPassManager::FunctionPassManager */
+LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
+
+/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
+LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
+
+/** Initializes, executes on the provided module, and finalizes all of the
+    passes scheduled in the pass manager. Returns 1 if any of the passes
+    modified the module, 0 otherwise.
+    @see llvm::PassManager::run(Module&) */
+LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
+
+/** Initializes all of the function passes scheduled in the function pass
+    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
+    @see llvm::FunctionPassManager::doInitialization */
+LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
+
+/** Executes all of the function passes scheduled in the function pass manager
+    on the provided function. Returns 1 if any of the passes modified the
+    function, false otherwise.
+    @see llvm::FunctionPassManager::run(Function&) */
+LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
+
+/** Finalizes all of the function passes scheduled in the function pass
+    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
+    @see llvm::FunctionPassManager::doFinalization */
+LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
+
+/** Frees the memory of a pass pipeline. For function pipelines, does not free
+    the module provider.
+    @see llvm::PassManagerBase::~PassManagerBase. */
+void LLVMDisposePassManager(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup LLVMCCoreThreading Threading
+ *
+ * Handle the structures needed to make LLVM safe for multithreading.
+ *
+ * @{
+ */
+
+/** Deprecated: Multi-threading can only be enabled/disabled with the compile
+    time define LLVM_ENABLE_THREADS.  This function always returns
+    LLVMIsMultithreaded(). */
+LLVMBool LLVMStartMultithreaded(void);
+
+/** Deprecated: Multi-threading can only be enabled/disabled with the compile
+    time define LLVM_ENABLE_THREADS. */
+void LLVMStopMultithreaded(void);
+
+/** Check whether LLVM is executing in thread-safe mode or not.
+    @see llvm::llvm_is_multithreaded */
+LLVMBool LLVMIsMultithreaded(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LLVM_C_CORE_H */
diff --git a/src/llvm-c/DataTypes.h b/src/llvm-c/DataTypes.h
new file mode 100644
index 000000000..893b22b49
--- /dev/null
+++ b/src/llvm-c/DataTypes.h
@@ -0,0 +1,90 @@
+/*===-- include/llvm-c/DataTypes.h - Define fixed size types ------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file contains definitions to figure out the size of _HOST_ data types.*|
+|* This file is important because different host OS's define different macros,*|
+|* which makes portability tough.  This file exports the following            *|
+|* definitions:                                                               *|
+|*                                                                            *|
+|*   [u]int(32|64)_t : typedefs for signed and unsigned 32/64 bit system types*|
+|*   [U]INT(8|16|32|64)_(MIN|MAX) : Constants for the min and max values.     *|
+|*                                                                            *|
+|* No library is required when using these functions.                         *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*/
+
+/* Please leave this file C-compatible. */
+
+#ifndef LLVM_C_DATATYPES_H
+#define LLVM_C_DATATYPES_H
+
+#ifdef __cplusplus
+#include <cmath>
+#else
+#include <math.h>
+#endif
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#ifndef _MSC_VER
+
+#if !defined(UINT32_MAX)
+# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
+        "__STDC_LIMIT_MACROS before #including llvm-c/DataTypes.h"
+#endif
+
+#if !defined(UINT32_C)
+# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
+        "__STDC_CONSTANT_MACROS before #including llvm-c/DataTypes.h"
+#endif
+
+/* Note that <inttypes.h> includes <stdint.h>, if this is a C99 system. */
+#include <sys/types.h>
+
+#ifdef _AIX
+// GCC is strict about defining large constants: they must have LL modifier.
+#undef INT64_MAX
+#undef INT64_MIN
+#endif
+
+#else /* _MSC_VER */
+#ifdef __cplusplus
+#include <cstddef>
+#include <cstdlib>
+#else
+#include <stddef.h>
+#include <stdlib.h>
+#endif
+#include <sys/types.h>
+
+#if defined(_WIN64)
+typedef signed __int64 ssize_t;
+#else
+typedef signed int ssize_t;
+#endif /* _WIN64 */
+
+#endif /* _MSC_VER */
+
+/* Set defaults for constants which we cannot find. */
+#if !defined(INT64_MAX)
+# define INT64_MAX 9223372036854775807LL
+#endif
+#if !defined(INT64_MIN)
+# define INT64_MIN ((-INT64_MAX)-1)
+#endif
+#if !defined(UINT64_MAX)
+# define UINT64_MAX 0xffffffffffffffffULL
+#endif
+
+#ifndef HUGE_VALF
+#define HUGE_VALF (float)HUGE_VAL
+#endif
+
+#endif /* LLVM_C_DATATYPES_H */
diff --git a/src/llvm-c/DebugInfo.h b/src/llvm-c/DebugInfo.h
new file mode 100644
index 000000000..33c8110a8
--- /dev/null
+++ b/src/llvm-c/DebugInfo.h
@@ -0,0 +1,1315 @@
+//===------------ DebugInfo.h - LLVM C API Debug Info API -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file declares the C API endpoints for generating DWARF Debug Info
+///
+/// Note: This interface is experimental. It is *NOT* stable, and may be
+///       changed without warning.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_C_DEBUGINFO_H
+#define LLVM_C_DEBUGINFO_H
+
+#include "llvm-c/Core.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Debug info flags.
+ */
+typedef enum {
+  LLVMDIFlagZero = 0,
+  LLVMDIFlagPrivate = 1,
+  LLVMDIFlagProtected = 2,
+  LLVMDIFlagPublic = 3,
+  LLVMDIFlagFwdDecl = 1 << 2,
+  LLVMDIFlagAppleBlock = 1 << 3,
+  LLVMDIFlagBlockByrefStruct = 1 << 4,
+  LLVMDIFlagVirtual = 1 << 5,
+  LLVMDIFlagArtificial = 1 << 6,
+  LLVMDIFlagExplicit = 1 << 7,
+  LLVMDIFlagPrototyped = 1 << 8,
+  LLVMDIFlagObjcClassComplete = 1 << 9,
+  LLVMDIFlagObjectPointer = 1 << 10,
+  LLVMDIFlagVector = 1 << 11,
+  LLVMDIFlagStaticMember = 1 << 12,
+  LLVMDIFlagLValueReference = 1 << 13,
+  LLVMDIFlagRValueReference = 1 << 14,
+  LLVMDIFlagReserved = 1 << 15,
+  LLVMDIFlagSingleInheritance = 1 << 16,
+  LLVMDIFlagMultipleInheritance = 2 << 16,
+  LLVMDIFlagVirtualInheritance = 3 << 16,
+  LLVMDIFlagIntroducedVirtual = 1 << 18,
+  LLVMDIFlagBitField = 1 << 19,
+  LLVMDIFlagNoReturn = 1 << 20,
+  LLVMDIFlagTypePassByValue = 1 << 22,
+  LLVMDIFlagTypePassByReference = 1 << 23,
+  LLVMDIFlagEnumClass = 1 << 24,
+  LLVMDIFlagFixedEnum = LLVMDIFlagEnumClass, // Deprecated.
+  LLVMDIFlagThunk = 1 << 25,
+  LLVMDIFlagNonTrivial = 1 << 26,
+  LLVMDIFlagBigEndian = 1 << 27,
+  LLVMDIFlagLittleEndian = 1 << 28,
+  LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5),
+  LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected |
+                            LLVMDIFlagPublic,
+  LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance |
+                             LLVMDIFlagMultipleInheritance |
+                             LLVMDIFlagVirtualInheritance
+} LLVMDIFlags;
+
+/**
+ * Source languages known by DWARF.
+ */
+typedef enum {
+  LLVMDWARFSourceLanguageC89,
+  LLVMDWARFSourceLanguageC,
+  LLVMDWARFSourceLanguageAda83,
+  LLVMDWARFSourceLanguageC_plus_plus,
+  LLVMDWARFSourceLanguageCobol74,
+  LLVMDWARFSourceLanguageCobol85,
+  LLVMDWARFSourceLanguageFortran77,
+  LLVMDWARFSourceLanguageFortran90,
+  LLVMDWARFSourceLanguagePascal83,
+  LLVMDWARFSourceLanguageModula2,
+  // New in DWARF v3:
+  LLVMDWARFSourceLanguageJava,
+  LLVMDWARFSourceLanguageC99,
+  LLVMDWARFSourceLanguageAda95,
+  LLVMDWARFSourceLanguageFortran95,
+  LLVMDWARFSourceLanguagePLI,
+  LLVMDWARFSourceLanguageObjC,
+  LLVMDWARFSourceLanguageObjC_plus_plus,
+  LLVMDWARFSourceLanguageUPC,
+  LLVMDWARFSourceLanguageD,
+  // New in DWARF v4:
+  LLVMDWARFSourceLanguagePython,
+  // New in DWARF v5:
+  LLVMDWARFSourceLanguageOpenCL,
+  LLVMDWARFSourceLanguageGo,
+  LLVMDWARFSourceLanguageModula3,
+  LLVMDWARFSourceLanguageHaskell,
+  LLVMDWARFSourceLanguageC_plus_plus_03,
+  LLVMDWARFSourceLanguageC_plus_plus_11,
+  LLVMDWARFSourceLanguageOCaml,
+  LLVMDWARFSourceLanguageRust,
+  LLVMDWARFSourceLanguageC11,
+  LLVMDWARFSourceLanguageSwift,
+  LLVMDWARFSourceLanguageJulia,
+  LLVMDWARFSourceLanguageDylan,
+  LLVMDWARFSourceLanguageC_plus_plus_14,
+  LLVMDWARFSourceLanguageFortran03,
+  LLVMDWARFSourceLanguageFortran08,
+  LLVMDWARFSourceLanguageRenderScript,
+  LLVMDWARFSourceLanguageBLISS,
+  // Vendor extensions:
+  LLVMDWARFSourceLanguageMips_Assembler,
+  LLVMDWARFSourceLanguageGOOGLE_RenderScript,
+  LLVMDWARFSourceLanguageBORLAND_Delphi
+} LLVMDWARFSourceLanguage;
+
+/**
+ * The amount of debug information to emit.
+ */
+typedef enum {
+    LLVMDWARFEmissionNone = 0,
+    LLVMDWARFEmissionFull,
+    LLVMDWARFEmissionLineTablesOnly
+} LLVMDWARFEmissionKind;
+
+/**
+ * The kind of metadata nodes.
+ */
+enum {
+  LLVMMDStringMetadataKind,
+  LLVMConstantAsMetadataMetadataKind,
+  LLVMLocalAsMetadataMetadataKind,
+  LLVMDistinctMDOperandPlaceholderMetadataKind,
+  LLVMMDTupleMetadataKind,
+  LLVMDILocationMetadataKind,
+  LLVMDIExpressionMetadataKind,
+  LLVMDIGlobalVariableExpressionMetadataKind,
+  LLVMGenericDINodeMetadataKind,
+  LLVMDISubrangeMetadataKind,
+  LLVMDIEnumeratorMetadataKind,
+  LLVMDIBasicTypeMetadataKind,
+  LLVMDIDerivedTypeMetadataKind,
+  LLVMDICompositeTypeMetadataKind,
+  LLVMDISubroutineTypeMetadataKind,
+  LLVMDIFileMetadataKind,
+  LLVMDICompileUnitMetadataKind,
+  LLVMDISubprogramMetadataKind,
+  LLVMDILexicalBlockMetadataKind,
+  LLVMDILexicalBlockFileMetadataKind,
+  LLVMDINamespaceMetadataKind,
+  LLVMDIModuleMetadataKind,
+  LLVMDITemplateTypeParameterMetadataKind,
+  LLVMDITemplateValueParameterMetadataKind,
+  LLVMDIGlobalVariableMetadataKind,
+  LLVMDILocalVariableMetadataKind,
+  LLVMDILabelMetadataKind,
+  LLVMDIObjCPropertyMetadataKind,
+  LLVMDIImportedEntityMetadataKind,
+  LLVMDIMacroMetadataKind,
+  LLVMDIMacroFileMetadataKind,
+  LLVMDICommonBlockMetadataKind
+};
+typedef unsigned LLVMMetadataKind;
+
+/**
+ * An LLVM DWARF type encoding.
+ */
+typedef unsigned LLVMDWARFTypeEncoding;
+
+/**
+ * The current debug metadata version number.
+ */
+unsigned LLVMDebugMetadataVersion(void);
+
+/**
+ * The version of debug metadata that's present in the provided \c Module.
+ */
+unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef Module);
+
+/**
+ * Strip debug info in the module if it exists.
+ * To do this, we remove all calls to the debugger intrinsics and any named
+ * metadata for debugging. We also remove debug locations for instructions.
+ * Return true if module is modified.
+ */
+LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef Module);
+
+/**
+ * Construct a builder for a module, and do not allow for unresolved nodes
+ * attached to the module.
+ */
+LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M);
+
+/**
+ * Construct a builder for a module and collect unresolved nodes attached
+ * to the module in order to resolve cycles during a call to
+ * \c LLVMDIBuilderFinalize.
+ */
+LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M);
+
+/**
+ * Deallocates the \c DIBuilder and everything it owns.
+ * @note You must call \c LLVMDIBuilderFinalize before this
+ */
+void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder);
+
+/**
+ * Construct any deferred debug info descriptors.
+ */
+void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder);
+
+/**
+ * A CompileUnit provides an anchor for all debugging
+ * information generated during this instance of compilation.
+ * \param Lang          Source programming language, eg.
+ *                      \c LLVMDWARFSourceLanguageC99
+ * \param FileRef       File info.
+ * \param Producer      Identify the producer of debugging information
+ *                      and code.  Usually this is a compiler
+ *                      version string.
+ * \param ProducerLen   The length of the C string passed to \c Producer.
+ * \param isOptimized   A boolean flag which indicates whether optimization
+ *                      is enabled or not.
+ * \param Flags         This string lists command line options. This
+ *                      string is directly embedded in debug info
+ *                      output which may be used by a tool
+ *                      analyzing generated debugging information.
+ * \param FlagsLen      The length of the C string passed to \c Flags.
+ * \param RuntimeVer    This indicates runtime version for languages like
+ *                      Objective-C.
+ * \param SplitName     The name of the file that we'll split debug info
+ *                      out into.
+ * \param SplitNameLen  The length of the C string passed to \c SplitName.
+ * \param Kind          The kind of debug information to generate.
+ * \param DWOId         The DWOId if this is a split skeleton compile unit.
+ * \param SplitDebugInlining    Whether to emit inline debug info.
+ * \param DebugInfoForProfiling Whether to emit extra debug info for
+ *                              profile collection.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
+    LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
+    LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
+    LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
+    unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
+    LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
+    LLVMBool DebugInfoForProfiling);
+
+/**
+ * Create a file descriptor to hold debugging information for a file.
+ * \param Builder      The \c DIBuilder.
+ * \param Filename     File name.
+ * \param FilenameLen  The length of the C string passed to \c Filename.
+ * \param Directory    Directory.
+ * \param DirectoryLen The length of the C string passed to \c Directory.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
+                        size_t FilenameLen, const char *Directory,
+                        size_t DirectoryLen);
+
+/**
+ * Creates a new descriptor for a module with the specified parent scope.
+ * \param Builder         The \c DIBuilder.
+ * \param ParentScope     The parent scope containing this module declaration.
+ * \param Name            Module name.
+ * \param NameLen         The length of the C string passed to \c Name.
+ * \param ConfigMacros    A space-separated shell-quoted list of -D macro
+                          definitions as they would appear on a command line.
+ * \param ConfigMacrosLen The length of the C string passed to \c ConfigMacros.
+ * \param IncludePath     The path to the module map file.
+ * \param IncludePathLen  The length of the C string passed to \c IncludePath.
+ * \param ISysRoot        The Clang system root (value of -isysroot).
+ * \param ISysRootLen     The length of the C string passed to \c ISysRoot.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope,
+                          const char *Name, size_t NameLen,
+                          const char *ConfigMacros, size_t ConfigMacrosLen,
+                          const char *IncludePath, size_t IncludePathLen,
+                          const char *ISysRoot, size_t ISysRootLen);
+
+/**
+ * Creates a new descriptor for a namespace with the specified parent scope.
+ * \param Builder          The \c DIBuilder.
+ * \param ParentScope      The parent scope containing this module declaration.
+ * \param Name             NameSpace name.
+ * \param NameLen          The length of the C string passed to \c Name.
+ * \param ExportSymbols    Whether or not the namespace exports symbols, e.g.
+ *                         this is true of C++ inline namespaces.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder,
+                             LLVMMetadataRef ParentScope,
+                             const char *Name, size_t NameLen,
+                             LLVMBool ExportSymbols);
+
+/**
+ * Create a new descriptor for the specified subprogram.
+ * \param Builder         The \c DIBuilder.
+ * \param Scope           Function scope.
+ * \param Name            Function name.
+ * \param NameLen         Length of enumeration name.
+ * \param LinkageName     Mangled function name.
+ * \param LinkageNameLen  Length of linkage name.
+ * \param File            File where this variable is defined.
+ * \param LineNo          Line number.
+ * \param Ty              Function type.
+ * \param IsLocalToUnit   True if this function is not externally visible.
+ * \param IsDefinition    True if this is a function definition.
+ * \param ScopeLine       Set to the beginning of the scope this starts
+ * \param Flags           E.g.: \c LLVMDIFlagLValueReference. These flags are
+ *                        used to emit dwarf attributes.
+ * \param IsOptimized     True if optimization is ON.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateFunction(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
+    unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized);
+
+/**
+ * Create a descriptor for a lexical block with the specified parent context.
+ * \param Builder      The \c DIBuilder.
+ * \param Scope        Parent lexical block.
+ * \param File         Source file.
+ * \param Line         The line in the source file.
+ * \param Column       The column in the source file.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
+    LLVMMetadataRef File, unsigned Line, unsigned Column);
+
+/**
+ * Create a descriptor for a lexical block with a new file attached.
+ * \param Builder        The \c DIBuilder.
+ * \param Scope          Lexical block.
+ * \param File           Source file.
+ * \param Discriminator  DWARF path discriminator value.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
+                                    LLVMMetadataRef Scope,
+                                    LLVMMetadataRef File,
+                                    unsigned Discriminator);
+
+/**
+ * Create a descriptor for an imported namespace. Suitable for e.g. C++
+ * using declarations.
+ * \param Builder    The \c DIBuilder.
+ * \param Scope      The scope this module is imported into
+ * \param File       File where the declaration is located.
+ * \param Line       Line number of the declaration.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder,
+                                               LLVMMetadataRef Scope,
+                                               LLVMMetadataRef NS,
+                                               LLVMMetadataRef File,
+                                               unsigned Line);
+
+/**
+ * Create a descriptor for an imported module that aliases another
+ * imported entity descriptor.
+ * \param Builder        The \c DIBuilder.
+ * \param Scope          The scope this module is imported into
+ * \param ImportedEntity Previous imported entity to alias.
+ * \param File           File where the declaration is located.
+ * \param Line           Line number of the declaration.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,
+                                           LLVMMetadataRef Scope,
+                                           LLVMMetadataRef ImportedEntity,
+                                           LLVMMetadataRef File,
+                                           unsigned Line);
+
+/**
+ * Create a descriptor for an imported module.
+ * \param Builder    The \c DIBuilder.
+ * \param Scope      The scope this module is imported into
+ * \param M          The module being imported here
+ * \param File       File where the declaration is located.
+ * \param Line       Line number of the declaration.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,
+                                            LLVMMetadataRef Scope,
+                                            LLVMMetadataRef M,
+                                            LLVMMetadataRef File,
+                                            unsigned Line);
+
+/**
+ * Create a descriptor for an imported function, type, or variable.  Suitable
+ * for e.g. FORTRAN-style USE declarations.
+ * \param Builder    The DIBuilder.
+ * \param Scope      The scope this module is imported into.
+ * \param Decl       The declaration (or definition) of a function, type,
+                     or variable.
+ * \param File       File where the declaration is located.
+ * \param Line       Line number of the declaration.
+ * \param Name       A name that uniquely identifies this imported declaration.
+ * \param NameLen    The length of the C string passed to \c Name.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,
+                                       LLVMMetadataRef Scope,
+                                       LLVMMetadataRef Decl,
+                                       LLVMMetadataRef File,
+                                       unsigned Line,
+                                       const char *Name, size_t NameLen);
+
+/**
+ * Creates a new DebugLocation that describes a source location.
+ * \param Line The line in the source file.
+ * \param Column The column in the source file.
+ * \param Scope The scope in which the location resides.
+ * \param InlinedAt The scope where this location was inlined, if at all.
+ *                  (optional).
+ * \note If the item to which this location is attached cannot be
+ *       attributed to a source line, pass 0 for the line and column.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
+                                 unsigned Column, LLVMMetadataRef Scope,
+                                 LLVMMetadataRef InlinedAt);
+
+/**
+ * Get the line number of this debug location.
+ * \param Location     The debug location.
+ *
+ * @see DILocation::getLine()
+ */
+unsigned LLVMDILocationGetLine(LLVMMetadataRef Location);
+
+/**
+ * Get the column number of this debug location.
+ * \param Location     The debug location.
+ *
+ * @see DILocation::getColumn()
+ */
+unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location);
+
+/**
+ * Get the local scope associated with this debug location.
+ * \param Location     The debug location.
+ *
+ * @see DILocation::getScope()
+ */
+LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location);
+
+/**
+ * Get the "inline at" location associated with this debug location.
+ * \param Location     The debug location.
+ *
+ * @see DILocation::getInlinedAt()
+ */
+LLVMMetadataRef LLVMDILocationGetInlinedAt(LLVMMetadataRef Location);
+
+/**
+ * Get the metadata of the file associated with a given scope.
+ * \param Scope     The scope object.
+ *
+ * @see DIScope::getFile()
+ */
+LLVMMetadataRef LLVMDIScopeGetFile(LLVMMetadataRef Scope);
+
+/**
+ * Get the directory of a given file.
+ * \param File     The file object.
+ * \param Len      The length of the returned string.
+ *
+ * @see DIFile::getDirectory()
+ */
+const char *LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len);
+
+/**
+ * Get the name of a given file.
+ * \param File     The file object.
+ * \param Len      The length of the returned string.
+ *
+ * @see DIFile::getFilename()
+ */
+const char *LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len);
+
+/**
+ * Get the source of a given file.
+ * \param File     The file object.
+ * \param Len      The length of the returned string.
+ *
+ * @see DIFile::getSource()
+ */
+const char *LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len);
+
+/**
+ * Create a type array.
+ * \param Builder        The DIBuilder.
+ * \param Data           The type elements.
+ * \param NumElements    Number of type elements.
+ */
+LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder,
+                                                  LLVMMetadataRef *Data,
+                                                  size_t NumElements);
+
+/**
+ * Create subroutine type.
+ * \param Builder        The DIBuilder.
+ * \param File            The file in which the subroutine resides.
+ * \param ParameterTypes  An array of subroutine parameter types. This
+ *                        includes return type at 0th index.
+ * \param NumParameterTypes The number of parameter types in \c ParameterTypes
+ * \param Flags           E.g.: \c LLVMDIFlagLValueReference.
+ *                        These flags are used to emit dwarf attributes.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
+                                  LLVMMetadataRef File,
+                                  LLVMMetadataRef *ParameterTypes,
+                                  unsigned NumParameterTypes,
+                                  LLVMDIFlags Flags);
+
+/**
+ * Create debugging information entry for an enumerator.
+ * @param Builder        The DIBuilder.
+ * @param Name           Enumerator name.
+ * @param NameLen        Length of enumerator name.
+ * @param Value          Enumerator value.
+ * @param IsUnsigned     True if the value is unsigned.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder,
+                                              const char *Name, size_t NameLen,
+                                              int64_t Value,
+                                              LLVMBool IsUnsigned);
+
+/**
+ * Create debugging information entry for an enumeration.
+ * \param Builder        The DIBuilder.
+ * \param Scope          Scope in which this enumeration is defined.
+ * \param Name           Enumeration name.
+ * \param NameLen        Length of enumeration name.
+ * \param File           File where this member is defined.
+ * \param LineNumber     Line number.
+ * \param SizeInBits     Member size.
+ * \param AlignInBits    Member alignment.
+ * \param Elements       Enumeration elements.
+ * \param NumElements    Number of enumeration elements.
+ * \param ClassTy        Underlying type of a C++11/ObjC fixed enum.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
+    unsigned NumElements, LLVMMetadataRef ClassTy);
+
+/**
+ * Create debugging information entry for a union.
+ * \param Builder      The DIBuilder.
+ * \param Scope        Scope in which this union is defined.
+ * \param Name         Union name.
+ * \param NameLen      Length of union name.
+ * \param File         File where this member is defined.
+ * \param LineNumber   Line number.
+ * \param SizeInBits   Member size.
+ * \param AlignInBits  Member alignment.
+ * \param Flags        Flags to encode member attribute, e.g. private
+ * \param Elements     Union elements.
+ * \param NumElements  Number of union elements.
+ * \param RunTimeLang  Optional parameter, Objective-C runtime version.
+ * \param UniqueId     A unique identifier for the union.
+ * \param UniqueIdLen  Length of unique identifier.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateUnionType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
+    LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
+    const char *UniqueId, size_t UniqueIdLen);
+
+
+/**
+ * Create debugging information entry for an array.
+ * \param Builder      The DIBuilder.
+ * \param Size         Array size.
+ * \param AlignInBits  Alignment.
+ * \param Ty           Element type.
+ * \param Subscripts   Subscripts.
+ * \param NumSubscripts Number of subscripts.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size,
+                             uint32_t AlignInBits, LLVMMetadataRef Ty,
+                             LLVMMetadataRef *Subscripts,
+                             unsigned NumSubscripts);
+
+/**
+ * Create debugging information entry for a vector type.
+ * \param Builder      The DIBuilder.
+ * \param Size         Vector size.
+ * \param AlignInBits  Alignment.
+ * \param Ty           Element type.
+ * \param Subscripts   Subscripts.
+ * \param NumSubscripts Number of subscripts.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, uint64_t Size,
+                              uint32_t AlignInBits, LLVMMetadataRef Ty,
+                              LLVMMetadataRef *Subscripts,
+                              unsigned NumSubscripts);
+
+/**
+ * Create a DWARF unspecified type.
+ * \param Builder   The DIBuilder.
+ * \param Name      The unspecified type's name.
+ * \param NameLen   Length of type name.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name,
+                                   size_t NameLen);
+
+/**
+ * Create debugging information entry for a basic
+ * type.
+ * \param Builder     The DIBuilder.
+ * \param Name        Type name.
+ * \param NameLen     Length of type name.
+ * \param SizeInBits  Size of the type.
+ * \param Encoding    DWARF encoding code, e.g. \c LLVMDWARFTypeEncoding_float.
+ * \param Flags       Flags to encode optional attribute like endianity
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
+                             size_t NameLen, uint64_t SizeInBits,
+                             LLVMDWARFTypeEncoding Encoding,
+                             LLVMDIFlags Flags);
+
+/**
+ * Create debugging information entry for a pointer.
+ * \param Builder     The DIBuilder.
+ * \param PointeeTy         Type pointed by this pointer.
+ * \param SizeInBits        Size.
+ * \param AlignInBits       Alignment. (optional, pass 0 to ignore)
+ * \param AddressSpace      DWARF address space. (optional, pass 0 to ignore)
+ * \param Name              Pointer type name. (optional)
+ * \param NameLen           Length of pointer type name. (optional)
+ */
+LLVMMetadataRef LLVMDIBuilderCreatePointerType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
+    uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
+    const char *Name, size_t NameLen);
+
+/**
+ * Create debugging information entry for a struct.
+ * \param Builder     The DIBuilder.
+ * \param Scope        Scope in which this struct is defined.
+ * \param Name         Struct name.
+ * \param NameLen      Struct name length.
+ * \param File         File where this member is defined.
+ * \param LineNumber   Line number.
+ * \param SizeInBits   Member size.
+ * \param AlignInBits  Member alignment.
+ * \param Flags        Flags to encode member attribute, e.g. private
+ * \param Elements     Struct elements.
+ * \param NumElements  Number of struct elements.
+ * \param RunTimeLang  Optional parameter, Objective-C runtime version.
+ * \param VTableHolder The object containing the vtable for the struct.
+ * \param UniqueId     A unique identifier for the struct.
+ * \param UniqueIdLen  Length of the unique identifier for the struct.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateStructType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
+    LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
+    unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
+    const char *UniqueId, size_t UniqueIdLen);
+
+/**
+ * Create debugging information entry for a member.
+ * \param Builder      The DIBuilder.
+ * \param Scope        Member scope.
+ * \param Name         Member name.
+ * \param NameLen      Length of member name.
+ * \param File         File where this member is defined.
+ * \param LineNo       Line number.
+ * \param SizeInBits   Member size.
+ * \param AlignInBits  Member alignment.
+ * \param OffsetInBits Member offset.
+ * \param Flags        Flags to encode member attribute, e.g. private
+ * \param Ty           Parent type.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateMemberType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
+    uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
+    LLVMDIFlags Flags, LLVMMetadataRef Ty);
+
+/**
+ * Create debugging information entry for a
+ * C++ static data member.
+ * \param Builder      The DIBuilder.
+ * \param Scope        Member scope.
+ * \param Name         Member name.
+ * \param NameLen      Length of member name.
+ * \param File         File where this member is declared.
+ * \param LineNumber   Line number.
+ * \param Type         Type of the static member.
+ * \param Flags        Flags to encode member attribute, e.g. private.
+ * \param ConstantVal  Const initializer of the member.
+ * \param AlignInBits  Member alignment.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateStaticMemberType(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
+    LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
+    uint32_t AlignInBits);
+
+/**
+ * Create debugging information entry for a pointer to member.
+ * \param Builder      The DIBuilder.
+ * \param PointeeType  Type pointed to by this pointer.
+ * \param ClassType    Type for which this pointer points to members of.
+ * \param SizeInBits   Size.
+ * \param AlignInBits  Alignment.
+ * \param Flags        Flags.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder,
+                                     LLVMMetadataRef PointeeType,
+                                     LLVMMetadataRef ClassType,
+                                     uint64_t SizeInBits,
+                                     uint32_t AlignInBits,
+                                     LLVMDIFlags Flags);
+/**
+ * Create debugging information entry for Objective-C instance variable.
+ * \param Builder      The DIBuilder.
+ * \param Name         Member name.
+ * \param NameLen      The length of the C string passed to \c Name.
+ * \param File         File where this member is defined.
+ * \param LineNo       Line number.
+ * \param SizeInBits   Member size.
+ * \param AlignInBits  Member alignment.
+ * \param OffsetInBits Member offset.
+ * \param Flags        Flags to encode member attribute, e.g. private
+ * \param Ty           Parent type.
+ * \param PropertyNode Property associated with this ivar.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder,
+                            const char *Name, size_t NameLen,
+                            LLVMMetadataRef File, unsigned LineNo,
+                            uint64_t SizeInBits, uint32_t AlignInBits,
+                            uint64_t OffsetInBits, LLVMDIFlags Flags,
+                            LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode);
+
+/**
+ * Create debugging information entry for Objective-C property.
+ * \param Builder            The DIBuilder.
+ * \param Name               Property name.
+ * \param NameLen            The length of the C string passed to \c Name.
+ * \param File               File where this property is defined.
+ * \param LineNo             Line number.
+ * \param GetterName         Name of the Objective C property getter selector.
+ * \param GetterNameLen      The length of the C string passed to \c GetterName.
+ * \param SetterName         Name of the Objective C property setter selector.
+ * \param SetterNameLen      The length of the C string passed to \c SetterName.
+ * \param PropertyAttributes Objective C property attributes.
+ * \param Ty                 Type.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder,
+                                const char *Name, size_t NameLen,
+                                LLVMMetadataRef File, unsigned LineNo,
+                                const char *GetterName, size_t GetterNameLen,
+                                const char *SetterName, size_t SetterNameLen,
+                                unsigned PropertyAttributes,
+                                LLVMMetadataRef Ty);
+
+/**
+ * Create a uniqued DIType* clone with FlagObjectPointer and FlagArtificial set.
+ * \param Builder   The DIBuilder.
+ * \param Type      The underlying type to which this pointer points.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder,
+                                     LLVMMetadataRef Type);
+
+/**
+ * Create debugging information entry for a qualified
+ * type, e.g. 'const int'.
+ * \param Builder     The DIBuilder.
+ * \param Tag         Tag identifying type,
+ *                    e.g. LLVMDWARFTypeQualifier_volatile_type
+ * \param Type        Base Type.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
+                                 LLVMMetadataRef Type);
+
+/**
+ * Create debugging information entry for a c++
+ * style reference or rvalue reference type.
+ * \param Builder   The DIBuilder.
+ * \param Tag       Tag identifying type,
+ * \param Type      Base Type.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag,
+                                 LLVMMetadataRef Type);
+
+/**
+ * Create C++11 nullptr type.
+ * \param Builder   The DIBuilder.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder);
+
+/**
+ * Create debugging information entry for a typedef.
+ * \param Builder    The DIBuilder.
+ * \param Type       Original type.
+ * \param Name       Typedef name.
+ * \param File       File where this type is defined.
+ * \param LineNo     Line number.
+ * \param Scope      The surrounding context for the typedef.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
+                           const char *Name, size_t NameLen,
+                           LLVMMetadataRef File, unsigned LineNo,
+                           LLVMMetadataRef Scope);
+
+/**
+ * Create debugging information entry to establish inheritance relationship
+ * between two types.
+ * \param Builder       The DIBuilder.
+ * \param Ty            Original type.
+ * \param BaseTy        Base type. Ty is inherits from base.
+ * \param BaseOffset    Base offset.
+ * \param VBPtrOffset  Virtual base pointer offset.
+ * \param Flags         Flags to describe inheritance attribute, e.g. private
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder,
+                               LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
+                               uint64_t BaseOffset, uint32_t VBPtrOffset,
+                               LLVMDIFlags Flags);
+
+/**
+ * Create a permanent forward-declared type.
+ * \param Builder             The DIBuilder.
+ * \param Tag                 A unique tag for this type.
+ * \param Name                Type name.
+ * \param NameLen             Length of type name.
+ * \param Scope               Type scope.
+ * \param File                File where this type is defined.
+ * \param Line                Line number where this type is defined.
+ * \param RuntimeLang         Indicates runtime version for languages like
+ *                            Objective-C.
+ * \param SizeInBits          Member size.
+ * \param AlignInBits         Member alignment.
+ * \param UniqueIdentifier    A unique identifier for the type.
+ * \param UniqueIdentifierLen Length of the unique identifier.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateForwardDecl(
+    LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
+    size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
+    unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
+    const char *UniqueIdentifier, size_t UniqueIdentifierLen);
+
+/**
+ * Create a temporary forward-declared type.
+ * \param Builder             The DIBuilder.
+ * \param Tag                 A unique tag for this type.
+ * \param Name                Type name.
+ * \param NameLen             Length of type name.
+ * \param Scope               Type scope.
+ * \param File                File where this type is defined.
+ * \param Line                Line number where this type is defined.
+ * \param RuntimeLang         Indicates runtime version for languages like
+ *                            Objective-C.
+ * \param SizeInBits          Member size.
+ * \param AlignInBits         Member alignment.
+ * \param Flags               Flags.
+ * \param UniqueIdentifier    A unique identifier for the type.
+ * \param UniqueIdentifierLen Length of the unique identifier.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateReplaceableCompositeType(
+    LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
+    size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
+    unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
+    LLVMDIFlags Flags, const char *UniqueIdentifier,
+    size_t UniqueIdentifierLen);
+
+/**
+ * Create debugging information entry for a bit field member.
+ * \param Builder             The DIBuilder.
+ * \param Scope               Member scope.
+ * \param Name                Member name.
+ * \param NameLen             Length of member name.
+ * \param File                File where this member is defined.
+ * \param LineNumber          Line number.
+ * \param SizeInBits          Member size.
+ * \param OffsetInBits        Member offset.
+ * \param StorageOffsetInBits Member storage offset.
+ * \param Flags               Flags to encode member attribute.
+ * \param Type                Parent type.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder,
+                                      LLVMMetadataRef Scope,
+                                      const char *Name, size_t NameLen,
+                                      LLVMMetadataRef File, unsigned LineNumber,
+                                      uint64_t SizeInBits,
+                                      uint64_t OffsetInBits,
+                                      uint64_t StorageOffsetInBits,
+                                      LLVMDIFlags Flags, LLVMMetadataRef Type);
+
+/**
+ * Create debugging information entry for a class.
+ * \param Scope               Scope in which this class is defined.
+ * \param Name                Class name.
+ * \param NameLen             The length of the C string passed to \c Name.
+ * \param File                File where this member is defined.
+ * \param LineNumber          Line number.
+ * \param SizeInBits          Member size.
+ * \param AlignInBits         Member alignment.
+ * \param OffsetInBits        Member offset.
+ * \param Flags               Flags to encode member attribute, e.g. private.
+ * \param DerivedFrom         Debug info of the base class of this type.
+ * \param Elements            Class members.
+ * \param NumElements         Number of class elements.
+ * \param VTableHolder        Debug info of the base class that contains vtable
+ *                            for this type. This is used in
+ *                            DW_AT_containing_type. See DWARF documentation
+ *                            for more info.
+ * \param TemplateParamsNode  Template type parameters.
+ * \param UniqueIdentifier    A unique identifier for the type.
+ * \param UniqueIdentifierLen Length of the unique identifier.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder,
+    LLVMMetadataRef Scope, const char *Name, size_t NameLen,
+    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
+    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
+    LLVMMetadataRef DerivedFrom,
+    LLVMMetadataRef *Elements, unsigned NumElements,
+    LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
+    const char *UniqueIdentifier, size_t UniqueIdentifierLen);
+
+/**
+ * Create a uniqued DIType* clone with FlagArtificial set.
+ * \param Builder     The DIBuilder.
+ * \param Type        The underlying type.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,
+                                  LLVMMetadataRef Type);
+
+/**
+ * Get the name of this DIType.
+ * \param DType     The DIType.
+ * \param Length    The length of the returned string.
+ *
+ * @see DIType::getName()
+ */
+const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length);
+
+/**
+ * Get the size of this DIType in bits.
+ * \param DType     The DIType.
+ *
+ * @see DIType::getSizeInBits()
+ */
+uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType);
+
+/**
+ * Get the offset of this DIType in bits.
+ * \param DType     The DIType.
+ *
+ * @see DIType::getOffsetInBits()
+ */
+uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType);
+
+/**
+ * Get the alignment of this DIType in bits.
+ * \param DType     The DIType.
+ *
+ * @see DIType::getAlignInBits()
+ */
+uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType);
+
+/**
+ * Get the source line where this DIType is declared.
+ * \param DType     The DIType.
+ *
+ * @see DIType::getLine()
+ */
+unsigned LLVMDITypeGetLine(LLVMMetadataRef DType);
+
+/**
+ * Get the flags associated with this DIType.
+ * \param DType     The DIType.
+ *
+ * @see DIType::getFlags()
+ */
+LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType);
+
+/**
+ * Create a descriptor for a value range.
+ * \param Builder    The DIBuilder.
+ * \param LowerBound Lower bound of the subrange, e.g. 0 for C, 1 for Fortran.
+ * \param Count      Count of elements in the subrange.
+ */
+LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder,
+                                                 int64_t LowerBound,
+                                                 int64_t Count);
+
+/**
+ * Create an array of DI Nodes.
+ * \param Builder        The DIBuilder.
+ * \param Data           The DI Node elements.
+ * \param NumElements    Number of DI Node elements.
+ */
+LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,
+                                              LLVMMetadataRef *Data,
+                                              size_t NumElements);
+
+/**
+ * Create a new descriptor for the specified variable which has a complex
+ * address expression for its address.
+ * \param Builder     The DIBuilder.
+ * \param Addr        An array of complex address operations.
+ * \param Length      Length of the address operation array.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,
+                                              int64_t *Addr, size_t Length);
+
+/**
+ * Create a new descriptor for the specified variable that does not have an
+ * address, but does have a constant value.
+ * \param Builder     The DIBuilder.
+ * \param Value       The constant value.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,
+                                           int64_t Value);
+
+/**
+ * Create a new descriptor for the specified variable.
+ * \param Scope       Variable scope.
+ * \param Name        Name of the variable.
+ * \param NameLen     The length of the C string passed to \c Name.
+ * \param Linkage     Mangled  name of the variable.
+ * \param LinkLen     The length of the C string passed to \c Linkage.
+ * \param File        File where this variable is defined.
+ * \param LineNo      Line number.
+ * \param Ty          Variable Type.
+ * \param LocalToUnit Boolean flag indicate whether this variable is
+ *                    externally visible or not.
+ * \param Expr        The location of the global relative to the attached
+ *                    GlobalVariable.
+ * \param Decl        Reference to the corresponding declaration.
+ *                    variables.
+ * \param AlignInBits Variable alignment(or 0 if no alignment attr was
+ *                    specified)
+ */
+LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
+    unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
+    LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits);
+
+/**
+ * Retrieves the \c DIVariable associated with this global variable expression.
+ * \param GVE    The global variable expression.
+ *
+ * @see llvm::DIGlobalVariableExpression::getVariable()
+ */
+LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE);
+
+/**
+ * Retrieves the \c DIExpression associated with this global variable expression.
+ * \param GVE    The global variable expression.
+ *
+ * @see llvm::DIGlobalVariableExpression::getExpression()
+ */
+LLVMMetadataRef LLVMDIGlobalVariableExpressionGetExpression(
+    LLVMMetadataRef GVE);
+
+/**
+ * Get the metadata of the file associated with a given variable.
+ * \param Var     The variable object.
+ *
+ * @see DIVariable::getFile()
+ */
+LLVMMetadataRef LLVMDIVariableGetFile(LLVMMetadataRef Var);
+
+/**
+ * Get the metadata of the scope associated with a given variable.
+ * \param Var     The variable object.
+ *
+ * @see DIVariable::getScope()
+ */
+LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var);
+
+/**
+ * Get the source line where this \c DIVariable is declared.
+ * \param Var     The DIVariable.
+ *
+ * @see DIVariable::getLine()
+ */
+unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var);
+
+/**
+ * Create a new temporary \c MDNode.  Suitable for use in constructing cyclic
+ * \c MDNode structures. A temporary \c MDNode is not uniqued, may be RAUW'd,
+ * and must be manually deleted with \c LLVMDisposeTemporaryMDNode.
+ * \param Ctx            The context in which to construct the temporary node.
+ * \param Data           The metadata elements.
+ * \param NumElements    Number of metadata elements.
+ */
+LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data,
+                                    size_t NumElements);
+
+/**
+ * Deallocate a temporary node.
+ *
+ * Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
+ * references will be reset.
+ * \param TempNode    The temporary metadata node.
+ */
+void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode);
+
+/**
+ * Replace all uses of temporary metadata.
+ * \param TempTargetMetadata    The temporary metadata node.
+ * \param Replacement           The replacement metadata node.
+ */
+void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TempTargetMetadata,
+                                    LLVMMetadataRef Replacement);
+
+/**
+ * Create a new descriptor for the specified global variable that is temporary
+ * and meant to be RAUWed.
+ * \param Scope       Variable scope.
+ * \param Name        Name of the variable.
+ * \param NameLen     The length of the C string passed to \c Name.
+ * \param Linkage     Mangled  name of the variable.
+ * \param LnkLen      The length of the C string passed to \c Linkage.
+ * \param File        File where this variable is defined.
+ * \param LineNo      Line number.
+ * \param Ty          Variable Type.
+ * \param LocalToUnit Boolean flag indicate whether this variable is
+ *                    externally visible or not.
+ * \param Decl        Reference to the corresponding declaration.
+ * \param AlignInBits Variable alignment(or 0 if no alignment attr was
+ *                    specified)
+ */
+LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
+    unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
+    LLVMMetadataRef Decl, uint32_t AlignInBits);
+
+/**
+ * Insert a new llvm.dbg.declare intrinsic call before the given instruction.
+ * \param Builder     The DIBuilder.
+ * \param Storage     The storage of the variable to declare.
+ * \param VarInfo     The variable's debug info descriptor.
+ * \param Expr        A complex location expression for the variable.
+ * \param DebugLoc    Debug info location.
+ * \param Instr       Instruction acting as a location for the new intrinsic.
+ */
+LLVMValueRef LLVMDIBuilderInsertDeclareBefore(
+  LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
+  LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr);
+
+/**
+ * Insert a new llvm.dbg.declare intrinsic call at the end of the given basic
+ * block. If the basic block has a terminator instruction, the intrinsic is
+ * inserted before that terminator instruction.
+ * \param Builder     The DIBuilder.
+ * \param Storage     The storage of the variable to declare.
+ * \param VarInfo     The variable's debug info descriptor.
+ * \param Expr        A complex location expression for the variable.
+ * \param DebugLoc    Debug info location.
+ * \param Block       Basic block acting as a location for the new intrinsic.
+ */
+LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(
+    LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
+    LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block);
+
+/**
+ * Insert a new llvm.dbg.value intrinsic call before the given instruction.
+ * \param Builder     The DIBuilder.
+ * \param Val         The value of the variable.
+ * \param VarInfo     The variable's debug info descriptor.
+ * \param Expr        A complex location expression for the variable.
+ * \param DebugLoc    Debug info location.
+ * \param Instr       Instruction acting as a location for the new intrinsic.
+ */
+LLVMValueRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder,
+                                               LLVMValueRef Val,
+                                               LLVMMetadataRef VarInfo,
+                                               LLVMMetadataRef Expr,
+                                               LLVMMetadataRef DebugLoc,
+                                               LLVMValueRef Instr);
+
+/**
+ * Insert a new llvm.dbg.value intrinsic call at the end of the given basic
+ * block. If the basic block has a terminator instruction, the intrinsic is
+ * inserted before that terminator instruction.
+ * \param Builder     The DIBuilder.
+ * \param Val         The value of the variable.
+ * \param VarInfo     The variable's debug info descriptor.
+ * \param Expr        A complex location expression for the variable.
+ * \param DebugLoc    Debug info location.
+ * \param Block       Basic block acting as a location for the new intrinsic.
+ */
+LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,
+                                              LLVMValueRef Val,
+                                              LLVMMetadataRef VarInfo,
+                                              LLVMMetadataRef Expr,
+                                              LLVMMetadataRef DebugLoc,
+                                              LLVMBasicBlockRef Block);
+
+/**
+ * Create a new descriptor for a local auto variable.
+ * \param Builder         The DIBuilder.
+ * \param Scope           The local scope the variable is declared in.
+ * \param Name            Variable name.
+ * \param NameLen         Length of variable name.
+ * \param File            File where this variable is defined.
+ * \param LineNo          Line number.
+ * \param Ty              Metadata describing the type of the variable.
+ * \param AlwaysPreserve  If true, this descriptor will survive optimizations.
+ * \param Flags           Flags.
+ * \param AlignInBits     Variable alignment.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits);
+
+/**
+ * Create a new descriptor for a function parameter variable.
+ * \param Builder         The DIBuilder.
+ * \param Scope           The local scope the variable is declared in.
+ * \param Name            Variable name.
+ * \param NameLen         Length of variable name.
+ * \param ArgNo           Unique argument number for this variable; starts at 1.
+ * \param File            File where this variable is defined.
+ * \param LineNo          Line number.
+ * \param Ty              Metadata describing the type of the variable.
+ * \param AlwaysPreserve  If true, this descriptor will survive optimizations.
+ * \param Flags           Flags.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
+    LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags);
+
+/**
+ * Get the metadata of the subprogram attached to a function.
+ *
+ * @see llvm::Function::getSubprogram()
+ */
+LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func);
+
+/**
+ * Set the subprogram attached to a function.
+ *
+ * @see llvm::Function::setSubprogram()
+ */
+void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP);
+
+/**
+ * Get the line associated with a given subprogram.
+ * \param Subprogram     The subprogram object.
+ *
+ * @see DISubprogram::getLine()
+ */
+unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram);
+
+/**
+ * Get the debug location for the given instruction.
+ *
+ * @see llvm::Instruction::getDebugLoc()
+ */
+LLVMMetadataRef LLVMInstructionGetDebugLoc(LLVMValueRef Inst);
+
+/**
+ * Set the debug location for the given instruction.
+ *
+ * To clear the location metadata of the given instruction, pass NULL to \p Loc.
+ *
+ * @see llvm::Instruction::setDebugLoc()
+ */
+void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc);
+
+/**
+ * Obtain the enumerated type of a Metadata instance.
+ *
+ * @see llvm::Metadata::getMetadataID()
+ */
+LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif
diff --git a/src/llvm-c/Disassembler.h b/src/llvm-c/Disassembler.h
new file mode 100644
index 000000000..3adcc3c47
--- /dev/null
+++ b/src/llvm-c/Disassembler.h
@@ -0,0 +1,113 @@
+/*===-- llvm-c/Disassembler.h - Disassembler Public C Interface ---*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header provides a public interface to a disassembler library.         *|
+|* LLVM provides an implementation of this interface.                         *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_DISASSEMBLER_H
+#define LLVM_C_DISASSEMBLER_H
+
+#include "llvm-c/DisassemblerTypes.h"
+
+/**
+ * @defgroup LLVMCDisassembler Disassembler
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* !defined(__cplusplus) */
+
+/**
+ * Create a disassembler for the TripleName.  Symbolic disassembly is supported
+ * by passing a block of information in the DisInfo parameter and specifying the
+ * TagType and callback functions as described above.  These can all be passed
+ * as NULL.  If successful, this returns a disassembler context.  If not, it
+ * returns NULL. This function is equivalent to calling
+ * LLVMCreateDisasmCPUFeatures() with an empty CPU name and feature set.
+ */
+LLVMDisasmContextRef LLVMCreateDisasm(const char *TripleName, void *DisInfo,
+                                      int TagType, LLVMOpInfoCallback GetOpInfo,
+                                      LLVMSymbolLookupCallback SymbolLookUp);
+
+/**
+ * Create a disassembler for the TripleName and a specific CPU.  Symbolic
+ * disassembly is supported by passing a block of information in the DisInfo
+ * parameter and specifying the TagType and callback functions as described
+ * above.  These can all be passed * as NULL.  If successful, this returns a
+ * disassembler context.  If not, it returns NULL. This function is equivalent
+ * to calling LLVMCreateDisasmCPUFeatures() with an empty feature set.
+ */
+LLVMDisasmContextRef LLVMCreateDisasmCPU(const char *Triple, const char *CPU,
+                                         void *DisInfo, int TagType,
+                                         LLVMOpInfoCallback GetOpInfo,
+                                         LLVMSymbolLookupCallback SymbolLookUp);
+
+/**
+ * Create a disassembler for the TripleName, a specific CPU and specific feature
+ * string.  Symbolic disassembly is supported by passing a block of information
+ * in the DisInfo parameter and specifying the TagType and callback functions as
+ * described above.  These can all be passed * as NULL.  If successful, this
+ * returns a disassembler context.  If not, it returns NULL.
+ */
+LLVMDisasmContextRef
+LLVMCreateDisasmCPUFeatures(const char *Triple, const char *CPU,
+                            const char *Features, void *DisInfo, int TagType,
+                            LLVMOpInfoCallback GetOpInfo,
+                            LLVMSymbolLookupCallback SymbolLookUp);
+
+/**
+ * Set the disassembler's options.  Returns 1 if it can set the Options and 0
+ * otherwise.
+ */
+int LLVMSetDisasmOptions(LLVMDisasmContextRef DC, uint64_t Options);
+
+/* The option to produce marked up assembly. */
+#define LLVMDisassembler_Option_UseMarkup 1
+/* The option to print immediates as hex. */
+#define LLVMDisassembler_Option_PrintImmHex 2
+/* The option use the other assembler printer variant */
+#define LLVMDisassembler_Option_AsmPrinterVariant 4
+/* The option to set comment on instructions */
+#define LLVMDisassembler_Option_SetInstrComments 8
+  /* The option to print latency information alongside instructions */
+#define LLVMDisassembler_Option_PrintLatency 16
+
+/**
+ * Dispose of a disassembler context.
+ */
+void LLVMDisasmDispose(LLVMDisasmContextRef DC);
+
+/**
+ * Disassemble a single instruction using the disassembler context specified in
+ * the parameter DC.  The bytes of the instruction are specified in the
+ * parameter Bytes, and contains at least BytesSize number of bytes.  The
+ * instruction is at the address specified by the PC parameter.  If a valid
+ * instruction can be disassembled, its string is returned indirectly in
+ * OutString whose size is specified in the parameter OutStringSize.  This
+ * function returns the number of bytes in the instruction or zero if there was
+ * no valid instruction.
+ */
+size_t LLVMDisasmInstruction(LLVMDisasmContextRef DC, uint8_t *Bytes,
+                             uint64_t BytesSize, uint64_t PC,
+                             char *OutString, size_t OutStringSize);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* !defined(__cplusplus) */
+
+#endif /* LLVM_C_DISASSEMBLER_H */
diff --git a/src/llvm-c/DisassemblerTypes.h b/src/llvm-c/DisassemblerTypes.h
new file mode 100644
index 000000000..389e5ee45
--- /dev/null
+++ b/src/llvm-c/DisassemblerTypes.h
@@ -0,0 +1,160 @@
+/*===-- llvm-c/DisassemblerTypedefs.h -----------------------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_DISASSEMBLER_TYPES_H
+#define LLVM_DISASSEMBLER_TYPES_H
+
+#include "llvm-c/DataTypes.h"
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#endif
+
+/**
+ * An opaque reference to a disassembler context.
+ */
+typedef void *LLVMDisasmContextRef;
+
+/**
+ * The type for the operand information call back function.  This is called to
+ * get the symbolic information for an operand of an instruction.  Typically
+ * this is from the relocation information, symbol table, etc.  That block of
+ * information is saved when the disassembler context is created and passed to
+ * the call back in the DisInfo parameter.  The instruction containing operand
+ * is at the PC parameter.  For some instruction sets, there can be more than
+ * one operand with symbolic information.  To determine the symbolic operand
+ * information for each operand, the bytes for the specific operand in the
+ * instruction are specified by the Offset parameter and its byte widith is the
+ * size parameter.  For instructions sets with fixed widths and one symbolic
+ * operand per instruction, the Offset parameter will be zero and Size parameter
+ * will be the instruction width.  The information is returned in TagBuf and is
+ * Triple specific with its specific information defined by the value of
+ * TagType for that Triple.  If symbolic information is returned the function
+ * returns 1, otherwise it returns 0.
+ */
+typedef int (*LLVMOpInfoCallback)(void *DisInfo, uint64_t PC,
+                                  uint64_t Offset, uint64_t Size,
+                                  int TagType, void *TagBuf);
+
+/**
+ * The initial support in LLVM MC for the most general form of a relocatable
+ * expression is "AddSymbol - SubtractSymbol + Offset".  For some Darwin targets
+ * this full form is encoded in the relocation information so that AddSymbol and
+ * SubtractSymbol can be link edited independent of each other.  Many other
+ * platforms only allow a relocatable expression of the form AddSymbol + Offset
+ * to be encoded.
+ *
+ * The LLVMOpInfoCallback() for the TagType value of 1 uses the struct
+ * LLVMOpInfo1.  The value of the relocatable expression for the operand,
+ * including any PC adjustment, is passed in to the call back in the Value
+ * field.  The symbolic information about the operand is returned using all
+ * the fields of the structure with the Offset of the relocatable expression
+ * returned in the Value field.  It is possible that some symbols in the
+ * relocatable expression were assembly temporary symbols, for example
+ * "Ldata - LpicBase + constant", and only the Values of the symbols without
+ * symbol names are present in the relocation information.  The VariantKind
+ * type is one of the Target specific #defines below and is used to print
+ * operands like "_foo@GOT", ":lower16:_foo", etc.
+ */
+struct LLVMOpInfoSymbol1 {
+  uint64_t Present;  /* 1 if this symbol is present */
+  const char *Name;  /* symbol name if not NULL */
+  uint64_t Value;    /* symbol value if name is NULL */
+};
+
+struct LLVMOpInfo1 {
+  struct LLVMOpInfoSymbol1 AddSymbol;
+  struct LLVMOpInfoSymbol1 SubtractSymbol;
+  uint64_t Value;
+  uint64_t VariantKind;
+};
+
+/**
+ * The operand VariantKinds for symbolic disassembly.
+ */
+#define LLVMDisassembler_VariantKind_None 0 /* all targets */
+
+/**
+ * The ARM target VariantKinds.
+ */
+#define LLVMDisassembler_VariantKind_ARM_HI16 1 /* :upper16: */
+#define LLVMDisassembler_VariantKind_ARM_LO16 2 /* :lower16: */
+
+/**
+ * The ARM64 target VariantKinds.
+ */
+#define LLVMDisassembler_VariantKind_ARM64_PAGE       1 /* @page */
+#define LLVMDisassembler_VariantKind_ARM64_PAGEOFF    2 /* @pageoff */
+#define LLVMDisassembler_VariantKind_ARM64_GOTPAGE    3 /* @gotpage */
+#define LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF 4 /* @gotpageoff */
+#define LLVMDisassembler_VariantKind_ARM64_TLVP       5 /* @tvlppage */
+#define LLVMDisassembler_VariantKind_ARM64_TLVOFF     6 /* @tvlppageoff */
+
+/**
+ * The type for the symbol lookup function.  This may be called by the
+ * disassembler for things like adding a comment for a PC plus a constant
+ * offset load instruction to use a symbol name instead of a load address value.
+ * It is passed the block information is saved when the disassembler context is
+ * created and the ReferenceValue to look up as a symbol.  If no symbol is found
+ * for the ReferenceValue NULL is returned.  The ReferenceType of the
+ * instruction is passed indirectly as is the PC of the instruction in
+ * ReferencePC.  If the output reference can be determined its type is returned
+ * indirectly in ReferenceType along with ReferenceName if any, or that is set
+ * to NULL.
+ */
+typedef const char *(*LLVMSymbolLookupCallback)(void *DisInfo,
+                                                uint64_t ReferenceValue,
+                                                uint64_t *ReferenceType,
+                                                uint64_t ReferencePC,
+                                                const char **ReferenceName);
+/**
+ * The reference types on input and output.
+ */
+/* No input reference type or no output reference type. */
+#define LLVMDisassembler_ReferenceType_InOut_None 0
+
+/* The input reference is from a branch instruction. */
+#define LLVMDisassembler_ReferenceType_In_Branch 1
+/* The input reference is from a PC relative load instruction. */
+#define LLVMDisassembler_ReferenceType_In_PCrel_Load 2
+
+/* The input reference is from an ARM64::ADRP instruction. */
+#define LLVMDisassembler_ReferenceType_In_ARM64_ADRP 0x100000001
+/* The input reference is from an ARM64::ADDXri instruction. */
+#define LLVMDisassembler_ReferenceType_In_ARM64_ADDXri 0x100000002
+/* The input reference is from an ARM64::LDRXui instruction. */
+#define LLVMDisassembler_ReferenceType_In_ARM64_LDRXui 0x100000003
+/* The input reference is from an ARM64::LDRXl instruction. */
+#define LLVMDisassembler_ReferenceType_In_ARM64_LDRXl 0x100000004
+/* The input reference is from an ARM64::ADR instruction. */
+#define LLVMDisassembler_ReferenceType_In_ARM64_ADR 0x100000005
+
+/* The output reference is to as symbol stub. */
+#define LLVMDisassembler_ReferenceType_Out_SymbolStub 1
+/* The output reference is to a symbol address in a literal pool. */
+#define LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr 2
+/* The output reference is to a cstring address in a literal pool. */
+#define LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr 3
+
+/* The output reference is to a Objective-C CoreFoundation string. */
+#define LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref 4
+/* The output reference is to a Objective-C message. */
+#define LLVMDisassembler_ReferenceType_Out_Objc_Message 5
+/* The output reference is to a Objective-C message ref. */
+#define LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref 6
+/* The output reference is to a Objective-C selector ref. */
+#define LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref 7
+/* The output reference is to a Objective-C class ref. */
+#define LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref 8
+
+/* The output reference is to a C++ symbol name. */
+#define LLVMDisassembler_ReferenceType_DeMangled_Name 9
+
+#endif
diff --git a/src/llvm-c/Error.h b/src/llvm-c/Error.h
new file mode 100644
index 000000000..52943063c
--- /dev/null
+++ b/src/llvm-c/Error.h
@@ -0,0 +1,69 @@
+/*===------- llvm-c/Error.h - llvm::Error class C Interface -------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to LLVM's Error class.                   *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_ERROR_H
+#define LLVM_C_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LLVMErrorSuccess 0
+
+/**
+ * Opaque reference to an error instance. Null serves as the 'success' value.
+ */
+typedef struct LLVMOpaqueError *LLVMErrorRef;
+
+/**
+ * Error type identifier.
+ */
+typedef const void *LLVMErrorTypeId;
+
+/**
+ * Returns the type id for the given error instance, which must be a failure
+ * value (i.e. non-null).
+ */
+LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err);
+
+/**
+ * Dispose of the given error without handling it. This operation consumes the
+ * error, and the given LLVMErrorRef value is not usable once this call returns.
+ * Note: This method *only* needs to be called if the error is not being passed
+ * to some other consuming operation, e.g. LLVMGetErrorMessage.
+ */
+void LLVMConsumeError(LLVMErrorRef Err);
+
+/**
+ * Returns the given string's error message. This operation consumes the error,
+ * and the given LLVMErrorRef value is not usable once this call returns.
+ * The caller is responsible for disposing of the string by calling
+ * LLVMDisposeErrorMessage.
+ */
+char *LLVMGetErrorMessage(LLVMErrorRef Err);
+
+/**
+ * Dispose of the given error message.
+ */
+void LLVMDisposeErrorMessage(char *ErrMsg);
+
+/**
+ * Returns the type id for llvm StringError.
+ */
+LLVMErrorTypeId LLVMGetStringErrorTypeId(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/ErrorHandling.h b/src/llvm-c/ErrorHandling.h
new file mode 100644
index 000000000..4927349d8
--- /dev/null
+++ b/src/llvm-c/ErrorHandling.h
@@ -0,0 +1,49 @@
+/*===-- llvm-c/ErrorHandling.h - Error Handling C Interface -------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to LLVM's error handling mechanism.      *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_ERROR_HANDLING_H
+#define LLVM_C_ERROR_HANDLING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*LLVMFatalErrorHandler)(const char *Reason);
+
+/**
+ * Install a fatal error handler. By default, if LLVM detects a fatal error, it
+ * will call exit(1). This may not be appropriate in many contexts. For example,
+ * doing exit(1) will bypass many crash reporting/tracing system tools. This
+ * function allows you to install a callback that will be invoked prior to the
+ * call to exit(1).
+ */
+void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
+
+/**
+ * Reset the fatal error handler. This resets LLVM's fatal error handling
+ * behavior to the default.
+ */
+void LLVMResetFatalErrorHandler(void);
+
+/**
+ * Enable LLVM's built-in stack trace code. This intercepts the OS's crash
+ * signals and prints which component of LLVM you were in at the time if the
+ * crash.
+ */
+void LLVMEnablePrettyStackTrace(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/ExecutionEngine.h b/src/llvm-c/ExecutionEngine.h
new file mode 100644
index 000000000..ef714cd06
--- /dev/null
+++ b/src/llvm-c/ExecutionEngine.h
@@ -0,0 +1,200 @@
+/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMExecutionEngine.o, which    *|
+|* implements various analyses of the LLVM IR.                                *|
+|*                                                                            *|
+|* 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_EXECUTIONENGINE_H
+#define LLVM_C_EXECUTIONENGINE_H
+
+#include "llvm-c/Target.h"
+#include "llvm-c/TargetMachine.h"
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCExecutionEngine Execution Engine
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+void LLVMLinkInMCJIT(void);
+void LLVMLinkInInterpreter(void);
+
+typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
+typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
+typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
+
+struct LLVMMCJITCompilerOptions {
+  unsigned OptLevel;
+  LLVMCodeModel CodeModel;
+  LLVMBool NoFramePointerElim;
+  LLVMBool EnableFastISel;
+  LLVMMCJITMemoryManagerRef MCJMM;
+};
+
+/*===-- Operations on generic values --------------------------------------===*/
+
+LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
+                                                unsigned long long N,
+                                                LLVMBool IsSigned);
+
+LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
+
+LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
+
+unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
+
+unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
+                                         LLVMBool IsSigned);
+
+void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
+
+double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
+
+void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
+
+/*===-- Operations on execution engines -----------------------------------===*/
+
+LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
+                                            LLVMModuleRef M,
+                                            char **OutError);
+
+LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
+                                        LLVMModuleRef M,
+                                        char **OutError);
+
+LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
+                                        LLVMModuleRef M,
+                                        unsigned OptLevel,
+                                        char **OutError);
+
+void LLVMInitializeMCJITCompilerOptions(
+  struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
+
+/**
+ * Create an MCJIT execution engine for a module, with the given options. It is
+ * the responsibility of the caller to ensure that all fields in Options up to
+ * the given SizeOfOptions are initialized. It is correct to pass a smaller
+ * value of SizeOfOptions that omits some fields. The canonical way of using
+ * this is:
+ *
+ * LLVMMCJITCompilerOptions options;
+ * LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
+ * ... fill in those options you care about
+ * LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
+ *                                  &error);
+ *
+ * Note that this is also correct, though possibly suboptimal:
+ *
+ * LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
+ */
+LLVMBool LLVMCreateMCJITCompilerForModule(
+  LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
+  struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
+  char **OutError);
+
+void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
+
+void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
+
+void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
+
+int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
+                          unsigned ArgC, const char * const *ArgV,
+                          const char * const *EnvP);
+
+LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
+                                    unsigned NumArgs,
+                                    LLVMGenericValueRef *Args);
+
+void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
+
+void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
+
+LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
+                          LLVMModuleRef *OutMod, char **OutError);
+
+LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
+                          LLVMValueRef *OutFn);
+
+void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
+                                     LLVMValueRef Fn);
+
+LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
+LLVMTargetMachineRef
+LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
+
+void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
+                          void* Addr);
+
+void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
+
+uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
+
+uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
+
+/*===-- Operations on memory managers -------------------------------------===*/
+
+typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
+  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
+  const char *SectionName);
+typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
+  void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
+  const char *SectionName, LLVMBool IsReadOnly);
+typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
+  void *Opaque, char **ErrMsg);
+typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
+
+/**
+ * Create a simple custom MCJIT memory manager. This memory manager can
+ * intercept allocations in a module-oblivious way. This will return NULL
+ * if any of the passed functions are NULL.
+ *
+ * @param Opaque An opaque client object to pass back to the callbacks.
+ * @param AllocateCodeSection Allocate a block of memory for executable code.
+ * @param AllocateDataSection Allocate a block of memory for data.
+ * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
+ *   success, 1 on error.
+ */
+LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
+  void *Opaque,
+  LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
+  LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
+  LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
+  LLVMMemoryManagerDestroyCallback Destroy);
+
+void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
+
+/*===-- JIT Event Listener functions -------------------------------------===*/
+
+LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void);
+LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void);
+LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void);
+LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/IRReader.h b/src/llvm-c/IRReader.h
new file mode 100644
index 000000000..4d0b696e9
--- /dev/null
+++ b/src/llvm-c/IRReader.h
@@ -0,0 +1,40 @@
+/*===-- llvm-c/IRReader.h - IR Reader C Interface -----------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to the IR Reader.                        *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_IRREADER_H
+#define LLVM_C_IRREADER_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Read LLVM IR from a memory buffer and convert it into an in-memory Module
+ * object. Returns 0 on success.
+ * Optionally returns a human-readable description of any errors that
+ * occurred during parsing IR. OutMessage must be disposed with
+ * LLVMDisposeMessage.
+ *
+ * @see llvm::ParseIR()
+ */
+LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
+                              LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
+                              char **OutMessage);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Initialization.h b/src/llvm-c/Initialization.h
new file mode 100644
index 000000000..36c41dbd8
--- /dev/null
+++ b/src/llvm-c/Initialization.h
@@ -0,0 +1,56 @@
+/*===-- llvm-c/Initialization.h - Initialization C Interface ------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to LLVM initialization routines,      *|
+|* which must be called before you can use the functionality provided by      *|
+|* the corresponding LLVM library.                                            *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_INITIALIZATION_H
+#define LLVM_C_INITIALIZATION_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCInitialization Initialization Routines
+ * @ingroup LLVMC
+ *
+ * This module contains routines used to initialize the LLVM system.
+ *
+ * @{
+ */
+
+void LLVMInitializeCore(LLVMPassRegistryRef R);
+void LLVMInitializeTransformUtils(LLVMPassRegistryRef R);
+void LLVMInitializeScalarOpts(LLVMPassRegistryRef R);
+void LLVMInitializeObjCARCOpts(LLVMPassRegistryRef R);
+void LLVMInitializeVectorization(LLVMPassRegistryRef R);
+void LLVMInitializeInstCombine(LLVMPassRegistryRef R);
+void LLVMInitializeAggressiveInstCombiner(LLVMPassRegistryRef R);
+void LLVMInitializeIPO(LLVMPassRegistryRef R);
+void LLVMInitializeInstrumentation(LLVMPassRegistryRef R);
+void LLVMInitializeAnalysis(LLVMPassRegistryRef R);
+void LLVMInitializeIPA(LLVMPassRegistryRef R);
+void LLVMInitializeCodeGen(LLVMPassRegistryRef R);
+void LLVMInitializeTarget(LLVMPassRegistryRef R);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/LinkTimeOptimizer.h b/src/llvm-c/LinkTimeOptimizer.h
new file mode 100644
index 000000000..19b4f5cf7
--- /dev/null
+++ b/src/llvm-c/LinkTimeOptimizer.h
@@ -0,0 +1,68 @@
+//===-- llvm/LinkTimeOptimizer.h - LTO Public C Interface -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This header provides a C API to use the LLVM link time optimization
+// library. This is intended to be used by linkers which are C-only in
+// their implementation for performing LTO.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_C_LINKTIMEOPTIMIZER_H
+#define LLVM_C_LINKTIMEOPTIMIZER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCLinkTimeOptimizer Link Time Optimization
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+  /// This provides a dummy type for pointers to the LTO object.
+  typedef void* llvm_lto_t;
+
+  /// This provides a C-visible enumerator to manage status codes.
+  /// This should map exactly onto the C++ enumerator LTOStatus.
+  typedef enum llvm_lto_status {
+    LLVM_LTO_UNKNOWN,
+    LLVM_LTO_OPT_SUCCESS,
+    LLVM_LTO_READ_SUCCESS,
+    LLVM_LTO_READ_FAILURE,
+    LLVM_LTO_WRITE_FAILURE,
+    LLVM_LTO_NO_TARGET,
+    LLVM_LTO_NO_WORK,
+    LLVM_LTO_MODULE_MERGE_FAILURE,
+    LLVM_LTO_ASM_FAILURE,
+
+    //  Added C-specific error codes
+    LLVM_LTO_NULL_OBJECT
+  } llvm_lto_status_t;
+
+  /// This provides C interface to initialize link time optimizer. This allows
+  /// linker to use dlopen() interface to dynamically load LinkTimeOptimizer.
+  /// extern "C" helps, because dlopen() interface uses name to find the symbol.
+  extern llvm_lto_t llvm_create_optimizer(void);
+  extern void llvm_destroy_optimizer(llvm_lto_t lto);
+
+  extern llvm_lto_status_t llvm_read_object_file
+    (llvm_lto_t lto, const char* input_filename);
+  extern llvm_lto_status_t llvm_optimize_modules
+    (llvm_lto_t lto, const char* output_filename);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Linker.h b/src/llvm-c/Linker.h
new file mode 100644
index 000000000..908513041
--- /dev/null
+++ b/src/llvm-c/Linker.h
@@ -0,0 +1,41 @@
+/*===-- llvm-c/Linker.h - Module Linker C Interface -------------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to the module/file/archive linker.       *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_LINKER_H
+#define LLVM_C_LINKER_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This enum is provided for backwards-compatibility only. It has no effect. */
+typedef enum {
+  LLVMLinkerDestroySource = 0, /* This is the default behavior. */
+  LLVMLinkerPreserveSource_Removed = 1 /* This option has been deprecated and
+                                          should not be used. */
+} LLVMLinkerMode;
+
+/* Links the source module into the destination module. The source module is
+ * destroyed.
+ * The return value is true if an error occurred, false otherwise.
+ * Use the diagnostic handler to get any diagnostic message.
+*/
+LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Object.h b/src/llvm-c/Object.h
new file mode 100644
index 000000000..1f6501c8e
--- /dev/null
+++ b/src/llvm-c/Object.h
@@ -0,0 +1,233 @@
+/*===-- llvm-c/Object.h - Object Lib C Iface --------------------*- C++ -*-===*/
+/*                                                                            */
+/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
+/* Exceptions.                                                                */
+/* See https://llvm.org/LICENSE.txt for license information.                  */
+/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                                                                            */
+/*===----------------------------------------------------------------------===*/
+/*                                                                            */
+/* 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/Types.h"
+#include "Config/llvm-config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCObject Object file reading and writing
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+// Opaque type wrappers
+typedef struct LLVMOpaqueSectionIterator *LLVMSectionIteratorRef;
+typedef struct LLVMOpaqueSymbolIterator *LLVMSymbolIteratorRef;
+typedef struct LLVMOpaqueRelocationIterator *LLVMRelocationIteratorRef;
+
+typedef enum {
+  LLVMBinaryTypeArchive,                /**< Archive file. */
+  LLVMBinaryTypeMachOUniversalBinary,   /**< Mach-O Universal Binary file. */
+  LLVMBinaryTypeCOFFImportFile,         /**< COFF Import file. */
+  LLVMBinaryTypeIR,                     /**< LLVM IR. */
+  LLVMBinaryTypeWinRes,                 /**< Windows resource (.res) file. */
+  LLVMBinaryTypeCOFF,                   /**< COFF Object file. */
+  LLVMBinaryTypeELF32L,                 /**< ELF 32-bit, little endian. */
+  LLVMBinaryTypeELF32B,                 /**< ELF 32-bit, big endian. */
+  LLVMBinaryTypeELF64L,                 /**< ELF 64-bit, little endian. */
+  LLVMBinaryTypeELF64B,                 /**< ELF 64-bit, big endian. */
+  LLVMBinaryTypeMachO32L,               /**< MachO 32-bit, little endian. */
+  LLVMBinaryTypeMachO32B,               /**< MachO 32-bit, big endian. */
+  LLVMBinaryTypeMachO64L,               /**< MachO 64-bit, little endian. */
+  LLVMBinaryTypeMachO64B,               /**< MachO 64-bit, big endian. */
+  LLVMBinaryTypeWasm,                   /**< Web Assembly. */
+} LLVMBinaryType;
+
+/**
+ * Create a binary file from the given memory buffer.
+ *
+ * The exact type of the binary file will be inferred automatically, and the
+ * appropriate implementation selected.  The context may be NULL except if
+ * the resulting file is an LLVM IR file.
+ *
+ * The memory buffer is not consumed by this function.  It is the responsibilty
+ * of the caller to free it with \c LLVMDisposeMemoryBuffer.
+ *
+ * If NULL is returned, the \p ErrorMessage parameter is populated with the
+ * error's description.  It is then the caller's responsibility to free this
+ * message by calling \c LLVMDisposeMessage.
+ *
+ * @see llvm::object::createBinary
+ */
+LLVMBinaryRef LLVMCreateBinary(LLVMMemoryBufferRef MemBuf,
+                               LLVMContextRef Context,
+                               char **ErrorMessage);
+
+/**
+ * Dispose of a binary file.
+ *
+ * The binary file does not own its backing buffer.  It is the responsibilty
+ * of the caller to free it with \c LLVMDisposeMemoryBuffer.
+ */
+void LLVMDisposeBinary(LLVMBinaryRef BR);
+
+/**
+ * Retrieves a copy of the memory buffer associated with this object file.
+ *
+ * The returned buffer is merely a shallow copy and does not own the actual
+ * backing buffer of the binary. Nevertheless, it is the responsibility of the
+ * caller to free it with \c LLVMDisposeMemoryBuffer.
+ *
+ * @see llvm::object::getMemoryBufferRef
+ */
+LLVMMemoryBufferRef LLVMBinaryCopyMemoryBuffer(LLVMBinaryRef BR);
+
+/**
+ * Retrieve the specific type of a binary.
+ *
+ * @see llvm::object::Binary::getType
+ */
+LLVMBinaryType LLVMBinaryGetType(LLVMBinaryRef BR);
+
+/*
+ * For a Mach-O universal binary file, retrieves the object file corresponding
+ * to the given architecture if it is present as a slice.
+ *
+ * If NULL is returned, the \p ErrorMessage parameter is populated with the
+ * error's description.  It is then the caller's responsibility to free this
+ * message by calling \c LLVMDisposeMessage.
+ *
+ * It is the responsiblity of the caller to free the returned object file by
+ * calling \c LLVMDisposeBinary.
+ */
+LLVMBinaryRef LLVMMachOUniversalBinaryCopyObjectForArch(LLVMBinaryRef BR,
+                                                        const char *Arch,
+                                                        size_t ArchLen,
+                                                        char **ErrorMessage);
+
+/**
+ * Retrieve a copy of the section iterator for this object file.
+ *
+ * If there are no sections, the result is NULL.
+ *
+ * The returned iterator is merely a shallow copy. Nevertheless, it is
+ * the responsibility of the caller to free it with
+ * \c LLVMDisposeSectionIterator.
+ *
+ * @see llvm::object::sections()
+ */
+LLVMSectionIteratorRef LLVMObjectFileCopySectionIterator(LLVMBinaryRef BR);
+
+/**
+ * Returns whether the given section iterator is at the end.
+ *
+ * @see llvm::object::section_end
+ */
+LLVMBool LLVMObjectFileIsSectionIteratorAtEnd(LLVMBinaryRef BR,
+                                              LLVMSectionIteratorRef SI);
+
+/**
+ * Retrieve a copy of the symbol iterator for this object file.
+ *
+ * If there are no symbols, the result is NULL.
+ *
+ * The returned iterator is merely a shallow copy. Nevertheless, it is
+ * the responsibility of the caller to free it with
+ * \c LLVMDisposeSymbolIterator.
+ *
+ * @see llvm::object::symbols()
+ */
+LLVMSymbolIteratorRef LLVMObjectFileCopySymbolIterator(LLVMBinaryRef BR);
+
+/**
+ * Returns whether the given symbol iterator is at the end.
+ *
+ * @see llvm::object::symbol_end
+ */
+LLVMBool LLVMObjectFileIsSymbolIteratorAtEnd(LLVMBinaryRef BR,
+                                             LLVMSymbolIteratorRef SI);
+
+void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI);
+
+void LLVMMoveToNextSection(LLVMSectionIteratorRef SI);
+void LLVMMoveToContainingSection(LLVMSectionIteratorRef Sect,
+                                 LLVMSymbolIteratorRef Sym);
+
+// ObjectFile Symbol iterators
+void LLVMDisposeSymbolIterator(LLVMSymbolIteratorRef SI);
+void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI);
+
+// SectionRef accessors
+const char *LLVMGetSectionName(LLVMSectionIteratorRef SI);
+uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI);
+const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI);
+uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI);
+LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
+                                 LLVMSymbolIteratorRef Sym);
+
+// Section Relocation iterators
+LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section);
+void LLVMDisposeRelocationIterator(LLVMRelocationIteratorRef RI);
+LLVMBool LLVMIsRelocationIteratorAtEnd(LLVMSectionIteratorRef Section,
+                                       LLVMRelocationIteratorRef RI);
+void LLVMMoveToNextRelocation(LLVMRelocationIteratorRef RI);
+
+
+// SymbolRef accessors
+const char *LLVMGetSymbolName(LLVMSymbolIteratorRef SI);
+uint64_t LLVMGetSymbolAddress(LLVMSymbolIteratorRef SI);
+uint64_t LLVMGetSymbolSize(LLVMSymbolIteratorRef SI);
+
+// RelocationRef accessors
+uint64_t LLVMGetRelocationOffset(LLVMRelocationIteratorRef RI);
+LLVMSymbolIteratorRef LLVMGetRelocationSymbol(LLVMRelocationIteratorRef RI);
+uint64_t LLVMGetRelocationType(LLVMRelocationIteratorRef RI);
+// NOTE: Caller takes ownership of returned string of the two
+// following functions.
+const char *LLVMGetRelocationTypeName(LLVMRelocationIteratorRef RI);
+const char *LLVMGetRelocationValueString(LLVMRelocationIteratorRef RI);
+
+/** Deprecated: Use LLVMBinaryRef instead. */
+typedef struct LLVMOpaqueObjectFile *LLVMObjectFileRef;
+
+/** Deprecated: Use LLVMCreateBinary instead. */
+LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf);
+
+/** Deprecated: Use LLVMDisposeBinary instead. */
+void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile);
+
+/** Deprecated: Use LLVMObjectFileCopySectionIterator instead. */
+LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile);
+
+/** Deprecated: Use LLVMObjectFileIsSectionIteratorAtEnd instead. */
+LLVMBool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile,
+                                    LLVMSectionIteratorRef SI);
+
+/** Deprecated: Use LLVMObjectFileCopySymbolIterator instead. */
+LLVMSymbolIteratorRef LLVMGetSymbols(LLVMObjectFileRef ObjectFile);
+
+/** Deprecated: Use LLVMObjectFileIsSymbolIteratorAtEnd instead. */
+LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef ObjectFile,
+                                   LLVMSymbolIteratorRef SI);
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/OrcBindings.h b/src/llvm-c/OrcBindings.h
new file mode 100644
index 000000000..9e92371b5
--- /dev/null
+++ b/src/llvm-c/OrcBindings.h
@@ -0,0 +1,172 @@
+/*===----------- llvm-c/OrcBindings.h - Orc Lib C Iface ---------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMOrcJIT.a, which implements  *|
+|* JIT compilation of LLVM IR.                                                *|
+|*                                                                            *|
+|* 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.                                           *|
+|*                                                                            *|
+|* Note: This interface is experimental. It is *NOT* stable, and may be       *|
+|*       changed without warning.                                             *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_ORCBINDINGS_H
+#define LLVM_C_ORCBINDINGS_H
+
+#include "llvm-c/Error.h"
+#include "llvm-c/Object.h"
+#include "llvm-c/TargetMachine.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
+typedef uint64_t LLVMOrcModuleHandle;
+typedef uint64_t LLVMOrcTargetAddress;
+typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx);
+typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack,
+                                                 void *CallbackCtx);
+
+/**
+ * Create an ORC JIT stack.
+ *
+ * The client owns the resulting stack, and must call OrcDisposeInstance(...)
+ * to destroy it and free its memory. The JIT stack will take ownership of the
+ * TargetMachine, which will be destroyed when the stack is destroyed. The
+ * client should not attempt to dispose of the Target Machine, or it will result
+ * in a double-free.
+ */
+LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM);
+
+/**
+ * Get the error message for the most recent error (if any).
+ *
+ * This message is owned by the ORC JIT Stack and will be freed when the stack
+ * is disposed of by LLVMOrcDisposeInstance.
+ */
+const char *LLVMOrcGetErrorMsg(LLVMOrcJITStackRef JITStack);
+
+/**
+ * Mangle the given symbol.
+ * Memory will be allocated for MangledSymbol to hold the result. The client
+ */
+void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledSymbol,
+                             const char *Symbol);
+
+/**
+ * Dispose of a mangled symbol.
+ */
+void LLVMOrcDisposeMangledSymbol(char *MangledSymbol);
+
+/**
+ * Create a lazy compile callback.
+ */
+LLVMErrorRef LLVMOrcCreateLazyCompileCallback(
+    LLVMOrcJITStackRef JITStack, LLVMOrcTargetAddress *RetAddr,
+    LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx);
+
+/**
+ * Create a named indirect call stub.
+ */
+LLVMErrorRef LLVMOrcCreateIndirectStub(LLVMOrcJITStackRef JITStack,
+                                       const char *StubName,
+                                       LLVMOrcTargetAddress InitAddr);
+
+/**
+ * Set the pointer for the given indirect stub.
+ */
+LLVMErrorRef LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
+                                           const char *StubName,
+                                           LLVMOrcTargetAddress NewAddr);
+
+/**
+ * Add module to be eagerly compiled.
+ */
+LLVMErrorRef LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
+                                         LLVMOrcModuleHandle *RetHandle,
+                                         LLVMModuleRef Mod,
+                                         LLVMOrcSymbolResolverFn SymbolResolver,
+                                         void *SymbolResolverCtx);
+
+/**
+ * Add module to be lazily compiled one function at a time.
+ */
+LLVMErrorRef LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
+                                        LLVMOrcModuleHandle *RetHandle,
+                                        LLVMModuleRef Mod,
+                                        LLVMOrcSymbolResolverFn SymbolResolver,
+                                        void *SymbolResolverCtx);
+
+/**
+ * Add an object file.
+ *
+ * This method takes ownership of the given memory buffer and attempts to add
+ * it to the JIT as an object file.
+ * Clients should *not* dispose of the 'Obj' argument: the JIT will manage it
+ * from this call onwards.
+ */
+LLVMErrorRef LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
+                                  LLVMOrcModuleHandle *RetHandle,
+                                  LLVMMemoryBufferRef Obj,
+                                  LLVMOrcSymbolResolverFn SymbolResolver,
+                                  void *SymbolResolverCtx);
+
+/**
+ * Remove a module set from the JIT.
+ *
+ * This works for all modules that can be added via OrcAdd*, including object
+ * files.
+ */
+LLVMErrorRef LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
+                                 LLVMOrcModuleHandle H);
+
+/**
+ * Get symbol address from JIT instance.
+ */
+LLVMErrorRef LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
+                                     LLVMOrcTargetAddress *RetAddr,
+                                     const char *SymbolName);
+
+/**
+ * Get symbol address from JIT instance, searching only the specified
+ * handle.
+ */
+LLVMErrorRef LLVMOrcGetSymbolAddressIn(LLVMOrcJITStackRef JITStack,
+                                       LLVMOrcTargetAddress *RetAddr,
+                                       LLVMOrcModuleHandle H,
+                                       const char *SymbolName);
+
+/**
+ * Dispose of an ORC JIT stack.
+ */
+LLVMErrorRef LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack);
+
+/**
+ * Register a JIT Event Listener.
+ *
+ * A NULL listener is ignored.
+ */
+void LLVMOrcRegisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L);
+
+/**
+ * Unegister a JIT Event Listener.
+ *
+ * A NULL listener is ignored.
+ */
+void LLVMOrcUnregisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L);
+
+#ifdef __cplusplus
+}
+#endif /* extern "C" */
+
+#endif /* LLVM_C_ORCBINDINGS_H */
diff --git a/src/llvm-c/Remarks.h b/src/llvm-c/Remarks.h
new file mode 100644
index 000000000..88eb5120c
--- /dev/null
+++ b/src/llvm-c/Remarks.h
@@ -0,0 +1,329 @@
+/*===-- llvm-c/Remarks.h - Remarks Public C Interface -------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header provides a public interface to a remark diagnostics library.   *|
+|* LLVM provides an implementation of this interface.                         *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_REMARKS_H
+#define LLVM_C_REMARKS_H
+
+#include "llvm-c/Types.h"
+#ifdef __cplusplus
+#include <cstddef>
+extern "C" {
+#else
+#include <stddef.h>
+#endif /* !defined(__cplusplus) */
+
+/**
+ * @defgroup LLVMCREMARKS Remarks
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+#define REMARKS_API_VERSION 0
+
+/**
+ * The type of the emitted remark.
+ */
+enum LLVMRemarkType {
+  LLVMRemarkTypeUnknown,
+  LLVMRemarkTypePassed,
+  LLVMRemarkTypeMissed,
+  LLVMRemarkTypeAnalysis,
+  LLVMRemarkTypeAnalysisFPCommute,
+  LLVMRemarkTypeAnalysisAliasing,
+  LLVMRemarkTypeFailure
+};
+
+/**
+ * String containing a buffer and a length. The buffer is not guaranteed to be
+ * zero-terminated.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+typedef struct LLVMRemarkOpaqueString *LLVMRemarkStringRef;
+
+/**
+ * Returns the buffer holding the string.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern const char *LLVMRemarkStringGetData(LLVMRemarkStringRef String);
+
+/**
+ * Returns the size of the string.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint32_t LLVMRemarkStringGetLen(LLVMRemarkStringRef String);
+
+/**
+ * DebugLoc containing File, Line and Column.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+typedef struct LLVMRemarkOpaqueDebugLoc *LLVMRemarkDebugLocRef;
+
+/**
+ * Return the path to the source file for a debug location.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef
+LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL);
+
+/**
+ * Return the line in the source file for a debug location.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint32_t LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL);
+
+/**
+ * Return the column in the source file for a debug location.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint32_t LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL);
+
+/**
+ * Element of the "Args" list. The key might give more information about what
+ * the semantics of the value are, e.g. "Callee" will tell you that the value
+ * is a symbol that names a function.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+typedef struct LLVMRemarkOpaqueArg *LLVMRemarkArgRef;
+
+/**
+ * Returns the key of an argument. The key defines what the value is, and the
+ * same key can appear multiple times in the list of arguments.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg);
+
+/**
+ * Returns the value of an argument. This is a string that can contain newlines.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg);
+
+/**
+ * Returns the debug location that is attached to the value of this argument.
+ *
+ * If there is no debug location, the return value will be `NULL`.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkDebugLocRef LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg);
+
+/**
+ * A remark emitted by the compiler.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+typedef struct LLVMRemarkOpaqueEntry *LLVMRemarkEntryRef;
+
+/**
+ * Free the resources used by the remark entry.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern void LLVMRemarkEntryDispose(LLVMRemarkEntryRef Remark);
+
+/**
+ * The type of the remark. For example, it can allow users to only keep the
+ * missed optimizations from the compiler.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern enum LLVMRemarkType LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark);
+
+/**
+ * Get the name of the pass that emitted this remark.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef
+LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark);
+
+/**
+ * Get an identifier of the remark.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef
+LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark);
+
+/**
+ * Get the name of the function being processed when the remark was emitted.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkStringRef
+LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark);
+
+/**
+ * Returns the debug location that is attached to this remark.
+ *
+ * If there is no debug location, the return value will be `NULL`.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkDebugLocRef
+LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark);
+
+/**
+ * Return the hotness of the remark.
+ *
+ * A hotness of `0` means this value is not set.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint64_t LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark);
+
+/**
+ * The number of arguments the remark holds.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark);
+
+/**
+ * Get a new iterator to iterate over a remark's argument.
+ *
+ * If there are no arguments in \p Remark, the return value will be `NULL`.
+ *
+ * The lifetime of the returned value is bound to the lifetime of \p Remark.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkArgRef LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark);
+
+/**
+ * Get the next argument in \p Remark from the position of \p It.
+ *
+ * Returns `NULL` if there are no more arguments available.
+ *
+ * The lifetime of the returned value is bound to the lifetime of \p Remark.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkArgRef LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef It,
+                                                  LLVMRemarkEntryRef Remark);
+
+typedef struct LLVMRemarkOpaqueParser *LLVMRemarkParserRef;
+
+/**
+ * Creates a remark parser that can be used to parse the buffer located in \p
+ * Buf of size \p Size bytes.
+ *
+ * \p Buf cannot be `NULL`.
+ *
+ * This function should be paired with LLVMRemarkParserDispose() to avoid
+ * leaking resources.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
+                                                      uint64_t Size);
+
+/**
+ * Returns the next remark in the file.
+ *
+ * The value pointed to by the return value needs to be disposed using a call to
+ * LLVMRemarkEntryDispose().
+ *
+ * All the entries in the returned value that are of LLVMRemarkStringRef type
+ * will become invalidated once a call to LLVMRemarkParserDispose is made.
+ *
+ * If the parser reaches the end of the buffer, the return value will be `NULL`.
+ *
+ * In the case of an error, the return value will be `NULL`, and:
+ *
+ * 1) LLVMRemarkParserHasError() will return `1`.
+ *
+ * 2) LLVMRemarkParserGetErrorMessage() will return a descriptive error
+ *    message.
+ *
+ * An error may occur if:
+ *
+ * 1) An argument is invalid.
+ *
+ * 2) There is a parsing error. This can occur on things like malformed YAML.
+ *
+ * 3) There is a Remark semantic error. This can occur on well-formed files with
+ *    missing or extra fields.
+ *
+ * Here is a quick example of the usage:
+ *
+ * ```
+ * LLVMRemarkParserRef Parser = LLVMRemarkParserCreateYAML(Buf, Size);
+ * LLVMRemarkEntryRef Remark = NULL;
+ * while ((Remark = LLVMRemarkParserGetNext(Parser))) {
+ *    // use Remark
+ *    LLVMRemarkEntryDispose(Remark); // Release memory.
+ * }
+ * bool HasError = LLVMRemarkParserHasError(Parser);
+ * LLVMRemarkParserDispose(Parser);
+ * ```
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMRemarkEntryRef LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser);
+
+/**
+ * Returns `1` if the parser encountered an error while parsing the buffer.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser);
+
+/**
+ * Returns a null-terminated string containing an error message.
+ *
+ * In case of no error, the result is `NULL`.
+ *
+ * The memory of the string is bound to the lifetime of \p Parser. If
+ * LLVMRemarkParserDispose() is called, the memory of the string will be
+ * released.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern const char *LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser);
+
+/**
+ * Releases all the resources used by \p Parser.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser);
+
+/**
+ * Returns the version of the remarks library.
+ *
+ * \since REMARKS_API_VERSION=0
+ */
+extern uint32_t LLVMRemarkVersion(void);
+
+/**
+ * @} // endgoup LLVMCREMARKS
+ */
+
+#ifdef __cplusplus
+}
+#endif /* !defined(__cplusplus) */
+
+#endif /* LLVM_C_REMARKS_H */
diff --git a/src/llvm-c/Support.h b/src/llvm-c/Support.h
new file mode 100644
index 000000000..097f78424
--- /dev/null
+++ b/src/llvm-c/Support.h
@@ -0,0 +1,65 @@
+/*===-- llvm-c/Support.h - Support C Interface --------------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to the LLVM support library.             *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_SUPPORT_H
+#define LLVM_C_SUPPORT_H
+
+#include "llvm-c/DataTypes.h"
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This function permanently loads the dynamic library at the given path.
+ * It is safe to call this function multiple times for the same library.
+ *
+ * @see sys::DynamicLibrary::LoadLibraryPermanently()
+  */
+LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
+
+/**
+ * This function parses the given arguments using the LLVM command line parser.
+ * Note that the only stable thing about this function is its signature; you
+ * cannot rely on any particular set of command line arguments being interpreted
+ * the same way across LLVM versions.
+ *
+ * @see llvm::cl::ParseCommandLineOptions()
+ */
+void LLVMParseCommandLineOptions(int argc, const char *const *argv,
+                                 const char *Overview);
+
+/**
+ * This function will search through all previously loaded dynamic
+ * libraries for the symbol \p symbolName. If it is found, the address of
+ * that symbol is returned. If not, null is returned.
+ *
+ * @see sys::DynamicLibrary::SearchForAddressOfSymbol()
+ */
+void *LLVMSearchForAddressOfSymbol(const char *symbolName);
+
+/**
+ * This functions permanently adds the symbol \p symbolName with the
+ * value \p symbolValue.  These symbols are searched before any
+ * libraries.
+ *
+ * @see sys::DynamicLibrary::AddSymbol()
+ */
+void LLVMAddSymbol(const char *symbolName, void *symbolValue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Target.h b/src/llvm-c/Target.h
new file mode 100644
index 000000000..e0d0c0b29
--- /dev/null
+++ b/src/llvm-c/Target.h
@@ -0,0 +1,295 @@
+/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*/
+/*                                                                            */
+/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
+/* Exceptions.                                                                */
+/* See https://llvm.org/LICENSE.txt for license information.                  */
+/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                                                                            */
+/*===----------------------------------------------------------------------===*/
+/*                                                                            */
+/* This header declares the C interface to libLLVMTarget.a, which             */
+/* implements target information.                                             */
+/*                                                                            */
+/* 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_TARGET_H
+#define LLVM_C_TARGET_H
+
+#include "Types.h"
+#include "Config/llvm-config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTarget Target information
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+enum LLVMByteOrdering { LLVMBigEndian, LLVMLittleEndian };
+
+typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
+typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef;
+
+/* Declare all of the target-initialization functions that are available. */
+#define LLVM_TARGET(TargetName) \
+  void LLVMInitialize##TargetName##TargetInfo(void);
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+
+#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void);
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+
+#define LLVM_TARGET(TargetName) \
+  void LLVMInitialize##TargetName##TargetMC(void);
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+
+/* Declare all of the available assembly printer initialization functions. */
+#define LLVM_ASM_PRINTER(TargetName) \
+  void LLVMInitialize##TargetName##AsmPrinter(void);
+#include "Config/AsmPrinters.def"
+#undef LLVM_ASM_PRINTER  /* Explicit undef to make SWIG happier */
+
+/* Declare all of the available assembly parser initialization functions. */
+#define LLVM_ASM_PARSER(TargetName) \
+  void LLVMInitialize##TargetName##AsmParser(void);
+#include "Config/AsmParsers.def"
+#undef LLVM_ASM_PARSER  /* Explicit undef to make SWIG happier */
+
+/* Declare all of the available disassembler initialization functions. */
+#define LLVM_DISASSEMBLER(TargetName) \
+  void LLVMInitialize##TargetName##Disassembler(void);
+#include "Config/Disassemblers.def"
+#undef LLVM_DISASSEMBLER  /* Explicit undef to make SWIG happier */
+
+/** LLVMInitializeAllTargetInfos - The main program should call this function if
+    it wants access to all available targets that LLVM is configured to
+    support. */
+static inline void LLVMInitializeAllTargetInfos(void) {
+#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeAllTargets - The main program should call this function if it
+    wants to link in all available targets that LLVM is configured to
+    support. */
+static inline void LLVMInitializeAllTargets(void) {
+#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeAllTargetMCs - The main program should call this function if
+    it wants access to all available target MC that LLVM is configured to
+    support. */
+static inline void LLVMInitializeAllTargetMCs(void) {
+#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC();
+#include "Config/Targets.def"
+#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeAllAsmPrinters - The main program should call this function if
+    it wants all asm printers that LLVM is configured to support, to make them
+    available via the TargetRegistry. */
+static inline void LLVMInitializeAllAsmPrinters(void) {
+#define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter();
+#include "Config/AsmPrinters.def"
+#undef LLVM_ASM_PRINTER  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeAllAsmParsers - The main program should call this function if
+    it wants all asm parsers that LLVM is configured to support, to make them
+    available via the TargetRegistry. */
+static inline void LLVMInitializeAllAsmParsers(void) {
+#define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser();
+#include "Config/AsmParsers.def"
+#undef LLVM_ASM_PARSER  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeAllDisassemblers - The main program should call this function
+    if it wants all disassemblers that LLVM is configured to support, to make
+    them available via the TargetRegistry. */
+static inline void LLVMInitializeAllDisassemblers(void) {
+#define LLVM_DISASSEMBLER(TargetName) \
+  LLVMInitialize##TargetName##Disassembler();
+#include "Config/Disassemblers.def"
+#undef LLVM_DISASSEMBLER  /* Explicit undef to make SWIG happier */
+}
+
+/** LLVMInitializeNativeTarget - The main program should call this function to
+    initialize the native target corresponding to the host.  This is useful
+    for JIT applications to ensure that the target gets linked in correctly. */
+static inline LLVMBool LLVMInitializeNativeTarget(void) {
+  /* If we have a native target, initialize it to ensure it is linked in. */
+#ifdef LLVM_NATIVE_TARGET
+  LLVM_NATIVE_TARGETINFO();
+  LLVM_NATIVE_TARGET();
+  LLVM_NATIVE_TARGETMC();
+  return 0;
+#else
+  return 1;
+#endif
+}
+
+/** LLVMInitializeNativeTargetAsmParser - The main program should call this
+    function to initialize the parser for the native target corresponding to the
+    host. */
+static inline LLVMBool LLVMInitializeNativeAsmParser(void) {
+#ifdef LLVM_NATIVE_ASMPARSER
+  LLVM_NATIVE_ASMPARSER();
+  return 0;
+#else
+  return 1;
+#endif
+}
+
+/** LLVMInitializeNativeTargetAsmPrinter - The main program should call this
+    function to initialize the printer for the native target corresponding to
+    the host. */
+static inline LLVMBool LLVMInitializeNativeAsmPrinter(void) {
+#ifdef LLVM_NATIVE_ASMPRINTER
+  LLVM_NATIVE_ASMPRINTER();
+  return 0;
+#else
+  return 1;
+#endif
+}
+
+/** LLVMInitializeNativeTargetDisassembler - The main program should call this
+    function to initialize the disassembler for the native target corresponding
+    to the host. */
+static inline LLVMBool LLVMInitializeNativeDisassembler(void) {
+#ifdef LLVM_NATIVE_DISASSEMBLER
+  LLVM_NATIVE_DISASSEMBLER();
+  return 0;
+#else
+  return 1;
+#endif
+}
+
+/*===-- Target Data -------------------------------------------------------===*/
+
+/**
+ * Obtain the data layout for a module.
+ *
+ * @see Module::getDataLayout()
+ */
+LLVMTargetDataRef LLVMGetModuleDataLayout(LLVMModuleRef M);
+
+/**
+ * Set the data layout for a module.
+ *
+ * @see Module::setDataLayout()
+ */
+void LLVMSetModuleDataLayout(LLVMModuleRef M, LLVMTargetDataRef DL);
+
+/** Creates target data from a target layout string.
+    See the constructor llvm::DataLayout::DataLayout. */
+LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);
+
+/** Deallocates a TargetData.
+    See the destructor llvm::DataLayout::~DataLayout. */
+void LLVMDisposeTargetData(LLVMTargetDataRef TD);
+
+/** Adds target library information to a pass manager. This does not take
+    ownership of the target library info.
+    See the method llvm::PassManagerBase::add. */
+void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef TLI,
+                              LLVMPassManagerRef PM);
+
+/** Converts target data to a target layout string. The string must be disposed
+    with LLVMDisposeMessage.
+    See the constructor llvm::DataLayout::DataLayout. */
+char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef TD);
+
+/** Returns the byte order of a target, either LLVMBigEndian or
+    LLVMLittleEndian.
+    See the method llvm::DataLayout::isLittleEndian. */
+enum LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef TD);
+
+/** Returns the pointer size in bytes for a target.
+    See the method llvm::DataLayout::getPointerSize. */
+unsigned LLVMPointerSize(LLVMTargetDataRef TD);
+
+/** Returns the pointer size in bytes for a target for a specified
+    address space.
+    See the method llvm::DataLayout::getPointerSize. */
+unsigned LLVMPointerSizeForAS(LLVMTargetDataRef TD, unsigned AS);
+
+/** Returns the integer type that is the same size as a pointer on a target.
+    See the method llvm::DataLayout::getIntPtrType. */
+LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef TD);
+
+/** Returns the integer type that is the same size as a pointer on a target.
+    This version allows the address space to be specified.
+    See the method llvm::DataLayout::getIntPtrType. */
+LLVMTypeRef LLVMIntPtrTypeForAS(LLVMTargetDataRef TD, unsigned AS);
+
+/** Returns the integer type that is the same size as a pointer on a target.
+    See the method llvm::DataLayout::getIntPtrType. */
+LLVMTypeRef LLVMIntPtrTypeInContext(LLVMContextRef C, LLVMTargetDataRef TD);
+
+/** Returns the integer type that is the same size as a pointer on a target.
+    This version allows the address space to be specified.
+    See the method llvm::DataLayout::getIntPtrType. */
+LLVMTypeRef LLVMIntPtrTypeForASInContext(LLVMContextRef C, LLVMTargetDataRef TD,
+                                         unsigned AS);
+
+/** Computes the size of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeSizeInBits. */
+unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the storage size of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeStoreSize. */
+unsigned long long LLVMStoreSizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the ABI size of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeAllocSize. */
+unsigned long long LLVMABISizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the ABI alignment of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeABISize. */
+unsigned LLVMABIAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the call frame alignment of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeABISize. */
+unsigned LLVMCallFrameAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the preferred alignment of a type in bytes for a target.
+    See the method llvm::DataLayout::getTypeABISize. */
+unsigned LLVMPreferredAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
+
+/** Computes the preferred alignment of a global variable in bytes for a target.
+    See the method llvm::DataLayout::getPreferredAlignment. */
+unsigned LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef TD,
+                                        LLVMValueRef GlobalVar);
+
+/** Computes the structure element that contains the byte offset for a target.
+    See the method llvm::StructLayout::getElementContainingOffset. */
+unsigned LLVMElementAtOffset(LLVMTargetDataRef TD, LLVMTypeRef StructTy,
+                             unsigned long long Offset);
+
+/** Computes the byte offset of the indexed struct element for a target.
+    See the method llvm::StructLayout::getElementContainingOffset. */
+unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef TD,
+                                       LLVMTypeRef StructTy, unsigned Element);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/TargetMachine.h b/src/llvm-c/TargetMachine.h
new file mode 100644
index 000000000..28d7c0968
--- /dev/null
+++ b/src/llvm-c/TargetMachine.h
@@ -0,0 +1,163 @@
+/*===-- llvm-c/TargetMachine.h - Target Machine Library C Interface - C++ -*-=*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to the Target and TargetMachine       *|
+|* classes, which can be used to generate assembly or object files.           *|
+|*                                                                            *|
+|* 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_TARGETMACHINE_H
+#define LLVM_C_TARGETMACHINE_H
+
+#include "llvm-c/Target.h"
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
+typedef struct LLVMTarget *LLVMTargetRef;
+
+typedef enum {
+    LLVMCodeGenLevelNone,
+    LLVMCodeGenLevelLess,
+    LLVMCodeGenLevelDefault,
+    LLVMCodeGenLevelAggressive
+} LLVMCodeGenOptLevel;
+
+typedef enum {
+    LLVMRelocDefault,
+    LLVMRelocStatic,
+    LLVMRelocPIC,
+    LLVMRelocDynamicNoPic,
+    LLVMRelocROPI,
+    LLVMRelocRWPI,
+    LLVMRelocROPI_RWPI
+} LLVMRelocMode;
+
+typedef enum {
+    LLVMCodeModelDefault,
+    LLVMCodeModelJITDefault,
+    LLVMCodeModelTiny,
+    LLVMCodeModelSmall,
+    LLVMCodeModelKernel,
+    LLVMCodeModelMedium,
+    LLVMCodeModelLarge
+} LLVMCodeModel;
+
+typedef enum {
+    LLVMAssemblyFile,
+    LLVMObjectFile
+} LLVMCodeGenFileType;
+
+/** Returns the first llvm::Target in the registered targets list. */
+LLVMTargetRef LLVMGetFirstTarget(void);
+/** Returns the next llvm::Target given a previous one (or null if there's none) */
+LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T);
+
+/*===-- Target ------------------------------------------------------------===*/
+/** Finds the target corresponding to the given name and stores it in \p T.
+  Returns 0 on success. */
+LLVMTargetRef LLVMGetTargetFromName(const char *Name);
+
+/** Finds the target corresponding to the given triple and stores it in \p T.
+  Returns 0 on success. Optionally returns any error in ErrorMessage.
+  Use LLVMDisposeMessage to dispose the message. */
+LLVMBool LLVMGetTargetFromTriple(const char* Triple, LLVMTargetRef *T,
+                                 char **ErrorMessage);
+
+/** Returns the name of a target. See llvm::Target::getName */
+const char *LLVMGetTargetName(LLVMTargetRef T);
+
+/** Returns the description  of a target. See llvm::Target::getDescription */
+const char *LLVMGetTargetDescription(LLVMTargetRef T);
+
+/** Returns if the target has a JIT */
+LLVMBool LLVMTargetHasJIT(LLVMTargetRef T);
+
+/** Returns if the target has a TargetMachine associated */
+LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T);
+
+/** Returns if the target as an ASM backend (required for emitting output) */
+LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T);
+
+/*===-- Target Machine ----------------------------------------------------===*/
+/** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */
+LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
+  const char *Triple, const char *CPU, const char *Features,
+  LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel);
+
+/** Dispose the LLVMTargetMachineRef instance generated by
+  LLVMCreateTargetMachine. */
+void LLVMDisposeTargetMachine(LLVMTargetMachineRef T);
+
+/** Returns the Target used in a TargetMachine */
+LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T);
+
+/** Returns the triple used creating this target machine. See
+  llvm::TargetMachine::getTriple. The result needs to be disposed with
+  LLVMDisposeMessage. */
+char *LLVMGetTargetMachineTriple(LLVMTargetMachineRef T);
+
+/** Returns the cpu used creating this target machine. See
+  llvm::TargetMachine::getCPU. The result needs to be disposed with
+  LLVMDisposeMessage. */
+char *LLVMGetTargetMachineCPU(LLVMTargetMachineRef T);
+
+/** Returns the feature string used creating this target machine. See
+  llvm::TargetMachine::getFeatureString. The result needs to be disposed with
+  LLVMDisposeMessage. */
+char *LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T);
+
+/** Create a DataLayout based on the targetMachine. */
+LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T);
+
+/** Set the target machine's ASM verbosity. */
+void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
+                                      LLVMBool VerboseAsm);
+
+/** Emits an asm or object file for the given module to the filename. This
+  wraps several c++ only classes (among them a file stream). Returns any
+  error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */
+LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
+  char *Filename, LLVMCodeGenFileType codegen, char **ErrorMessage);
+
+/** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
+LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
+  LLVMCodeGenFileType codegen, char** ErrorMessage, LLVMMemoryBufferRef *OutMemBuf);
+
+/*===-- Triple ------------------------------------------------------------===*/
+/** Get a triple for the host machine as a string. The result needs to be
+  disposed with LLVMDisposeMessage. */
+char* LLVMGetDefaultTargetTriple(void);
+
+/** Normalize a target triple. The result needs to be disposed with
+  LLVMDisposeMessage. */
+char* LLVMNormalizeTargetTriple(const char* triple);
+
+/** Get the host CPU as a string. The result needs to be disposed with
+  LLVMDisposeMessage. */
+char* LLVMGetHostCPUName(void);
+
+/** Get the host CPU's features as a string. The result needs to be disposed
+  with LLVMDisposeMessage. */
+char* LLVMGetHostCPUFeatures(void);
+
+/** Adds the target-specific analysis passes to the pass manager. */
+void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Transforms/AggressiveInstCombine.h b/src/llvm-c/Transforms/AggressiveInstCombine.h
new file mode 100644
index 000000000..c0b0141c3
--- /dev/null
+++ b/src/llvm-c/Transforms/AggressiveInstCombine.h
@@ -0,0 +1,43 @@
+/*===-- AggressiveInstCombine.h ---------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMAggressiveInstCombine.a,    *|
+|* which combines instructions to form fewer, simple IR instructions.         *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_TRANSFORMS_AGGRESSIVEINSTCOMBINE_H
+#define LLVM_C_TRANSFORMS_AGGRESSIVEINSTCOMBINE_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsAggressiveInstCombine Aggressive Instruction Combining transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createAggressiveInstCombinerPass function. */
+void LLVMAddAggressiveInstCombinerPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
+
diff --git a/src/llvm-c/Transforms/Coroutines.h b/src/llvm-c/Transforms/Coroutines.h
new file mode 100644
index 000000000..227e7cf0a
--- /dev/null
+++ b/src/llvm-c/Transforms/Coroutines.h
@@ -0,0 +1,55 @@
+/*===-- Coroutines.h - Coroutines Library C Interface -----------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMCoroutines.a, which         *|
+|* implements various scalar transformations of the LLVM IR.                  *|
+|*                                                                            *|
+|* 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_TRANSFORMS_COROUTINES_H
+#define LLVM_C_TRANSFORMS_COROUTINES_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsCoroutines Coroutine transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createCoroEarlyPass function. */
+void LLVMAddCoroEarlyPass(LLVMPassManagerRef PM);
+
+/** See llvm::createCoroSplitPass function. */
+void LLVMAddCoroSplitPass(LLVMPassManagerRef PM);
+
+/** See llvm::createCoroElidePass function. */
+void LLVMAddCoroElidePass(LLVMPassManagerRef PM);
+
+/** See llvm::createCoroCleanupPass function. */
+void LLVMAddCoroCleanupPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/Transforms/IPO.h b/src/llvm-c/Transforms/IPO.h
new file mode 100644
index 000000000..7a82ed464
--- /dev/null
+++ b/src/llvm-c/Transforms/IPO.h
@@ -0,0 +1,84 @@
+/*===-- IPO.h - Interprocedural Transformations C Interface -----*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMIPO.a, which implements     *|
+|* various interprocedural transformations of the LLVM IR.                    *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_TRANSFORMS_IPO_H
+#define LLVM_C_TRANSFORMS_IPO_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsIPO Interprocedural transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createArgumentPromotionPass function. */
+void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM);
+
+/** See llvm::createConstantMergePass function. */
+void LLVMAddConstantMergePass(LLVMPassManagerRef PM);
+
+/** See llvm::createCalledValuePropagationPass function. */
+void LLVMAddCalledValuePropagationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createDeadArgEliminationPass function. */
+void LLVMAddDeadArgEliminationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createFunctionAttrsPass function. */
+void LLVMAddFunctionAttrsPass(LLVMPassManagerRef PM);
+
+/** See llvm::createFunctionInliningPass function. */
+void LLVMAddFunctionInliningPass(LLVMPassManagerRef PM);
+
+/** See llvm::createAlwaysInlinerPass function. */
+void LLVMAddAlwaysInlinerPass(LLVMPassManagerRef PM);
+
+/** See llvm::createGlobalDCEPass function. */
+void LLVMAddGlobalDCEPass(LLVMPassManagerRef PM);
+
+/** See llvm::createGlobalOptimizerPass function. */
+void LLVMAddGlobalOptimizerPass(LLVMPassManagerRef PM);
+
+/** See llvm::createIPConstantPropagationPass function. */
+void LLVMAddIPConstantPropagationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createPruneEHPass function. */
+void LLVMAddPruneEHPass(LLVMPassManagerRef PM);
+
+/** See llvm::createIPSCCPPass function. */
+void LLVMAddIPSCCPPass(LLVMPassManagerRef PM);
+
+/** See llvm::createInternalizePass function. */
+void LLVMAddInternalizePass(LLVMPassManagerRef, unsigned AllButMain);
+
+/** See llvm::createStripDeadPrototypesPass function. */
+void LLVMAddStripDeadPrototypesPass(LLVMPassManagerRef PM);
+
+/** See llvm::createStripSymbolsPass function. */
+void LLVMAddStripSymbolsPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/Transforms/InstCombine.h b/src/llvm-c/Transforms/InstCombine.h
new file mode 100644
index 000000000..166f278d9
--- /dev/null
+++ b/src/llvm-c/Transforms/InstCombine.h
@@ -0,0 +1,43 @@
+/*===-- Scalar.h - Scalar Transformation Library C Interface ----*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMInstCombine.a, which        *|
+|* combines instructions to form fewer, simple IR instructions.               *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_TRANSFORMS_INSTCOMBINE_H
+#define LLVM_C_TRANSFORMS_INSTCOMBINE_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsInstCombine Instruction Combining transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createInstructionCombiningPass function. */
+void LLVMAddInstructionCombiningPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
+
diff --git a/src/llvm-c/Transforms/PassManagerBuilder.h b/src/llvm-c/Transforms/PassManagerBuilder.h
new file mode 100644
index 000000000..d164c00d4
--- /dev/null
+++ b/src/llvm-c/Transforms/PassManagerBuilder.h
@@ -0,0 +1,90 @@
+/*===-- llvm-c/Transform/PassManagerBuilder.h - PMB C Interface ---*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to the PassManagerBuilder class.      *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H
+#define LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H
+
+#include "llvm-c/Types.h"
+
+typedef struct LLVMOpaquePassManagerBuilder *LLVMPassManagerBuilderRef;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsPassManagerBuilder Pass manager builder
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::PassManagerBuilder. */
+LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate(void);
+void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB);
+
+/** See llvm::PassManagerBuilder::OptLevel. */
+void
+LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,
+                                  unsigned OptLevel);
+
+/** See llvm::PassManagerBuilder::SizeLevel. */
+void
+LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,
+                                   unsigned SizeLevel);
+
+/** See llvm::PassManagerBuilder::DisableUnitAtATime. */
+void
+LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,
+                                            LLVMBool Value);
+
+/** See llvm::PassManagerBuilder::DisableUnrollLoops. */
+void
+LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,
+                                            LLVMBool Value);
+
+/** See llvm::PassManagerBuilder::DisableSimplifyLibCalls */
+void
+LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,
+                                                 LLVMBool Value);
+
+/** See llvm::PassManagerBuilder::Inliner. */
+void
+LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
+                                              unsigned Threshold);
+
+/** See llvm::PassManagerBuilder::populateFunctionPassManager. */
+void
+LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
+                                                  LLVMPassManagerRef PM);
+
+/** See llvm::PassManagerBuilder::populateModulePassManager. */
+void
+LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
+                                                LLVMPassManagerRef PM);
+
+/** See llvm::PassManagerBuilder::populateLTOPassManager. */
+void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
+                                                  LLVMPassManagerRef PM,
+                                                  LLVMBool Internalize,
+                                                  LLVMBool RunInliner);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/Transforms/Scalar.h b/src/llvm-c/Transforms/Scalar.h
new file mode 100644
index 000000000..031cf98b2
--- /dev/null
+++ b/src/llvm-c/Transforms/Scalar.h
@@ -0,0 +1,167 @@
+/*===-- Scalar.h - Scalar Transformation Library C Interface ----*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMScalarOpts.a, which         *|
+|* implements various scalar transformations of the LLVM IR.                  *|
+|*                                                                            *|
+|* 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_TRANSFORMS_SCALAR_H
+#define LLVM_C_TRANSFORMS_SCALAR_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsScalar Scalar transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createAggressiveDCEPass function. */
+void LLVMAddAggressiveDCEPass(LLVMPassManagerRef PM);
+
+/** See llvm::createBitTrackingDCEPass function. */
+void LLVMAddBitTrackingDCEPass(LLVMPassManagerRef PM);
+
+/** See llvm::createAlignmentFromAssumptionsPass function. */
+void LLVMAddAlignmentFromAssumptionsPass(LLVMPassManagerRef PM);
+
+/** See llvm::createCFGSimplificationPass function. */
+void LLVMAddCFGSimplificationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createDeadStoreEliminationPass function. */
+void LLVMAddDeadStoreEliminationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createScalarizerPass function. */
+void LLVMAddScalarizerPass(LLVMPassManagerRef PM);
+
+/** See llvm::createMergedLoadStoreMotionPass function. */
+void LLVMAddMergedLoadStoreMotionPass(LLVMPassManagerRef PM);
+
+/** See llvm::createGVNPass function. */
+void LLVMAddGVNPass(LLVMPassManagerRef PM);
+
+/** See llvm::createGVNPass function. */
+void LLVMAddNewGVNPass(LLVMPassManagerRef PM);
+
+/** See llvm::createIndVarSimplifyPass function. */
+void LLVMAddIndVarSimplifyPass(LLVMPassManagerRef PM);
+
+/** See llvm::createInstructionCombiningPass function. */
+void LLVMAddInstructionCombiningPass(LLVMPassManagerRef PM);
+
+/** See llvm::createJumpThreadingPass function. */
+void LLVMAddJumpThreadingPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLICMPass function. */
+void LLVMAddLICMPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopDeletionPass function. */
+void LLVMAddLoopDeletionPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopIdiomPass function */
+void LLVMAddLoopIdiomPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopRotatePass function. */
+void LLVMAddLoopRotatePass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopRerollPass function. */
+void LLVMAddLoopRerollPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopUnrollPass function. */
+void LLVMAddLoopUnrollPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopUnrollAndJamPass function. */
+void LLVMAddLoopUnrollAndJamPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLoopUnswitchPass function. */
+void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLowerAtomicPass function. */
+void LLVMAddLowerAtomicPass(LLVMPassManagerRef PM);
+
+/** See llvm::createMemCpyOptPass function. */
+void LLVMAddMemCpyOptPass(LLVMPassManagerRef PM);
+
+/** See llvm::createPartiallyInlineLibCallsPass function. */
+void LLVMAddPartiallyInlineLibCallsPass(LLVMPassManagerRef PM);
+
+/** See llvm::createReassociatePass function. */
+void LLVMAddReassociatePass(LLVMPassManagerRef PM);
+
+/** See llvm::createSCCPPass function. */
+void LLVMAddSCCPPass(LLVMPassManagerRef PM);
+
+/** See llvm::createSROAPass function. */
+void LLVMAddScalarReplAggregatesPass(LLVMPassManagerRef PM);
+
+/** See llvm::createSROAPass function. */
+void LLVMAddScalarReplAggregatesPassSSA(LLVMPassManagerRef PM);
+
+/** See llvm::createSROAPass function. */
+void LLVMAddScalarReplAggregatesPassWithThreshold(LLVMPassManagerRef PM,
+                                                  int Threshold);
+
+/** See llvm::createSimplifyLibCallsPass function. */
+void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM);
+
+/** See llvm::createTailCallEliminationPass function. */
+void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createConstantPropagationPass function. */
+void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM);
+
+/** See llvm::demotePromoteMemoryToRegisterPass function. */
+void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM);
+
+/** See llvm::createVerifierPass function. */
+void LLVMAddVerifierPass(LLVMPassManagerRef PM);
+
+/** See llvm::createCorrelatedValuePropagationPass function */
+void LLVMAddCorrelatedValuePropagationPass(LLVMPassManagerRef PM);
+
+/** See llvm::createEarlyCSEPass function */
+void LLVMAddEarlyCSEPass(LLVMPassManagerRef PM);
+
+/** See llvm::createEarlyCSEPass function */
+void LLVMAddEarlyCSEMemSSAPass(LLVMPassManagerRef PM);
+
+/** See llvm::createLowerExpectIntrinsicPass function */
+void LLVMAddLowerExpectIntrinsicPass(LLVMPassManagerRef PM);
+
+/** See llvm::createTypeBasedAliasAnalysisPass function */
+void LLVMAddTypeBasedAliasAnalysisPass(LLVMPassManagerRef PM);
+
+/** See llvm::createScopedNoAliasAAPass function */
+void LLVMAddScopedNoAliasAAPass(LLVMPassManagerRef PM);
+
+/** See llvm::createBasicAliasAnalysisPass function */
+void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM);
+
+/** See llvm::createUnifyFunctionExitNodesPass function */
+void LLVMAddUnifyFunctionExitNodesPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/Transforms/Utils.h b/src/llvm-c/Transforms/Utils.h
new file mode 100644
index 000000000..63594abfa
--- /dev/null
+++ b/src/llvm-c/Transforms/Utils.h
@@ -0,0 +1,53 @@
+/*===-- Utils.h - Transformation Utils Library C Interface ------*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMTransformUtils.a, which     *|
+|* implements various transformation utilities of the LLVM IR.                *|
+|*                                                                            *|
+|* 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_TRANSFORMS_UTILS_H
+#define LLVM_C_TRANSFORMS_UTILS_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsUtils Transformation Utilities
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createLowerSwitchPass function. */
+void LLVMAddLowerSwitchPass(LLVMPassManagerRef PM);
+
+/** See llvm::createPromoteMemoryToRegisterPass function. */
+void LLVMAddPromoteMemoryToRegisterPass(LLVMPassManagerRef PM);
+
+/** See llvm::createAddDiscriminatorsPass function. */
+void LLVMAddAddDiscriminatorsPass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
+
diff --git a/src/llvm-c/Transforms/Vectorize.h b/src/llvm-c/Transforms/Vectorize.h
new file mode 100644
index 000000000..e383481fe
--- /dev/null
+++ b/src/llvm-c/Transforms/Vectorize.h
@@ -0,0 +1,50 @@
+/*===---------------------------Vectorize.h --------------------- -*- C -*-===*\
+|*===----------- Vectorization Transformation Library C Interface ---------===*|
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to libLLVMVectorize.a, which          *|
+|* implements various vectorization transformations of the LLVM IR.           *|
+|*                                                                            *|
+|* 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_TRANSFORMS_VECTORIZE_H
+#define LLVM_C_TRANSFORMS_VECTORIZE_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCTransformsVectorize Vectorization transformations
+ * @ingroup LLVMCTransforms
+ *
+ * @{
+ */
+
+/** See llvm::createLoopVectorizePass function. */
+void LLVMAddLoopVectorizePass(LLVMPassManagerRef PM);
+
+/** See llvm::createSLPVectorizerPass function. */
+void LLVMAddSLPVectorizePass(LLVMPassManagerRef PM);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* defined(__cplusplus) */
+
+#endif
diff --git a/src/llvm-c/Types.h b/src/llvm-c/Types.h
new file mode 100644
index 000000000..612c7d3ef
--- /dev/null
+++ b/src/llvm-c/Types.h
@@ -0,0 +1,179 @@
+/*===-- llvm-c/Support.h - C Interface Types declarations ---------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines types used by the C interface to LLVM.                   *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_TYPES_H
+#define LLVM_C_TYPES_H
+
+#include "llvm-c/DataTypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup LLVMCSupportTypes Types and Enumerations
+ *
+ * @{
+ */
+
+typedef int LLVMBool;
+
+/* Opaque types. */
+
+/**
+ * LLVM uses a polymorphic type hierarchy which C cannot represent, therefore
+ * parameters must be passed as base types. Despite the declared types, most
+ * of the functions provided operate only on branches of the type hierarchy.
+ * The declared parameter names are descriptive and specify which type is
+ * required. Additionally, each type hierarchy is documented along with the
+ * functions that operate upon it. For more detail, refer to LLVM's C++ code.
+ * If in doubt, refer to Core.cpp, which performs parameter downcasts in the
+ * form unwrap<RequiredType>(Param).
+ */
+
+/**
+ * Used to pass regions of memory through LLVM interfaces.
+ *
+ * @see llvm::MemoryBuffer
+ */
+typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
+
+/**
+ * The top-level container for all LLVM global data. See the LLVMContext class.
+ */
+typedef struct LLVMOpaqueContext *LLVMContextRef;
+
+/**
+ * The top-level container for all other LLVM Intermediate Representation (IR)
+ * objects.
+ *
+ * @see llvm::Module
+ */
+typedef struct LLVMOpaqueModule *LLVMModuleRef;
+
+/**
+ * Each value in the LLVM IR has a type, an LLVMTypeRef.
+ *
+ * @see llvm::Type
+ */
+typedef struct LLVMOpaqueType *LLVMTypeRef;
+
+/**
+ * Represents an individual value in LLVM IR.
+ *
+ * This models llvm::Value.
+ */
+typedef struct LLVMOpaqueValue *LLVMValueRef;
+
+/**
+ * Represents a basic block of instructions in LLVM IR.
+ *
+ * This models llvm::BasicBlock.
+ */
+typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
+
+/**
+ * Represents an LLVM Metadata.
+ *
+ * This models llvm::Metadata.
+ */
+typedef struct LLVMOpaqueMetadata *LLVMMetadataRef;
+
+/**
+ * Represents an LLVM Named Metadata Node.
+ *
+ * This models llvm::NamedMDNode.
+ */
+typedef struct LLVMOpaqueNamedMDNode *LLVMNamedMDNodeRef;
+
+/**
+ * Represents an entry in a Global Object's metadata attachments.
+ *
+ * This models std::pair<unsigned, MDNode *>
+ */
+typedef struct LLVMOpaqueValueMetadataEntry LLVMValueMetadataEntry;
+
+/**
+ * Represents an LLVM basic block builder.
+ *
+ * This models llvm::IRBuilder.
+ */
+typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
+
+/**
+ * Represents an LLVM debug info builder.
+ *
+ * This models llvm::DIBuilder.
+ */
+typedef struct LLVMOpaqueDIBuilder *LLVMDIBuilderRef;
+
+/**
+ * Interface used to provide a module to JIT or interpreter.
+ * This is now just a synonym for llvm::Module, but we have to keep using the
+ * different type to keep binary compatibility.
+ */
+typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
+
+/** @see llvm::PassManagerBase */
+typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
+
+/** @see llvm::PassRegistry */
+typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
+
+/**
+ * Used to get the users and usees of a Value.
+ *
+ * @see llvm::Use */
+typedef struct LLVMOpaqueUse *LLVMUseRef;
+
+/**
+ * Used to represent an attributes.
+ *
+ * @see llvm::Attribute
+ */
+typedef struct LLVMOpaqueAttributeRef *LLVMAttributeRef;
+
+/**
+ * @see llvm::DiagnosticInfo
+ */
+typedef struct LLVMOpaqueDiagnosticInfo *LLVMDiagnosticInfoRef;
+
+/**
+ * @see llvm::Comdat
+ */
+typedef struct LLVMComdat *LLVMComdatRef;
+
+/**
+ * @see llvm::Module::ModuleFlagEntry
+ */
+typedef struct LLVMOpaqueModuleFlagEntry LLVMModuleFlagEntry;
+
+/**
+ * @see llvm::JITEventListener
+ */
+typedef struct LLVMOpaqueJITEventListener *LLVMJITEventListenerRef;
+
+/**
+ * @see llvm::object::Binary
+ */
+typedef struct LLVMOpaqueBinary *LLVMBinaryRef;
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-c/lto.h b/src/llvm-c/lto.h
new file mode 100644
index 000000000..2467722b1
--- /dev/null
+++ b/src/llvm-c/lto.h
@@ -0,0 +1,899 @@
+/*===-- llvm-c/lto.h - LTO Public C Interface ---------------------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header provides public interface to an abstract link time optimization*|
+|* library.  LLVM provides an implementation of this interface for use with   *|
+|* llvm bitcode files.                                                        *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_LTO_H
+#define LLVM_C_LTO_H
+
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#endif
+#include <sys/types.h>
+
+#ifndef __cplusplus
+#if !defined(_MSC_VER)
+#include <stdbool.h>
+typedef bool lto_bool_t;
+#else
+/* MSVC in particular does not have anything like _Bool or bool in C, but we can
+   at least make sure the type is the same size.  The implementation side will
+   use C++ bool. */
+typedef unsigned char lto_bool_t;
+#endif
+#else
+typedef bool lto_bool_t;
+#endif
+
+/**
+ * @defgroup LLVMCLTO LTO
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+#define LTO_API_VERSION 24
+
+/**
+ * \since prior to LTO_API_VERSION=3
+ */
+typedef enum {
+    LTO_SYMBOL_ALIGNMENT_MASK              = 0x0000001F, /* log2 of alignment */
+    LTO_SYMBOL_PERMISSIONS_MASK            = 0x000000E0,
+    LTO_SYMBOL_PERMISSIONS_CODE            = 0x000000A0,
+    LTO_SYMBOL_PERMISSIONS_DATA            = 0x000000C0,
+    LTO_SYMBOL_PERMISSIONS_RODATA          = 0x00000080,
+    LTO_SYMBOL_DEFINITION_MASK             = 0x00000700,
+    LTO_SYMBOL_DEFINITION_REGULAR          = 0x00000100,
+    LTO_SYMBOL_DEFINITION_TENTATIVE        = 0x00000200,
+    LTO_SYMBOL_DEFINITION_WEAK             = 0x00000300,
+    LTO_SYMBOL_DEFINITION_UNDEFINED        = 0x00000400,
+    LTO_SYMBOL_DEFINITION_WEAKUNDEF        = 0x00000500,
+    LTO_SYMBOL_SCOPE_MASK                  = 0x00003800,
+    LTO_SYMBOL_SCOPE_INTERNAL              = 0x00000800,
+    LTO_SYMBOL_SCOPE_HIDDEN                = 0x00001000,
+    LTO_SYMBOL_SCOPE_PROTECTED             = 0x00002000,
+    LTO_SYMBOL_SCOPE_DEFAULT               = 0x00001800,
+    LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN = 0x00002800,
+    LTO_SYMBOL_COMDAT                      = 0x00004000,
+    LTO_SYMBOL_ALIAS                       = 0x00008000
+} lto_symbol_attributes;
+
+/**
+ * \since prior to LTO_API_VERSION=3
+ */
+typedef enum {
+    LTO_DEBUG_MODEL_NONE         = 0,
+    LTO_DEBUG_MODEL_DWARF        = 1
+} lto_debug_model;
+
+/**
+ * \since prior to LTO_API_VERSION=3
+ */
+typedef enum {
+    LTO_CODEGEN_PIC_MODEL_STATIC         = 0,
+    LTO_CODEGEN_PIC_MODEL_DYNAMIC        = 1,
+    LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2,
+    LTO_CODEGEN_PIC_MODEL_DEFAULT        = 3
+} lto_codegen_model;
+
+/** opaque reference to a loaded object module */
+typedef struct LLVMOpaqueLTOModule *lto_module_t;
+
+/** opaque reference to a code generator */
+typedef struct LLVMOpaqueLTOCodeGenerator *lto_code_gen_t;
+
+/** opaque reference to a thin code generator */
+typedef struct LLVMOpaqueThinLTOCodeGenerator *thinlto_code_gen_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Returns a printable string.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern const char*
+lto_get_version(void);
+
+/**
+ * Returns the last error string or NULL if last operation was successful.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern const char*
+lto_get_error_message(void);
+
+/**
+ * Checks if a file is a loadable object file.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_module_is_object_file(const char* path);
+
+/**
+ * Checks if a file is a loadable object compiled for requested target.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_module_is_object_file_for_target(const char* path,
+                                     const char* target_triple_prefix);
+
+/**
+ * Return true if \p Buffer contains a bitcode file with ObjC code (category
+ * or class) in it.
+ *
+ * \since LTO_API_VERSION=20
+ */
+extern lto_bool_t
+lto_module_has_objc_category(const void *mem, size_t length);
+
+/**
+ * Checks if a buffer is a loadable object file.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t lto_module_is_object_file_in_memory(const void *mem,
+                                                      size_t length);
+
+/**
+ * Checks if a buffer is a loadable object compiled for requested target.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_module_is_object_file_in_memory_for_target(const void* mem, size_t length,
+                                              const char* target_triple_prefix);
+
+/**
+ * Loads an object file from disk.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_module_t
+lto_module_create(const char* path);
+
+/**
+ * Loads an object file from memory.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_module_t
+lto_module_create_from_memory(const void* mem, size_t length);
+
+/**
+ * Loads an object file from memory with an extra path argument.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=9
+ */
+extern lto_module_t
+lto_module_create_from_memory_with_path(const void* mem, size_t length,
+                                        const char *path);
+
+/**
+ * Loads an object file in its own context.
+ *
+ * Loads an object file in its own LLVMContext.  This function call is
+ * thread-safe.  However, modules created this way should not be merged into an
+ * lto_code_gen_t using \a lto_codegen_add_module().
+ *
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=11
+ */
+extern lto_module_t
+lto_module_create_in_local_context(const void *mem, size_t length,
+                                   const char *path);
+
+/**
+ * Loads an object file in the codegen context.
+ *
+ * Loads an object file into the same context as \c cg.  The module is safe to
+ * add using \a lto_codegen_add_module().
+ *
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=11
+ */
+extern lto_module_t
+lto_module_create_in_codegen_context(const void *mem, size_t length,
+                                     const char *path, lto_code_gen_t cg);
+
+/**
+ * Loads an object file from disk. The seek point of fd is not preserved.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=5
+ */
+extern lto_module_t
+lto_module_create_from_fd(int fd, const char *path, size_t file_size);
+
+/**
+ * Loads an object file from disk. The seek point of fd is not preserved.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=5
+ */
+extern lto_module_t
+lto_module_create_from_fd_at_offset(int fd, const char *path, size_t file_size,
+                                    size_t map_size, off_t offset);
+
+/**
+ * Frees all memory internally allocated by the module.
+ * Upon return the lto_module_t is no longer valid.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern void
+lto_module_dispose(lto_module_t mod);
+
+/**
+ * Returns triple string which the object module was compiled under.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern const char*
+lto_module_get_target_triple(lto_module_t mod);
+
+/**
+ * Sets triple string with which the object will be codegened.
+ *
+ * \since LTO_API_VERSION=4
+ */
+extern void
+lto_module_set_target_triple(lto_module_t mod, const char *triple);
+
+/**
+ * Returns the number of symbols in the object module.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern unsigned int
+lto_module_get_num_symbols(lto_module_t mod);
+
+/**
+ * Returns the name of the ith symbol in the object module.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern const char*
+lto_module_get_symbol_name(lto_module_t mod, unsigned int index);
+
+/**
+ * Returns the attributes of the ith symbol in the object module.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_symbol_attributes
+lto_module_get_symbol_attribute(lto_module_t mod, unsigned int index);
+
+/**
+ * Returns the module's linker options.
+ *
+ * The linker options may consist of multiple flags. It is the linker's
+ * responsibility to split the flags using a platform-specific mechanism.
+ *
+ * \since LTO_API_VERSION=16
+ */
+extern const char*
+lto_module_get_linkeropts(lto_module_t mod);
+
+/**
+ * Diagnostic severity.
+ *
+ * \since LTO_API_VERSION=7
+ */
+typedef enum {
+  LTO_DS_ERROR = 0,
+  LTO_DS_WARNING = 1,
+  LTO_DS_REMARK = 3, // Added in LTO_API_VERSION=10.
+  LTO_DS_NOTE = 2
+} lto_codegen_diagnostic_severity_t;
+
+/**
+ * Diagnostic handler type.
+ * \p severity defines the severity.
+ * \p diag is the actual diagnostic.
+ * The diagnostic is not prefixed by any of severity keyword, e.g., 'error: '.
+ * \p ctxt is used to pass the context set with the diagnostic handler.
+ *
+ * \since LTO_API_VERSION=7
+ */
+typedef void (*lto_diagnostic_handler_t)(
+    lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt);
+
+/**
+ * Set a diagnostic handler and the related context (void *).
+ * This is more general than lto_get_error_message, as the diagnostic handler
+ * can be called at anytime within lto.
+ *
+ * \since LTO_API_VERSION=7
+ */
+extern void lto_codegen_set_diagnostic_handler(lto_code_gen_t,
+                                               lto_diagnostic_handler_t,
+                                               void *);
+
+/**
+ * Instantiates a code generator.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * All modules added using \a lto_codegen_add_module() must have been created
+ * in the same context as the codegen.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_code_gen_t
+lto_codegen_create(void);
+
+/**
+ * Instantiate a code generator in its own context.
+ *
+ * Instantiates a code generator in its own context.  Modules added via \a
+ * lto_codegen_add_module() must have all been created in the same context,
+ * using \a lto_module_create_in_codegen_context().
+ *
+ * \since LTO_API_VERSION=11
+ */
+extern lto_code_gen_t
+lto_codegen_create_in_local_context(void);
+
+/**
+ * Frees all code generator and all memory it internally allocated.
+ * Upon return the lto_code_gen_t is no longer valid.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern void
+lto_codegen_dispose(lto_code_gen_t);
+
+/**
+ * Add an object module to the set of modules for which code will be generated.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \c cg and \c mod must both be in the same context.  See \a
+ * lto_codegen_create_in_local_context() and \a
+ * lto_module_create_in_codegen_context().
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod);
+
+/**
+ * Sets the object module for code generation. This will transfer the ownership
+ * of the module to the code generator.
+ *
+ * \c cg and \c mod must both be in the same context.
+ *
+ * \since LTO_API_VERSION=13
+ */
+extern void
+lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod);
+
+/**
+ * Sets if debug info should be generated.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model);
+
+/**
+ * Sets which PIC code model to generated.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern lto_bool_t
+lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model);
+
+/**
+ * Sets the cpu to generate code for.
+ *
+ * \since LTO_API_VERSION=4
+ */
+extern void
+lto_codegen_set_cpu(lto_code_gen_t cg, const char *cpu);
+
+/**
+ * Sets the location of the assembler tool to run. If not set, libLTO
+ * will use gcc to invoke the assembler.
+ *
+ * \since LTO_API_VERSION=3
+ */
+extern void
+lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path);
+
+/**
+ * Sets extra arguments that libLTO should pass to the assembler.
+ *
+ * \since LTO_API_VERSION=4
+ */
+extern void
+lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
+                               int nargs);
+
+/**
+ * Adds to a list of all global symbols that must exist in the final generated
+ * code. If a function is not listed there, it might be inlined into every usage
+ * and optimized away.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern void
+lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol);
+
+/**
+ * Writes a new object file at the specified path that contains the
+ * merged contents of all modules added so far.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=5
+ */
+extern lto_bool_t
+lto_codegen_write_merged_modules(lto_code_gen_t cg, const char* path);
+
+/**
+ * Generates code for all added modules into one native object file.
+ * This calls lto_codegen_optimize then lto_codegen_compile_optimized.
+ *
+ * On success returns a pointer to a generated mach-o/ELF buffer and
+ * length set to the buffer size.  The buffer is owned by the
+ * lto_code_gen_t and will be freed when lto_codegen_dispose()
+ * is called, or lto_codegen_compile() is called again.
+ * On failure, returns NULL (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern const void*
+lto_codegen_compile(lto_code_gen_t cg, size_t* length);
+
+/**
+ * Generates code for all added modules into one native object file.
+ * This calls lto_codegen_optimize then lto_codegen_compile_optimized (instead
+ * of returning a generated mach-o/ELF buffer, it writes to a file).
+ *
+ * The name of the file is written to name. Returns true on error.
+ *
+ * \since LTO_API_VERSION=5
+ */
+extern lto_bool_t
+lto_codegen_compile_to_file(lto_code_gen_t cg, const char** name);
+
+/**
+ * Runs optimization for the merged module. Returns true on error.
+ *
+ * \since LTO_API_VERSION=12
+ */
+extern lto_bool_t
+lto_codegen_optimize(lto_code_gen_t cg);
+
+/**
+ * Generates code for the optimized merged module into one native object file.
+ * It will not run any IR optimizations on the merged module.
+ *
+ * On success returns a pointer to a generated mach-o/ELF buffer and length set
+ * to the buffer size.  The buffer is owned by the lto_code_gen_t and will be
+ * freed when lto_codegen_dispose() is called, or
+ * lto_codegen_compile_optimized() is called again. On failure, returns NULL
+ * (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=12
+ */
+extern const void*
+lto_codegen_compile_optimized(lto_code_gen_t cg, size_t* length);
+
+/**
+ * Returns the runtime API version.
+ *
+ * \since LTO_API_VERSION=12
+ */
+extern unsigned int
+lto_api_version(void);
+
+/**
+ * Sets options to help debug codegen bugs.
+ *
+ * \since prior to LTO_API_VERSION=3
+ */
+extern void
+lto_codegen_debug_options(lto_code_gen_t cg, const char *);
+
+/**
+ * Initializes LLVM disassemblers.
+ * FIXME: This doesn't really belong here.
+ *
+ * \since LTO_API_VERSION=5
+ */
+extern void
+lto_initialize_disassembler(void);
+
+/**
+ * Sets if we should run internalize pass during optimization and code
+ * generation.
+ *
+ * \since LTO_API_VERSION=14
+ */
+extern void
+lto_codegen_set_should_internalize(lto_code_gen_t cg,
+                                   lto_bool_t ShouldInternalize);
+
+/**
+ * Set whether to embed uselists in bitcode.
+ *
+ * Sets whether \a lto_codegen_write_merged_modules() should embed uselists in
+ * output bitcode.  This should be turned on for all -save-temps output.
+ *
+ * \since LTO_API_VERSION=15
+ */
+extern void
+lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
+                                      lto_bool_t ShouldEmbedUselists);
+
+/**
+ * @} // endgoup LLVMCLTO
+ * @defgroup LLVMCTLTO ThinLTO
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+/**
+ * Type to wrap a single object returned by ThinLTO.
+ *
+ * \since LTO_API_VERSION=18
+ */
+typedef struct {
+  const char *Buffer;
+  size_t Size;
+} LTOObjectBuffer;
+
+/**
+ * Instantiates a ThinLTO code generator.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ *
+ * The ThinLTOCodeGenerator is not intended to be reuse for multiple
+ * compilation: the model is that the client adds modules to the generator and
+ * ask to perform the ThinLTO optimizations / codegen, and finally destroys the
+ * codegenerator.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern thinlto_code_gen_t thinlto_create_codegen(void);
+
+/**
+ * Frees the generator and all memory it internally allocated.
+ * Upon return the thinlto_code_gen_t is no longer valid.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_dispose(thinlto_code_gen_t cg);
+
+/**
+ * Add a module to a ThinLTO code generator. Identifier has to be unique among
+ * all the modules in a code generator. The data buffer stays owned by the
+ * client, and is expected to be available for the entire lifetime of the
+ * thinlto_code_gen_t it is added to.
+ *
+ * On failure, returns NULL (check lto_get_error_message() for details).
+ *
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_add_module(thinlto_code_gen_t cg,
+                                       const char *identifier, const char *data,
+                                       int length);
+
+/**
+ * Optimize and codegen all the modules added to the codegenerator using
+ * ThinLTO. Resulting objects are accessible using thinlto_module_get_object().
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_process(thinlto_code_gen_t cg);
+
+/**
+ * Returns the number of object files produced by the ThinLTO CodeGenerator.
+ *
+ * It usually matches the number of input files, but this is not a guarantee of
+ * the API and may change in future implementation, so the client should not
+ * assume it.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern unsigned int thinlto_module_get_num_objects(thinlto_code_gen_t cg);
+
+/**
+ * Returns a reference to the ith object file produced by the ThinLTO
+ * CodeGenerator.
+ *
+ * Client should use \p thinlto_module_get_num_objects() to get the number of
+ * available objects.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern LTOObjectBuffer thinlto_module_get_object(thinlto_code_gen_t cg,
+                                                 unsigned int index);
+
+/**
+ * Returns the number of object files produced by the ThinLTO CodeGenerator.
+ *
+ * It usually matches the number of input files, but this is not a guarantee of
+ * the API and may change in future implementation, so the client should not
+ * assume it.
+ *
+ * \since LTO_API_VERSION=21
+ */
+unsigned int thinlto_module_get_num_object_files(thinlto_code_gen_t cg);
+
+/**
+ * Returns the path to the ith object file produced by the ThinLTO
+ * CodeGenerator.
+ *
+ * Client should use \p thinlto_module_get_num_object_files() to get the number
+ * of available objects.
+ *
+ * \since LTO_API_VERSION=21
+ */
+const char *thinlto_module_get_object_file(thinlto_code_gen_t cg,
+                                           unsigned int index);
+
+/**
+ * Sets which PIC code model to generate.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg,
+                                                lto_codegen_model);
+
+/**
+ * Sets the path to a directory to use as a storage for temporary bitcode files.
+ * The intention is to make the bitcode files available for debugging at various
+ * stage of the pipeline.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_savetemps_dir(thinlto_code_gen_t cg,
+                                              const char *save_temps_dir);
+
+/**
+ * Set the path to a directory where to save generated object files. This
+ * path can be used by a linker to request on-disk files instead of in-memory
+ * buffers. When set, results are available through
+ * thinlto_module_get_object_file() instead of thinlto_module_get_object().
+ *
+ * \since LTO_API_VERSION=21
+ */
+void thinlto_set_generated_objects_dir(thinlto_code_gen_t cg,
+                                       const char *save_temps_dir);
+
+/**
+ * Sets the cpu to generate code for.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu);
+
+/**
+ * Disable CodeGen, only run the stages till codegen and stop. The output will
+ * be bitcode.
+ *
+ * \since LTO_API_VERSION=19
+ */
+extern void thinlto_codegen_disable_codegen(thinlto_code_gen_t cg,
+                                            lto_bool_t disable);
+
+/**
+ * Perform CodeGen only: disable all other stages.
+ *
+ * \since LTO_API_VERSION=19
+ */
+extern void thinlto_codegen_set_codegen_only(thinlto_code_gen_t cg,
+                                             lto_bool_t codegen_only);
+
+/**
+ * Parse -mllvm style debug options.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_debug_options(const char *const *options, int number);
+
+/**
+ * Test if a module has support for ThinLTO linking.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern lto_bool_t lto_module_is_thinlto(lto_module_t mod);
+
+/**
+ * Adds a symbol to the list of global symbols that must exist in the final
+ * generated code. If a function is not listed there, it might be inlined into
+ * every usage and optimized away. For every single module, the functions
+ * referenced from code outside of the ThinLTO modules need to be added here.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg,
+                                                     const char *name,
+                                                     int length);
+
+/**
+ * Adds a symbol to the list of global symbols that are cross-referenced between
+ * ThinLTO files. If the ThinLTO CodeGenerator can ensure that every
+ * references from a ThinLTO module to this symbol is optimized away, then
+ * the symbol can be discarded.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_add_cross_referenced_symbol(thinlto_code_gen_t cg,
+                                                        const char *name,
+                                                        int length);
+
+/**
+ * @} // endgoup LLVMCTLTO
+ * @defgroup LLVMCTLTO_CACHING ThinLTO Cache Control
+ * @ingroup LLVMCTLTO
+ *
+ * These entry points control the ThinLTO cache. The cache is intended to
+ * support incremental builds, and thus needs to be persistent across builds.
+ * The client enables the cache by supplying a path to an existing directory.
+ * The code generator will use this to store objects files that may be reused
+ * during a subsequent build.
+ * To avoid filling the disk space, a few knobs are provided:
+ *  - The pruning interval limits the frequency at which the garbage collector
+ *    will try to scan the cache directory to prune expired entries.
+ *    Setting to a negative number disables the pruning.
+ *  - The pruning expiration time indicates to the garbage collector how old an
+ *    entry needs to be to be removed.
+ *  - Finally, the garbage collector can be instructed to prune the cache until
+ *    the occupied space goes below a threshold.
+ * @{
+ */
+
+/**
+ * Sets the path to a directory to use as a cache storage for incremental build.
+ * Setting this activates caching.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg,
+                                          const char *cache_dir);
+
+/**
+ * Sets the cache pruning interval (in seconds). A negative value disables the
+ * pruning. An unspecified default value will be applied, and a value of 0 will
+ * force prunning to occur.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cache_pruning_interval(thinlto_code_gen_t cg,
+                                                       int interval);
+
+/**
+ * Sets the maximum cache size that can be persistent across build, in terms of
+ * percentage of the available space on the disk. Set to 100 to indicate
+ * no limit, 50 to indicate that the cache size will not be left over half the
+ * available space. A value over 100 will be reduced to 100, a value of 0 will
+ * be ignored. An unspecified default value will be applied.
+ *
+ * The formula looks like:
+ *  AvailableSpace = FreeSpace + ExistingCacheSize
+ *  NewCacheSize = AvailableSpace * P/100
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_final_cache_size_relative_to_available_space(
+    thinlto_code_gen_t cg, unsigned percentage);
+
+/**
+ * Sets the expiration (in seconds) for an entry in the cache. An unspecified
+ * default value will be applied. A value of 0 will be ignored.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cache_entry_expiration(thinlto_code_gen_t cg,
+                                                       unsigned expiration);
+
+/**
+ * Sets the maximum size of the cache directory (in bytes). A value over the
+ * amount of available space on the disk will be reduced to the amount of
+ * available space. An unspecified default value will be applied. A value of 0
+ * will be ignored.
+ *
+ * \since LTO_API_VERSION=22
+ */
+extern void thinlto_codegen_set_cache_size_bytes(thinlto_code_gen_t cg,
+                                                 unsigned max_size_bytes);
+
+/**
+ * Same as thinlto_codegen_set_cache_size_bytes, except the maximum size is in
+ * megabytes (2^20 bytes).
+ *
+ * \since LTO_API_VERSION=23
+ */
+extern void
+thinlto_codegen_set_cache_size_megabytes(thinlto_code_gen_t cg,
+                                         unsigned max_size_megabytes);
+
+/**
+ * Sets the maximum number of files in the cache directory. An unspecified
+ * default value will be applied. A value of 0 will be ignored.
+ *
+ * \since LTO_API_VERSION=22
+ */
+extern void thinlto_codegen_set_cache_size_files(thinlto_code_gen_t cg,
+                                                 unsigned max_size_files);
+
+/** Opaque reference to an LTO input file */
+typedef struct LLVMOpaqueLTOInput *lto_input_t;
+
+/**
+  * Creates an LTO input file from a buffer. The path
+  * argument is used for diagnotics as this function
+  * otherwise does not know which file the given buffer
+  * is associated with.
+  *
+  * \since LTO_API_VERSION=24
+  */
+extern lto_input_t lto_input_create(const void *buffer,
+                                    size_t buffer_size,
+                                    const char *path);
+
+/**
+  * Frees all memory internally allocated by the LTO input file.
+  * Upon return the lto_module_t is no longer valid.
+  *
+  * \since LTO_API_VERSION=24
+  */
+extern void lto_input_dispose(lto_input_t input);
+
+/**
+  * Returns the number of dependent library specifiers
+  * for the given LTO input file.
+  *
+  * \since LTO_API_VERSION=24
+  */
+extern unsigned lto_input_get_num_dependent_libraries(lto_input_t input);
+
+/**
+  * Returns the ith dependent library specifier
+  * for the given LTO input file. The returned
+  * string is not null-terminated.
+  *
+  * \since LTO_API_VERSION=24
+  */
+extern const char * lto_input_get_dependent_library(lto_input_t input,
+                                                    size_t index,
+                                                    size_t *size);
+
+/**
+ * @} // endgroup LLVMCTLTO_CACHING
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LLVM_C_LTO_H */
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
new file mode 100644
index 000000000..b2ab67442
--- /dev/null
+++ b/src/llvm_backend.cpp
@@ -0,0 +1,831 @@
+#include "llvm-c/Core.h"
+#include "llvm-c/ExecutionEngine.h"
+#include "llvm-c/Target.h"
+#include "llvm-c/Analysis.h"
+#include "llvm-c/Object.h"
+#include "llvm-c/BitWriter.h"
+
+struct lbModule {
+	LLVMModuleRef mod;
+
+	Map<LLVMValueRef> values; // Key: Entity *
+};
+
+struct lbGenerator {
+	lbModule module;
+	CheckerInfo *info;
+
+	gbFile   output_file;
+	String   output_base;
+	String   output_name;
+};
+
+enum lbAddrKind {
+	lbAddr_Default,
+	lbAddr_Map,
+	lbAddr_BitField,
+	lbAddr_Context,
+	lbAddr_SoaVariable,
+};
+
+struct lbAddr {
+	lbAddrKind kind;
+	LLVMValueRef addr;
+	union {
+		struct {
+			LLVMValueRef key;
+			Type *type;
+			Type *result;
+		} map;
+		struct {
+			i32 value_index;
+		} bit_field;
+		struct {
+			Selection sel;
+		} ctx;
+		struct {
+			LLVMValueRef index;
+			Ast *index_expr;
+		} soa;
+	};
+};
+
+struct lbBlock {
+	LLVMBasicBlockRef block;
+	Scope *scope;
+	isize scope_index;
+};
+
+struct lbProcedure {
+	lbProcedure *parent;
+	Array<lbProcedure> children;
+
+	Entity *     entity;
+	lbModule *   module;
+	String       name;
+	Type *       type;
+	Ast *        type_expr;
+	Ast *        body;
+	u64          tags;
+	ProcInlining inlining;
+	bool         is_foreign;
+	bool         is_export;
+	bool         is_entry_point;
+
+
+	LLVMValueRef    value;
+	LLVMBuilderRef  builder;
+
+	LLVMValueRef        return_ptr;
+	Array<LLVMValueRef> params;
+	Array<lbBlock *>    blocks;
+	Scope *             curr_scope;
+	i32                 scope_index;
+	lbBlock *           decl_block;
+	lbBlock *           entry_block;
+	lbBlock *           curr_block;
+};
+
+lbBlock *    lb_create_block(lbProcedure *p, char const *name);
+LLVMTypeRef  lb_type(Type *type);
+void         lb_build_stmt  (lbProcedure *p, Ast *stmt);
+LLVMValueRef lb_build_expr  (lbProcedure *p, Ast *expr);
+
+lbAddr lb_addr(LLVMValueRef addr) {
+	lbAddr v = {lbAddr_Default, addr};
+	return v;
+}
+
+LLVMTypeRef lb_addr_type(lbAddr const &addr) {
+	return LLVMGetElementType(LLVMTypeOf(addr.addr));
+}
+
+void lb_addr_store(lbProcedure *p, lbAddr const &addr, LLVMValueRef value) {
+	if (addr.addr == nullptr) {
+		return;
+	}
+	GB_ASSERT(value != nullptr);
+	LLVMBuildStore(p->builder, value, addr.addr);
+}
+
+LLVMTypeRef lb_type_internal(Type *type) {
+	switch (type->kind) {
+	case Type_Basic:
+		switch (type->Basic.kind) {
+		case Basic_llvm_bool: return LLVMInt1Type();
+		case Basic_bool:      return LLVMInt8Type();
+		case Basic_b8:        return LLVMInt8Type();
+		case Basic_b16:       return LLVMInt16Type();
+		case Basic_b32:       return LLVMInt32Type();
+		case Basic_b64:       return LLVMInt64Type();
+
+		case Basic_i8:   return LLVMInt8Type();
+		case Basic_u8:   return LLVMInt8Type();
+		case Basic_i16:  return LLVMInt16Type();
+		case Basic_u16:  return LLVMInt16Type();
+		case Basic_i32:  return LLVMInt32Type();
+		case Basic_u32:  return LLVMInt32Type();
+		case Basic_i64:  return LLVMInt64Type();
+		case Basic_u64:  return LLVMInt64Type();
+		case Basic_i128: return LLVMInt128Type();
+		case Basic_u128: return LLVMInt128Type();
+
+		case Basic_rune: return LLVMInt32Type();
+
+		// Basic_f16,
+		case Basic_f32: return LLVMFloatType();
+		case Basic_f64: return LLVMDoubleType();
+
+		// Basic_complex32,
+		case Basic_complex64:
+			{
+				LLVMTypeRef fields[2] = {
+					lb_type(t_f32),
+					lb_type(t_f32),
+				};
+				return LLVMStructType(fields, 2, false);
+			}
+		case Basic_complex128:
+			{
+				LLVMTypeRef fields[2] = {
+					lb_type(t_f64),
+					lb_type(t_f64),
+				};
+				return LLVMStructType(fields, 2, false);
+			}
+
+		case Basic_quaternion128:
+			{
+				LLVMTypeRef fields[4] = {
+					lb_type(t_f32),
+					lb_type(t_f32),
+					lb_type(t_f32),
+					lb_type(t_f32),
+				};
+				return LLVMStructType(fields, 4, false);
+			}
+		case Basic_quaternion256:
+			{
+				LLVMTypeRef fields[4] = {
+					lb_type(t_f64),
+					lb_type(t_f64),
+					lb_type(t_f64),
+					lb_type(t_f64),
+				};
+				return LLVMStructType(fields, 4, false);
+			}
+
+		case Basic_int:  return LLVMIntType(8*cast(unsigned)build_context.word_size);
+		case Basic_uint: return LLVMIntType(8*cast(unsigned)build_context.word_size);
+
+		case Basic_uintptr: return LLVMIntType(8*cast(unsigned)build_context.word_size);
+
+		case Basic_rawptr: return LLVMPointerType(LLVMInt8Type(), 0);
+		case Basic_string:
+			{
+				LLVMTypeRef fields[2] = {
+					LLVMPointerType(lb_type(t_u8), 0),
+					lb_type(t_int),
+				};
+				return LLVMStructType(fields, 2, false);
+			}
+		case Basic_cstring: return LLVMPointerType(LLVMInt8Type(), 0);
+		case Basic_any:
+			{
+				LLVMTypeRef fields[2] = {
+					LLVMPointerType(lb_type(t_rawptr), 0),
+					lb_type(t_typeid),
+				};
+				return LLVMStructType(fields, 2, false);
+			}
+
+		case Basic_typeid: return LLVMIntType(8*cast(unsigned)build_context.word_size);
+
+		// Endian Specific Types
+		case Basic_i16le: return LLVMInt16Type();
+		case Basic_u16le: return LLVMInt16Type();
+		case Basic_i32le: return LLVMInt32Type();
+		case Basic_u32le: return LLVMInt32Type();
+		case Basic_i64le: return LLVMInt64Type();
+		case Basic_u64le: return LLVMInt64Type();
+		case Basic_i128le: return LLVMInt128Type();
+		case Basic_u128le: return LLVMInt128Type();
+
+		case Basic_i16be: return LLVMInt16Type();
+		case Basic_u16be: return LLVMInt16Type();
+		case Basic_i32be: return LLVMInt32Type();
+		case Basic_u32be: return LLVMInt32Type();
+		case Basic_i64be: return LLVMInt64Type();
+		case Basic_u64be: return LLVMInt64Type();
+		case Basic_i128be: return LLVMInt128Type();
+		case Basic_u128be: return LLVMInt128Type();
+
+		// Untyped types
+		case Basic_UntypedBool:       GB_PANIC("Basic_UntypedBool"); break;
+		case Basic_UntypedInteger:    GB_PANIC("Basic_UntypedInteger"); break;
+		case Basic_UntypedFloat:      GB_PANIC("Basic_UntypedFloat"); break;
+		case Basic_UntypedComplex:    GB_PANIC("Basic_UntypedComplex"); break;
+		case Basic_UntypedQuaternion: GB_PANIC("Basic_UntypedQuaternion"); break;
+		case Basic_UntypedString:     GB_PANIC("Basic_UntypedString"); break;
+		case Basic_UntypedRune:       GB_PANIC("Basic_UntypedRune"); break;
+		case Basic_UntypedNil:        GB_PANIC("Basic_UntypedNil"); break;
+		case Basic_UntypedUndef:      GB_PANIC("Basic_UntypedUndef"); break;
+		}
+		break;
+	case Type_Named:
+		GB_PANIC("Type_Named");
+		return nullptr;
+	case Type_Pointer:
+		return LLVMPointerType(lb_type(type_deref(type)), 0);
+	case Type_Opaque:
+		return lb_type(base_type(type));
+	case Type_Array:
+		return LLVMArrayType(lb_type(type->Array.elem), cast(unsigned)type->Array.count);
+	case Type_EnumeratedArray:
+		return LLVMArrayType(lb_type(type->EnumeratedArray.elem), cast(unsigned)type->EnumeratedArray.count);
+	case Type_Slice:
+		{
+			LLVMTypeRef fields[2] = {
+				LLVMPointerType(lb_type(type->Slice.elem), 0), // data
+				lb_type(t_int), // len
+			};
+			return LLVMStructType(fields, 2, false);
+		}
+		break;
+	case Type_DynamicArray:
+		{
+			LLVMTypeRef fields[4] = {
+				LLVMPointerType(lb_type(type->DynamicArray.elem), 0), // data
+				lb_type(t_int), // len
+				lb_type(t_int), // cap
+				lb_type(t_allocator), // allocator
+			};
+			return LLVMStructType(fields, 4, false);
+		}
+		break;
+	case Type_Map:
+		return lb_type(type->Map.internal_type);
+	case Type_Struct:
+		GB_PANIC("Type_Struct");
+		break;
+	case Type_Union:
+		GB_PANIC("Type_Union");
+		break;
+	case Type_Enum:
+		return LLVMIntType(8*cast(unsigned)type_size_of(type));
+	case Type_Tuple:
+		GB_PANIC("Type_Tuple");
+		break;
+	case Type_Proc:
+		set_procedure_abi_types(heap_allocator(), type);
+		GB_PANIC("Type_Proc");
+		break;
+	case Type_BitFieldValue:
+		return LLVMIntType(type->BitFieldValue.bits);
+	case Type_BitField:
+		GB_PANIC("Type_BitField");
+		break;
+	case Type_BitSet:
+		return LLVMIntType(8*cast(unsigned)type_size_of(type));
+	case Type_SimdVector:
+		if (type->SimdVector.is_x86_mmx) {
+			return LLVMX86MMXType();
+		}
+		return LLVMVectorType(lb_type(type->SimdVector.elem), cast(unsigned)type->SimdVector.count);
+	}
+
+	GB_PANIC("Invalid type");
+	return LLVMInt32Type();
+}
+
+LLVMTypeRef lb_type(Type *type) {
+	if (type->llvm_type) {
+		return type->llvm_type;
+	}
+
+	LLVMTypeRef llvm_type = lb_type_internal(type);
+	type->llvm_type = llvm_type;
+
+	return llvm_type;
+}
+
+lbProcedure *lb_create_procedure(lbModule *module, Entity *entity) {
+	lbProcedure *p = gb_alloc_item(heap_allocator(), lbProcedure);
+
+	p->module = module;
+	p->entity = entity;
+	p->name = entity->token.string;
+
+	DeclInfo *decl = entity->decl_info;
+
+	ast_node(pl, ProcLit, decl->proc_lit);
+	Type *pt = base_type(entity->type);
+	GB_ASSERT(pt->kind == Type_Proc);
+
+	p->type           = entity->type;
+	p->type_expr      = decl->type_expr;
+	p->body           = pl->body;
+	p->tags           = pt->Proc.tags;
+	p->inlining       = ProcInlining_none;
+	p->is_foreign     = false;
+	p->is_export      = false;
+	p->is_entry_point = false;
+
+	p->children.allocator = heap_allocator();
+	p->params.allocator = heap_allocator();
+	p->blocks.allocator = heap_allocator();
+
+
+	char *name = alloc_cstring(heap_allocator(), p->name);
+	LLVMTypeRef ret_type = LLVMFunctionType(LLVMVoidType(), nullptr, 0, false);
+
+	p->value = LLVMAddFunction(module->mod, name, ret_type);
+	p->builder = LLVMCreateBuilder();
+
+	p->decl_block = lb_create_block(p, "decls");
+	p->entry_block = lb_create_block(p, "entry");
+	p->curr_block = p->entry_block;
+
+	set_procedure_abi_types(heap_allocator(), p->type);
+
+	LLVMPositionBuilderAtEnd(p->builder, p->curr_block->block);
+
+	return p;
+}
+
+void lb_end_procedure(lbProcedure *p) {
+	LLVMPositionBuilderAtEnd(p->builder, p->decl_block->block);
+	LLVMBuildBr(p->builder, p->entry_block->block);
+	LLVMPositionBuilderAtEnd(p->builder, p->curr_block->block);
+
+	LLVMDisposeBuilder(p->builder);
+}
+
+
+lbBlock *lb_create_block(lbProcedure *p, char const *name) {
+	lbBlock *b = gb_alloc_item(heap_allocator(), lbBlock);
+	b->block = LLVMAppendBasicBlock(p->value, name);
+	b->scope = p->curr_scope;
+	b->scope_index = p->scope_index;
+	array_add(&p->blocks, b);
+	return b;
+}
+
+lbAddr lb_add_local(lbProcedure *p, Type *type, Entity *e=nullptr) {
+	LLVMPositionBuilderAtEnd(p->builder, p->decl_block->block);
+
+	LLVMTypeRef llvm_type = lb_type(type);
+	LLVMValueRef ptr = LLVMBuildAlloca(p->builder, llvm_type, "");
+	LLVMSetAlignment(ptr, 16);
+
+	LLVMPositionBuilderAtEnd(p->builder, p->curr_block->block);
+
+	if (e != nullptr) {
+		map_set(&p->module->values, hash_entity(e), ptr);
+	}
+
+	return lb_addr(ptr);
+}
+
+
+bool lb_init_generator(lbGenerator *gen, Checker *c) {
+	if (global_error_collector.count != 0) {
+		return false;
+	}
+
+	isize tc = c->parser->total_token_count;
+	if (tc < 2) {
+		return false;
+	}
+
+
+	String init_fullpath = c->parser->init_fullpath;
+
+	if (build_context.out_filepath.len == 0) {
+		gen->output_name = remove_directory_from_path(init_fullpath);
+		gen->output_name = remove_extension_from_path(gen->output_name);
+		gen->output_base = gen->output_name;
+	} else {
+		gen->output_name = build_context.out_filepath;
+		isize pos = string_extension_position(gen->output_name);
+		if (pos < 0) {
+			gen->output_base = gen->output_name;
+		} else {
+			gen->output_base = substring(gen->output_name, 0, pos);
+		}
+	}
+	gbAllocator ha = heap_allocator();
+	gen->output_base = path_to_full_path(ha, gen->output_base);
+
+	gbString output_file_path = gb_string_make_length(ha, gen->output_base.text, gen->output_base.len);
+	output_file_path = gb_string_appendc(output_file_path, ".obj");
+	defer (gb_string_free(output_file_path));
+
+	gbFileError err = gb_file_create(&gen->output_file, output_file_path);
+	if (err != gbFileError_None) {
+		gb_printf_err("Failed to create file %s\n", output_file_path);
+		return false;
+	}
+
+	gen->info = &c->info;
+
+	return true;
+}
+
+
+void lb_build_stmt_list(lbProcedure *p, Array<Ast *> const &stmts) {
+	for_array(i, stmts) {
+		Ast *stmt = stmts[i];
+		switch (stmt->kind) {
+		case_ast_node(vd, ValueDecl, stmt);
+			// lb_build_constant_value_decl(b, vd);
+		case_end;
+		case_ast_node(fb, ForeignBlockDecl, stmt);
+			ast_node(block, BlockStmt, fb->body);
+			lb_build_stmt_list(p, block->stmts);
+		case_end;
+		}
+	}
+	for_array(i, stmts) {
+		lb_build_stmt(p, stmts[i]);
+	}
+}
+
+
+void lb_build_stmt(lbProcedure *p, Ast *node) {
+	switch (node->kind) {
+	case_ast_node(bs, EmptyStmt, node);
+	case_end;
+
+	case_ast_node(us, UsingStmt, node);
+	case_end;
+
+	case_ast_node(bs, BlockStmt, node);
+		lb_build_stmt_list(p, bs->stmts);
+	case_end;
+
+	case_ast_node(vd, ValueDecl, node);
+		if (!vd->is_mutable) {
+			return;
+		}
+
+		bool is_static = false;
+		if (vd->names.count > 0) {
+			Entity *e = entity_of_ident(vd->names[0]);
+			if (e->flags & EntityFlag_Static) {
+				// NOTE(bill): If one of the entities is static, they all are
+				is_static = true;
+			}
+		}
+
+		GB_ASSERT_MSG(!is_static, "handle static variables");
+
+
+		auto addrs = array_make<lbAddr>(heap_allocator(), vd->names.count);
+		auto values = array_make<LLVMValueRef>(heap_allocator(), 0, vd->names.count);
+		defer (array_free(&addrs));
+		defer (array_free(&values));
+
+		for_array(i, vd->names) {
+			Ast *name = vd->names[i];
+			if (!is_blank_ident(name)) {
+				Entity *e = entity_of_ident(name);
+				addrs[i] = lb_add_local(p, e->type, e);
+				if (vd->values.count == 0) {
+					lb_addr_store(p, addrs[i], LLVMConstNull(lb_addr_type(addrs[i])));
+				}
+			}
+		}
+
+		for_array(i, vd->values) {
+			LLVMValueRef value = lb_build_expr(p, vd->values[i]);
+			array_add(&values, value);
+		}
+
+		for_array(i, values) {
+			lb_addr_store(p, addrs[i], values[i]);
+		}
+
+	case_end;
+	}
+}
+
+LLVMValueRef lb_value_constant(Type *type, ExactValue const &value) {
+
+	switch (value.kind) {
+	case ExactValue_Invalid:
+		return LLVMConstNull(lb_type(type));
+	case ExactValue_Bool:
+		return LLVMConstInt(lb_type(type), value.value_bool, false);
+	case ExactValue_String:
+		return LLVMConstInt(lb_type(type), value.value_bool, false);
+	case ExactValue_Integer:
+		return LLVMConstIntOfArbitraryPrecision(lb_type(type), cast(unsigned)value.value_integer.len, big_int_ptr(&value.value_integer));
+	case ExactValue_Float:
+		return LLVMConstReal(lb_type(type), value.value_float);
+	case ExactValue_Complex:
+		GB_PANIC("ExactValue_Complex");
+		break;
+	case ExactValue_Quaternion:
+		GB_PANIC("ExactValue_Quaternion");
+		break;
+
+	case ExactValue_Pointer:
+		return LLVMConstBitCast(LLVMConstInt(lb_type(t_uintptr), value.value_pointer, false), lb_type(type));
+	case ExactValue_Compound:
+		GB_PANIC("ExactValue_Compound");
+		break;
+	case ExactValue_Procedure:
+		GB_PANIC("ExactValue_Procedure");
+		break;
+	case ExactValue_Typeid:
+		GB_PANIC("ExactValue_Typeid");
+		break;
+	}
+
+	GB_PANIC("UNKNOWN ExactValue kind");
+	return nullptr;
+}
+
+LLVMValueRef lb_add_module_constant(lbModule *m, Type *type, ExactValue const &value) {
+	gbAllocator a = heap_allocator();
+
+	if (is_type_slice(type)) {
+		GB_PANIC("lb_add_module_constant -> slice");
+	}
+
+	return lb_value_constant(type, value);
+}
+
+LLVMValueRef lb_emit_arith(lbProcedure *p, TokenKind op, LLVMValueRef lhs, LLVMValueRef rhs, Type *type) {
+	switch (op) {
+	case Token_Add:
+		return LLVMBuildAdd(p->builder, lhs, rhs, "");
+	case Token_Sub:
+		return LLVMBuildSub(p->builder, lhs, rhs, "");
+	case Token_Mul:
+		return LLVMBuildMul(p->builder, lhs, rhs, "");
+	case Token_Quo:
+	case Token_Mod:
+	case Token_ModMod:
+	case Token_And:
+		return LLVMBuildAdd(p->builder, lhs, rhs, "");
+	case Token_Or:
+		return LLVMBuildOr(p->builder, lhs, rhs, "");
+	case Token_Xor:
+		return LLVMBuildXor(p->builder, lhs, rhs, "");
+	case Token_Shl:
+		return LLVMBuildShl(p->builder, lhs, rhs, "");
+	case Token_Shr:
+
+	case Token_AndNot:
+		break;
+	}
+
+	GB_PANIC("unhandled operator of lb_emit_arith");
+
+	return nullptr;
+}
+
+LLVMValueRef lb_build_binary_expr(lbProcedure *p, Ast *expr) {
+	ast_node(be, BinaryExpr, expr);
+
+	TypeAndValue tv = type_and_value_of_expr(expr);
+
+	switch (be->op.kind) {
+	case Token_Add:
+	case Token_Sub:
+	case Token_Mul:
+	case Token_Quo:
+	case Token_Mod:
+	case Token_ModMod:
+	case Token_And:
+	case Token_Or:
+	case Token_Xor:
+	case Token_AndNot:
+	case Token_Shl:
+	case Token_Shr: {
+		Type *type = default_type(tv.type);
+		LLVMValueRef left = lb_build_expr(p, be->left);
+		LLVMValueRef right = lb_build_expr(p, be->right);
+		return lb_emit_arith(p, be->op.kind, left, right, type);
+	}
+	default:
+		GB_PANIC("Invalid binary expression");
+		break;
+	}
+	return nullptr;
+}
+
+LLVMValueRef lb_build_expr(lbProcedure *p, Ast *expr) {
+	expr = unparen_expr(expr);
+
+	TypeAndValue tv = type_and_value_of_expr(expr);
+	GB_ASSERT(tv.mode != Addressing_Invalid);
+	GB_ASSERT(tv.mode != Addressing_Type);
+
+	if (tv.value.kind != ExactValue_Invalid) {
+		// // NOTE(bill): Edge case
+		// if (tv.value.kind != ExactValue_Compound &&
+		//     is_type_array(tv.type)) {
+		// 	Type *elem = core_array_type(tv.type);
+		// 	ExactValue value = convert_exact_value_for_type(tv.value, elem);
+		// 	irValue *x = ir_add_module_constant(proc->module, elem, value);
+		// 	return ir_emit_conv(proc, x, tv.type);
+		// }
+
+		// if (tv.value.kind == ExactValue_Typeid) {
+		// 	irValue *v = ir_typeid(proc->module, tv.value.value_typeid);
+		// 	return ir_emit_conv(proc, v, tv.type);
+		// }
+
+		return lb_add_module_constant(p->module, tv.type, tv.value);
+	}
+
+
+	switch (expr->kind) {
+	case_ast_node(bl, BasicLit, expr);
+		TokenPos pos = bl->token.pos;
+		GB_PANIC("Non-constant basic literal %.*s(%td:%td) - %.*s", LIT(pos.file), pos.line, pos.column, LIT(token_strings[bl->token.kind]));
+	case_end;
+
+	case_ast_node(bd, BasicDirective, expr);
+		TokenPos pos = bd->token.pos;
+		GB_PANIC("Non-constant basic literal %.*s(%td:%td) - %.*s", LIT(pos.file), pos.line, pos.column, LIT(bd->name));
+	case_end;
+
+	// case_ast_node(i, Implicit, expr);
+	// 	return ir_addr_load(proc, ir_build_addr(proc, expr));
+	// case_end;
+
+	case_ast_node(u, Undef, expr);
+		return LLVMGetUndef(lb_type(tv.type));
+	case_end;
+
+	case_ast_node(i, Ident, expr);
+		Entity *e = entity_of_ident(expr);
+		GB_ASSERT_MSG(e != nullptr, "%s", expr_to_string(expr));
+		if (e->kind == Entity_Builtin) {
+			Token token = ast_token(expr);
+			GB_PANIC("TODO(bill): ir_build_expr Entity_Builtin '%.*s'\n"
+			         "\t at %.*s(%td:%td)", LIT(builtin_procs[e->Builtin.id].name),
+			         LIT(token.pos.file), token.pos.line, token.pos.column);
+			return nullptr;
+		} else if (e->kind == Entity_Nil) {
+			return LLVMConstNull(lb_type(tv.type));
+		}
+
+		auto *found = map_get(&p->module->values, hash_entity(e));
+		if (found) {
+			LLVMValueRef v = *found;
+			LLVMTypeKind kind = LLVMGetTypeKind(LLVMTypeOf(v));
+			if (kind == LLVMFunctionTypeKind) {
+				return v;
+			}
+			return LLVMBuildLoad2(p->builder, LLVMGetElementType(LLVMTypeOf(v)), v, "");
+		// } else if (e != nullptr && e->kind == Entity_Variable) {
+		// 	return ir_addr_load(proc, ir_build_addr(proc, expr));
+		}
+		GB_PANIC("nullptr value for expression from identifier: %.*s : %s @ %p", LIT(i->token.string), type_to_string(e->type), expr);
+		return nullptr;
+	case_end;
+
+	case_ast_node(be, BinaryExpr, expr);
+		return lb_build_binary_expr(p, expr);
+	case_end;
+	}
+
+	return nullptr;
+}
+
+
+
+
+void lb_generate_module(lbGenerator *gen) {
+	gen->module.mod = LLVMModuleCreateWithName("odin_module");
+	map_init(&gen->module.values, heap_allocator());
+
+	LLVMModuleRef mod = gen->module.mod;
+	CheckerInfo *info = gen->info;
+
+	Arena temp_arena = {};
+	arena_init(&temp_arena, heap_allocator());
+	gbAllocator temp_allocator = arena_allocator(&temp_arena);
+
+	Entity *entry_point = info->entry_point;
+
+	auto *min_dep_set = &info->minimum_dependency_set;
+
+
+	for_array(i, info->entities) {
+		arena_free_all(&temp_arena);
+		gbAllocator a = temp_allocator;
+
+		Entity *e = info->entities[i];
+		String    name  = e->token.string;
+		DeclInfo *decl  = e->decl_info;
+		Scope *   scope = e->scope;
+
+		if ((scope->flags & ScopeFlag_File) == 0) {
+			continue;
+		}
+
+		Scope *package_scope = scope->parent;
+		GB_ASSERT(package_scope->flags & ScopeFlag_Pkg);
+
+		switch (e->kind) {
+		case Entity_Variable:
+			// NOTE(bill): Handled above as it requires a specific load order
+			continue;
+		case Entity_ProcGroup:
+			continue;
+
+		case Entity_TypeName:
+		case Entity_Procedure:
+			break;
+		}
+
+		bool polymorphic_struct = false;
+		if (e->type != nullptr && e->kind == Entity_TypeName) {
+			Type *bt = base_type(e->type);
+			if (bt->kind == Type_Struct) {
+				polymorphic_struct = is_type_polymorphic(bt);
+			}
+		}
+
+		if (!polymorphic_struct && !ptr_set_exists(min_dep_set, e)) {
+			// NOTE(bill): Nothing depends upon it so doesn't need to be built
+			continue;
+		}
+
+
+		if (entry_point == e) {
+			lbProcedure *p = lb_create_procedure(&gen->module, e);
+
+			if (p->body != nullptr) { // Build Procedure
+
+				lb_build_stmt(p, p->body);
+
+				LLVMBuildRet(p->builder, nullptr);
+			}
+
+			lb_end_procedure(p);
+		}
+	}
+
+	{
+		LLVMTypeRef ret_type = LLVMFunctionType(LLVMVoidType(), nullptr, 0, false);
+
+		LLVMValueRef p = LLVMAddFunction(mod, "mainCRTStartup", ret_type);
+
+
+		LLVMBasicBlockRef entry = LLVMAppendBasicBlock(p, "entry");
+
+		LLVMBuilderRef b = LLVMCreateBuilder();
+		defer (LLVMDisposeBuilder(b));
+
+		LLVMPositionBuilderAtEnd(b, entry);
+
+
+		LLVMBuildRetVoid(b);
+		// LLVMBuildRet(b, nullptr);
+	}
+
+	char *llvm_error = nullptr;
+	defer (LLVMDisposeMessage(llvm_error));
+
+	LLVMVerifyModule(mod, LLVMAbortProcessAction, &llvm_error);
+	llvm_error = nullptr;
+
+	LLVMDumpModule(mod);
+
+
+	LLVMPassManagerRef pass_manager = LLVMCreatePassManager();
+	defer (LLVMDisposePassManager(pass_manager));
+
+	LLVMRunPassManager(pass_manager, mod);
+	LLVMFinalizeFunctionPassManager(pass_manager);
+
+	LLVMInitializeAllTargetInfos();
+	LLVMInitializeAllTargets();
+	LLVMInitializeAllTargetMCs();
+	LLVMInitializeAllAsmParsers();
+	LLVMInitializeAllAsmPrinters();
+
+	char const *target_triple = "x86_64-pc-windows-msvc";
+	char const *target_data_layout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128";
+	LLVMSetTarget(mod, target_triple);
+
+	LLVMTargetRef target = {};
+	LLVMGetTargetFromTriple(target_triple, &target, &llvm_error);
+	GB_ASSERT(target != nullptr);
+
+	LLVMTargetMachineRef target_machine = LLVMCreateTargetMachine(target, target_triple, "generic", "", LLVMCodeGenLevelNone, LLVMRelocDefault, LLVMCodeModelDefault);
+	defer (LLVMDisposeTargetMachine(target_machine));
+
+	LLVMBool ok = LLVMTargetMachineEmitToFile(target_machine, mod, "llvm_demo.obj", LLVMObjectFile, &llvm_error);
+	if (ok) {
+		gb_printf_err("LLVM Error: %s\n", llvm_error);
+		return;
+	}
+}
diff --git a/src/main.cpp b/src/main.cpp
index 317e8f577..95bc52d63 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -17,11 +17,15 @@ gb_global Timings global_timings = {0};
 #include "parser.cpp"
 #include "docs.cpp"
 #include "checker.cpp"
+
+#include "llvm_backend.cpp"
+
 #include "ir.cpp"
 #include "ir_opt.cpp"
 #include "ir_print.cpp"
 #include "query_data.cpp"
 
+
 #if defined(GB_SYSTEM_WINDOWS)
 // NOTE(IC): In order to find Visual C++ paths without relying on environment variables.
 #include "microsoft_craziness.h"
@@ -234,6 +238,7 @@ enum BuildFlagKind {
 	BuildFlag_NoCRT,
 	BuildFlag_UseLLD,
 	BuildFlag_Vet,
+	BuildFlag_UseLLVMApi,
 	BuildFlag_IgnoreUnknownAttributes,
 
 	BuildFlag_Compact,
@@ -324,6 +329,7 @@ bool parse_build_flags(Array<String> args) {
 	add_flag(&build_flags, BuildFlag_NoCRT,             str_lit("no-crt"),            BuildFlagParam_None);
 	add_flag(&build_flags, BuildFlag_UseLLD,            str_lit("lld"),               BuildFlagParam_None);
 	add_flag(&build_flags, BuildFlag_Vet,               str_lit("vet"),               BuildFlagParam_None);
+	add_flag(&build_flags, BuildFlag_UseLLVMApi,        str_lit("llvm-api"),          BuildFlagParam_None);
 	add_flag(&build_flags, BuildFlag_IgnoreUnknownAttributes, str_lit("ignore-unknown-attributes"), BuildFlagParam_None);
 
 	add_flag(&build_flags, BuildFlag_Compact, str_lit("compact"), BuildFlagParam_None);
@@ -347,6 +353,7 @@ bool parse_build_flags(Array<String> args) {
 			gb_printf_err("Invalid flag: %.*s\n", LIT(flag));
 			continue;
 		}
+
 		String name = substring(flag, 1, flag.len);
 		isize end = 0;
 		for (; end < name.len; end++) {
@@ -692,6 +699,10 @@ bool parse_build_flags(Array<String> args) {
 							build_context.vet = true;
 							break;
 
+						case BuildFlag_UseLLVMApi:
+							build_context.use_llvm_api = true;
+							break;
+
 						case BuildFlag_IgnoreUnknownAttributes:
 							build_context.ignore_unknown_attributes = true;
 							break;
@@ -1263,6 +1274,15 @@ int main(int arg_count, char const **arg_ptr) {
 		return 1;
 	}
 
+	if (build_context.use_llvm_api) {
+		lbGenerator gen = {};
+		if (!lb_init_generator(&gen, &checker)) {
+			return 1;
+		}
+		lb_generate_module(&gen);
+		return 0;
+	}
+
 	irGen ir_gen = {0};
 	if (!ir_gen_init(&ir_gen, &checker)) {
 		return 1;
diff --git a/src/types.cpp b/src/types.cpp
index d2a040b0b..822583fee 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -1,3 +1,5 @@
+#include "llvm-c/Types.h"
+
 struct Scope;
 struct Ast;
 
@@ -299,6 +301,7 @@ struct Type {
 	i64  cached_size;
 	i64  cached_align;
 	u32  flags; // TypeFlag
+	LLVMTypeRef llvm_type;
 	bool failure;
 };