Imported Upstream version 5.18.0.167

Former-commit-id: 289509151e0fee68a1b591a20c9f109c3c789d3a

external/llvm/bindings/go/README.txt

@@ -1,61 +0,0 @@
-This directory contains LLVM bindings for the Go programming language
-(http://golang.org).
-
-Prerequisites
--------------
-
-* Go 1.2+.
-* CMake (to build LLVM).
-
-Using the bindings
-------------------
-
-The package path "llvm.org/llvm/bindings/go/llvm" can be used to
-import the latest development version of LLVM from SVN. Paths such as
-"llvm.org/llvm.v36/bindings/go/llvm" refer to released versions of LLVM.
-
-It is recommended to use the "-d" flag with "go get" to download the
-package or a dependency, as an additional step is required to build LLVM
-(see "Building LLVM" below).
-
-Building LLVM
--------------
-
-The script "build.sh" in this directory can be used to build LLVM and prepare
-it to be used by the bindings. If you receive an error message from "go build"
-like this:
-
-    ./analysis.go:4:84: fatal error: llvm-c/Analysis.h: No such file or directory
-     #include <llvm-c/Analysis.h> // If you are getting an error here read bindings/go/README.txt
-
-or like this:
-
-    ./llvm_dep.go:5: undefined: run_build_sh
-
-it means that LLVM needs to be built or updated by running the script.
-
-    $ $GOPATH/src/llvm.org/llvm/bindings/go/build.sh
-
-Any command line arguments supplied to the script are passed to LLVM's CMake
-build system. A good set of arguments to use during development are:
-
-    $ $GOPATH/src/llvm.org/llvm/bindings/go/build.sh -DCMAKE_BUILD_TYPE=Debug -DLLVM_TARGETS_TO_BUILD=host -DBUILD_SHARED_LIBS=ON
-
-Note that CMake keeps a cache of build settings so once you have built
-LLVM there is no need to pass these arguments again after updating.
-
-Alternatively, you can build LLVM yourself, but you must then set the
-CGO_CPPFLAGS, CGO_CXXFLAGS and CGO_LDFLAGS environment variables:
-
-    $ export CGO_CPPFLAGS="`/path/to/llvm-build/bin/llvm-config --cppflags`"
-    $ export CGO_CXXFLAGS=-std=c++11
-    $ export CGO_LDFLAGS="`/path/to/llvm-build/bin/llvm-config --ldflags --libs --system-libs all`"
-    $ go build -tags byollvm
-
-If you see a compilation error while compiling your code with Go 1.9.4 or later as follows,
-
-    go build llvm.org/llvm/bindings/go/llvm: invalid flag in #cgo LDFLAGS: -Wl,-headerpad_max_install_names
-
-you need to setup $CGO_LDFLAGS_ALLOW to allow a compiler to specify some linker options:
-
-    $ export CGO_LDFLAGS_ALLOW='-Wl,(-search_paths_first|-headerpad_max_install_names)'

external/llvm/bindings/go/build.sh

@@ -1,28 +0,0 @@
-#!/bin/sh -xe
-
-gollvmdir=$(dirname "$0")/llvm
-
-workdir=$gollvmdir/workdir
-llvmdir=$gollvmdir/../../..
-llvm_builddir=$workdir/llvm_build
-
-mkdir -p $llvm_builddir
-
-cmake_flags="../../../../.. $@"
-llvm_config="$llvm_builddir/bin/llvm-config"
-llvm_go="$llvm_builddir/bin/llvm-go"
-
-if test -n "`which ninja`" ; then
-  # If Ninja is available, we can speed up the build by building only the
-  # required subset of LLVM.
-  (cd $llvm_builddir && cmake -G Ninja $cmake_flags)
-  ninja -C $llvm_builddir llvm-config llvm-go
-  llvm_components="$($llvm_go print-components)"
-  llvm_buildtargets="$($llvm_config --libs $llvm_components | sed -e 's/-l//g')"
-  ninja -C $llvm_builddir $llvm_buildtargets FileCheck
-else
-  (cd $llvm_builddir && cmake $cmake_flags)
-  make -C $llvm_builddir -j4
-fi
-
-$llvm_go print-config > $gollvmdir/llvm_config.go

external/llvm/bindings/go/conftest.go

@@ -1,16 +0,0 @@
-package main
-
-import (
-	"go/build"
-	"os"
-)
-
-// Tests that the Go compiler is at least version 1.2.
-func main() {
-	for _, tag := range build.Default.ReleaseTags {
-		if tag == "go1.2" {
-			os.Exit(0)
-		}
-	}
-	os.Exit(1)
-}

external/llvm/bindings/go/llvm/DIBuilderBindings.cpp

@@ -1,234 +0,0 @@
-//===- DIBuilderBindings.cpp - Bindings for DIBuilder ---------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines C bindings for the DIBuilder class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DIBuilderBindings.h"
-#include "IRBindings.h"
-#include "llvm/IR/DIBuilder.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/Module.h"
-
-using namespace llvm;
-
-LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef mref) {
-  Module *m = unwrap(mref);
-  return wrap(new DIBuilder(*m));
-}
-
-void LLVMDIBuilderDestroy(LLVMDIBuilderRef dref) {
-  DIBuilder *d = unwrap(dref);
-  delete d;
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
-                                                LLVMMetadataRef Scope,
-                                                LLVMMetadataRef File,
-                                                unsigned Line,
-                                                unsigned Column) {
-  DIBuilder *D = unwrap(Dref);
-  auto *LB = D->createLexicalBlock(unwrap<DILocalScope>(Scope),
-                                   unwrap<DIFile>(File), Line, Column);
-  return wrap(LB);
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
-                                                    LLVMMetadataRef Scope,
-                                                    LLVMMetadataRef File,
-                                                    unsigned Discriminator) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createLexicalBlockFile(unwrap<DILocalScope>(Scope),
-                                        unwrap<DIFile>(File), Discriminator));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateFunction(
-    LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
-    const char *LinkageName, LLVMMetadataRef File, unsigned Line,
-    LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
-    unsigned ScopeLine, unsigned Flags, int IsOptimized) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createFunction(
-      unwrap<DIScope>(Scope), Name, LinkageName,
-      File ? unwrap<DIFile>(File) : nullptr, Line,
-      unwrap<DISubroutineType>(CompositeType), IsLocalToUnit, IsDefinition,
-      ScopeLine, static_cast<DINode::DIFlags>(Flags), IsOptimized));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
-    LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
-    LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
-    unsigned Flags, uint32_t AlignInBits) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(
-      D->createAutoVariable(unwrap<DIScope>(Scope), Name, unwrap<DIFile>(File),
-                            Line, unwrap<DIType>(Ty), AlwaysPreserve,
-                            static_cast<DINode::DIFlags>(Flags), AlignInBits));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
-    LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
-    unsigned ArgNo, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty,
-    int AlwaysPreserve, unsigned Flags) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createParameterVariable(
-      unwrap<DIScope>(Scope), Name, ArgNo, unwrap<DIFile>(File), Line,
-      unwrap<DIType>(Ty), AlwaysPreserve, static_cast<DINode::DIFlags>(Flags)));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
-                                             const char *Name,
-                                             uint64_t SizeInBits,
-                                             unsigned Encoding) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createBasicType(Name, SizeInBits, Encoding));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
-                                               LLVMMetadataRef PointeeType,
-                                               uint64_t SizeInBits,
-                                               uint32_t AlignInBits,
-                                               const char *Name) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createPointerType(unwrap<DIType>(PointeeType), SizeInBits,
-                                   AlignInBits, /* DWARFAddressSpace */ None,
-                                   Name));
-}
-
-LLVMMetadataRef
-LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
-                                  LLVMMetadataRef ParameterTypes) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(
-      D->createSubroutineType(DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateStructType(
-    LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
-    LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
-    uint32_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
-    LLVMMetadataRef ElementTypes) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createStructType(
-      unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
-      SizeInBits, AlignInBits, static_cast<DINode::DIFlags>(Flags),
-      DerivedFrom ? unwrap<DIType>(DerivedFrom) : nullptr,
-      ElementTypes ? DINodeArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
-    LLVMDIBuilderRef Dref, unsigned Tag, const char *Name,
-    LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
-    unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
-    unsigned Flags) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createReplaceableCompositeType(
-      Tag, Name, unwrap<DIScope>(Scope), File ? unwrap<DIFile>(File) : nullptr,
-      Line, RuntimeLang, SizeInBits, AlignInBits,
-      static_cast<DINode::DIFlags>(Flags)));
-}
-
-LLVMMetadataRef
-LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
-                              const char *Name, LLVMMetadataRef File,
-                              unsigned Line, uint64_t SizeInBits,
-                              uint32_t AlignInBits, uint64_t OffsetInBits,
-                              unsigned Flags, LLVMMetadataRef Ty) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createMemberType(
-      unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
-      SizeInBits, AlignInBits, OffsetInBits,
-      static_cast<DINode::DIFlags>(Flags), unwrap<DIType>(Ty)));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
-                                             uint64_t SizeInBits,
-                                             uint32_t AlignInBits,
-                                             LLVMMetadataRef ElementType,
-                                             LLVMMetadataRef Subscripts) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createArrayType(SizeInBits, AlignInBits,
-                                 unwrap<DIType>(ElementType),
-                                 DINodeArray(unwrap<MDTuple>(Subscripts))));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
-                                           LLVMMetadataRef Ty, const char *Name,
-                                           LLVMMetadataRef File, unsigned Line,
-                                           LLVMMetadataRef Context) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createTypedef(unwrap<DIType>(Ty), Name,
-                               File ? unwrap<DIFile>(File) : nullptr, Line,
-                               Context ? unwrap<DIScope>(Context) : nullptr));
-}
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Dref,
-                                                 int64_t Lo, int64_t Count) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->getOrCreateSubrange(Lo, Count));
-}
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Dref,
-                                              LLVMMetadataRef *Data,
-                                              size_t Length) {
-  DIBuilder *D = unwrap(Dref);
-  Metadata **DataValue = unwrap(Data);
-  ArrayRef<Metadata *> Elements(DataValue, Length);
-  DINodeArray A = D->getOrCreateArray(Elements);
-  return wrap(A.get());
-}
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
-                                                  LLVMMetadataRef *Data,
-                                                  size_t Length) {
-  DIBuilder *D = unwrap(Dref);
-  Metadata **DataValue = unwrap(Data);
-  ArrayRef<Metadata *> Elements(DataValue, Length);
-  DITypeRefArray A = D->getOrCreateTypeArray(Elements);
-  return wrap(A.get());
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref,
-                                              int64_t *Addr, size_t Length) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createExpression(ArrayRef<int64_t>(Addr, Length)));
-}
-
-LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Dref,
-                                             LLVMValueRef Storage,
-                                             LLVMMetadataRef VarInfo,
-                                             LLVMMetadataRef Expr,
-                                             LLVMBasicBlockRef Block) {
-  // Fail immediately here until the llgo folks update their bindings.  The
-  // called function is going to assert out anyway.
-  llvm_unreachable("DIBuilder API change requires a DebugLoc");
-
-  DIBuilder *D = unwrap(Dref);
-  Instruction *Instr = D->insertDeclare(
-      unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
-      unwrap<DIExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
-  return wrap(Instr);
-}
-
-LLVMValueRef LLVMDIBuilderInsertValueAtEnd(LLVMDIBuilderRef Dref,
-                                           LLVMValueRef Val,
-                                           LLVMMetadataRef VarInfo,
-                                           LLVMMetadataRef Expr,
-                                           LLVMBasicBlockRef Block) {
-  // Fail immediately here until the llgo folks update their bindings.  The
-  // called function is going to assert out anyway.
-  llvm_unreachable("DIBuilder API change requires a DebugLoc");
-
-  DIBuilder *D = unwrap(Dref);
-  Instruction *Instr = D->insertDbgValueIntrinsic(
-      unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
-      /* DebugLoc */ nullptr, unwrap(Block));
-  return wrap(Instr);
-}

external/llvm/bindings/go/llvm/DIBuilderBindings.h

@@ -1,134 +0,0 @@
-//===- DIBuilderBindings.h - Bindings for DIBuilder -------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines C bindings for the DIBuilder class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BINDINGS_GO_LLVM_DIBUILDERBINDINGS_H
-#define LLVM_BINDINGS_GO_LLVM_DIBUILDERBINDINGS_H
-
-#include "IRBindings.h"
-#include "llvm-c/Core.h"
-#include "llvm-c/DebugInfo.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// FIXME: These bindings shouldn't be Go-specific and should eventually move to
-// a (somewhat) less stable collection of C APIs for use in creating bindings of
-// LLVM in other languages.
-
-typedef struct LLVMOpaqueDIBuilder *LLVMDIBuilderRef;
-
-LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef m);
-
-void LLVMDIBuilderDestroy(LLVMDIBuilderRef d);
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef D,
-                                                LLVMMetadataRef Scope,
-                                                LLVMMetadataRef File,
-                                                unsigned Line, unsigned Column);
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef D,
-                                                    LLVMMetadataRef Scope,
-                                                    LLVMMetadataRef File,
-                                                    unsigned Discriminator);
-
-LLVMMetadataRef LLVMDIBuilderCreateFunction(
-    LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
-    const char *LinkageName, LLVMMetadataRef File, unsigned Line,
-    LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
-    unsigned ScopeLine, unsigned Flags, int IsOptimized);
-
-LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
-    LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
-    LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
-    unsigned Flags, uint32_t AlignInBits);
-
-LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
-    LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name, unsigned ArgNo,
-    LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
-    unsigned Flags);
-
-LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef D,
-                                             const char *Name,
-                                             uint64_t SizeInBits,
-                                             unsigned Encoding);
-
-LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef D,
-                                               LLVMMetadataRef PointeeType,
-                                               uint64_t SizeInBits,
-                                               uint32_t AlignInBits,
-                                               const char *Name);
-
-LLVMMetadataRef
-LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef D, LLVMMetadataRef File,
-                                  LLVMMetadataRef ParameterTypes);
-
-LLVMMetadataRef LLVMDIBuilderCreateStructType(
-    LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
-    LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
-    uint32_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
-    LLVMMetadataRef ElementTypes);
-
-LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
-    LLVMDIBuilderRef D, unsigned Tag, const char *Name, LLVMMetadataRef Scope,
-    LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang,
-    uint64_t SizeInBits, uint32_t AlignInBits, unsigned Flags);
-
-LLVMMetadataRef
-LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef D, LLVMMetadataRef Scope,
-                              const char *Name, LLVMMetadataRef File,
-                              unsigned Line, uint64_t SizeInBits,
-                              uint32_t AlignInBits, uint64_t OffsetInBits,
-                              unsigned Flags, LLVMMetadataRef Ty);
-
-LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef D,
-                                             uint64_t SizeInBits,
-                                             uint32_t AlignInBits,
-                                             LLVMMetadataRef ElementType,
-                                             LLVMMetadataRef Subscripts);
-
-LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef D,
-                                           LLVMMetadataRef Ty, const char *Name,
-                                           LLVMMetadataRef File, unsigned Line,
-                                           LLVMMetadataRef Context);
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef D, int64_t Lo,
-                                                 int64_t Count);
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef D,
-                                              LLVMMetadataRef *Data,
-                                              size_t Length);
-
-LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef D,
-                                                  LLVMMetadataRef *Data,
-                                                  size_t Length);
-
-LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref,
-                                              int64_t *Addr, size_t Length);
-
-LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef D,
-                                             LLVMValueRef Storage,
-                                             LLVMMetadataRef VarInfo,
-                                             LLVMMetadataRef Expr,
-                                             LLVMBasicBlockRef Block);
-
-LLVMValueRef LLVMDIBuilderInsertValueAtEnd(LLVMDIBuilderRef D, LLVMValueRef Val,
-                                           LLVMMetadataRef VarInfo,
-                                           LLVMMetadataRef Expr,
-                                           LLVMBasicBlockRef Block);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif

external/llvm/bindings/go/llvm/IRBindings.cpp

@@ -1,89 +0,0 @@
-//===- IRBindings.cpp - Additional bindings for ir ------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines additional C bindings for the ir component.
-//
-//===----------------------------------------------------------------------===//
-
-#include "IRBindings.h"
-#include "llvm/IR/Attributes.h"
-#include "llvm/IR/DebugLoc.h"
-#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
-
-using namespace llvm;
-
-LLVMMetadataRef LLVMConstantAsMetadata(LLVMValueRef C) {
-  return wrap(ConstantAsMetadata::get(unwrap<Constant>(C)));
-}
-
-LLVMMetadataRef LLVMMDString2(LLVMContextRef C, const char *Str, unsigned SLen) {
-  return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen)));
-}
-
-LLVMMetadataRef LLVMMDNode2(LLVMContextRef C, LLVMMetadataRef *MDs,
-                            unsigned Count) {
-  return wrap(
-      MDNode::get(*unwrap(C), ArrayRef<Metadata *>(unwrap(MDs), Count)));
-}
-
-LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef C, LLVMMetadataRef *MDs,
-                                    unsigned Count) {
-  return wrap(MDTuple::getTemporary(*unwrap(C),
-                                    ArrayRef<Metadata *>(unwrap(MDs), Count))
-                  .release());
-}
-
-void LLVMAddNamedMetadataOperand2(LLVMModuleRef M, const char *name,
-                                  LLVMMetadataRef Val) {
-  NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name);
-  if (!N)
-    return;
-  if (!Val)
-    return;
-  N->addOperand(unwrap<MDNode>(Val));
-}
-
-void LLVMSetMetadata2(LLVMValueRef Inst, unsigned KindID, LLVMMetadataRef MD) {
-  MDNode *N = MD ? unwrap<MDNode>(MD) : nullptr;
-  unwrap<Instruction>(Inst)->setMetadata(KindID, N);
-}
-
-void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef MD, LLVMMetadataRef New) {
-  auto *Node = unwrap<MDNode>(MD);
-  Node->replaceAllUsesWith(unwrap<Metadata>(New));
-  MDNode::deleteTemporary(Node);
-}
-
-void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Bref, unsigned Line,
-                                  unsigned Col, LLVMMetadataRef Scope,
-                                  LLVMMetadataRef InlinedAt) {
-  unwrap(Bref)->SetCurrentDebugLocation(
-      DebugLoc::get(Line, Col, Scope ? unwrap<MDNode>(Scope) : nullptr,
-                    InlinedAt ? unwrap<MDNode>(InlinedAt) : nullptr));
-}
-
-LLVMDebugLocMetadata LLVMGetCurrentDebugLocation2(LLVMBuilderRef Bref) {
-  const auto& Loc = unwrap(Bref)->getCurrentDebugLocation();
-  const auto* InlinedAt = Loc.getInlinedAt();
-  const LLVMDebugLocMetadata md{
-    Loc.getLine(),
-    Loc.getCol(),
-    wrap(Loc.getScope()),
-    InlinedAt == nullptr ? nullptr : wrap(InlinedAt->getRawInlinedAt()),
-  };
-  return md;
-}
-
-void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
-  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
-}

external/llvm/bindings/go/llvm/IRBindings.h

@@ -1,63 +0,0 @@
-//===- IRBindings.h - Additional bindings for IR ----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines additional C bindings for the IR component.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BINDINGS_GO_LLVM_IRBINDINGS_H
-#define LLVM_BINDINGS_GO_LLVM_IRBINDINGS_H
-
-#include "llvm-c/Core.h"
-#ifdef __cplusplus
-#include "llvm/IR/Metadata.h"
-#include "llvm/Support/CBindingWrapping.h"
-#endif
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct LLVMDebugLocMetadata{
-    unsigned Line;
-    unsigned Col;
-    LLVMMetadataRef Scope;
-    LLVMMetadataRef InlinedAt;
-};
-
-LLVMMetadataRef LLVMConstantAsMetadata(LLVMValueRef Val);
-
-LLVMMetadataRef LLVMMDString2(LLVMContextRef C, const char *Str, unsigned SLen);
-LLVMMetadataRef LLVMMDNode2(LLVMContextRef C, LLVMMetadataRef *MDs,
-                            unsigned Count);
-LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef C, LLVMMetadataRef *MDs,
-                                    unsigned Count);
-
-void LLVMAddNamedMetadataOperand2(LLVMModuleRef M, const char *name,
-                                  LLVMMetadataRef Val);
-void LLVMSetMetadata2(LLVMValueRef Inst, unsigned KindID, LLVMMetadataRef MD);
-
-void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef MD, LLVMMetadataRef New);
-
-void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Bref, unsigned Line,
-                                  unsigned Col, LLVMMetadataRef Scope,
-                                  LLVMMetadataRef InlinedAt);
-
-struct LLVMDebugLocMetadata LLVMGetCurrentDebugLocation2(LLVMBuilderRef Bref);
-
-void LLVMSetSubprogram(LLVMValueRef Fn, LLVMMetadataRef SP);
-
-#ifdef __cplusplus
-}
-
-#endif
-
-#endif

external/llvm/bindings/go/llvm/InstrumentationBindings.cpp

@@ -1,46 +0,0 @@
-//===- InstrumentationBindings.cpp - instrumentation bindings -------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines C bindings for the instrumentation component.
-//
-//===----------------------------------------------------------------------===//
-
-#include "InstrumentationBindings.h"
-#include "llvm-c/Core.h"
-#include "llvm/IR/LegacyPassManager.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Transforms/Instrumentation.h"
-
-using namespace llvm;
-
-void LLVMAddAddressSanitizerFunctionPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createAddressSanitizerFunctionPass());
-}
-
-void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createAddressSanitizerModulePass());
-}
-
-void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createThreadSanitizerPass());
-}
-
-void LLVMAddMemorySanitizerPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createMemorySanitizerPass());
-}
-
-void LLVMAddDataFlowSanitizerPass(LLVMPassManagerRef PM,
-                                  int ABIListFilesNum,
-                                  const char **ABIListFiles) {
-  std::vector<std::string> ABIListFilesVec;
-  for (int i = 0; i != ABIListFilesNum; ++i) {
-    ABIListFilesVec.push_back(ABIListFiles[i]);
-  }
-  unwrap(PM)->add(createDataFlowSanitizerPass(ABIListFilesVec));
-}

external/llvm/bindings/go/llvm/InstrumentationBindings.h

@@ -1,38 +0,0 @@
-//===- InstrumentationBindings.h - instrumentation bindings -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines C bindings for the Transforms/Instrumentation component.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BINDINGS_GO_LLVM_INSTRUMENTATIONBINDINGS_H
-#define LLVM_BINDINGS_GO_LLVM_INSTRUMENTATIONBINDINGS_H
-
-#include "llvm-c/Core.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// FIXME: These bindings shouldn't be Go-specific and should eventually move to
-// a (somewhat) less stable collection of C APIs for use in creating bindings of
-// LLVM in other languages.
-
-void LLVMAddAddressSanitizerFunctionPass(LLVMPassManagerRef PM);
-void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM);
-void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM);
-void LLVMAddMemorySanitizerPass(LLVMPassManagerRef PM);
-void LLVMAddDataFlowSanitizerPass(LLVMPassManagerRef PM, int ABIListFilesNum,
-                                  const char **ABIListFiles);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

external/llvm/bindings/go/llvm/SupportBindings.cpp

@@ -1,26 +0,0 @@
-//===- SupportBindings.cpp - Additional bindings for support --------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines additional C bindings for the support component.
-//
-//===----------------------------------------------------------------------===//
-
-#include "SupportBindings.h"
-#include "llvm/Support/DynamicLibrary.h"
-#include <stdlib.h>
-#include <string.h>
-
-void LLVMLoadLibraryPermanently2(const char *Filename, char **ErrMsg) {
-  std::string ErrMsgStr;
-  if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename, &ErrMsgStr)) {
-    *ErrMsg = static_cast<char *>(malloc(ErrMsgStr.size() + 1));
-    memcpy(static_cast<void *>(*ErrMsg),
-           static_cast<const void *>(ErrMsgStr.c_str()), ErrMsgStr.size() + 1);
-  }
-}

external/llvm/bindings/go/llvm/SupportBindings.h

@@ -1,30 +0,0 @@
-//===- SupportBindings.h - Additional bindings for Support ------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines additional C bindings for the Support component.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BINDINGS_GO_LLVM_SUPPORTBINDINGS_H
-#define LLVM_BINDINGS_GO_LLVM_SUPPORTBINDINGS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// This function duplicates the LLVMLoadLibraryPermanently function in the
-// stable C API and adds an extra ErrMsg parameter to retrieve the error
-// message.
-void LLVMLoadLibraryPermanently2(const char *Filename, char **ErrMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

external/llvm/bindings/go/llvm/analysis.go

@@ -1,69 +0,0 @@
-//===- analysis.go - Bindings for analysis --------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines bindings for the analysis component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-/*
-#include "llvm-c/Analysis.h" // If you are getting an error here read bindings/go/README.txt
-#include "llvm-c/Core.h"
-#include <stdlib.h>
-*/
-import "C"
-import "errors"
-
-type VerifierFailureAction C.LLVMVerifierFailureAction
-
-const (
-	// verifier will print to stderr and abort()
-	AbortProcessAction VerifierFailureAction = C.LLVMAbortProcessAction
-	// verifier will print to stderr and return 1
-	PrintMessageAction VerifierFailureAction = C.LLVMPrintMessageAction
-	// verifier will just return 1
-	ReturnStatusAction VerifierFailureAction = C.LLVMReturnStatusAction
-)
-
-// Verifies that a module is valid, taking the specified action if not.
-// Optionally returns a human-readable description of any invalid constructs.
-func VerifyModule(m Module, a VerifierFailureAction) error {
-	var cmsg *C.char
-	broken := C.LLVMVerifyModule(m.C, C.LLVMVerifierFailureAction(a), &cmsg)
-
-	// C++'s verifyModule means isModuleBroken, so it returns false if
-	// there are no errors
-	if broken != 0 {
-		err := errors.New(C.GoString(cmsg))
-		C.LLVMDisposeMessage(cmsg)
-		return err
-	}
-	return nil
-}
-
-var verifyFunctionError = errors.New("Function is broken")
-
-// Verifies that a single function is valid, taking the specified action.
-// Useful for debugging.
-func VerifyFunction(f Value, a VerifierFailureAction) error {
-	broken := C.LLVMVerifyFunction(f.C, C.LLVMVerifierFailureAction(a))
-
-	// C++'s verifyFunction means isFunctionBroken, so it returns false if
-	// there are no errors
-	if broken != 0 {
-		return verifyFunctionError
-	}
-	return nil
-}
-
-// Open up a ghostview window that displays the CFG of the current function.
-// Useful for debugging.
-func ViewFunctionCFG(f Value)     { C.LLVMViewFunctionCFG(f.C) }
-func ViewFunctionCFGOnly(f Value) { C.LLVMViewFunctionCFGOnly(f.C) }

external/llvm/bindings/go/llvm/bitreader.go

@@ -1,51 +0,0 @@
-//===- bitreader.go - Bindings for bitreader ------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines bindings for the bitreader component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-/*
-#include "llvm-c/BitReader.h"
-#include "llvm-c/Core.h"
-#include <stdlib.h>
-*/
-import "C"
-
-import (
-	"errors"
-	"unsafe"
-)
-
-// ParseBitcodeFile parses the LLVM IR (bitcode) in the file with the
-// specified name, and returns a new LLVM module.
-func ParseBitcodeFile(name string) (Module, error) {
-	var buf C.LLVMMemoryBufferRef
-	var errmsg *C.char
-	var cfilename *C.char = C.CString(name)
-	defer C.free(unsafe.Pointer(cfilename))
-	result := C.LLVMCreateMemoryBufferWithContentsOfFile(cfilename, &buf, &errmsg)
-	if result != 0 {
-		err := errors.New(C.GoString(errmsg))
-		C.free(unsafe.Pointer(errmsg))
-		return Module{}, err
-	}
-	defer C.LLVMDisposeMemoryBuffer(buf)
-
-	var m Module
-	if C.LLVMParseBitcode2(buf, &m.C) == 0 {
-		return m, nil
-	}
-
-	err := errors.New(C.GoString(errmsg))
-	C.free(unsafe.Pointer(errmsg))
-	return Module{}, err
-}

external/llvm/bindings/go/llvm/bitwriter.go

@@ -1,39 +0,0 @@
-//===- bitwriter.go - Bindings for bitwriter ------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines bindings for the bitwriter component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-/*
-#include "llvm-c/BitWriter.h"
-#include <stdlib.h>
-*/
-import "C"
-import "os"
-import "errors"
-
-var writeBitcodeToFileErr = errors.New("Failed to write bitcode to file")
-
-func WriteBitcodeToFile(m Module, file *os.File) error {
-	fail := C.LLVMWriteBitcodeToFD(m.C, C.int(file.Fd()), C.int(0), C.int(0))
-	if fail != 0 {
-		return writeBitcodeToFileErr
-	}
-	return nil
-}
-
-func WriteBitcodeToMemoryBuffer(m Module) MemoryBuffer {
-	mb := C.LLVMWriteBitcodeToMemoryBuffer(m.C)
-	return MemoryBuffer{mb}
-}
-
-// TODO(nsf): Figure out way how to make it work with io.Writer

external/llvm/bindings/go/llvm/executionengine.go

@@ -1,178 +0,0 @@
-//===- executionengine.go - Bindings for executionengine ------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines bindings for the executionengine component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-/*
-#include "llvm-c/Core.h"
-#include "llvm-c/ExecutionEngine.h"
-#include <stdlib.h>
-*/
-import "C"
-import "unsafe"
-import "errors"
-
-func LinkInMCJIT()       { C.LLVMLinkInMCJIT() }
-func LinkInInterpreter() { C.LLVMLinkInInterpreter() }
-
-type GenericValue struct {
-	C C.LLVMGenericValueRef
-}
-type ExecutionEngine struct {
-	C C.LLVMExecutionEngineRef
-}
-
-type MCJITCompilerOptions struct {
-	C C.struct_LLVMMCJITCompilerOptions
-}
-
-func (options *MCJITCompilerOptions) SetMCJITOptimizationLevel(level uint) {
-	options.C.OptLevel = C.uint(level)
-}
-
-func (options *MCJITCompilerOptions) SetMCJITNoFramePointerElim(nfp bool) {
-	options.C.NoFramePointerElim = boolToLLVMBool(nfp)
-}
-
-func (options *MCJITCompilerOptions) SetMCJITEnableFastISel(fastisel bool) {
-	options.C.EnableFastISel = boolToLLVMBool(fastisel)
-}
-
-func (options *MCJITCompilerOptions) SetMCJITCodeModel(CodeModel CodeModel) {
-	options.C.CodeModel = C.LLVMCodeModel(CodeModel)
-}
-
-// helpers
-func llvmGenericValueRefPtr(t *GenericValue) *C.LLVMGenericValueRef {
-	return (*C.LLVMGenericValueRef)(unsafe.Pointer(t))
-}
-
-//-------------------------------------------------------------------------
-// llvm.GenericValue
-//-------------------------------------------------------------------------
-
-func NewGenericValueFromInt(t Type, n uint64, signed bool) (g GenericValue) {
-	g.C = C.LLVMCreateGenericValueOfInt(t.C, C.ulonglong(n), boolToLLVMBool(signed))
-	return
-}
-func NewGenericValueFromPointer(p unsafe.Pointer) (g GenericValue) {
-	g.C = C.LLVMCreateGenericValueOfPointer(p)
-	return
-}
-func NewGenericValueFromFloat(t Type, n float64) (g GenericValue) {
-	g.C = C.LLVMCreateGenericValueOfFloat(t.C, C.double(n))
-	return
-}
-func (g GenericValue) IntWidth() int { return int(C.LLVMGenericValueIntWidth(g.C)) }
-func (g GenericValue) Int(signed bool) uint64 {
-	return uint64(C.LLVMGenericValueToInt(g.C, boolToLLVMBool(signed)))
-}
-func (g GenericValue) Float(t Type) float64 {
-	return float64(C.LLVMGenericValueToFloat(t.C, g.C))
-}
-func (g GenericValue) Pointer() unsafe.Pointer {
-	return C.LLVMGenericValueToPointer(g.C)
-}
-func (g GenericValue) Dispose() { C.LLVMDisposeGenericValue(g.C) }
-
-//-------------------------------------------------------------------------
-// llvm.ExecutionEngine
-//-------------------------------------------------------------------------
-
-func NewExecutionEngine(m Module) (ee ExecutionEngine, err error) {
-	var cmsg *C.char
-	fail := C.LLVMCreateExecutionEngineForModule(&ee.C, m.C, &cmsg)
-	if fail != 0 {
-		ee.C = nil
-		err = errors.New(C.GoString(cmsg))
-		C.LLVMDisposeMessage(cmsg)
-	}
-	return
-}
-
-func NewInterpreter(m Module) (ee ExecutionEngine, err error) {
-	var cmsg *C.char
-	fail := C.LLVMCreateInterpreterForModule(&ee.C, m.C, &cmsg)
-	if fail != 0 {
-		ee.C = nil
-		err = errors.New(C.GoString(cmsg))
-		C.LLVMDisposeMessage(cmsg)
-	}
-	return
-}
-
-func NewMCJITCompilerOptions() MCJITCompilerOptions {
-	var options C.struct_LLVMMCJITCompilerOptions
-	C.LLVMInitializeMCJITCompilerOptions(&options, C.size_t(unsafe.Sizeof(C.struct_LLVMMCJITCompilerOptions{})))
-	return MCJITCompilerOptions{options}
-}
-
-func NewMCJITCompiler(m Module, options MCJITCompilerOptions) (ee ExecutionEngine, err error) {
-	var cmsg *C.char
-	fail := C.LLVMCreateMCJITCompilerForModule(&ee.C, m.C, &options.C, C.size_t(unsafe.Sizeof(C.struct_LLVMMCJITCompilerOptions{})), &cmsg)
-	if fail != 0 {
-		ee.C = nil
-		err = errors.New(C.GoString(cmsg))
-		C.LLVMDisposeMessage(cmsg)
-	}
-	return
-}
-
-func (ee ExecutionEngine) Dispose()               { C.LLVMDisposeExecutionEngine(ee.C) }
-func (ee ExecutionEngine) RunStaticConstructors() { C.LLVMRunStaticConstructors(ee.C) }
-func (ee ExecutionEngine) RunStaticDestructors()  { C.LLVMRunStaticDestructors(ee.C) }
-
-func (ee ExecutionEngine) RunFunction(f Value, args []GenericValue) (g GenericValue) {
-	nargs := len(args)
-	var argptr *GenericValue
-	if nargs > 0 {
-		argptr = &args[0]
-	}
-	g.C = C.LLVMRunFunction(ee.C, f.C,
-		C.unsigned(nargs), llvmGenericValueRefPtr(argptr))
-	return
-}
-
-func (ee ExecutionEngine) FreeMachineCodeForFunction(f Value) {
-	C.LLVMFreeMachineCodeForFunction(ee.C, f.C)
-}
-func (ee ExecutionEngine) AddModule(m Module) { C.LLVMAddModule(ee.C, m.C) }
-
-func (ee ExecutionEngine) RemoveModule(m Module) {
-	var modtmp C.LLVMModuleRef
-	C.LLVMRemoveModule(ee.C, m.C, &modtmp, nil)
-}
-
-func (ee ExecutionEngine) FindFunction(name string) (f Value) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-	C.LLVMFindFunction(ee.C, cname, &f.C)
-	return
-}
-
-func (ee ExecutionEngine) RecompileAndRelinkFunction(f Value) unsafe.Pointer {
-	return C.LLVMRecompileAndRelinkFunction(ee.C, f.C)
-}
-
-func (ee ExecutionEngine) TargetData() (td TargetData) {
-	td.C = C.LLVMGetExecutionEngineTargetData(ee.C)
-	return
-}
-
-func (ee ExecutionEngine) AddGlobalMapping(global Value, addr unsafe.Pointer) {
-	C.LLVMAddGlobalMapping(ee.C, global.C, addr)
-}
-
-func (ee ExecutionEngine) PointerToGlobal(global Value) unsafe.Pointer {
-	return C.LLVMGetPointerToGlobal(ee.C, global.C)
-}

external/llvm/bindings/go/llvm/executionengine_test.go

@@ -1,97 +0,0 @@
-//===- executionengine_test.go - Tests for executionengine ----------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file tests bindings for the executionengine component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-import (
-	"testing"
-)
-
-func TestFactorial(t *testing.T) {
-	LinkInMCJIT()
-	InitializeNativeTarget()
-	InitializeNativeAsmPrinter()
-
-	mod := NewModule("fac_module")
-
-	fac_args := []Type{Int32Type()}
-	fac_type := FunctionType(Int32Type(), fac_args, false)
-	fac := AddFunction(mod, "fac", fac_type)
-	fac.SetFunctionCallConv(CCallConv)
-	n := fac.Param(0)
-
-	entry := AddBasicBlock(fac, "entry")
-	iftrue := AddBasicBlock(fac, "iftrue")
-	iffalse := AddBasicBlock(fac, "iffalse")
-	end := AddBasicBlock(fac, "end")
-
-	builder := NewBuilder()
-	defer builder.Dispose()
-
-	builder.SetInsertPointAtEnd(entry)
-	If := builder.CreateICmp(IntEQ, n, ConstInt(Int32Type(), 0, false), "cmptmp")
-	builder.CreateCondBr(If, iftrue, iffalse)
-
-	builder.SetInsertPointAtEnd(iftrue)
-	res_iftrue := ConstInt(Int32Type(), 1, false)
-	builder.CreateBr(end)
-
-	builder.SetInsertPointAtEnd(iffalse)
-	n_minus := builder.CreateSub(n, ConstInt(Int32Type(), 1, false), "subtmp")
-	call_fac_args := []Value{n_minus}
-	call_fac := builder.CreateCall(fac, call_fac_args, "calltmp")
-	res_iffalse := builder.CreateMul(n, call_fac, "multmp")
-	builder.CreateBr(end)
-
-	builder.SetInsertPointAtEnd(end)
-	res := builder.CreatePHI(Int32Type(), "result")
-	phi_vals := []Value{res_iftrue, res_iffalse}
-	phi_blocks := []BasicBlock{iftrue, iffalse}
-	res.AddIncoming(phi_vals, phi_blocks)
-	builder.CreateRet(res)
-
-	err := VerifyModule(mod, ReturnStatusAction)
-	if err != nil {
-		t.Errorf("Error verifying module: %s", err)
-		return
-	}
-
-	options := NewMCJITCompilerOptions()
-	options.SetMCJITOptimizationLevel(2)
-	options.SetMCJITEnableFastISel(true)
-	options.SetMCJITNoFramePointerElim(true)
-	options.SetMCJITCodeModel(CodeModelJITDefault)
-	engine, err := NewMCJITCompiler(mod, options)
-	if err != nil {
-		t.Errorf("Error creating JIT: %s", err)
-		return
-	}
-	defer engine.Dispose()
-
-	pass := NewPassManager()
-	defer pass.Dispose()
-
-	pass.AddConstantPropagationPass()
-	pass.AddInstructionCombiningPass()
-	pass.AddPromoteMemoryToRegisterPass()
-	pass.AddGVNPass()
-	pass.AddCFGSimplificationPass()
-	pass.Run(mod)
-
-	exec_args := []GenericValue{NewGenericValueFromInt(Int32Type(), 10, false)}
-	exec_res := engine.RunFunction(fac, exec_args)
-	var fac10 uint64 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
-	if exec_res.Int(false) != fac10 {
-		t.Errorf("Expected %d, got %d", fac10, exec_res.Int(false))
-	}
-}

external/llvm/bindings/go/llvm/ir_test.go

@@ -1,162 +0,0 @@
-//===- ir_test.go - Tests for ir ------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file tests bindings for the ir component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-import (
-	"strings"
-	"testing"
-)
-
-func testAttribute(t *testing.T, name string) {
-	mod := NewModule("")
-	defer mod.Dispose()
-
-	ftyp := FunctionType(VoidType(), nil, false)
-	fn := AddFunction(mod, "foo", ftyp)
-
-	kind := AttributeKindID(name)
-	attr := mod.Context().CreateEnumAttribute(kind, 0)
-
-	fn.AddFunctionAttr(attr)
-	newattr := fn.GetEnumFunctionAttribute(kind)
-	if attr != newattr {
-		t.Errorf("got attribute mask %d, want %d", newattr, attr)
-	}
-
-	text := mod.String()
-	if !strings.Contains(text, " "+name+" ") {
-		t.Errorf("expected attribute '%s', got:\n%s", name, text)
-	}
-
-	fn.RemoveEnumFunctionAttribute(kind)
-	newattr = fn.GetEnumFunctionAttribute(kind)
-	if !newattr.IsNil() {
-		t.Errorf("got attribute mask %d, want 0", newattr)
-	}
-}
-
-func TestAttributes(t *testing.T) {
-	// Tests that our attribute constants haven't drifted from LLVM's.
-	attrTests := []string{
-		"sanitize_address",
-		"alwaysinline",
-		"builtin",
-		"byval",
-		"convergent",
-		"inalloca",
-		"inlinehint",
-		"inreg",
-		"jumptable",
-		"minsize",
-		"naked",
-		"nest",
-		"noalias",
-		"nobuiltin",
-		"nocapture",
-		"noduplicate",
-		"noimplicitfloat",
-		"noinline",
-		"nonlazybind",
-		"nonnull",
-		"noredzone",
-		"noreturn",
-		"nounwind",
-		"optnone",
-		"optsize",
-		"readnone",
-		"readonly",
-		"returned",
-		"returns_twice",
-		"signext",
-		"safestack",
-		"ssp",
-		"sspreq",
-		"sspstrong",
-		"sret",
-		"sanitize_thread",
-		"sanitize_memory",
-		"uwtable",
-		"zeroext",
-		"cold",
-	}
-
-	for _, name := range attrTests {
-		testAttribute(t, name)
-	}
-}
-
-func TestDebugLoc(t *testing.T) {
-	mod := NewModule("")
-	defer mod.Dispose()
-
-	ctx := mod.Context()
-
-	b := ctx.NewBuilder()
-	defer b.Dispose()
-
-	d := NewDIBuilder(mod)
-	defer func() {
-		d.Destroy()
-	}()
-	file := d.CreateFile("dummy_file", "dummy_dir")
-	voidInfo := d.CreateBasicType(DIBasicType{Name: "void"})
-	typeInfo := d.CreateSubroutineType(DISubroutineType{file, []Metadata{voidInfo}})
-	scope := d.CreateFunction(file, DIFunction{
-		Name:         "foo",
-		LinkageName:  "foo",
-		Line:         10,
-		ScopeLine:    10,
-		Type:         typeInfo,
-		File:         file,
-		IsDefinition: true,
-	})
-
-	b.SetCurrentDebugLocation(10, 20, scope, Metadata{})
-	loc := b.GetCurrentDebugLocation()
-	if loc.Line != 10 {
-		t.Errorf("Got line %d, though wanted 10", loc.Line)
-	}
-	if loc.Col != 20 {
-		t.Errorf("Got column %d, though wanted 20", loc.Col)
-	}
-	if loc.Scope.C != scope.C {
-		t.Errorf("Got metadata %v as scope, though wanted %v", loc.Scope.C, scope.C)
-	}
-}
-
-func TestSubtypes(t *testing.T) {
-	cont := NewContext()
-	defer cont.Dispose()
-
-	int_pointer := PointerType(cont.Int32Type(), 0)
-	int_inner := int_pointer.Subtypes()
-	if len(int_inner) != 1 {
-		t.Errorf("Got size %d, though wanted 1", len(int_inner))
-	}
-	if int_inner[0] != cont.Int32Type() {
-		t.Errorf("Expected int32 type")
-	}
-
-	st_pointer := cont.StructType([]Type{cont.Int32Type(), cont.Int8Type()}, false)
-	st_inner := st_pointer.Subtypes()
-	if len(st_inner) != 2 {
-		t.Errorf("Got size %d, though wanted 2", len(int_inner))
-	}
-	if st_inner[0] != cont.Int32Type() {
-		t.Errorf("Expected first struct field to be int32")
-	}
-	if st_inner[1] != cont.Int8Type() {
-		t.Errorf("Expected second struct field to be int8")
-	}
-}

external/llvm/bindings/go/llvm/linker.go

@@ -1,31 +0,0 @@
-//===- linker.go - Bindings for linker ------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines bindings for the linker component.
-//
-//===----------------------------------------------------------------------===//
-
-package llvm
-
-/*
-#include "llvm-c/Core.h"
-#include "llvm-c/Linker.h"
-#include <stdlib.h>
-*/
-import "C"
-import "errors"
-
-func LinkModules(Dest, Src Module) error {
-	failed := C.LLVMLinkModules2(Dest.C, Src.C)
-	if failed != 0 {
-		err := errors.New("Linking failed")
-		return err
-	}
-	return nil
-}