This is an archive of the discontinued LLVM Phabricator instance.

Differential D5684

Initial version of Go bindings.
ClosedPublic

Authored by pcc on Oct 8 2014, 4:37 PM.

Details

Reviewers
chandlerc
ruiu
Commits
rG82e3e373b3e0: Initial version of Go bindings.
rL219976: Initial version of Go bindings.
Summary

This code is based on the existing LLVM Go bindings project hosted at:
https://github.com/go-llvm/llvm

Note that all contributors to the gollvm project have agreed to relicense
their changes under the LLVM license and submit them to the LLVM project.

Diff Detail

Repository
rL LLVM

Event Timeline

pcc updated this revision to Diff 14609.Oct 8 2014, 4:37 PM
pcc retitled this revision from to Initial version of Go bindings..
pcc updated this object.
pcc edited the test plan for this revision. (Show Details)
pcc added a subscriber: Unknown Object (MLST).
pcc updated this revision to Diff 14752.Oct 10 2014, 3:44 PM
  • Remove unnecessary explicit StringRef conversions
  • Move build script up a level
  • Add entries to .gitignore
pcc updated this revision to Diff 14758.Oct 10 2014, 4:49 PM
  • Add a Go version check
ruiu added a subscriber: ruiu.Oct 10 2014, 5:05 PM

Looks like a straightforward LLVM binding for Go.
Here's my review comments from the perspective of a Go programmer.

bindings/go/llvm/bitreader.go
49 ↗(On Diff #14752)

At line 38 you return Module{}, err. Here you return Module{nil}, err. Are these different?

bindings/go/llvm/dibuilder.go
26 ↗(On Diff #14752)

What is this number?

176 ↗(On Diff #14752)

Do you follow 80 column rule even in Go? We don't have the Go coding style in LLVM, but are you going to set it?

bindings/go/llvm/executionengine.go
40 ↗(On Diff #14752)

I prefer writing

type GenericValue struct {
  ...
}

type ExecutionEngine struct {
  ...
}

instead of grouping them in the type.

87 ↗(On Diff #14752)

You don't need this line

100 ↗(On Diff #14752)

Ditto

119 ↗(On Diff #14752)

Ditto

173 ↗(On Diff #14752)

Remove

bindings/go/llvm/string.go
107 ↗(On Diff #14752)

Remove

bindings/go/llvm/support.go
53 ↗(On Diff #14752)

Throughout this patch, you seems to avoid using defer where possible. Is there any reason behind that decision? It seems to me that this function could be written like this

for i, arg := range args {
  argstr[i] = C.CString(arg)
  defer C.free(unsafe.Pointer(argstr[i]))
}

and

overviewstr := C.CString(overview)
defer C.Free(unsafe.Pointer(ovewviewstr))
bindings/go/llvm/transforms_pmbuilder.go
22 ↗(On Diff #14752)

type PassManagerBuilder struct {

pcc updated this revision to Diff 14825.Oct 13 2014, 2:36 PM
  • Address reviewer comments
bindings/go/llvm/bitreader.go
49 ↗(On Diff #14752)

No. Changed here and elsewhere to be consistent.

bindings/go/llvm/dibuilder.go
26 ↗(On Diff #14752)

It appears to refer to a set of debug info version constants that are no longer used. Removed (and sent D5760 to remove the constants).

176 ↗(On Diff #14752)

To me it seems reasonable to follow the Go coding conventions for Go code in LLVM -- there doesn't seem to be any compelling reason to define our own conventions. I've sent out D5761 which formalizes this.

In this particular case we probably don't need the line break; removed.

bindings/go/llvm/executionengine.go
40 ↗(On Diff #14752)

Done.

87 ↗(On Diff #14752)

Removed.

100 ↗(On Diff #14752)

Ditto

119 ↗(On Diff #14752)

Ditto

173 ↗(On Diff #14752)

Done.

bindings/go/llvm/string.go
107 ↗(On Diff #14752)

Done.

bindings/go/llvm/support.go
53 ↗(On Diff #14752)

That certainly helps with conciseness here; done.

I was not the original author of most of this code, but I agree that it would be useful (and more idiomatic) to start using defer. I went through the code to make it use defer where it made sense.

bindings/go/llvm/transforms_pmbuilder.go
22 ↗(On Diff #14752)

Done.

ruiu accepted this revision.Oct 13 2014, 2:41 PM
ruiu added a reviewer: ruiu.

LGTM. Go code looks good to me.

This revision is now accepted and ready to land.Oct 13 2014, 2:41 PM
chandlerc added a subscriber: chandlerc.Oct 13 2014, 3:08 PM

First pass at the LLVM C++ and build system side.

bindings/go/llvm/bitwriter.cpp
25 ↗(On Diff #14825)

Is there any particular reason to not add this to the existing C APIs?

Also, if it remains, this file should be named with CamelCase. Probably as GoBitWriter or BitWriterBindings.

bindings/go/llvm/dibuilder.cpp
18 ↗(On Diff #14825)

iostreams aren't used in LLVM

bindings/go/llvm/dibuilder.h
10 ↗(On Diff #14825)

This file too should be GoDIBuilderBindings.{h,cpp} or something CamelCased.

Do you think these should be Go-specific, or generic C APIs for bindings? I'm curious how you see this evolving over time.

bindings/go/llvm/ir.h
24–26 ↗(On Diff #14825)

I really thought we already had the C APIs for this... If not, they make a lot of sense to just add.

bindings/go/llvm/support.h
21–24 ↗(On Diff #14825)

These both seem moderately terrifying to expose in the Go bindings. Why were they needed?

bindings/go/llvm/transforms_instrumentation.h
23–28 ↗(On Diff #14825)

I think it would be reasonable to add an 'Instrumentation.h' to llvm-c/Transforms with these in it.

test/Bindings/Go/go.test
1 ↗(On Diff #14825)

Ow.

Is there any way to factor some of this into the lit.local.cfg?

At the least split it into multiple lines with '\' to smash them together?

pcc updated this revision to Diff 14846.Oct 13 2014, 5:44 PM
pcc edited edge metadata.
  • Address review comments
bindings/go/llvm/bitwriter.cpp
25 ↗(On Diff #14825)

Is there any particular reason to not add this to the existing C APIs?

In general, for this change I tried to avoid modifying the C API, mainly because of the stability policy.

That said, this specific function looks fine to add to the C API. Done in r219643.

Also, if it remains, this file should be named with CamelCase. Probably as GoBitWriter or BitWriterBindings.

From the point of view of a maintainer, it's convenient to be able to find the C++ for foo.go in foo.cpp. Also, the coding standards don't seem to prescribe file names. But this isn't a big deal, I'm happy to rename them.

bindings/go/llvm/dibuilder.cpp
18 ↗(On Diff #14825)

Removed. Not sure how that got there.

bindings/go/llvm/dibuilder.h
10 ↗(On Diff #14825)

There's no technical reason why these couldn't be part of the C API, but because of our C API stability policy, I think they should live here for now.

We could consider changing this policy in the future, for example by defining a core 'stable' subset of the C API, but I feel that that discussion should only happen as and when it needs to (e.g. if we add another set of language bindings that expose debug info).

bindings/go/llvm/ir.h
24–26 ↗(On Diff #14825)

We have LLVMAddFunctionAttr etc, but they take a 32-bit attribute value; in particular, we need a 64-bit attribute value to set some of the sanitizer attributes. We could add a 64-bit variant of this function, but it would probably need its own set of constants.

bindings/go/llvm/support.h
21–24 ↗(On Diff #14825)

These were needed to implement -fload-plugin and -mllvm in the Go frontend; despite the problems with them, it is sometimes useful or convenient for Go frontend users or developers to be able to set llvm::cl flags or load plugins from the command line. I'd imagine that if we expose command line flags through some other mechanism in the future, this API would change as well.

bindings/go/llvm/transforms_instrumentation.h
23–28 ↗(On Diff #14825)

I am not sure if we can consider the APIs for these to be stable yet; in particular, there are some changes for DFSan that I have in mind that might change this API.

test/Bindings/Go/go.test
1 ↗(On Diff #14825)

I wanted to keep the command output of lit.cfg copy-pastable if this test fails (at least in most normal situations).

I didn't know (or had forgotten) that you could use '\' on these lines. Changed.

pcc added a comment.Oct 16 2014, 10:14 AM

Ping.

chandlerc added a comment.Oct 16 2014, 11:44 AM

Here are mostly replies to your comments Peter. Looking at the updated patch now...

bindings/go/llvm/bitwriter.cpp
25 ↗(On Diff #14825)

I think I end up on the side of consistency with other C++ code rather than consistency with the Go code. This is probably because I want to see all of the C++ code moved out of the Go bindings and into a common C interface that other bindings can use. =]

I would suggest normal PascalCase file names, and suffixing with 'Bindings' to avoid collisions with the existing files.

bindings/go/llvm/dibuilder.h
10 ↗(On Diff #14825)

Yes, I agree and having talked to others suspect this would be a widely appreciated change. Clearly it can't happen here though.

However, I would structure the code in anticipation of that change and leave comments in the relevant .h files that 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.

That seem like a good path?

15 ↗(On Diff #14825)

I would probably name these LLVM_BINDINGS_GO_LLVM_DIBUILDERBINDINGS_H for consistency... Not a big deal, but 'GOLLVM' seems hard to intuit without knowing the history of the project. =]

26 ↗(On Diff #14825)

The (arguably bad) LLVM convention for C-APIs has been: 'LLVMFooBarBaz'. Considering you're using 'LLVMDIBuilderRef' above, I think it makes sense to go ahead and follow this convention here. Doesn't much matter whether that lands in this patch or in a follow-up though.

bindings/go/llvm/support.h
21–24 ↗(On Diff #14825)

I'm much more comfortable exposing the command line option parsing (until some glorious day when the -mllvm tunables can be set through a saner API). The plugin loading is somewhat concerning to me... Our plugin support is dodgy at best, and surfacing it to frontends is frankly terrifying... but hey, there you go.

I'm actually rather surprised that the plugin loading is best accomplished through LLVM's pretty terrible shared library loading wrapper rather than through native Go interfaces.

For the commandline flags, I would actually be find to put it into the C API. If it changes (when, I hope), it will just become a no-op and a new interface will be provided for setting such flags.

bindings/go/llvm/transforms_instrumentation.h
23–28 ↗(On Diff #14825)

Sure. Same comments as in the DIBuilder case.

chandlerc accepted this revision.Oct 16 2014, 11:51 AM
chandlerc added a reviewer: chandlerc.

I think with the C interface naming tweaks and some other minor stuff this is ready to go in.

If you'd like me to take another look at anything, let me know, otherwise feel free to commit once you've addressed the comments (or refuted them as wrong headed!).

Thanks!

bindings/go/llvm/ir.go
1 ↗(On Diff #14846)

I know its pedantic, but could you capitalize 'IR' when using it as a normal noun in a sentence? (Clearly the Go APIs and files need to remain lower case, just talking about the comments.)

bindings/go/llvm/target.go
210 ↗(On Diff #14846)

nit: There seem to be a mixture of horizontal rule comment styles... I would pick on and be consistent with it.

But maybe there is some Go style thing going on here that I'm just not aware of. If so, ignore me. =]

pcc added inline comments.Oct 16 2014, 3:58 PM
bindings/go/llvm/bitwriter.cpp
25 ↗(On Diff #14825)

Done.

bindings/go/llvm/dibuilder.h
10 ↗(On Diff #14825)

Sounds good, done.

15 ↗(On Diff #14825)

Done.

26 ↗(On Diff #14825)

Done.

bindings/go/llvm/ir.go
1 ↗(On Diff #14846)

Done.

bindings/go/llvm/support.h
21–24 ↗(On Diff #14825)

I'm actually rather surprised that the plugin loading is best accomplished through LLVM's pretty terrible shared library loading wrapper rather than through native Go interfaces.

Go (the language) does not currently support dynamic loading of packages, so there is no standard library function for this. You can call dlopen directly from Go, but that isn't portable (admittedly LLVM's wrapper isn't much better, but I suppose in theory it would know what the "correct" way of loading LLVM plugins is for any given platform).

For the commandline flags, I would actually be find to put it into the C API. If it changes (when, I hope), it will just become a no-op and a new interface will be provided for setting such flags.

Sounds good. I split this out into r219975.

bindings/go/llvm/target.go
210 ↗(On Diff #14846)

Done.

pcc closed this revision.Oct 16 2014, 3:58 PM
pcc updated this revision to Diff 15052.

Closed by commit rL219976 (authored by @pcc).

Revision Contents

PathSize
llvm/
trunk/
6 lines
1 line
autoconf/
19 lines
bindings/
6 lines
go/
53 lines
67 lines
16 lines
llvm/
123 lines
222 lines
37 lines
47 lines
38 lines
42 lines
30 lines
27 lines
68 lines
50 lines
39 lines
492 lines
163 lines
93 lines
1823 lines
95 lines
39 lines
12 lines
19 lines
105 lines
28 lines
54 lines
300 lines
43 lines
42 lines
48 lines
45 lines
3 lines
cmake/
15 lines
modules/
3 lines
64 lines
test/
Bindings/
Go/
8 lines
33 lines
Ocaml/
3 lines
3 lines
1 line
5 lines
utils/
lit/
lit/
2 lines

Diff 15052

llvm/trunk/.gitignore

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
# LLDB, which is tracked independently. # LLDB, which is tracked independently.
tools/lldb tools/lldb
# lld, which is tracked independently. # lld, which is tracked independently.
tools/lld tools/lld
# Polly, which is tracked independently. # Polly, which is tracked independently.
tools/polly tools/polly
# Sphinx build tree, if building in-source dir. # Sphinx build tree, if building in-source dir.
docs/_build docs/_build
#==============================================================================#
# Files created in tree by the Go bindings.
#==============================================================================#
bindings/go/llvm/llvm_config.go
bindings/go/llvm/workdir

llvm/trunk/Makefile.config.in

Show First 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
# Paths to miscellaneous programs we hope are present but might not be # Paths to miscellaneous programs we hope are present but might not be
BZIP2 := @BZIP2@ BZIP2 := @BZIP2@
CAT := @CAT@ CAT := @CAT@
DOT := @DOT@ DOT := @DOT@
DOXYGEN := @DOXYGEN@ DOXYGEN := @DOXYGEN@
GROFF := @GROFF@ GROFF := @GROFF@
GZIPBIN := @GZIPBIN@ GZIPBIN := @GZIPBIN@
GO := @GO@
OCAMLC := @OCAMLC@ OCAMLC := @OCAMLC@
OCAMLOPT := @OCAMLOPT@ OCAMLOPT := @OCAMLOPT@
OCAMLDEP := @OCAMLDEP@ OCAMLDEP := @OCAMLDEP@
OCAMLDOC := @OCAMLDOC@ OCAMLDOC := @OCAMLDOC@
GAS := @GAS@ GAS := @GAS@
POD2HTML := @POD2HTML@ POD2HTML := @POD2HTML@
POD2MAN := @POD2MAN@ POD2MAN := @POD2MAN@
PDFROFF := @PDFROFF@ PDFROFF := @PDFROFF@
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/trunk/autoconf/configure.ac

Show First 20 Lines • Show All 1,281 Lines • ▼ Show 20 Lines
dnl something if the tool was available. dnl something if the tool was available.
AC_PATH_PROG(BZIP2, [bzip2]) AC_PATH_PROG(BZIP2, [bzip2])
AC_PATH_PROG(CAT, [cat]) AC_PATH_PROG(CAT, [cat])
AC_PATH_PROG(DOXYGEN, [doxygen]) AC_PATH_PROG(DOXYGEN, [doxygen])
AC_PATH_PROG(GROFF, [groff]) AC_PATH_PROG(GROFF, [groff])
AC_PATH_PROG(GZIPBIN, [gzip]) AC_PATH_PROG(GZIPBIN, [gzip])
AC_PATH_PROG(PDFROFF, [pdfroff]) AC_PATH_PROG(PDFROFF, [pdfroff])
AC_PATH_PROG(ZIP, [zip]) AC_PATH_PROG(ZIP, [zip])
AC_PATH_PROG(GO, [go])
AC_PATH_PROGS(OCAMLC, [ocamlc]) AC_PATH_PROGS(OCAMLC, [ocamlc])
AC_PATH_PROGS(OCAMLOPT, [ocamlopt]) AC_PATH_PROGS(OCAMLOPT, [ocamlopt])
AC_PATH_PROGS(OCAMLDEP, [ocamldep]) AC_PATH_PROGS(OCAMLDEP, [ocamldep])
AC_PATH_PROGS(OCAMLDOC, [ocamldoc]) AC_PATH_PROGS(OCAMLDOC, [ocamldoc])
AC_PATH_PROGS(GAS, [gas as]) AC_PATH_PROGS(GAS, [gas as])
dnl Get the version of the linker in use. dnl Get the version of the linker in use.
AC_LINK_GET_VERSION AC_LINK_GET_VERSION
▲ Show 20 Lines • Show All 564 Lines • ▼ Show 20 LinesAC_DEFINE_UNQUOTED(LLVM_DEFAULT_TARGET_TRIPLE, "$target",
[Target triple LLVM will generate code for by default]) [Target triple LLVM will generate code for by default])
dnl Determine which bindings to build. dnl Determine which bindings to build.
if test "$BINDINGS_TO_BUILD" = auto ; then if test "$BINDINGS_TO_BUILD" = auto ; then
BINDINGS_TO_BUILD="" BINDINGS_TO_BUILD=""
if test "x$OCAMLC" != x -a "x$OCAMLDEP" != x ; then if test "x$OCAMLC" != x -a "x$OCAMLDEP" != x ; then
BINDINGS_TO_BUILD="ocaml $BINDINGS_TO_BUILD" BINDINGS_TO_BUILD="ocaml $BINDINGS_TO_BUILD"
fi fi
if test "x$GO" != x ; then
if $GO run ${srcdir}/bindings/go/conftest.go ; then
BINDINGS_TO_BUILD="go $BINDINGS_TO_BUILD"
fi
fi
fi fi
AC_SUBST(BINDINGS_TO_BUILD,$BINDINGS_TO_BUILD) AC_SUBST(BINDINGS_TO_BUILD,$BINDINGS_TO_BUILD)
dnl Do any work necessary to ensure that bindings have what they need. dnl Do any work necessary to ensure that bindings have what they need.
binding_prereqs_failed=0 binding_prereqs_failed=0
for a_binding in $BINDINGS_TO_BUILD ; do for a_binding in $BINDINGS_TO_BUILD ; do
case "$a_binding" in case "$a_binding" in
ocaml) ocaml)
Show All 18 Lines else
# ocaml stdlib is beneath our prefix; use stdlib # ocaml stdlib is beneath our prefix; use stdlib
AC_SUBST(OCAML_LIBDIR,$ocaml_stdlib) AC_SUBST(OCAML_LIBDIR,$ocaml_stdlib)
else else
# ocaml stdlib is outside our prefix; use libdir/ocaml # ocaml stdlib is outside our prefix; use libdir/ocaml
AC_SUBST(OCAML_LIBDIR,${prefix}/lib/ocaml) AC_SUBST(OCAML_LIBDIR,${prefix}/lib/ocaml)
fi fi
fi fi
;; ;;
go)
if test "x$GO" = x ; then
AC_MSG_WARN([--enable-bindings=go specified, but go not found. Try configure GO=/path/to/go])
binding_prereqs_failed=1
else
if $GO run ${srcdir}/bindings/go/conftest.go ; then
:
else
AC_MSG_WARN([--enable-bindings=go specified, but need at least Go 1.2. Try configure GO=/path/to/go])
binding_prereqs_failed=1
fi
fi
;;
esac esac
done done
if test "$binding_prereqs_failed" = 1 ; then if test "$binding_prereqs_failed" = 1 ; then
AC_MSG_ERROR([Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings.]) AC_MSG_ERROR([Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings.])
fi fi
dnl Determine whether the compiler supports -fvisibility-inlines-hidden. dnl Determine whether the compiler supports -fvisibility-inlines-hidden.
AC_CXX_USE_VISIBILITY_INLINES_HIDDEN AC_CXX_USE_VISIBILITY_INLINES_HIDDEN
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/trunk/bindings/Makefile

##===- bindings/Makefile -----------------------------------*- Makefile -*-===## ##===- bindings/Makefile -----------------------------------*- Makefile -*-===##
# #
# The LLVM Compiler Infrastructure # The LLVM Compiler Infrastructure
# #
# This file is distributed under the University of Illinois Open Source # This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details. # License. See LICENSE.TXT for details.
# #
##===----------------------------------------------------------------------===## ##===----------------------------------------------------------------------===##
LEVEL := .. LEVEL := ..
include $(LEVEL)/Makefile.config include $(LEVEL)/Makefile.config
PARALLEL_DIRS = $(BINDINGS_TO_BUILD) PARALLEL_DIRS =
ifneq (,$(filter ocaml,$(BINDINGS_TO_BUILD)))
PARALLEL_DIRS += ocaml
endif
include $(LEVEL)/Makefile.common include $(LEVEL)/Makefile.common

llvm/trunk/bindings/go/README.txt

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

llvm/trunk/bindings/go/build.sh

PropertyOld ValueNew Value
svn:executablenull*
#!/bin/sh -xe
llvm_components="\
all-targets \
analysis \
asmparser \
asmprinter \
bitreader \
bitwriter \
codegen \
core \
debuginfo \
executionengine \
instrumentation \
interpreter \
ipo \
irreader \
linker \
mc \
mcjit \
objcarcopts \
option \
profiledata \
scalaropts \
support \
target \
"
if [ "$1" == "--print-components" ] ; then
echo $llvm_components
exit 0
fi
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"
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_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_version="$($llvm_config --version)"
llvm_cflags="$($llvm_config --cppflags)"
llvm_ldflags="$($llvm_config --ldflags) $($llvm_config --libs $llvm_components) $($llvm_config --system-libs)"
if [ $(uname) != "Darwin" ]; then
# OS X doesn't like -rpath with cgo. See:
# https://code.google.com/p/go/issues/detail?id=7293
llvm_ldflags="-Wl,-rpath,$($llvm_config --libdir) $llvm_ldflags"
fi
sed -e "s#@LLVM_CFLAGS@#$llvm_cflags#g; s#@LLVM_LDFLAGS@#$llvm_ldflags#g" $gollvmdir/llvm_config.go.in > \
$gollvmdir/llvm_config.go
printf "package llvm\n\nconst Version = \"%s\"\n" "$llvm_version" > $gollvmdir/version.go

llvm/trunk/bindings/go/conftest.go

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)
}

llvm/trunk/bindings/go/llvm/DIBuilderBindings.h

//===- 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 "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.
typedef struct LLVMOpaqueDIBuilder *LLVMDIBuilderRef;
LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef m);
void LLVMDIBuilderDestroy(LLVMDIBuilderRef d);
void LLVMDIBuilderFinalize(LLVMDIBuilderRef d);
LLVMValueRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef D,
unsigned Language, const char *File,
const char *Dir,
const char *Producer, int Optimized,
const char *Flags,
unsigned RuntimeVersion);
LLVMValueRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef D, const char *File,
const char *Dir);
LLVMValueRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef D,
LLVMValueRef Scope,
LLVMValueRef File, unsigned Line,
unsigned Column);
LLVMValueRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef D,
LLVMValueRef Scope,
LLVMValueRef File,
unsigned Discriminator);
LLVMValueRef LLVMDIBuilderCreateFunction(
LLVMDIBuilderRef D, LLVMValueRef Scope, const char *Name,
const char *LinkageName, LLVMValueRef File, unsigned Line,
LLVMValueRef CompositeType, int IsLocalToUnit, int IsDefinition,
unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Function);
LLVMValueRef LLVMDIBuilderCreateLocalVariable(
LLVMDIBuilderRef D, unsigned Tag, LLVMValueRef Scope, const char *Name,
LLVMValueRef File, unsigned Line, LLVMValueRef Ty, int AlwaysPreserve,
unsigned Flags, unsigned ArgNo);
LLVMValueRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef D, const char *Name,
uint64_t SizeInBits,
uint64_t AlignInBits,
unsigned Encoding);
LLVMValueRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef D,
LLVMValueRef PointeeType,
uint64_t SizeInBits,
uint64_t AlignInBits,
const char *Name);
LLVMValueRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef D,
LLVMValueRef File,
LLVMValueRef ParameterTypes);
LLVMValueRef LLVMDIBuilderCreateStructType(
LLVMDIBuilderRef D, LLVMValueRef Scope, const char *Name, LLVMValueRef File,
unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
LLVMValueRef DerivedFrom, LLVMValueRef ElementTypes);
LLVMValueRef LLVMDIBuilderCreateMemberType(
LLVMDIBuilderRef D, LLVMValueRef Scope, const char *Name, LLVMValueRef File,
unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags, LLVMValueRef Ty);
LLVMValueRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef D,
uint64_t SizeInBits,
uint64_t AlignInBits,
LLVMValueRef ElementType,
LLVMValueRef Subscripts);
LLVMValueRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef D, LLVMValueRef Ty,
const char *Name, LLVMValueRef File,
unsigned Line, LLVMValueRef Context);
LLVMValueRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef D, int64_t Lo,
int64_t Count);
LLVMValueRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef D,
LLVMValueRef *Data, size_t Length);
LLVMValueRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef D,
LLVMValueRef *Data,
size_t Length);
LLVMValueRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref, int64_t *Addr,
size_t Length);
LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef D,
LLVMValueRef Storage,
LLVMValueRef VarInfo,
LLVMValueRef Expr,
LLVMBasicBlockRef Block);
#ifdef __cplusplus
} // extern "C"
#endif
#endif

llvm/trunk/bindings/go/llvm/DIBuilderBindings.cpp

//===- 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 "llvm/IR/Module.h"
#include "llvm/IR/DIBuilder.h"
using namespace llvm;
namespace {
template <typename T>
T unwrapDI(LLVMValueRef v) {
return v ? T(unwrap<MDNode>(v)) : T();
}
}
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DIBuilder, LLVMDIBuilderRef)
LLVMDIBuilderRef LLVMNewDIBuilder(LLVMModuleRef mref) {
Module *m = unwrap(mref);
return wrap(new DIBuilder(*m));
}
void LLVMDIBuilderDestroy(LLVMDIBuilderRef dref) {
DIBuilder *d = unwrap(dref);
delete d;
}
void LLVMDIBuilderFinalize(LLVMDIBuilderRef dref) { unwrap(dref)->finalize(); }
LLVMValueRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Dref,
unsigned Lang, const char *File,
const char *Dir,
const char *Producer, int Optimized,
const char *Flags,
unsigned RuntimeVersion) {
DIBuilder *D = unwrap(Dref);
DICompileUnit CU = D->createCompileUnit(Lang, File, Dir, Producer, Optimized,
Flags, RuntimeVersion);
return wrap(CU);
}
LLVMValueRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Dref, const char *File,
const char *Dir) {
DIBuilder *D = unwrap(Dref);
DIFile F = D->createFile(File, Dir);
return wrap(F);
}
LLVMValueRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
LLVMValueRef Scope,
LLVMValueRef File, unsigned Line,
unsigned Column) {
DIBuilder *D = unwrap(Dref);
DILexicalBlock LB = D->createLexicalBlock(
unwrapDI<DIDescriptor>(Scope), unwrapDI<DIFile>(File), Line, Column);
return wrap(LB);
}
LLVMValueRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
LLVMValueRef Scope,
LLVMValueRef File,
unsigned Discriminator) {
DIBuilder *D = unwrap(Dref);
DILexicalBlockFile LBF = D->createLexicalBlockFile(
unwrapDI<DIDescriptor>(Scope), unwrapDI<DIFile>(File), Discriminator);
return wrap(LBF);
}
LLVMValueRef LLVMDIBuilderCreateFunction(
LLVMDIBuilderRef Dref, LLVMValueRef Scope, const char *Name,
const char *LinkageName, LLVMValueRef File, unsigned Line,
LLVMValueRef CompositeType, int IsLocalToUnit, int IsDefinition,
unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
DIBuilder *D = unwrap(Dref);
DISubprogram SP = D->createFunction(
unwrapDI<DIDescriptor>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
Line, unwrapDI<DICompositeType>(CompositeType), IsLocalToUnit,
IsDefinition, ScopeLine, Flags, IsOptimized, unwrap<Function>(Func));
return wrap(SP);
}
LLVMValueRef LLVMDIBuilderCreateLocalVariable(
LLVMDIBuilderRef Dref, unsigned Tag, LLVMValueRef Scope, const char *Name,
LLVMValueRef File, unsigned Line, LLVMValueRef Ty, int AlwaysPreserve,
unsigned Flags, unsigned ArgNo) {
DIBuilder *D = unwrap(Dref);
DIVariable V = D->createLocalVariable(
Tag, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
unwrapDI<DIType>(Ty), AlwaysPreserve, Flags, ArgNo);
return wrap(V);
}
LLVMValueRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
const char *Name, uint64_t SizeInBits,
uint64_t AlignInBits,
unsigned Encoding) {
DIBuilder *D = unwrap(Dref);
DIBasicType T = D->createBasicType(Name, SizeInBits, AlignInBits, Encoding);
return wrap(T);
}
LLVMValueRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
LLVMValueRef PointeeType,
uint64_t SizeInBits,
uint64_t AlignInBits,
const char *Name) {
DIBuilder *D = unwrap(Dref);
DIDerivedType T = D->createPointerType(unwrapDI<DIType>(PointeeType),
SizeInBits, AlignInBits, Name);
return wrap(T);
}
LLVMValueRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref,
LLVMValueRef File,
LLVMValueRef ParameterTypes) {
DIBuilder *D = unwrap(Dref);
DICompositeType CT = D->createSubroutineType(
unwrapDI<DIFile>(File), unwrapDI<DITypeArray>(ParameterTypes));
return wrap(CT);
}
LLVMValueRef LLVMDIBuilderCreateStructType(
LLVMDIBuilderRef Dref, LLVMValueRef Scope, const char *Name,
LLVMValueRef File, unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
unsigned Flags, LLVMValueRef DerivedFrom, LLVMValueRef ElementTypes) {
DIBuilder *D = unwrap(Dref);
DICompositeType CT = D->createStructType(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
SizeInBits, AlignInBits, Flags, unwrapDI<DIType>(DerivedFrom),
unwrapDI<DIArray>(ElementTypes));
return wrap(CT);
}
LLVMValueRef LLVMDIBuilderCreateMemberType(
LLVMDIBuilderRef Dref, LLVMValueRef Scope, const char *Name,
LLVMValueRef File, unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags, LLVMValueRef Ty) {
DIBuilder *D = unwrap(Dref);
DIDerivedType DT = D->createMemberType(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), Line,
SizeInBits, AlignInBits, OffsetInBits, Flags, unwrapDI<DIType>(Ty));
return wrap(DT);
}
LLVMValueRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
uint64_t SizeInBits,
uint64_t AlignInBits,
LLVMValueRef ElementType,
LLVMValueRef Subscripts) {
DIBuilder *D = unwrap(Dref);
DICompositeType CT =
D->createArrayType(SizeInBits, AlignInBits, unwrapDI<DIType>(ElementType),
unwrapDI<DIArray>(Subscripts));
return wrap(CT);
}
LLVMValueRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref, LLVMValueRef Ty,
const char *Name, LLVMValueRef File,
unsigned Line, LLVMValueRef Context) {
DIBuilder *D = unwrap(Dref);
DIDerivedType DT =
D->createTypedef(unwrapDI<DIType>(Ty), Name, unwrapDI<DIFile>(File), Line,
unwrapDI<DIDescriptor>(Context));
return wrap(DT);
}
LLVMValueRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Dref, int64_t Lo,
int64_t Count) {
DIBuilder *D = unwrap(Dref);
DISubrange S = D->getOrCreateSubrange(Lo, Count);
return wrap(S);
}
LLVMValueRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Dref,
LLVMValueRef *Data, size_t Length) {
DIBuilder *D = unwrap(Dref);
Value **DataValue = unwrap(Data);
ArrayRef<Value *> Elements(DataValue, Length);
DIArray A = D->getOrCreateArray(Elements);
return wrap(A);
}
LLVMValueRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
LLVMValueRef *Data,
size_t Length) {
DIBuilder *D = unwrap(Dref);
Value **DataValue = unwrap(Data);
ArrayRef<Value *> Elements(DataValue, Length);
DITypeArray A = D->getOrCreateTypeArray(Elements);
return wrap(A);
}
LLVMValueRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Dref, int64_t *Addr,
size_t Length) {
DIBuilder *D = unwrap(Dref);
DIExpression Expr = D->createExpression(ArrayRef<int64_t>(Addr, Length));
return wrap(Expr);
}
LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Dref,
LLVMValueRef Storage,
LLVMValueRef VarInfo,
LLVMValueRef Expr,
LLVMBasicBlockRef Block) {
DIBuilder *D = unwrap(Dref);
Instruction *Instr =
D->insertDeclare(unwrap(Storage), unwrapDI<DIVariable>(VarInfo),
unwrapDI<DIExpression>(Expr), unwrap(Block));
return wrap(Instr);
}

llvm/trunk/bindings/go/llvm/IRBindings.h

//===- 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"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
// These functions duplicate the LLVM*FunctionAttr functions in the stable C
// API. We cannot use the existing functions because they take 32-bit attribute
// values, and the Go bindings expose all of the LLVM attributes, some of which
// have values >= 1<<32.
void LLVMAddFunctionAttr2(LLVMValueRef Fn, uint64_t PA);
uint64_t LLVMGetFunctionAttr2(LLVMValueRef Fn);
void LLVMRemoveFunctionAttr2(LLVMValueRef Fn, uint64_t PA);
#ifdef __cplusplus
}
#endif
#endif

llvm/trunk/bindings/go/llvm/IRBindings.cpp

//===- 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/Function.h"
using namespace llvm;
void LLVMAddFunctionAttr2(LLVMValueRef Fn, uint64_t PA) {
Function *Func = unwrap<Function>(Fn);
const AttributeSet PAL = Func->getAttributes();
AttrBuilder B(PA);
const AttributeSet PALnew =
PAL.addAttributes(Func->getContext(), AttributeSet::FunctionIndex,
AttributeSet::get(Func->getContext(),
AttributeSet::FunctionIndex, B));
Func->setAttributes(PALnew);
}
uint64_t LLVMGetFunctionAttr2(LLVMValueRef Fn) {
Function *Func = unwrap<Function>(Fn);
const AttributeSet PAL = Func->getAttributes();
return PAL.Raw(AttributeSet::FunctionIndex);
}
void LLVMRemoveFunctionAttr2(LLVMValueRef Fn, uint64_t PA) {
Function *Func = unwrap<Function>(Fn);
const AttributeSet PAL = Func->getAttributes();
AttrBuilder B(PA);
const AttributeSet PALnew =
PAL.removeAttributes(Func->getContext(), AttributeSet::FunctionIndex,
AttributeSet::get(Func->getContext(),
AttributeSet::FunctionIndex, B));
Func->setAttributes(PALnew);
}

llvm/trunk/bindings/go/llvm/InstrumentationBindings.h

//===- 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,
const char *ABIListFile);
#ifdef __cplusplus
}
#endif
#endif

llvm/trunk/bindings/go/llvm/InstrumentationBindings.cpp

//===- 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/Module.h"
#include "llvm/PassManager.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,
const char *ABIListFile) {
unwrap(PM)->add(createDataFlowSanitizerPass(ABIListFile));
}

llvm/trunk/bindings/go/llvm/SupportBindings.h

//===- 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

llvm/trunk/bindings/go/llvm/SupportBindings.cpp

//===- 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);
}
}

llvm/trunk/bindings/go/llvm/analysis.go

//===- 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 <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) }

llvm/trunk/bindings/go/llvm/bitreader.go

//===- 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 <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.LLVMParseBitcode(buf, &m.C, &errmsg) == 0 {
return m, nil
}
err := errors.New(C.GoString(errmsg))
C.free(unsafe.Pointer(errmsg))
return Module{}, err
}

llvm/trunk/bindings/go/llvm/bitwriter.go

//===- 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

llvm/trunk/bindings/go/llvm/dibuilder.go

//===- dibuilder.go - 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 bindings for the DIBuilder class.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "DIBuilderBindings.h"
#include <stdlib.h>
*/
import "C"
import (
"debug/dwarf"
"unsafe"
)
type DwarfTag uint32
const (
DW_TAG_lexical_block DwarfTag = 0x0b
DW_TAG_compile_unit DwarfTag = 0x11
DW_TAG_variable DwarfTag = 0x34
DW_TAG_base_type DwarfTag = 0x24
DW_TAG_pointer_type DwarfTag = 0x0F
DW_TAG_structure_type DwarfTag = 0x13
DW_TAG_subroutine_type DwarfTag = 0x15
DW_TAG_file_type DwarfTag = 0x29
DW_TAG_subprogram DwarfTag = 0x2E
DW_TAG_auto_variable DwarfTag = 0x100
DW_TAG_arg_variable DwarfTag = 0x101
)
const (
FlagPrivate = 1 << iota
FlagProtected
FlagFwdDecl
FlagAppleBlock
FlagBlockByrefStruct
FlagVirtual
FlagArtificial
FlagExplicit
FlagPrototyped
FlagObjcClassComplete
FlagObjectPointer
FlagVector
FlagStaticMember
FlagIndirectVariable
)
type DwarfLang uint32
const (
// http://dwarfstd.org/ShowIssue.php?issue=101014.1&type=open
DW_LANG_Go DwarfLang = 0x0016
)
type DwarfTypeEncoding uint32
const (
DW_ATE_address DwarfTypeEncoding = 0x01
DW_ATE_boolean DwarfTypeEncoding = 0x02
DW_ATE_complex_float DwarfTypeEncoding = 0x03
DW_ATE_float DwarfTypeEncoding = 0x04
DW_ATE_signed DwarfTypeEncoding = 0x05
DW_ATE_signed_char DwarfTypeEncoding = 0x06
DW_ATE_unsigned DwarfTypeEncoding = 0x07
DW_ATE_unsigned_char DwarfTypeEncoding = 0x08
DW_ATE_imaginary_float DwarfTypeEncoding = 0x09
DW_ATE_packed_decimal DwarfTypeEncoding = 0x0a
DW_ATE_numeric_string DwarfTypeEncoding = 0x0b
DW_ATE_edited DwarfTypeEncoding = 0x0c
DW_ATE_signed_fixed DwarfTypeEncoding = 0x0d
DW_ATE_unsigned_fixed DwarfTypeEncoding = 0x0e
DW_ATE_decimal_float DwarfTypeEncoding = 0x0f
DW_ATE_UTF DwarfTypeEncoding = 0x10
DW_ATE_lo_user DwarfTypeEncoding = 0x80
DW_ATE_hi_user DwarfTypeEncoding = 0xff
)
// DIBuilder is a wrapper for the LLVM DIBuilder class.
type DIBuilder struct {
ref C.LLVMDIBuilderRef
m Module
}
// NewDIBuilder creates a new DIBuilder, associated with the given module.
func NewDIBuilder(m Module) *DIBuilder {
d := C.LLVMNewDIBuilder(m.C)
return &DIBuilder{ref: d, m: m}
}
// Destroy destroys the DIBuilder.
func (d *DIBuilder) Destroy() {
C.LLVMDIBuilderDestroy(d.ref)
}
// FInalize finalizes the debug information generated by the DIBuilder.
func (d *DIBuilder) Finalize() {
C.LLVMDIBuilderFinalize(d.ref)
}
// DICompileUnit holds the values for creating compile unit debug metadata.
type DICompileUnit struct {
Language DwarfLang
File string
Dir string
Producer string
Optimized bool
Flags string
RuntimeVersion int
}
// CreateCompileUnit creates compile unit debug metadata.
func (d *DIBuilder) CreateCompileUnit(cu DICompileUnit) Value {
file := C.CString(cu.File)
defer C.free(unsafe.Pointer(file))
dir := C.CString(cu.Dir)
defer C.free(unsafe.Pointer(dir))
producer := C.CString(cu.Producer)
defer C.free(unsafe.Pointer(producer))
flags := C.CString(cu.Flags)
defer C.free(unsafe.Pointer(flags))
result := C.LLVMDIBuilderCreateCompileUnit(
d.ref,
C.unsigned(cu.Language),
file, dir,
producer,
boolToCInt(cu.Optimized),
flags,
C.unsigned(cu.RuntimeVersion),
)
return Value{C: result}
}
// CreateCompileUnit creates file debug metadata.
func (d *DIBuilder) CreateFile(filename, dir string) Value {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
cdir := C.CString(dir)
defer C.free(unsafe.Pointer(cdir))
result := C.LLVMDIBuilderCreateFile(d.ref, cfilename, cdir)
return Value{C: result}
}
// DILexicalBlock holds the values for creating lexical block debug metadata.
type DILexicalBlock struct {
File Value
Line int
Column int
}
// CreateCompileUnit creates lexical block debug metadata.
func (d *DIBuilder) CreateLexicalBlock(diScope Value, b DILexicalBlock) Value {
result := C.LLVMDIBuilderCreateLexicalBlock(
d.ref,
diScope.C,
b.File.C,
C.unsigned(b.Line),
C.unsigned(b.Column),
)
return Value{C: result}
}
func (d *DIBuilder) CreateLexicalBlockFile(diScope Value, diFile Value, discriminator int) Value {
result := C.LLVMDIBuilderCreateLexicalBlockFile(d.ref, diScope.C, diFile.C,
C.unsigned(discriminator))
return Value{C: result}
}
// DIFunction holds the values for creating function debug metadata.
type DIFunction struct {
Name string
LinkageName string
File Value
Line int
Type Value
LocalToUnit bool
IsDefinition bool
ScopeLine int
Flags int
Optimized bool
Function Value
}
// CreateCompileUnit creates function debug metadata.
func (d *DIBuilder) CreateFunction(diScope Value, f DIFunction) Value {
name := C.CString(f.Name)
defer C.free(unsafe.Pointer(name))
linkageName := C.CString(f.LinkageName)
defer C.free(unsafe.Pointer(linkageName))
result := C.LLVMDIBuilderCreateFunction(
d.ref,
diScope.C,
name,
linkageName,
f.File.C,
C.unsigned(f.Line),
f.Type.C,
boolToCInt(f.LocalToUnit),
boolToCInt(f.IsDefinition),
C.unsigned(f.ScopeLine),
C.unsigned(f.Flags),
boolToCInt(f.Optimized),
f.Function.C,
)
return Value{C: result}
}
// DILocalVariable holds the values for creating local variable debug metadata.
type DILocalVariable struct {
Tag dwarf.Tag
Name string
File Value
Line int
Type Value
AlwaysPreserve bool
Flags int
// ArgNo is the 1-based index of the argument in the function's
// parameter list if it is an argument, or 0 otherwise.
ArgNo int
}
// CreateLocalVariable creates local variable debug metadata.
func (d *DIBuilder) CreateLocalVariable(scope Value, v DILocalVariable) Value {
name := C.CString(v.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreateLocalVariable(
d.ref,
C.unsigned(v.Tag),
scope.C,
name,
v.File.C,
C.unsigned(v.Line),
v.Type.C,
boolToCInt(v.AlwaysPreserve),
C.unsigned(v.Flags),
C.unsigned(v.ArgNo),
)
return Value{C: result}
}
// DIBasicType holds the values for creating basic type debug metadata.
type DIBasicType struct {
Name string
SizeInBits uint64
AlignInBits uint64
Encoding DwarfTypeEncoding
}
// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreateBasicType(t DIBasicType) Value {
name := C.CString(t.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreateBasicType(
d.ref,
name,
C.uint64_t(t.SizeInBits),
C.uint64_t(t.AlignInBits),
C.unsigned(t.Encoding),
)
return Value{C: result}
}
// DIPointerType holds the values for creating pointer type debug metadata.
type DIPointerType struct {
Pointee Value
SizeInBits uint64
AlignInBits uint64 // optional
Name string // optional
}
// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreatePointerType(t DIPointerType) Value {
name := C.CString(t.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreatePointerType(
d.ref,
t.Pointee.C,
C.uint64_t(t.SizeInBits),
C.uint64_t(t.AlignInBits),
name,
)
return Value{C: result}
}
// DISubroutineType holds the values for creating subroutine type debug metadata.
type DISubroutineType struct {
// File is the file in which the subroutine type is defined.
File Value
// Parameters contains the subroutine parameter types,
// including the return type at the 0th index.
Parameters []Value
}
// CreateSubroutineType creates subroutine type debug metadata.
func (d *DIBuilder) CreateSubroutineType(t DISubroutineType) Value {
params := d.getOrCreateTypeArray(t.Parameters)
result := C.LLVMDIBuilderCreateSubroutineType(d.ref, t.File.C, params.C)
return Value{C: result}
}
// DIStructType holds the values for creating struct type debug metadata.
type DIStructType struct {
Name string
File Value
Line int
SizeInBits uint64
AlignInBits uint64
Flags int
DerivedFrom Value
Elements []Value
}
// CreateStructType creates struct type debug metadata.
func (d *DIBuilder) CreateStructType(scope Value, t DIStructType) Value {
elements := d.getOrCreateArray(t.Elements)
name := C.CString(t.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreateStructType(
d.ref,
scope.C,
name,
t.File.C,
C.unsigned(t.Line),
C.uint64_t(t.SizeInBits),
C.uint64_t(t.AlignInBits),
C.unsigned(t.Flags),
t.DerivedFrom.C,
elements.C,
)
return Value{C: result}
}
// DIMemberType holds the values for creating member type debug metadata.
type DIMemberType struct {
Name string
File Value
Line int
SizeInBits uint64
AlignInBits uint64
OffsetInBits uint64
Flags int
Type Value
}
// CreateMemberType creates struct type debug metadata.
func (d *DIBuilder) CreateMemberType(scope Value, t DIMemberType) Value {
name := C.CString(t.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreateMemberType(
d.ref,
scope.C,
name,
t.File.C,
C.unsigned(t.Line),
C.uint64_t(t.SizeInBits),
C.uint64_t(t.AlignInBits),
C.uint64_t(t.OffsetInBits),
C.unsigned(t.Flags),
t.Type.C,
)
return Value{C: result}
}
// DISubrange describes an integer value range.
type DISubrange struct {
Lo int64
Count int64
}
// DIArrayType holds the values for creating array type debug metadata.
type DIArrayType struct {
SizeInBits uint64
AlignInBits uint64
ElementType Value
Subscripts []DISubrange
}
// CreateArrayType creates struct type debug metadata.
func (d *DIBuilder) CreateArrayType(t DIArrayType) Value {
subscriptsSlice := make([]Value, len(t.Subscripts))
for i, s := range t.Subscripts {
subscriptsSlice[i] = d.getOrCreateSubrange(s.Lo, s.Count)
}
subscripts := d.getOrCreateArray(subscriptsSlice)
result := C.LLVMDIBuilderCreateArrayType(
d.ref,
C.uint64_t(t.SizeInBits),
C.uint64_t(t.AlignInBits),
t.ElementType.C,
subscripts.C,
)
return Value{C: result}
}
// DITypedef holds the values for creating typedef type debug metadata.
type DITypedef struct {
Type Value
Name string
File Value
Line int
Context Value
}
// CreateTypedef creates typedef type debug metadata.
func (d *DIBuilder) CreateTypedef(t DITypedef) Value {
name := C.CString(t.Name)
defer C.free(unsafe.Pointer(name))
result := C.LLVMDIBuilderCreateTypedef(
d.ref,
t.Type.C,
name,
t.File.C,
C.unsigned(t.Line),
t.Context.C,
)
return Value{C: result}
}
// getOrCreateSubrange gets a metadata node for the specified subrange,
// creating if required.
func (d *DIBuilder) getOrCreateSubrange(lo, count int64) Value {
result := C.LLVMDIBuilderGetOrCreateSubrange(d.ref, C.int64_t(lo), C.int64_t(count))
return Value{C: result}
}
// getOrCreateArray gets a metadata node containing the specified values,
// creating if required.
func (d *DIBuilder) getOrCreateArray(values []Value) Value {
if len(values) == 0 {
return Value{}
}
var data *C.LLVMValueRef
length := len(values)
if length > 0 {
data = &values[0].C
}
result := C.LLVMDIBuilderGetOrCreateArray(d.ref, data, C.size_t(length))
return Value{C: result}
}
// getOrCreateTypeArray gets a metadata node for a type array containing the
// specified values, creating if required.
func (d *DIBuilder) getOrCreateTypeArray(values []Value) Value {
if len(values) == 0 {
return Value{}
}
var data *C.LLVMValueRef
length := len(values)
if length > 0 {
data = &values[0].C
}
result := C.LLVMDIBuilderGetOrCreateTypeArray(d.ref, data, C.size_t(length))
return Value{C: result}
}
// CreateExpression creates a new descriptor for the specified
// variable which has a complex address expression for its address.
func (d *DIBuilder) CreateExpression(addr []int64) Value {
var data *C.int64_t
if len(addr) > 0 {
data = (*C.int64_t)(unsafe.Pointer(&addr[0]))
}
result := C.LLVMDIBuilderCreateExpression(d.ref, data, C.size_t(len(addr)))
return Value{C: result}
}
// InsertDeclareAtEnd inserts a call to llvm.dbg.declare at the end of the
// specified basic block for the given value and associated debug metadata.
func (d *DIBuilder) InsertDeclareAtEnd(v, diVarInfo, expr Value, bb BasicBlock) Value {
result := C.LLVMDIBuilderInsertDeclareAtEnd(d.ref, v.C, diVarInfo.C, expr.C, bb.C)
return Value{C: result}
}
func boolToCInt(v bool) C.int {
if v {
return 1
}
return 0
}

llvm/trunk/bindings/go/llvm/executionengine.go

//===- 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/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 {
OptLevel uint
CodeModel CodeModel
NoFramePointerElim bool
EnableFastISel bool
}
// 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 NewMCJITCompiler(m Module, options MCJITCompilerOptions) (ee ExecutionEngine, err error) {
var cmsg *C.char
copts := C.struct_LLVMMCJITCompilerOptions{
OptLevel: C.unsigned(options.OptLevel),
CodeModel: C.LLVMCodeModel(options.CodeModel),
NoFramePointerElim: boolToLLVMBool(options.NoFramePointerElim),
EnableFastISel: boolToLLVMBool(options.EnableFastISel),
}
fail := C.LLVMCreateMCJITCompilerForModule(&ee.C, m.C, &copts, C.size_t(unsafe.Sizeof(copts)), &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)
}

llvm/trunk/bindings/go/llvm/executionengine_test.go

//===- 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
}
engine, err := NewMCJITCompiler(mod, MCJITCompilerOptions{OptLevel: 2})
if err != nil {
t.Errorf("Error creating JIT: %s", err)
return
}
defer engine.Dispose()
pass := NewPassManager()
defer pass.Dispose()
pass.Add(engine.TargetData())
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))
}
}

llvm/trunk/bindings/go/llvm/ir.go

//===- ir.go - 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 bindings for the ir component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Core.h"
#include "IRBindings.h"
#include <stdlib.h>
*/
import "C"
import "unsafe"
import "errors"
type (
// We use these weird structs here because *Ref types are pointers and
// Go's spec says that a pointer cannot be used as a receiver base type.
Context struct {
C C.LLVMContextRef
}
Module struct {
C C.LLVMModuleRef
}
Type struct {
C C.LLVMTypeRef
}
Value struct {
C C.LLVMValueRef
}
BasicBlock struct {
C C.LLVMBasicBlockRef
}
Builder struct {
C C.LLVMBuilderRef
}
ModuleProvider struct {
C C.LLVMModuleProviderRef
}
MemoryBuffer struct {
C C.LLVMMemoryBufferRef
}
PassManager struct {
C C.LLVMPassManagerRef
}
Use struct {
C C.LLVMUseRef
}
Attribute uint64
Opcode C.LLVMOpcode
TypeKind C.LLVMTypeKind
Linkage C.LLVMLinkage
Visibility C.LLVMVisibility
CallConv C.LLVMCallConv
IntPredicate C.LLVMIntPredicate
FloatPredicate C.LLVMRealPredicate
LandingPadClause C.LLVMLandingPadClauseTy
)
func (c Context) IsNil() bool { return c.C == nil }
func (c Module) IsNil() bool { return c.C == nil }
func (c Type) IsNil() bool { return c.C == nil }
func (c Value) IsNil() bool { return c.C == nil }
func (c BasicBlock) IsNil() bool { return c.C == nil }
func (c Builder) IsNil() bool { return c.C == nil }
func (c ModuleProvider) IsNil() bool { return c.C == nil }
func (c MemoryBuffer) IsNil() bool { return c.C == nil }
func (c PassManager) IsNil() bool { return c.C == nil }
func (c Use) IsNil() bool { return c.C == nil }
// helpers
func llvmTypeRefPtr(t *Type) *C.LLVMTypeRef { return (*C.LLVMTypeRef)(unsafe.Pointer(t)) }
func llvmValueRefPtr(t *Value) *C.LLVMValueRef { return (*C.LLVMValueRef)(unsafe.Pointer(t)) }
func llvmBasicBlockRefPtr(t *BasicBlock) *C.LLVMBasicBlockRef {
return (*C.LLVMBasicBlockRef)(unsafe.Pointer(t))
}
func boolToLLVMBool(b bool) C.LLVMBool {
if b {
return C.LLVMBool(1)
}
return C.LLVMBool(0)
}
func llvmValueRefs(values []Value) (*C.LLVMValueRef, C.unsigned) {
var pt *C.LLVMValueRef
ptlen := C.unsigned(len(values))
if ptlen > 0 {
pt = llvmValueRefPtr(&values[0])
}
return pt, ptlen
}
//-------------------------------------------------------------------------
// llvm.Attribute
//-------------------------------------------------------------------------
const (
NoneAttribute Attribute = 0
ZExtAttribute Attribute = C.LLVMZExtAttribute
SExtAttribute Attribute = C.LLVMSExtAttribute
NoReturnAttribute Attribute = C.LLVMNoReturnAttribute
InRegAttribute Attribute = C.LLVMInRegAttribute
StructRetAttribute Attribute = C.LLVMStructRetAttribute
NoUnwindAttribute Attribute = C.LLVMNoUnwindAttribute
NoAliasAttribute Attribute = C.LLVMNoAliasAttribute
ByValAttribute Attribute = C.LLVMByValAttribute
NestAttribute Attribute = C.LLVMNestAttribute
ReadNoneAttribute Attribute = C.LLVMReadNoneAttribute
ReadOnlyAttribute Attribute = C.LLVMReadOnlyAttribute
NoInlineAttribute Attribute = C.LLVMNoInlineAttribute
AlwaysInlineAttribute Attribute = C.LLVMAlwaysInlineAttribute
OptimizeForSizeAttribute Attribute = C.LLVMOptimizeForSizeAttribute
StackProtectAttribute Attribute = C.LLVMStackProtectAttribute
StackProtectReqAttribute Attribute = C.LLVMStackProtectReqAttribute
Alignment Attribute = C.LLVMAlignment
NoCaptureAttribute Attribute = C.LLVMNoCaptureAttribute
NoRedZoneAttribute Attribute = C.LLVMNoRedZoneAttribute
NoImplicitFloatAttribute Attribute = C.LLVMNoImplicitFloatAttribute
NakedAttribute Attribute = C.LLVMNakedAttribute
InlineHintAttribute Attribute = C.LLVMInlineHintAttribute
StackAlignment Attribute = C.LLVMStackAlignment
ReturnsTwiceAttribute Attribute = C.LLVMReturnsTwice
UWTableAttribute Attribute = C.LLVMUWTable
NonLazyBindAttribute Attribute = 1 << 31
SanitizeAddressAttribute Attribute = 1 << 32
MinSizeAttribute Attribute = 1 << 33
NoDuplicateAttribute Attribute = 1 << 34
StackProtectStrongAttribute Attribute = 1 << 35
SanitizeThreadAttribute Attribute = 1 << 36
SanitizeMemoryAttribute Attribute = 1 << 37
NoBuiltinAttribute Attribute = 1 << 38
ReturnedAttribute Attribute = 1 << 39
ColdAttribute Attribute = 1 << 40
BuiltinAttribute Attribute = 1 << 41
OptimizeNoneAttribute Attribute = 1 << 42
InAllocaAttribute Attribute = 1 << 43
NonNullAttribute Attribute = 1 << 44
JumpTableAttribute Attribute = 1 << 45
)
//-------------------------------------------------------------------------
// llvm.Opcode
//-------------------------------------------------------------------------
const (
Ret Opcode = C.LLVMRet
Br Opcode = C.LLVMBr
Switch Opcode = C.LLVMSwitch
IndirectBr Opcode = C.LLVMIndirectBr
Invoke Opcode = C.LLVMInvoke
Unreachable Opcode = C.LLVMUnreachable
// Standard Binary Operators
Add Opcode = C.LLVMAdd
FAdd Opcode = C.LLVMFAdd
Sub Opcode = C.LLVMSub
FSub Opcode = C.LLVMFSub
Mul Opcode = C.LLVMMul
FMul Opcode = C.LLVMFMul
UDiv Opcode = C.LLVMUDiv
SDiv Opcode = C.LLVMSDiv
FDiv Opcode = C.LLVMFDiv
URem Opcode = C.LLVMURem
SRem Opcode = C.LLVMSRem
FRem Opcode = C.LLVMFRem
// Logical Operators
Shl Opcode = C.LLVMShl
LShr Opcode = C.LLVMLShr
AShr Opcode = C.LLVMAShr
And Opcode = C.LLVMAnd
Or Opcode = C.LLVMOr
Xor Opcode = C.LLVMXor
// Memory Operators
Alloca Opcode = C.LLVMAlloca
Load Opcode = C.LLVMLoad
Store Opcode = C.LLVMStore
GetElementPtr Opcode = C.LLVMGetElementPtr
// Cast Operators
Trunc Opcode = C.LLVMTrunc
ZExt Opcode = C.LLVMZExt
SExt Opcode = C.LLVMSExt
FPToUI Opcode = C.LLVMFPToUI
FPToSI Opcode = C.LLVMFPToSI
UIToFP Opcode = C.LLVMUIToFP
SIToFP Opcode = C.LLVMSIToFP
FPTrunc Opcode = C.LLVMFPTrunc
FPExt Opcode = C.LLVMFPExt
PtrToInt Opcode = C.LLVMPtrToInt
IntToPtr Opcode = C.LLVMIntToPtr
BitCast Opcode = C.LLVMBitCast
// Other Operators
ICmp Opcode = C.LLVMICmp
FCmp Opcode = C.LLVMFCmp
PHI Opcode = C.LLVMPHI
Call Opcode = C.LLVMCall
Select Opcode = C.LLVMSelect
// UserOp1
// UserOp2
VAArg Opcode = C.LLVMVAArg
ExtractElement Opcode = C.LLVMExtractElement
InsertElement Opcode = C.LLVMInsertElement
ShuffleVector Opcode = C.LLVMShuffleVector
ExtractValue Opcode = C.LLVMExtractValue
InsertValue Opcode = C.LLVMInsertValue
)
//-------------------------------------------------------------------------
// llvm.TypeKind
//-------------------------------------------------------------------------
const (
VoidTypeKind TypeKind = C.LLVMVoidTypeKind
FloatTypeKind TypeKind = C.LLVMFloatTypeKind
DoubleTypeKind TypeKind = C.LLVMDoubleTypeKind
X86_FP80TypeKind TypeKind = C.LLVMX86_FP80TypeKind
FP128TypeKind TypeKind = C.LLVMFP128TypeKind
PPC_FP128TypeKind TypeKind = C.LLVMPPC_FP128TypeKind
LabelTypeKind TypeKind = C.LLVMLabelTypeKind
IntegerTypeKind TypeKind = C.LLVMIntegerTypeKind
FunctionTypeKind TypeKind = C.LLVMFunctionTypeKind
StructTypeKind TypeKind = C.LLVMStructTypeKind
ArrayTypeKind TypeKind = C.LLVMArrayTypeKind
PointerTypeKind TypeKind = C.LLVMPointerTypeKind
VectorTypeKind TypeKind = C.LLVMVectorTypeKind
MetadataTypeKind TypeKind = C.LLVMMetadataTypeKind
)
//-------------------------------------------------------------------------
// llvm.Linkage
//-------------------------------------------------------------------------
const (
ExternalLinkage Linkage = C.LLVMExternalLinkage
AvailableExternallyLinkage Linkage = C.LLVMAvailableExternallyLinkage
LinkOnceAnyLinkage Linkage = C.LLVMLinkOnceAnyLinkage
LinkOnceODRLinkage Linkage = C.LLVMLinkOnceODRLinkage
WeakAnyLinkage Linkage = C.LLVMWeakAnyLinkage
WeakODRLinkage Linkage = C.LLVMWeakODRLinkage
AppendingLinkage Linkage = C.LLVMAppendingLinkage
InternalLinkage Linkage = C.LLVMInternalLinkage
PrivateLinkage Linkage = C.LLVMPrivateLinkage
ExternalWeakLinkage Linkage = C.LLVMExternalWeakLinkage
CommonLinkage Linkage = C.LLVMCommonLinkage
)
//-------------------------------------------------------------------------
// llvm.Visibility
//-------------------------------------------------------------------------
const (
DefaultVisibility Visibility = C.LLVMDefaultVisibility
HiddenVisibility Visibility = C.LLVMHiddenVisibility
ProtectedVisibility Visibility = C.LLVMProtectedVisibility
)
//-------------------------------------------------------------------------
// llvm.CallConv
//-------------------------------------------------------------------------
const (
CCallConv CallConv = C.LLVMCCallConv
FastCallConv CallConv = C.LLVMFastCallConv
ColdCallConv CallConv = C.LLVMColdCallConv
X86StdcallCallConv CallConv = C.LLVMX86StdcallCallConv
X86FastcallCallConv CallConv = C.LLVMX86FastcallCallConv
)
//-------------------------------------------------------------------------
// llvm.IntPredicate
//-------------------------------------------------------------------------
const (
IntEQ IntPredicate = C.LLVMIntEQ
IntNE IntPredicate = C.LLVMIntNE
IntUGT IntPredicate = C.LLVMIntUGT
IntUGE IntPredicate = C.LLVMIntUGE
IntULT IntPredicate = C.LLVMIntULT
IntULE IntPredicate = C.LLVMIntULE
IntSGT IntPredicate = C.LLVMIntSGT
IntSGE IntPredicate = C.LLVMIntSGE
IntSLT IntPredicate = C.LLVMIntSLT
IntSLE IntPredicate = C.LLVMIntSLE
)
//-------------------------------------------------------------------------
// llvm.FloatPredicate
//-------------------------------------------------------------------------
const (
FloatPredicateFalse FloatPredicate = C.LLVMRealPredicateFalse
FloatOEQ FloatPredicate = C.LLVMRealOEQ
FloatOGT FloatPredicate = C.LLVMRealOGT
FloatOGE FloatPredicate = C.LLVMRealOGE
FloatOLT FloatPredicate = C.LLVMRealOLT
FloatOLE FloatPredicate = C.LLVMRealOLE
FloatONE FloatPredicate = C.LLVMRealONE
FloatORD FloatPredicate = C.LLVMRealORD
FloatUNO FloatPredicate = C.LLVMRealUNO
FloatUEQ FloatPredicate = C.LLVMRealUEQ
FloatUGT FloatPredicate = C.LLVMRealUGT
FloatUGE FloatPredicate = C.LLVMRealUGE
FloatULT FloatPredicate = C.LLVMRealULT
FloatULE FloatPredicate = C.LLVMRealULE
FloatUNE FloatPredicate = C.LLVMRealUNE
FloatPredicateTrue FloatPredicate = C.LLVMRealPredicateTrue
)
//-------------------------------------------------------------------------
// llvm.LandingPadClause
//-------------------------------------------------------------------------
const (
LandingPadCatch LandingPadClause = C.LLVMLandingPadCatch
LandingPadFilter LandingPadClause = C.LLVMLandingPadFilter
)
//-------------------------------------------------------------------------
// llvm.Context
//-------------------------------------------------------------------------
func NewContext() Context { return Context{C.LLVMContextCreate()} }
func GlobalContext() Context { return Context{C.LLVMGetGlobalContext()} }
func (c Context) Dispose() { C.LLVMContextDispose(c.C) }
func (c Context) MDKindID(name string) (id int) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
id = int(C.LLVMGetMDKindIDInContext(c.C, cname, C.unsigned(len(name))))
return
}
func MDKindID(name string) (id int) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
id = int(C.LLVMGetMDKindID(cname, C.unsigned(len(name))))
return
}
//-------------------------------------------------------------------------
// llvm.Module
//-------------------------------------------------------------------------
// Create and destroy modules.
// See llvm::Module::Module.
func NewModule(name string) (m Module) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
m.C = C.LLVMModuleCreateWithName(cname)
return
}
func (c Context) NewModule(name string) (m Module) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
m.C = C.LLVMModuleCreateWithNameInContext(cname, c.C)
return
}
// See llvm::Module::~Module
func (m Module) Dispose() { C.LLVMDisposeModule(m.C) }
// Data layout. See Module::getDataLayout.
func (m Module) DataLayout() string {
clayout := C.LLVMGetDataLayout(m.C)
return C.GoString(clayout)
}
func (m Module) SetDataLayout(layout string) {
clayout := C.CString(layout)
defer C.free(unsafe.Pointer(clayout))
C.LLVMSetDataLayout(m.C, clayout)
}
// Target triple. See Module::getTargetTriple.
func (m Module) Target() string {
ctarget := C.LLVMGetTarget(m.C)
return C.GoString(ctarget)
}
func (m Module) SetTarget(target string) {
ctarget := C.CString(target)
defer C.free(unsafe.Pointer(ctarget))
C.LLVMSetTarget(m.C, ctarget)
}
func (m Module) GetTypeByName(name string) (t Type) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
t.C = C.LLVMGetTypeByName(m.C, cname)
return
}
// See Module::dump.
func (m Module) Dump() {
C.LLVMDumpModule(m.C)
}
func (m Module) String() string {
cir := C.LLVMPrintModuleToString(m.C)
defer C.free(unsafe.Pointer(cir))
ir := C.GoString(cir)
return ir
}
// See Module::setModuleInlineAsm.
func (m Module) SetInlineAsm(asm string) {
casm := C.CString(asm)
defer C.free(unsafe.Pointer(casm))
C.LLVMSetModuleInlineAsm(m.C, casm)
}
func (m Module) AddNamedMetadataOperand(name string, operand Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
C.LLVMAddNamedMetadataOperand(m.C, cname, operand.C)
}
func (m Module) Context() (c Context) {
c.C = C.LLVMGetModuleContext(m.C)
return
}
//-------------------------------------------------------------------------
// llvm.Type
//-------------------------------------------------------------------------
// LLVM types conform to the following hierarchy:
//
// types:
// integer type
// real type
// function type
// sequence types:
// array type
// pointer type
// vector type
// void type
// label type
// opaque type
// See llvm::LLVMTypeKind::getTypeID.
func (t Type) TypeKind() TypeKind { return TypeKind(C.LLVMGetTypeKind(t.C)) }
// See llvm::LLVMType::getContext.
func (t Type) Context() (c Context) {
c.C = C.LLVMGetTypeContext(t.C)
return
}
// Operations on integer types
func (c Context) Int1Type() (t Type) { t.C = C.LLVMInt1TypeInContext(c.C); return }
func (c Context) Int8Type() (t Type) { t.C = C.LLVMInt8TypeInContext(c.C); return }
func (c Context) Int16Type() (t Type) { t.C = C.LLVMInt16TypeInContext(c.C); return }
func (c Context) Int32Type() (t Type) { t.C = C.LLVMInt32TypeInContext(c.C); return }
func (c Context) Int64Type() (t Type) { t.C = C.LLVMInt64TypeInContext(c.C); return }
func (c Context) IntType(numbits int) (t Type) {
t.C = C.LLVMIntTypeInContext(c.C, C.unsigned(numbits))
return
}
func Int1Type() (t Type) { t.C = C.LLVMInt1Type(); return }
func Int8Type() (t Type) { t.C = C.LLVMInt8Type(); return }
func Int16Type() (t Type) { t.C = C.LLVMInt16Type(); return }
func Int32Type() (t Type) { t.C = C.LLVMInt32Type(); return }
func Int64Type() (t Type) { t.C = C.LLVMInt64Type(); return }
func IntType(numbits int) (t Type) {
t.C = C.LLVMIntType(C.unsigned(numbits))
return
}
func (t Type) IntTypeWidth() int {
return int(C.LLVMGetIntTypeWidth(t.C))
}
// Operations on real types
func (c Context) FloatType() (t Type) { t.C = C.LLVMFloatTypeInContext(c.C); return }
func (c Context) DoubleType() (t Type) { t.C = C.LLVMDoubleTypeInContext(c.C); return }
func (c Context) X86FP80Type() (t Type) { t.C = C.LLVMX86FP80TypeInContext(c.C); return }
func (c Context) FP128Type() (t Type) { t.C = C.LLVMFP128TypeInContext(c.C); return }
func (c Context) PPCFP128Type() (t Type) { t.C = C.LLVMPPCFP128TypeInContext(c.C); return }
func FloatType() (t Type) { t.C = C.LLVMFloatType(); return }
func DoubleType() (t Type) { t.C = C.LLVMDoubleType(); return }
func X86FP80Type() (t Type) { t.C = C.LLVMX86FP80Type(); return }
func FP128Type() (t Type) { t.C = C.LLVMFP128Type(); return }
func PPCFP128Type() (t Type) { t.C = C.LLVMPPCFP128Type(); return }
// Operations on function types
func FunctionType(returnType Type, paramTypes []Type, isVarArg bool) (t Type) {
var pt *C.LLVMTypeRef
var ptlen C.unsigned
if len(paramTypes) > 0 {
pt = llvmTypeRefPtr(&paramTypes[0])
ptlen = C.unsigned(len(paramTypes))
}
t.C = C.LLVMFunctionType(returnType.C,
pt,
ptlen,
boolToLLVMBool(isVarArg))
return
}
func (t Type) IsFunctionVarArg() bool { return C.LLVMIsFunctionVarArg(t.C) != 0 }
func (t Type) ReturnType() (rt Type) { rt.C = C.LLVMGetReturnType(t.C); return }
func (t Type) ParamTypesCount() int { return int(C.LLVMCountParamTypes(t.C)) }
func (t Type) ParamTypes() []Type {
count := t.ParamTypesCount()
if count > 0 {
out := make([]Type, count)
C.LLVMGetParamTypes(t.C, llvmTypeRefPtr(&out[0]))
return out
}
return nil
}
// Operations on struct types
func (c Context) StructType(elementTypes []Type, packed bool) (t Type) {
var pt *C.LLVMTypeRef
var ptlen C.unsigned
if len(elementTypes) > 0 {
pt = llvmTypeRefPtr(&elementTypes[0])
ptlen = C.unsigned(len(elementTypes))
}
t.C = C.LLVMStructTypeInContext(c.C,
pt,
ptlen,
boolToLLVMBool(packed))
return
}
func StructType(elementTypes []Type, packed bool) (t Type) {
var pt *C.LLVMTypeRef
var ptlen C.unsigned
if len(elementTypes) > 0 {
pt = llvmTypeRefPtr(&elementTypes[0])
ptlen = C.unsigned(len(elementTypes))
}
t.C = C.LLVMStructType(pt, ptlen, boolToLLVMBool(packed))
return
}
func (c Context) StructCreateNamed(name string) (t Type) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
t.C = C.LLVMStructCreateNamed(c.C, cname)
return
}
func (t Type) StructName() string {
return C.GoString(C.LLVMGetStructName(t.C))
}
func (t Type) StructSetBody(elementTypes []Type, packed bool) {
var pt *C.LLVMTypeRef
var ptlen C.unsigned
if len(elementTypes) > 0 {
pt = llvmTypeRefPtr(&elementTypes[0])
ptlen = C.unsigned(len(elementTypes))
}
C.LLVMStructSetBody(t.C, pt, ptlen, boolToLLVMBool(packed))
}
func (t Type) IsStructPacked() bool { return C.LLVMIsPackedStruct(t.C) != 0 }
func (t Type) StructElementTypesCount() int { return int(C.LLVMCountStructElementTypes(t.C)) }
func (t Type) StructElementTypes() []Type {
out := make([]Type, t.StructElementTypesCount())
if len(out) > 0 {
C.LLVMGetStructElementTypes(t.C, llvmTypeRefPtr(&out[0]))
}
return out
}
// Operations on array, pointer, and vector types (sequence types)
func ArrayType(elementType Type, elementCount int) (t Type) {
t.C = C.LLVMArrayType(elementType.C, C.unsigned(elementCount))
return
}
func PointerType(elementType Type, addressSpace int) (t Type) {
t.C = C.LLVMPointerType(elementType.C, C.unsigned(addressSpace))
return
}
func VectorType(elementType Type, elementCount int) (t Type) {
t.C = C.LLVMVectorType(elementType.C, C.unsigned(elementCount))
return
}
func (t Type) ElementType() (rt Type) { rt.C = C.LLVMGetElementType(t.C); return }
func (t Type) ArrayLength() int { return int(C.LLVMGetArrayLength(t.C)) }
func (t Type) PointerAddressSpace() int { return int(C.LLVMGetPointerAddressSpace(t.C)) }
func (t Type) VectorSize() int { return int(C.LLVMGetVectorSize(t.C)) }
// Operations on other types
func (c Context) VoidType() (t Type) { t.C = C.LLVMVoidTypeInContext(c.C); return }
func (c Context) LabelType() (t Type) { t.C = C.LLVMLabelTypeInContext(c.C); return }
func VoidType() (t Type) { t.C = C.LLVMVoidType(); return }
func LabelType() (t Type) { t.C = C.LLVMLabelType(); return }
//-------------------------------------------------------------------------
// llvm.Value
//-------------------------------------------------------------------------
// Operations on all values
func (v Value) Type() (t Type) { t.C = C.LLVMTypeOf(v.C); return }
func (v Value) Name() string { return C.GoString(C.LLVMGetValueName(v.C)) }
func (v Value) SetName(name string) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
C.LLVMSetValueName(v.C, cname)
}
func (v Value) Dump() { C.LLVMDumpValue(v.C) }
func (v Value) ReplaceAllUsesWith(nv Value) { C.LLVMReplaceAllUsesWith(v.C, nv.C) }
func (v Value) HasMetadata() bool { return C.LLVMHasMetadata(v.C) != 0 }
func (v Value) Metadata(kind int) (rv Value) {
rv.C = C.LLVMGetMetadata(v.C, C.unsigned(kind))
return
}
func (v Value) SetMetadata(kind int, node Value) {
C.LLVMSetMetadata(v.C, C.unsigned(kind), node.C)
}
// Conversion functions.
// Return the input value if it is an instance of the specified class, otherwise NULL.
// See llvm::dyn_cast_or_null<>.
func (v Value) IsAArgument() (rv Value) { rv.C = C.LLVMIsAArgument(v.C); return }
func (v Value) IsABasicBlock() (rv Value) { rv.C = C.LLVMIsABasicBlock(v.C); return }
func (v Value) IsAInlineAsm() (rv Value) { rv.C = C.LLVMIsAInlineAsm(v.C); return }
func (v Value) IsAUser() (rv Value) { rv.C = C.LLVMIsAUser(v.C); return }
func (v Value) IsAConstant() (rv Value) { rv.C = C.LLVMIsAConstant(v.C); return }
func (v Value) IsAConstantAggregateZero() (rv Value) {
rv.C = C.LLVMIsAConstantAggregateZero(v.C)
return
}
func (v Value) IsAConstantArray() (rv Value) { rv.C = C.LLVMIsAConstantArray(v.C); return }
func (v Value) IsAConstantExpr() (rv Value) { rv.C = C.LLVMIsAConstantExpr(v.C); return }
func (v Value) IsAConstantFP() (rv Value) { rv.C = C.LLVMIsAConstantFP(v.C); return }
func (v Value) IsAConstantInt() (rv Value) { rv.C = C.LLVMIsAConstantInt(v.C); return }
func (v Value) IsAConstantPointerNull() (rv Value) { rv.C = C.LLVMIsAConstantPointerNull(v.C); return }
func (v Value) IsAConstantStruct() (rv Value) { rv.C = C.LLVMIsAConstantStruct(v.C); return }
func (v Value) IsAConstantVector() (rv Value) { rv.C = C.LLVMIsAConstantVector(v.C); return }
func (v Value) IsAGlobalValue() (rv Value) { rv.C = C.LLVMIsAGlobalValue(v.C); return }
func (v Value) IsAFunction() (rv Value) { rv.C = C.LLVMIsAFunction(v.C); return }
func (v Value) IsAGlobalAlias() (rv Value) { rv.C = C.LLVMIsAGlobalAlias(v.C); return }
func (v Value) IsAGlobalVariable() (rv Value) { rv.C = C.LLVMIsAGlobalVariable(v.C); return }
func (v Value) IsAUndefValue() (rv Value) { rv.C = C.LLVMIsAUndefValue(v.C); return }
func (v Value) IsAInstruction() (rv Value) { rv.C = C.LLVMIsAInstruction(v.C); return }
func (v Value) IsABinaryOperator() (rv Value) { rv.C = C.LLVMIsABinaryOperator(v.C); return }
func (v Value) IsACallInst() (rv Value) { rv.C = C.LLVMIsACallInst(v.C); return }
func (v Value) IsAIntrinsicInst() (rv Value) { rv.C = C.LLVMIsAIntrinsicInst(v.C); return }
func (v Value) IsADbgInfoIntrinsic() (rv Value) { rv.C = C.LLVMIsADbgInfoIntrinsic(v.C); return }
func (v Value) IsADbgDeclareInst() (rv Value) { rv.C = C.LLVMIsADbgDeclareInst(v.C); return }
func (v Value) IsAMemIntrinsic() (rv Value) { rv.C = C.LLVMIsAMemIntrinsic(v.C); return }
func (v Value) IsAMemCpyInst() (rv Value) { rv.C = C.LLVMIsAMemCpyInst(v.C); return }
func (v Value) IsAMemMoveInst() (rv Value) { rv.C = C.LLVMIsAMemMoveInst(v.C); return }
func (v Value) IsAMemSetInst() (rv Value) { rv.C = C.LLVMIsAMemSetInst(v.C); return }
func (v Value) IsACmpInst() (rv Value) { rv.C = C.LLVMIsACmpInst(v.C); return }
func (v Value) IsAFCmpInst() (rv Value) { rv.C = C.LLVMIsAFCmpInst(v.C); return }
func (v Value) IsAICmpInst() (rv Value) { rv.C = C.LLVMIsAICmpInst(v.C); return }
func (v Value) IsAExtractElementInst() (rv Value) { rv.C = C.LLVMIsAExtractElementInst(v.C); return }
func (v Value) IsAGetElementPtrInst() (rv Value) { rv.C = C.LLVMIsAGetElementPtrInst(v.C); return }
func (v Value) IsAInsertElementInst() (rv Value) { rv.C = C.LLVMIsAInsertElementInst(v.C); return }
func (v Value) IsAInsertValueInst() (rv Value) { rv.C = C.LLVMIsAInsertValueInst(v.C); return }
func (v Value) IsAPHINode() (rv Value) { rv.C = C.LLVMIsAPHINode(v.C); return }
func (v Value) IsASelectInst() (rv Value) { rv.C = C.LLVMIsASelectInst(v.C); return }
func (v Value) IsAShuffleVectorInst() (rv Value) { rv.C = C.LLVMIsAShuffleVectorInst(v.C); return }
func (v Value) IsAStoreInst() (rv Value) { rv.C = C.LLVMIsAStoreInst(v.C); return }
func (v Value) IsATerminatorInst() (rv Value) { rv.C = C.LLVMIsATerminatorInst(v.C); return }
func (v Value) IsABranchInst() (rv Value) { rv.C = C.LLVMIsABranchInst(v.C); return }
func (v Value) IsAInvokeInst() (rv Value) { rv.C = C.LLVMIsAInvokeInst(v.C); return }
func (v Value) IsAReturnInst() (rv Value) { rv.C = C.LLVMIsAReturnInst(v.C); return }
func (v Value) IsASwitchInst() (rv Value) { rv.C = C.LLVMIsASwitchInst(v.C); return }
func (v Value) IsAUnreachableInst() (rv Value) { rv.C = C.LLVMIsAUnreachableInst(v.C); return }
func (v Value) IsAUnaryInstruction() (rv Value) { rv.C = C.LLVMIsAUnaryInstruction(v.C); return }
func (v Value) IsAAllocaInst() (rv Value) { rv.C = C.LLVMIsAAllocaInst(v.C); return }
func (v Value) IsACastInst() (rv Value) { rv.C = C.LLVMIsACastInst(v.C); return }
func (v Value) IsABitCastInst() (rv Value) { rv.C = C.LLVMIsABitCastInst(v.C); return }
func (v Value) IsAFPExtInst() (rv Value) { rv.C = C.LLVMIsAFPExtInst(v.C); return }
func (v Value) IsAFPToSIInst() (rv Value) { rv.C = C.LLVMIsAFPToSIInst(v.C); return }
func (v Value) IsAFPToUIInst() (rv Value) { rv.C = C.LLVMIsAFPToUIInst(v.C); return }
func (v Value) IsAFPTruncInst() (rv Value) { rv.C = C.LLVMIsAFPTruncInst(v.C); return }
func (v Value) IsAIntToPtrInst() (rv Value) { rv.C = C.LLVMIsAIntToPtrInst(v.C); return }
func (v Value) IsAPtrToIntInst() (rv Value) { rv.C = C.LLVMIsAPtrToIntInst(v.C); return }
func (v Value) IsASExtInst() (rv Value) { rv.C = C.LLVMIsASExtInst(v.C); return }
func (v Value) IsASIToFPInst() (rv Value) { rv.C = C.LLVMIsASIToFPInst(v.C); return }
func (v Value) IsATruncInst() (rv Value) { rv.C = C.LLVMIsATruncInst(v.C); return }
func (v Value) IsAUIToFPInst() (rv Value) { rv.C = C.LLVMIsAUIToFPInst(v.C); return }
func (v Value) IsAZExtInst() (rv Value) { rv.C = C.LLVMIsAZExtInst(v.C); return }
func (v Value) IsAExtractValueInst() (rv Value) { rv.C = C.LLVMIsAExtractValueInst(v.C); return }
func (v Value) IsALoadInst() (rv Value) { rv.C = C.LLVMIsALoadInst(v.C); return }
func (v Value) IsAVAArgInst() (rv Value) { rv.C = C.LLVMIsAVAArgInst(v.C); return }
// Operations on Uses
func (v Value) FirstUse() (u Use) { u.C = C.LLVMGetFirstUse(v.C); return }
func (u Use) NextUse() (ru Use) { ru.C = C.LLVMGetNextUse(u.C); return }
func (u Use) User() (v Value) { v.C = C.LLVMGetUser(u.C); return }
func (u Use) UsedValue() (v Value) { v.C = C.LLVMGetUsedValue(u.C); return }
// Operations on Users
func (v Value) Operand(i int) (rv Value) { rv.C = C.LLVMGetOperand(v.C, C.unsigned(i)); return }
func (v Value) SetOperand(i int, op Value) { C.LLVMSetOperand(v.C, C.unsigned(i), op.C) }
func (v Value) OperandsCount() int { return int(C.LLVMGetNumOperands(v.C)) }
// Operations on constants of any type
func ConstNull(t Type) (v Value) { v.C = C.LLVMConstNull(t.C); return }
func ConstAllOnes(t Type) (v Value) { v.C = C.LLVMConstAllOnes(t.C); return }
func Undef(t Type) (v Value) { v.C = C.LLVMGetUndef(t.C); return }
func (v Value) IsConstant() bool { return C.LLVMIsConstant(v.C) != 0 }
func (v Value) IsNull() bool { return C.LLVMIsNull(v.C) != 0 }
func (v Value) IsUndef() bool { return C.LLVMIsUndef(v.C) != 0 }
func ConstPointerNull(t Type) (v Value) { v.C = C.LLVMConstPointerNull(t.C); return }
// Operations on metadata
func (c Context) MDString(str string) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMMDStringInContext(c.C, cstr, C.unsigned(len(str)))
return
}
func MDString(str string) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMMDString(cstr, C.unsigned(len(str)))
return
}
func (c Context) MDNode(vals []Value) (v Value) {
ptr, nvals := llvmValueRefs(vals)
v.C = C.LLVMMDNodeInContext(c.C, ptr, nvals)
return
}
func MDNode(vals []Value) (v Value) {
ptr, nvals := llvmValueRefs(vals)
v.C = C.LLVMMDNode(ptr, nvals)
return
}
// Operations on scalar constants
func ConstInt(t Type, n uint64, signExtend bool) (v Value) {
v.C = C.LLVMConstInt(t.C,
C.ulonglong(n),
boolToLLVMBool(signExtend))
return
}
func ConstIntFromString(t Type, str string, radix int) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMConstIntOfString(t.C, cstr, C.uint8_t(radix))
return
}
func ConstFloat(t Type, n float64) (v Value) {
v.C = C.LLVMConstReal(t.C, C.double(n))
return
}
func ConstFloatFromString(t Type, str string) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMConstRealOfString(t.C, cstr)
return
}
func (v Value) ZExtValue() uint64 { return uint64(C.LLVMConstIntGetZExtValue(v.C)) }
func (v Value) SExtValue() int64 { return int64(C.LLVMConstIntGetSExtValue(v.C)) }
// Operations on composite constants
func (c Context) ConstString(str string, addnull bool) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMConstStringInContext(c.C, cstr,
C.unsigned(len(str)), boolToLLVMBool(!addnull))
return
}
func (c Context) ConstStruct(constVals []Value, packed bool) (v Value) {
ptr, nvals := llvmValueRefs(constVals)
v.C = C.LLVMConstStructInContext(c.C, ptr, nvals,
boolToLLVMBool(packed))
return
}
func ConstNamedStruct(t Type, constVals []Value) (v Value) {
ptr, nvals := llvmValueRefs(constVals)
v.C = C.LLVMConstNamedStruct(t.C, ptr, nvals)
return
}
func ConstString(str string, addnull bool) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
v.C = C.LLVMConstString(cstr,
C.unsigned(len(str)), boolToLLVMBool(!addnull))
return
}
func ConstArray(t Type, constVals []Value) (v Value) {
ptr, nvals := llvmValueRefs(constVals)
v.C = C.LLVMConstArray(t.C, ptr, nvals)
return
}
func ConstStruct(constVals []Value, packed bool) (v Value) {
ptr, nvals := llvmValueRefs(constVals)
v.C = C.LLVMConstStruct(ptr, nvals, boolToLLVMBool(packed))
return
}
func ConstVector(scalarConstVals []Value, packed bool) (v Value) {
ptr, nvals := llvmValueRefs(scalarConstVals)
v.C = C.LLVMConstVector(ptr, nvals)
return
}
// Constant expressions
func (v Value) Opcode() Opcode { return Opcode(C.LLVMGetConstOpcode(v.C)) }
func (v Value) InstructionOpcode() Opcode { return Opcode(C.LLVMGetInstructionOpcode(v.C)) }
func AlignOf(t Type) (v Value) { v.C = C.LLVMAlignOf(t.C); return }
func SizeOf(t Type) (v Value) { v.C = C.LLVMSizeOf(t.C); return }
func ConstNeg(v Value) (rv Value) { rv.C = C.LLVMConstNeg(v.C); return }
func ConstNSWNeg(v Value) (rv Value) { rv.C = C.LLVMConstNSWNeg(v.C); return }
func ConstNUWNeg(v Value) (rv Value) { rv.C = C.LLVMConstNUWNeg(v.C); return }
func ConstFNeg(v Value) (rv Value) { rv.C = C.LLVMConstFNeg(v.C); return }
func ConstNot(v Value) (rv Value) { rv.C = C.LLVMConstNot(v.C); return }
func ConstAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAdd(lhs.C, rhs.C); return }
func ConstNSWAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWAdd(lhs.C, rhs.C); return }
func ConstNUWAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWAdd(lhs.C, rhs.C); return }
func ConstFAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFAdd(lhs.C, rhs.C); return }
func ConstSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstSub(lhs.C, rhs.C); return }
func ConstNSWSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWSub(lhs.C, rhs.C); return }
func ConstNUWSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWSub(lhs.C, rhs.C); return }
func ConstFSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFSub(lhs.C, rhs.C); return }
func ConstMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstMul(lhs.C, rhs.C); return }
func ConstNSWMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWMul(lhs.C, rhs.C); return }
func ConstNUWMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWMul(lhs.C, rhs.C); return }
func ConstFMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFMul(lhs.C, rhs.C); return }
func ConstUDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstUDiv(lhs.C, rhs.C); return }
func ConstSDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstSDiv(lhs.C, rhs.C); return }
func ConstExactSDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstExactSDiv(lhs.C, rhs.C); return }
func ConstFDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFDiv(lhs.C, rhs.C); return }
func ConstURem(lhs, rhs Value) (v Value) { v.C = C.LLVMConstURem(lhs.C, rhs.C); return }
func ConstSRem(lhs, rhs Value) (v Value) { v.C = C.LLVMConstSRem(lhs.C, rhs.C); return }
func ConstFRem(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFRem(lhs.C, rhs.C); return }
func ConstAnd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAnd(lhs.C, rhs.C); return }
func ConstOr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstOr(lhs.C, rhs.C); return }
func ConstXor(lhs, rhs Value) (v Value) { v.C = C.LLVMConstXor(lhs.C, rhs.C); return }
func ConstICmp(pred IntPredicate, lhs, rhs Value) (v Value) {
v.C = C.LLVMConstICmp(C.LLVMIntPredicate(pred), lhs.C, rhs.C)
return
}
func ConstFCmp(pred FloatPredicate, lhs, rhs Value) (v Value) {
v.C = C.LLVMConstFCmp(C.LLVMRealPredicate(pred), lhs.C, rhs.C)
return
}
func ConstShl(lhs, rhs Value) (v Value) { v.C = C.LLVMConstShl(lhs.C, rhs.C); return }
func ConstLShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstLShr(lhs.C, rhs.C); return }
func ConstAShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAShr(lhs.C, rhs.C); return }
func ConstGEP(v Value, indices []Value) (rv Value) {
ptr, nvals := llvmValueRefs(indices)
rv.C = C.LLVMConstGEP(v.C, ptr, nvals)
return
}
func ConstInBoundsGEP(v Value, indices []Value) (rv Value) {
ptr, nvals := llvmValueRefs(indices)
rv.C = C.LLVMConstInBoundsGEP(v.C, ptr, nvals)
return
}
func ConstTrunc(v Value, t Type) (rv Value) { rv.C = C.LLVMConstTrunc(v.C, t.C); return }
func ConstSExt(v Value, t Type) (rv Value) { rv.C = C.LLVMConstSExt(v.C, t.C); return }
func ConstZExt(v Value, t Type) (rv Value) { rv.C = C.LLVMConstZExt(v.C, t.C); return }
func ConstFPTrunc(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPTrunc(v.C, t.C); return }
func ConstFPExt(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPExt(v.C, t.C); return }
func ConstUIToFP(v Value, t Type) (rv Value) { rv.C = C.LLVMConstUIToFP(v.C, t.C); return }
func ConstSIToFP(v Value, t Type) (rv Value) { rv.C = C.LLVMConstSIToFP(v.C, t.C); return }
func ConstFPToUI(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPToUI(v.C, t.C); return }
func ConstFPToSI(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPToSI(v.C, t.C); return }
func ConstPtrToInt(v Value, t Type) (rv Value) { rv.C = C.LLVMConstPtrToInt(v.C, t.C); return }
func ConstIntToPtr(v Value, t Type) (rv Value) { rv.C = C.LLVMConstIntToPtr(v.C, t.C); return }
func ConstBitCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstBitCast(v.C, t.C); return }
func ConstZExtOrBitCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstZExtOrBitCast(v.C, t.C); return }
func ConstSExtOrBitCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstSExtOrBitCast(v.C, t.C); return }
func ConstTruncOrBitCast(v Value, t Type) (rv Value) {
rv.C = C.LLVMConstTruncOrBitCast(v.C, t.C)
return
}
func ConstPointerCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstPointerCast(v.C, t.C); return }
func ConstIntCast(v Value, t Type, signed bool) (rv Value) {
rv.C = C.LLVMConstIntCast(v.C, t.C, boolToLLVMBool(signed))
return
}
func ConstFPCast(v Value, t Type) (rv Value) { rv.C = C.LLVMConstFPCast(v.C, t.C); return }
func ConstSelect(cond, iftrue, iffalse Value) (rv Value) {
rv.C = C.LLVMConstSelect(cond.C, iftrue.C, iffalse.C)
return
}
func ConstExtractElement(vec, i Value) (rv Value) {
rv.C = C.LLVMConstExtractElement(vec.C, i.C)
return
}
func ConstInsertElement(vec, elem, i Value) (rv Value) {
rv.C = C.LLVMConstInsertElement(vec.C, elem.C, i.C)
return
}
func ConstShuffleVector(veca, vecb, mask Value) (rv Value) {
rv.C = C.LLVMConstShuffleVector(veca.C, vecb.C, mask.C)
return
}
//TODO
//LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
// unsigned NumIdx);
func ConstExtractValue(agg Value, indices []uint32) (rv Value) {
n := len(indices)
if n == 0 {
panic("one or more indices are required")
}
ptr := (*C.unsigned)(&indices[0])
rv.C = C.LLVMConstExtractValue(agg.C, ptr, C.unsigned(n))
return
}
func ConstInsertValue(agg, val Value, indices []uint32) (rv Value) {
n := len(indices)
if n == 0 {
panic("one or more indices are required")
}
ptr := (*C.unsigned)(&indices[0])
rv.C = C.LLVMConstInsertValue(agg.C, val.C, ptr, C.unsigned(n))
return
}
func BlockAddress(f Value, bb BasicBlock) (v Value) {
v.C = C.LLVMBlockAddress(f.C, bb.C)
return
}
// Operations on global variables, functions, and aliases (globals)
func (v Value) GlobalParent() (m Module) { m.C = C.LLVMGetGlobalParent(v.C); return }
func (v Value) IsDeclaration() bool { return C.LLVMIsDeclaration(v.C) != 0 }
func (v Value) Linkage() Linkage { return Linkage(C.LLVMGetLinkage(v.C)) }
func (v Value) SetLinkage(l Linkage) { C.LLVMSetLinkage(v.C, C.LLVMLinkage(l)) }
func (v Value) Section() string { return C.GoString(C.LLVMGetSection(v.C)) }
func (v Value) SetSection(str string) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
C.LLVMSetSection(v.C, cstr)
}
func (v Value) Visibility() Visibility { return Visibility(C.LLVMGetVisibility(v.C)) }
func (v Value) SetVisibility(vi Visibility) { C.LLVMSetVisibility(v.C, C.LLVMVisibility(vi)) }
func (v Value) Alignment() int { return int(C.LLVMGetAlignment(v.C)) }
func (v Value) SetAlignment(a int) { C.LLVMSetAlignment(v.C, C.unsigned(a)) }
// Operations on global variables
func AddGlobal(m Module, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMAddGlobal(m.C, t.C, cname)
return
}
func AddGlobalInAddressSpace(m Module, t Type, name string, addressSpace int) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMAddGlobalInAddressSpace(m.C, t.C, cname, C.unsigned(addressSpace))
return
}
func (m Module) NamedGlobal(name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMGetNamedGlobal(m.C, cname)
return
}
func (m Module) FirstGlobal() (v Value) { v.C = C.LLVMGetFirstGlobal(m.C); return }
func (m Module) LastGlobal() (v Value) { v.C = C.LLVMGetLastGlobal(m.C); return }
func NextGlobal(v Value) (rv Value) { rv.C = C.LLVMGetNextGlobal(v.C); return }
func PrevGlobal(v Value) (rv Value) { rv.C = C.LLVMGetPreviousGlobal(v.C); return }
func (v Value) EraseFromParentAsGlobal() { C.LLVMDeleteGlobal(v.C) }
func (v Value) Initializer() (rv Value) { rv.C = C.LLVMGetInitializer(v.C); return }
func (v Value) SetInitializer(cv Value) { C.LLVMSetInitializer(v.C, cv.C) }
func (v Value) IsThreadLocal() bool { return C.LLVMIsThreadLocal(v.C) != 0 }
func (v Value) SetThreadLocal(tl bool) { C.LLVMSetThreadLocal(v.C, boolToLLVMBool(tl)) }
func (v Value) IsGlobalConstant() bool { return C.LLVMIsGlobalConstant(v.C) != 0 }
func (v Value) SetGlobalConstant(gc bool) { C.LLVMSetGlobalConstant(v.C, boolToLLVMBool(gc)) }
// Operations on aliases
func AddAlias(m Module, t Type, aliasee Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMAddAlias(m.C, t.C, aliasee.C, cname)
return
}
// Operations on functions
func AddFunction(m Module, name string, ft Type) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMAddFunction(m.C, cname, ft.C)
return
}
func (m Module) NamedFunction(name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMGetNamedFunction(m.C, cname)
return
}
func (m Module) FirstFunction() (v Value) { v.C = C.LLVMGetFirstFunction(m.C); return }
func (m Module) LastFunction() (v Value) { v.C = C.LLVMGetLastFunction(m.C); return }
func NextFunction(v Value) (rv Value) { rv.C = C.LLVMGetNextFunction(v.C); return }
func PrevFunction(v Value) (rv Value) { rv.C = C.LLVMGetPreviousFunction(v.C); return }
func (v Value) EraseFromParentAsFunction() { C.LLVMDeleteFunction(v.C) }
func (v Value) IntrinsicID() int { return int(C.LLVMGetIntrinsicID(v.C)) }
func (v Value) FunctionCallConv() CallConv {
return CallConv(C.LLVMCallConv(C.LLVMGetFunctionCallConv(v.C)))
}
func (v Value) SetFunctionCallConv(cc CallConv) { C.LLVMSetFunctionCallConv(v.C, C.unsigned(cc)) }
func (v Value) GC() string { return C.GoString(C.LLVMGetGC(v.C)) }
func (v Value) SetGC(name string) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
C.LLVMSetGC(v.C, cname)
}
func (v Value) AddFunctionAttr(a Attribute) { C.LLVMAddFunctionAttr2(v.C, C.uint64_t(a)) }
func (v Value) FunctionAttr() Attribute { return Attribute(C.LLVMGetFunctionAttr2(v.C)) }
func (v Value) RemoveFunctionAttr(a Attribute) { C.LLVMRemoveFunctionAttr2(v.C, C.uint64_t(a)) }
func (v Value) AddTargetDependentFunctionAttr(attr, value string) {
cattr := C.CString(attr)
defer C.free(unsafe.Pointer(cattr))
cvalue := C.CString(value)
defer C.free(unsafe.Pointer(cvalue))
C.LLVMAddTargetDependentFunctionAttr(v.C, cattr, cvalue)
}
// Operations on parameters
func (v Value) ParamsCount() int { return int(C.LLVMCountParams(v.C)) }
func (v Value) Params() []Value {
out := make([]Value, v.ParamsCount())
if len(out) > 0 {
C.LLVMGetParams(v.C, llvmValueRefPtr(&out[0]))
}
return out
}
func (v Value) Param(i int) (rv Value) { rv.C = C.LLVMGetParam(v.C, C.unsigned(i)); return }
func (v Value) ParamParent() (rv Value) { rv.C = C.LLVMGetParamParent(v.C); return }
func (v Value) FirstParam() (rv Value) { rv.C = C.LLVMGetFirstParam(v.C); return }
func (v Value) LastParam() (rv Value) { rv.C = C.LLVMGetLastParam(v.C); return }
func NextParam(v Value) (rv Value) { rv.C = C.LLVMGetNextParam(v.C); return }
func PrevParam(v Value) (rv Value) { rv.C = C.LLVMGetPreviousParam(v.C); return }
func (v Value) AddAttribute(a Attribute) {
if a >= 1<<32 {
panic("attribute value currently unsupported")
}
C.LLVMAddAttribute(v.C, C.LLVMAttribute(a))
}
func (v Value) RemoveAttribute(a Attribute) {
if a >= 1<<32 {
panic("attribute value currently unsupported")
}
C.LLVMRemoveAttribute(v.C, C.LLVMAttribute(a))
}
func (v Value) Attribute() Attribute { return Attribute(C.LLVMGetAttribute(v.C)) }
func (v Value) SetParamAlignment(align int) { C.LLVMSetParamAlignment(v.C, C.unsigned(align)) }
// Operations on basic blocks
func (bb BasicBlock) AsValue() (v Value) { v.C = C.LLVMBasicBlockAsValue(bb.C); return }
func (v Value) IsBasicBlock() bool { return C.LLVMValueIsBasicBlock(v.C) != 0 }
func (v Value) AsBasicBlock() (bb BasicBlock) { bb.C = C.LLVMValueAsBasicBlock(v.C); return }
func (bb BasicBlock) Parent() (v Value) { v.C = C.LLVMGetBasicBlockParent(bb.C); return }
func (v Value) BasicBlocksCount() int { return int(C.LLVMCountBasicBlocks(v.C)) }
func (v Value) BasicBlocks() []BasicBlock {
out := make([]BasicBlock, v.BasicBlocksCount())
C.LLVMGetBasicBlocks(v.C, llvmBasicBlockRefPtr(&out[0]))
return out
}
func (v Value) FirstBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetFirstBasicBlock(v.C); return }
func (v Value) LastBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetLastBasicBlock(v.C); return }
func NextBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetNextBasicBlock(bb.C); return }
func PrevBasicBlock(bb BasicBlock) (rbb BasicBlock) { rbb.C = C.LLVMGetPreviousBasicBlock(bb.C); return }
func (v Value) EntryBasicBlock() (bb BasicBlock) { bb.C = C.LLVMGetEntryBasicBlock(v.C); return }
func (c Context) AddBasicBlock(f Value, name string) (bb BasicBlock) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
bb.C = C.LLVMAppendBasicBlockInContext(c.C, f.C, cname)
return
}
func (c Context) InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
bb.C = C.LLVMInsertBasicBlockInContext(c.C, ref.C, cname)
return
}
func AddBasicBlock(f Value, name string) (bb BasicBlock) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
bb.C = C.LLVMAppendBasicBlock(f.C, cname)
return
}
func InsertBasicBlock(ref BasicBlock, name string) (bb BasicBlock) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
bb.C = C.LLVMInsertBasicBlock(ref.C, cname)
return
}
func (bb BasicBlock) EraseFromParent() { C.LLVMDeleteBasicBlock(bb.C) }
func (bb BasicBlock) MoveBefore(pos BasicBlock) { C.LLVMMoveBasicBlockBefore(bb.C, pos.C) }
func (bb BasicBlock) MoveAfter(pos BasicBlock) { C.LLVMMoveBasicBlockAfter(bb.C, pos.C) }
// Operations on instructions
func (v Value) InstructionParent() (bb BasicBlock) { bb.C = C.LLVMGetInstructionParent(v.C); return }
func (bb BasicBlock) FirstInstruction() (v Value) { v.C = C.LLVMGetFirstInstruction(bb.C); return }
func (bb BasicBlock) LastInstruction() (v Value) { v.C = C.LLVMGetLastInstruction(bb.C); return }
func NextInstruction(v Value) (rv Value) { rv.C = C.LLVMGetNextInstruction(v.C); return }
func PrevInstruction(v Value) (rv Value) { rv.C = C.LLVMGetPreviousInstruction(v.C); return }
// Operations on call sites
func (v Value) SetInstructionCallConv(cc CallConv) {
C.LLVMSetInstructionCallConv(v.C, C.unsigned(cc))
}
func (v Value) InstructionCallConv() CallConv {
return CallConv(C.LLVMCallConv(C.LLVMGetInstructionCallConv(v.C)))
}
func (v Value) AddInstrAttribute(i int, a Attribute) {
if a >= 1<<32 {
panic("attribute value currently unsupported")
}
C.LLVMAddInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
}
func (v Value) RemoveInstrAttribute(i int, a Attribute) {
if a >= 1<<32 {
panic("attribute value currently unsupported")
}
C.LLVMRemoveInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
}
func (v Value) SetInstrParamAlignment(i int, align int) {
C.LLVMSetInstrParamAlignment(v.C, C.unsigned(i), C.unsigned(align))
}
// Operations on call instructions (only)
func (v Value) IsTailCall() bool { return C.LLVMIsTailCall(v.C) != 0 }
func (v Value) SetTailCall(is bool) { C.LLVMSetTailCall(v.C, boolToLLVMBool(is)) }
// Operations on phi nodes
func (v Value) AddIncoming(vals []Value, blocks []BasicBlock) {
ptr, nvals := llvmValueRefs(vals)
C.LLVMAddIncoming(v.C, ptr, llvmBasicBlockRefPtr(&blocks[0]), nvals)
}
func (v Value) IncomingCount() int { return int(C.LLVMCountIncoming(v.C)) }
func (v Value) IncomingValue(i int) (rv Value) {
rv.C = C.LLVMGetIncomingValue(v.C, C.unsigned(i))
return
}
func (v Value) IncomingBlock(i int) (bb BasicBlock) {
bb.C = C.LLVMGetIncomingBlock(v.C, C.unsigned(i))
return
}
//-------------------------------------------------------------------------
// llvm.Builder
//-------------------------------------------------------------------------
// An instruction builder represents a point within a basic block, and is the
// exclusive means of building instructions using the C interface.
func (c Context) NewBuilder() (b Builder) { b.C = C.LLVMCreateBuilderInContext(c.C); return }
func NewBuilder() (b Builder) { b.C = C.LLVMCreateBuilder(); return }
func (b Builder) SetInsertPoint(block BasicBlock, instr Value) {
C.LLVMPositionBuilder(b.C, block.C, instr.C)
}
func (b Builder) SetInsertPointBefore(instr Value) { C.LLVMPositionBuilderBefore(b.C, instr.C) }
func (b Builder) SetInsertPointAtEnd(block BasicBlock) { C.LLVMPositionBuilderAtEnd(b.C, block.C) }
func (b Builder) GetInsertBlock() (bb BasicBlock) { bb.C = C.LLVMGetInsertBlock(b.C); return }
func (b Builder) ClearInsertionPoint() { C.LLVMClearInsertionPosition(b.C) }
func (b Builder) Insert(instr Value) { C.LLVMInsertIntoBuilder(b.C, instr.C) }
func (b Builder) InsertWithName(instr Value, name string) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
C.LLVMInsertIntoBuilderWithName(b.C, instr.C, cname)
}
func (b Builder) Dispose() { C.LLVMDisposeBuilder(b.C) }
// Metadata
func (b Builder) SetCurrentDebugLocation(v Value) { C.LLVMSetCurrentDebugLocation(b.C, v.C) }
func (b Builder) CurrentDebugLocation() (v Value) { v.C = C.LLVMGetCurrentDebugLocation(b.C); return }
func (b Builder) SetInstDebugLocation(v Value) { C.LLVMSetInstDebugLocation(b.C, v.C) }
func (b Builder) InsertDeclare(module Module, storage Value, md Value) Value {
f := module.NamedFunction("llvm.dbg.declare")
if f.IsNil() {
ftyp := FunctionType(VoidType(), []Type{storage.Type(), md.Type()}, false)
f = AddFunction(module, "llvm.dbg.declare", ftyp)
}
return b.CreateCall(f, []Value{storage, md}, "")
}
// Terminators
func (b Builder) CreateRetVoid() (rv Value) { rv.C = C.LLVMBuildRetVoid(b.C); return }
func (b Builder) CreateRet(v Value) (rv Value) { rv.C = C.LLVMBuildRet(b.C, v.C); return }
func (b Builder) CreateAggregateRet(vs []Value) (rv Value) {
ptr, nvals := llvmValueRefs(vs)
rv.C = C.LLVMBuildAggregateRet(b.C, ptr, nvals)
return
}
func (b Builder) CreateBr(bb BasicBlock) (rv Value) { rv.C = C.LLVMBuildBr(b.C, bb.C); return }
func (b Builder) CreateCondBr(ifv Value, thenb, elseb BasicBlock) (rv Value) {
rv.C = C.LLVMBuildCondBr(b.C, ifv.C, thenb.C, elseb.C)
return
}
func (b Builder) CreateSwitch(v Value, elseb BasicBlock, numCases int) (rv Value) {
rv.C = C.LLVMBuildSwitch(b.C, v.C, elseb.C, C.unsigned(numCases))
return
}
func (b Builder) CreateIndirectBr(addr Value, numDests int) (rv Value) {
rv.C = C.LLVMBuildIndirectBr(b.C, addr.C, C.unsigned(numDests))
return
}
func (b Builder) CreateInvoke(fn Value, args []Value, then, catch BasicBlock, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
ptr, nvals := llvmValueRefs(args)
rv.C = C.LLVMBuildInvoke(b.C, fn.C, ptr, nvals, then.C, catch.C, cname)
return
}
func (b Builder) CreateUnreachable() (rv Value) { rv.C = C.LLVMBuildUnreachable(b.C); return }
// Add a case to the switch instruction
func (v Value) AddCase(on Value, dest BasicBlock) { C.LLVMAddCase(v.C, on.C, dest.C) }
// Add a destination to the indirectbr instruction
func (v Value) AddDest(dest BasicBlock) { C.LLVMAddDestination(v.C, dest.C) }
// Arithmetic
func (b Builder) CreateAdd(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildAdd(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNSWAdd(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNSWAdd(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNUWAdd(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNUWAdd(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFAdd(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFAdd(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateSub(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSub(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNSWSub(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNSWSub(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNUWSub(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNUWSub(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFSub(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
v.C = C.LLVMBuildFSub(b.C, lhs.C, rhs.C, cname)
C.free(unsafe.Pointer(cname))
return
}
func (b Builder) CreateMul(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildMul(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNSWMul(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNSWMul(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNUWMul(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildNUWMul(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFMul(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFMul(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateUDiv(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildUDiv(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateSDiv(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSDiv(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateExactSDiv(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildExactSDiv(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFDiv(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFDiv(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateURem(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildURem(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateSRem(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSRem(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFRem(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFRem(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateShl(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildShl(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateLShr(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildLShr(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateAShr(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildAShr(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateAnd(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildAnd(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateOr(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildOr(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateXor(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildXor(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateBinOp(op Opcode, lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildBinOp(b.C, C.LLVMOpcode(op), lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateNeg(v Value, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
rv.C = C.LLVMBuildNeg(b.C, v.C, cname)
return
}
func (b Builder) CreateNSWNeg(v Value, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
rv.C = C.LLVMBuildNSWNeg(b.C, v.C, cname)
return
}
func (b Builder) CreateNUWNeg(v Value, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
rv.C = C.LLVMBuildNUWNeg(b.C, v.C, cname)
return
}
func (b Builder) CreateFNeg(v Value, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
rv.C = C.LLVMBuildFNeg(b.C, v.C, cname)
return
}
func (b Builder) CreateNot(v Value, name string) (rv Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
rv.C = C.LLVMBuildNot(b.C, v.C, cname)
return
}
// Memory
func (b Builder) CreateMalloc(t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildMalloc(b.C, t.C, cname)
return
}
func (b Builder) CreateArrayMalloc(t Type, val Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildArrayMalloc(b.C, t.C, val.C, cname)
return
}
func (b Builder) CreateAlloca(t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildAlloca(b.C, t.C, cname)
return
}
func (b Builder) CreateArrayAlloca(t Type, val Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildArrayAlloca(b.C, t.C, val.C, cname)
return
}
func (b Builder) CreateFree(p Value) (v Value) {
v.C = C.LLVMBuildFree(b.C, p.C)
return
}
func (b Builder) CreateLoad(p Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildLoad(b.C, p.C, cname)
return
}
func (b Builder) CreateStore(val Value, p Value) (v Value) {
v.C = C.LLVMBuildStore(b.C, val.C, p.C)
return
}
func (b Builder) CreateGEP(p Value, indices []Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
ptr, nvals := llvmValueRefs(indices)
v.C = C.LLVMBuildGEP(b.C, p.C, ptr, nvals, cname)
return
}
func (b Builder) CreateInBoundsGEP(p Value, indices []Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
ptr, nvals := llvmValueRefs(indices)
v.C = C.LLVMBuildInBoundsGEP(b.C, p.C, ptr, nvals, cname)
return
}
func (b Builder) CreateStructGEP(p Value, i int, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildStructGEP(b.C, p.C, C.unsigned(i), cname)
return
}
func (b Builder) CreateGlobalString(str, name string) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildGlobalString(b.C, cstr, cname)
return
}
func (b Builder) CreateGlobalStringPtr(str, name string) (v Value) {
cstr := C.CString(str)
defer C.free(unsafe.Pointer(cstr))
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildGlobalStringPtr(b.C, cstr, cname)
return
}
// Casts
func (b Builder) CreateTrunc(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildTrunc(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateZExt(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildZExt(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateSExt(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSExt(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateFPToUI(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFPToUI(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateFPToSI(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFPToSI(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateUIToFP(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildUIToFP(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateSIToFP(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSIToFP(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateFPTrunc(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFPTrunc(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateFPExt(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFPExt(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreatePtrToInt(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildPtrToInt(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateIntToPtr(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildIntToPtr(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateBitCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildBitCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateZExtOrBitCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildZExtOrBitCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateSExtOrBitCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSExtOrBitCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateTruncOrBitCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildTruncOrBitCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateCast(val Value, op Opcode, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildCast(b.C, C.LLVMOpcode(op), val.C, t.C, cname)
return
} //
func (b Builder) CreatePointerCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildPointerCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateIntCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildIntCast(b.C, val.C, t.C, cname)
return
}
func (b Builder) CreateFPCast(val Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFPCast(b.C, val.C, t.C, cname)
return
}
// Comparisons
func (b Builder) CreateICmp(pred IntPredicate, lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildICmp(b.C, C.LLVMIntPredicate(pred), lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateFCmp(pred FloatPredicate, lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildFCmp(b.C, C.LLVMRealPredicate(pred), lhs.C, rhs.C, cname)
return
}
// Miscellaneous instructions
func (b Builder) CreatePHI(t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildPhi(b.C, t.C, cname)
return
}
func (b Builder) CreateCall(fn Value, args []Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
ptr, nvals := llvmValueRefs(args)
v.C = C.LLVMBuildCall(b.C, fn.C, ptr, nvals, cname)
return
}
func (b Builder) CreateSelect(ifv, thenv, elsev Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildSelect(b.C, ifv.C, thenv.C, elsev.C, cname)
return
}
func (b Builder) CreateVAArg(list Value, t Type, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildVAArg(b.C, list.C, t.C, cname)
return
}
func (b Builder) CreateExtractElement(vec, i Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildExtractElement(b.C, vec.C, i.C, cname)
return
}
func (b Builder) CreateInsertElement(vec, elt, i Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildInsertElement(b.C, vec.C, elt.C, i.C, cname)
return
}
func (b Builder) CreateShuffleVector(v1, v2, mask Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildShuffleVector(b.C, v1.C, v2.C, mask.C, cname)
return
}
func (b Builder) CreateExtractValue(agg Value, i int, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildExtractValue(b.C, agg.C, C.unsigned(i), cname)
return
}
func (b Builder) CreateInsertValue(agg, elt Value, i int, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildInsertValue(b.C, agg.C, elt.C, C.unsigned(i), cname)
return
}
func (b Builder) CreateIsNull(val Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildIsNull(b.C, val.C, cname)
return
}
func (b Builder) CreateIsNotNull(val Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildIsNotNull(b.C, val.C, cname)
return
}
func (b Builder) CreatePtrDiff(lhs, rhs Value, name string) (v Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
v.C = C.LLVMBuildPtrDiff(b.C, lhs.C, rhs.C, cname)
return
}
func (b Builder) CreateLandingPad(t Type, personality Value, nclauses int, name string) (l Value) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
l.C = C.LLVMBuildLandingPad(b.C, t.C, personality.C, C.unsigned(nclauses), cname)
return l
}
func (l Value) AddClause(v Value) {
C.LLVMAddClause(l.C, v.C)
}
func (l Value) SetCleanup(cleanup bool) {
C.LLVMSetCleanup(l.C, boolToLLVMBool(cleanup))
}
func (b Builder) CreateResume(ex Value) (v Value) {
v.C = C.LLVMBuildResume(b.C, ex.C)
return
}
//-------------------------------------------------------------------------
// llvm.ModuleProvider
//-------------------------------------------------------------------------
// Changes the type of M so it can be passed to FunctionPassManagers and the
// JIT. They take ModuleProviders for historical reasons.
func NewModuleProviderForModule(m Module) (mp ModuleProvider) {
mp.C = C.LLVMCreateModuleProviderForExistingModule(m.C)
return
}
// Destroys the module M.
func (mp ModuleProvider) Dispose() { C.LLVMDisposeModuleProvider(mp.C) }
//-------------------------------------------------------------------------
// llvm.MemoryBuffer
//-------------------------------------------------------------------------
func NewMemoryBufferFromFile(path string) (b MemoryBuffer, err error) {
var cmsg *C.char
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
fail := C.LLVMCreateMemoryBufferWithContentsOfFile(cpath, &b.C, &cmsg)
if fail != 0 {
b.C = nil
err = errors.New(C.GoString(cmsg))
C.LLVMDisposeMessage(cmsg)
}
return
}
func NewMemoryBufferFromStdin() (b MemoryBuffer, err error) {
var cmsg *C.char
fail := C.LLVMCreateMemoryBufferWithSTDIN(&b.C, &cmsg)
if fail != 0 {
b.C = nil
err = errors.New(C.GoString(cmsg))
C.LLVMDisposeMessage(cmsg)
}
return
}
func (b MemoryBuffer) Bytes() []byte {
cstart := C.LLVMGetBufferStart(b.C)
csize := C.LLVMGetBufferSize(b.C)
return C.GoBytes(unsafe.Pointer(cstart), C.int(csize))
}
func (b MemoryBuffer) Dispose() { C.LLVMDisposeMemoryBuffer(b.C) }
//-------------------------------------------------------------------------
// llvm.PassManager
//-------------------------------------------------------------------------
// 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.
func NewPassManager() (pm PassManager) { pm.C = C.LLVMCreatePassManager(); return }
// 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.
func NewFunctionPassManagerForModule(m Module) (pm PassManager) {
pm.C = C.LLVMCreateFunctionPassManagerForModule(m.C)
return
}
// 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&).
func (pm PassManager) Run(m Module) bool { return C.LLVMRunPassManager(pm.C, m.C) != 0 }
// 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.
func (pm PassManager) InitializeFunc() bool { return C.LLVMInitializeFunctionPassManager(pm.C) != 0 }
// 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&).
func (pm PassManager) RunFunc(f Value) bool { return C.LLVMRunFunctionPassManager(pm.C, f.C) != 0 }
// Finalizes all of the function passes scheduled in in the function pass
// manager. Returns 1 if any of the passes modified the module, 0 otherwise.
// See llvm::FunctionPassManager::doFinalization.
func (pm PassManager) FinalizeFunc() bool { return C.LLVMFinalizeFunctionPassManager(pm.C) != 0 }
// Frees the memory of a pass pipeline. For function pipelines, does not free
// the module provider.
// See llvm::PassManagerBase::~PassManagerBase.
func (pm PassManager) Dispose() { C.LLVMDisposePassManager(pm.C) }

llvm/trunk/bindings/go/llvm/ir_test.go

//===- 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, attr Attribute, name string) {
mod := NewModule("")
defer mod.Dispose()
ftyp := FunctionType(VoidType(), nil, false)
fn := AddFunction(mod, "foo", ftyp)
fn.AddFunctionAttr(attr)
newattr := fn.FunctionAttr()
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.RemoveFunctionAttr(attr)
newattr = fn.FunctionAttr()
if newattr != 0 {
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 := []struct {
attr Attribute
name string
}{
{SanitizeAddressAttribute, "sanitize_address"},
{AlwaysInlineAttribute, "alwaysinline"},
{BuiltinAttribute, "builtin"},
{ByValAttribute, "byval"},
{InAllocaAttribute, "inalloca"},
{InlineHintAttribute, "inlinehint"},
{InRegAttribute, "inreg"},
{JumpTableAttribute, "jumptable"},
{MinSizeAttribute, "minsize"},
{NakedAttribute, "naked"},
{NestAttribute, "nest"},
{NoAliasAttribute, "noalias"},
{NoBuiltinAttribute, "nobuiltin"},
{NoCaptureAttribute, "nocapture"},
{NoDuplicateAttribute, "noduplicate"},
{NoImplicitFloatAttribute, "noimplicitfloat"},
{NoInlineAttribute, "noinline"},
{NonLazyBindAttribute, "nonlazybind"},
{NonNullAttribute, "nonnull"},
{NoRedZoneAttribute, "noredzone"},
{NoReturnAttribute, "noreturn"},
{NoUnwindAttribute, "nounwind"},
{OptimizeNoneAttribute, "optnone"},
{OptimizeForSizeAttribute, "optsize"},
{ReadNoneAttribute, "readnone"},
{ReadOnlyAttribute, "readonly"},
{ReturnedAttribute, "returned"},
{ReturnsTwiceAttribute, "returns_twice"},
{SExtAttribute, "signext"},
{StackProtectAttribute, "ssp"},
{StackProtectReqAttribute, "sspreq"},
{StackProtectStrongAttribute, "sspstrong"},
{StructRetAttribute, "sret"},
{SanitizeThreadAttribute, "sanitize_thread"},
{SanitizeMemoryAttribute, "sanitize_memory"},
{UWTableAttribute, "uwtable"},
{ZExtAttribute, "zeroext"},
{ColdAttribute, "cold"},
}
for _, a := range attrTests {
testAttribute(t, a.attr, a.name)
}
}

llvm/trunk/bindings/go/llvm/linker.go

//===- 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/Linker.h"
#include <stdlib.h>
*/
import "C"
import "errors"
type LinkerMode C.LLVMLinkerMode
const (
LinkerDestroySource = C.LLVMLinkerDestroySource
LinkerPreserveSource = C.LLVMLinkerPreserveSource
)
func LinkModules(Dest, Src Module, Mode LinkerMode) error {
var cmsg *C.char
failed := C.LLVMLinkModules(Dest.C, Src.C, C.LLVMLinkerMode(Mode), &cmsg)
if failed != 0 {
err := errors.New(C.GoString(cmsg))
C.LLVMDisposeMessage(cmsg)
return err
}
return nil
}

llvm/trunk/bindings/go/llvm/llvm_config.go.in

// +build !byollvm
package llvm
/*
#cgo CXXFLAGS: -std=c++11
#cgo CPPFLAGS: @LLVM_CFLAGS@
#cgo LDFLAGS: @LLVM_LDFLAGS@
*/
import "C"
type (run_build_sh int)

llvm/trunk/bindings/go/llvm/llvm_dep.go

//===- llvm_dep.go - creates LLVM dependency ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file ensures that the LLVM libraries are built before using the
// bindings.
//
//===----------------------------------------------------------------------===//
// +build !byollvm
package llvm
var _ run_build_sh

llvm/trunk/bindings/go/llvm/string.go

//===- string.go - Stringer implementation for Type -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the Stringer interface for the Type type.
//
//===----------------------------------------------------------------------===//
package llvm
import "fmt"
func (t TypeKind) String() string {
switch t {
case VoidTypeKind:
return "VoidTypeKind"
case FloatTypeKind:
return "FloatTypeKind"
case DoubleTypeKind:
return "DoubleTypeKind"
case X86_FP80TypeKind:
return "X86_FP80TypeKind"
case FP128TypeKind:
return "FP128TypeKind"
case PPC_FP128TypeKind:
return "PPC_FP128TypeKind"
case LabelTypeKind:
return "LabelTypeKind"
case IntegerTypeKind:
return "IntegerTypeKind"
case FunctionTypeKind:
return "FunctionTypeKind"
case StructTypeKind:
return "StructTypeKind"
case ArrayTypeKind:
return "ArrayTypeKind"
case PointerTypeKind:
return "PointerTypeKind"
case VectorTypeKind:
return "VectorTypeKind"
case MetadataTypeKind:
return "MetadataTypeKind"
}
panic("unreachable")
}
func (t Type) String() string {
ts := typeStringer{s: make(map[Type]string)}
return ts.typeString(t)
}
type typeStringer struct {
s map[Type]string
}
func (ts *typeStringer) typeString(t Type) string {
if s, ok := ts.s[t]; ok {
return s
}
k := t.TypeKind()
s := k.String()
s = s[:len(s)-len("Kind")]
switch k {
case ArrayTypeKind:
s += fmt.Sprintf("(%v[%v])", ts.typeString(t.ElementType()), t.ArrayLength())
case PointerTypeKind:
s += fmt.Sprintf("(%v)", ts.typeString(t.ElementType()))
case FunctionTypeKind:
params := t.ParamTypes()
s += "("
if len(params) > 0 {
s += fmt.Sprintf("%v", ts.typeString(params[0]))
for i := 1; i < len(params); i++ {
s += fmt.Sprintf(", %v", ts.typeString(params[i]))
}
}
s += fmt.Sprintf("):%v", ts.typeString(t.ReturnType()))
case StructTypeKind:
if name := t.StructName(); name != "" {
ts.s[t] = "%" + name
s = fmt.Sprintf("%%%s: %s", name, s)
}
etypes := t.StructElementTypes()
s += "("
if n := len(etypes); n > 0 {
s += ts.typeString(etypes[0])
for i := 1; i < n; i++ {
s += fmt.Sprintf(", %v", ts.typeString(etypes[i]))
}
}
s += ")"
case IntegerTypeKind:
s += fmt.Sprintf("(%d bits)", t.IntTypeWidth())
}
ts.s[t] = s
return s
}

llvm/trunk/bindings/go/llvm/string_test.go

//===- string_test.go - test Stringer implementation for Type -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file tests the Stringer interface for the Type type.
//
//===----------------------------------------------------------------------===//
package llvm
import (
"testing"
)
func TestStringRecursiveType(t *testing.T) {
ctx := NewContext()
defer ctx.Dispose()
s := ctx.StructCreateNamed("recursive")
s.StructSetBody([]Type{s, s}, false)
if str := s.String(); str != "%recursive: StructType(%recursive, %recursive)" {
t.Errorf("incorrect string result %q", str)
}
}

llvm/trunk/bindings/go/llvm/support.go

//===- support.go - 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 bindings for the support component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Support.h"
#include "SupportBindings.h"
#include <stdlib.h>
*/
import "C"
import (
"errors"
"unsafe"
)
// Loads a dynamic library such that it may be used as an LLVM plugin.
// See llvm::sys::DynamicLibrary::LoadLibraryPermanently.
func LoadLibraryPermanently(lib string) error {
var errstr *C.char
libstr := C.CString(lib)
defer C.free(unsafe.Pointer(libstr))
C.LLVMLoadLibraryPermanently2(libstr, &errstr)
if errstr != nil {
err := errors.New(C.GoString(errstr))
C.free(unsafe.Pointer(errstr))
return err
}
return nil
}
// Parse the given arguments using the LLVM command line parser.
// See llvm::cl::ParseCommandLineOptions.
func ParseCommandLineOptions(args []string, overview string) {
argstrs := make([]*C.char, len(args))
for i, arg := range args {
argstrs[i] = C.CString(arg)
defer C.free(unsafe.Pointer(argstrs[i]))
}
overviewstr := C.CString(overview)
defer C.free(unsafe.Pointer(overviewstr))
C.LLVMParseCommandLineOptions(C.int(len(args)), &argstrs[0], overviewstr)
}

llvm/trunk/bindings/go/llvm/target.go

//===- target.go - Bindings for target ------------------------------------===//
//
// 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 target component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Target.h"
#include "llvm-c/TargetMachine.h"
#include <stdlib.h>
*/
import "C"
import "unsafe"
import "errors"
type (
TargetData struct {
C C.LLVMTargetDataRef
}
Target struct {
C C.LLVMTargetRef
}
TargetMachine struct {
C C.LLVMTargetMachineRef
}
ByteOrdering C.enum_LLVMByteOrdering
RelocMode C.LLVMRelocMode
CodeGenOptLevel C.LLVMCodeGenOptLevel
CodeGenFileType C.LLVMCodeGenFileType
CodeModel C.LLVMCodeModel
)
const (
BigEndian ByteOrdering = C.LLVMBigEndian
LittleEndian ByteOrdering = C.LLVMLittleEndian
)
const (
RelocDefault RelocMode = C.LLVMRelocDefault
RelocStatic RelocMode = C.LLVMRelocStatic
RelocPIC RelocMode = C.LLVMRelocPIC
RelocDynamicNoPic RelocMode = C.LLVMRelocDynamicNoPic
)
const (
CodeGenLevelNone CodeGenOptLevel = C.LLVMCodeGenLevelNone
CodeGenLevelLess CodeGenOptLevel = C.LLVMCodeGenLevelLess
CodeGenLevelDefault CodeGenOptLevel = C.LLVMCodeGenLevelDefault
CodeGenLevelAggressive CodeGenOptLevel = C.LLVMCodeGenLevelAggressive
)
const (
CodeModelDefault CodeModel = C.LLVMCodeModelDefault
CodeModelJITDefault CodeModel = C.LLVMCodeModelJITDefault
CodeModelSmall CodeModel = C.LLVMCodeModelSmall
CodeModelKernel CodeModel = C.LLVMCodeModelKernel
CodeModelMedium CodeModel = C.LLVMCodeModelMedium
CodeModelLarge CodeModel = C.LLVMCodeModelLarge
)
const (
AssemblyFile CodeGenFileType = C.LLVMAssemblyFile
ObjectFile CodeGenFileType = C.LLVMObjectFile
)
// InitializeAllTargetInfos - The main program should call this function if it
// wants access to all available targets that LLVM is configured to support.
func InitializeAllTargetInfos() { C.LLVMInitializeAllTargetInfos() }
// InitializeAllTargets - The main program should call this function if it wants
// to link in all available targets that LLVM is configured to support.
func InitializeAllTargets() { C.LLVMInitializeAllTargets() }
func InitializeAllTargetMCs() { C.LLVMInitializeAllTargetMCs() }
func InitializeAllAsmParsers() { C.LLVMInitializeAllAsmParsers() }
func InitializeAllAsmPrinters() { C.LLVMInitializeAllAsmPrinters() }
var initializeNativeTargetError = errors.New("Failed to initialize native target")
// InitializeNativeTarget - 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.
func InitializeNativeTarget() error {
fail := C.LLVMInitializeNativeTarget()
if fail != 0 {
return initializeNativeTargetError
}
return nil
}
func InitializeNativeAsmPrinter() error {
fail := C.LLVMInitializeNativeAsmPrinter()
if fail != 0 {
return initializeNativeTargetError
}
return nil
}
//-------------------------------------------------------------------------
// llvm.TargetData
//-------------------------------------------------------------------------
// Creates target data from a target layout string.
// See the constructor llvm::TargetData::TargetData.
func NewTargetData(rep string) (td TargetData) {
crep := C.CString(rep)
defer C.free(unsafe.Pointer(crep))
td.C = C.LLVMCreateTargetData(crep)
return
}
// Adds target data information to a pass manager. This does not take ownership
// of the target data.
// See the method llvm::PassManagerBase::add.
func (pm PassManager) Add(td TargetData) {
C.LLVMAddTargetData(td.C, pm.C)
}
// Converts target data to a target layout string. The string must be disposed
// with LLVMDisposeMessage.
// See the constructor llvm::TargetData::TargetData.
func (td TargetData) String() (s string) {
cmsg := C.LLVMCopyStringRepOfTargetData(td.C)
s = C.GoString(cmsg)
C.LLVMDisposeMessage(cmsg)
return
}
// Returns the byte order of a target, either BigEndian or LittleEndian.
// See the method llvm::TargetData::isLittleEndian.
func (td TargetData) ByteOrder() ByteOrdering { return ByteOrdering(C.LLVMByteOrder(td.C)) }
// Returns the pointer size in bytes for a target.
// See the method llvm::TargetData::getPointerSize.
func (td TargetData) PointerSize() int { return int(C.LLVMPointerSize(td.C)) }
// Returns the integer type that is the same size as a pointer on a target.
// See the method llvm::TargetData::getIntPtrType.
func (td TargetData) IntPtrType() (t Type) { t.C = C.LLVMIntPtrType(td.C); return }
// Computes the size of a type in bytes for a target.
// See the method llvm::TargetData::getTypeSizeInBits.
func (td TargetData) TypeSizeInBits(t Type) uint64 {
return uint64(C.LLVMSizeOfTypeInBits(td.C, t.C))
}
// Computes the storage size of a type in bytes for a target.
// See the method llvm::TargetData::getTypeStoreSize.
func (td TargetData) TypeStoreSize(t Type) uint64 {
return uint64(C.LLVMStoreSizeOfType(td.C, t.C))
}
// Computes the ABI size of a type in bytes for a target.
// See the method llvm::TargetData::getTypeAllocSize.
func (td TargetData) TypeAllocSize(t Type) uint64 {
return uint64(C.LLVMABISizeOfType(td.C, t.C))
}
// Computes the ABI alignment of a type in bytes for a target.
// See the method llvm::TargetData::getABITypeAlignment.
func (td TargetData) ABITypeAlignment(t Type) int {
return int(C.LLVMABIAlignmentOfType(td.C, t.C))
}
// Computes the call frame alignment of a type in bytes for a target.
// See the method llvm::TargetData::getCallFrameTypeAlignment.
func (td TargetData) CallFrameTypeAlignment(t Type) int {
return int(C.LLVMCallFrameAlignmentOfType(td.C, t.C))
}
// Computes the preferred alignment of a type in bytes for a target.
// See the method llvm::TargetData::getPrefTypeAlignment.
func (td TargetData) PrefTypeAlignment(t Type) int {
return int(C.LLVMPreferredAlignmentOfType(td.C, t.C))
}
// Computes the preferred alignment of a global variable in bytes for a target.
// See the method llvm::TargetData::getPreferredAlignment.
func (td TargetData) PreferredAlignment(g Value) int {
return int(C.LLVMPreferredAlignmentOfGlobal(td.C, g.C))
}
// Computes the structure element that contains the byte offset for a target.
// See the method llvm::StructLayout::getElementContainingOffset.
func (td TargetData) ElementContainingOffset(t Type, offset uint64) int {
return int(C.LLVMElementAtOffset(td.C, t.C, C.ulonglong(offset)))
}
// Computes the byte offset of the indexed struct element for a target.
// See the method llvm::StructLayout::getElementOffset.
func (td TargetData) ElementOffset(t Type, element int) uint64 {
return uint64(C.LLVMOffsetOfElement(td.C, t.C, C.unsigned(element)))
}
// Deallocates a TargetData.
// See the destructor llvm::TargetData::~TargetData.
func (td TargetData) Dispose() { C.LLVMDisposeTargetData(td.C) }
//-------------------------------------------------------------------------
// llvm.Target
//-------------------------------------------------------------------------
func FirstTarget() Target {
return Target{C.LLVMGetFirstTarget()}
}
func (t Target) NextTarget() Target {
return Target{C.LLVMGetNextTarget(t.C)}
}
func GetTargetFromTriple(triple string) (t Target, err error) {
var errstr *C.char
ctriple := C.CString(triple)
defer C.free(unsafe.Pointer(ctriple))
fail := C.LLVMGetTargetFromTriple(ctriple, &t.C, &errstr)
if fail != 0 {
err = errors.New(C.GoString(errstr))
C.free(unsafe.Pointer(errstr))
}
return
}
func (t Target) Name() string {
return C.GoString(C.LLVMGetTargetName(t.C))
}
func (t Target) Description() string {
return C.GoString(C.LLVMGetTargetDescription(t.C))
}
//-------------------------------------------------------------------------
// llvm.TargetMachine
//-------------------------------------------------------------------------
// CreateTargetMachine creates a new TargetMachine.
func (t Target) CreateTargetMachine(Triple string, CPU string, Features string,
Level CodeGenOptLevel, Reloc RelocMode,
CodeModel CodeModel) (tm TargetMachine) {
cTriple := C.CString(Triple)
defer C.free(unsafe.Pointer(cTriple))
cCPU := C.CString(CPU)
defer C.free(unsafe.Pointer(cCPU))
cFeatures := C.CString(Features)
defer C.free(unsafe.Pointer(cFeatures))
tm.C = C.LLVMCreateTargetMachine(t.C, cTriple, cCPU, cFeatures,
C.LLVMCodeGenOptLevel(Level),
C.LLVMRelocMode(Reloc),
C.LLVMCodeModel(CodeModel))
return
}
// Triple returns the triple describing the machine (arch-vendor-os).
func (tm TargetMachine) Triple() string {
cstr := C.LLVMGetTargetMachineTriple(tm.C)
return C.GoString(cstr)
}
// TargetData returns the TargetData for the machine.
func (tm TargetMachine) TargetData() TargetData {
return TargetData{C.LLVMGetTargetMachineData(tm.C)}
}
func (tm TargetMachine) EmitToMemoryBuffer(m Module, ft CodeGenFileType) (MemoryBuffer, error) {
var errstr *C.char
var mb MemoryBuffer
fail := C.LLVMTargetMachineEmitToMemoryBuffer(tm.C, m.C, C.LLVMCodeGenFileType(ft), &errstr, &mb.C)
if fail != 0 {
err := errors.New(C.GoString(errstr))
C.free(unsafe.Pointer(errstr))
return MemoryBuffer{}, err
}
return mb, nil
}
func (tm TargetMachine) AddAnalysisPasses(pm PassManager) {
C.LLVMAddAnalysisPasses(tm.C, pm.C)
}
// Dispose releases resources related to the TargetMachine.
func (tm TargetMachine) Dispose() {
C.LLVMDisposeTargetMachine(tm.C)
}
func DefaultTargetTriple() (triple string) {
cTriple := C.LLVMGetDefaultTargetTriple()
defer C.free(unsafe.Pointer(cTriple))
triple = C.GoString(cTriple)
return
}

llvm/trunk/bindings/go/llvm/transforms_instrumentation.go

//===- transforms_instrumentation.go - Bindings for instrumentation -------===//
//
// 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 instrumentation component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "InstrumentationBindings.h"
#include <stdlib.h>
*/
import "C"
import "unsafe"
func (pm PassManager) AddAddressSanitizerFunctionPass() {
C.LLVMAddAddressSanitizerFunctionPass(pm.C)
}
func (pm PassManager) AddAddressSanitizerModulePass() {
C.LLVMAddAddressSanitizerModulePass(pm.C)
}
func (pm PassManager) AddThreadSanitizerPass() {
C.LLVMAddThreadSanitizerPass(pm.C)
}
func (pm PassManager) AddMemorySanitizerPass() {
C.LLVMAddMemorySanitizerPass(pm.C)
}
func (pm PassManager) AddDataFlowSanitizerPass(abilist string) {
cabilist := C.CString(abilist)
defer C.free(unsafe.Pointer(cabilist))
C.LLVMAddDataFlowSanitizerPass(pm.C, cabilist)
}

llvm/trunk/bindings/go/llvm/transforms_ipo.go

//===- transforms_ipo.go - Bindings for ipo -------------------------------===//
//
// 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 ipo component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Transforms/IPO.h"
*/
import "C"
// helpers
func boolToUnsigned(b bool) C.unsigned {
if b {
return 1
}
return 0
}
func (pm PassManager) AddArgumentPromotionPass() { C.LLVMAddArgumentPromotionPass(pm.C) }
func (pm PassManager) AddConstantMergePass() { C.LLVMAddConstantMergePass(pm.C) }
func (pm PassManager) AddDeadArgEliminationPass() { C.LLVMAddDeadArgEliminationPass(pm.C) }
func (pm PassManager) AddFunctionAttrsPass() { C.LLVMAddFunctionAttrsPass(pm.C) }
func (pm PassManager) AddFunctionInliningPass() { C.LLVMAddFunctionInliningPass(pm.C) }
func (pm PassManager) AddGlobalDCEPass() { C.LLVMAddGlobalDCEPass(pm.C) }
func (pm PassManager) AddGlobalOptimizerPass() { C.LLVMAddGlobalOptimizerPass(pm.C) }
func (pm PassManager) AddIPConstantPropagationPass() { C.LLVMAddIPConstantPropagationPass(pm.C) }
func (pm PassManager) AddPruneEHPass() { C.LLVMAddPruneEHPass(pm.C) }
func (pm PassManager) AddIPSCCPPass() { C.LLVMAddIPSCCPPass(pm.C) }
func (pm PassManager) AddInternalizePass(allButMain bool) {
C.LLVMAddInternalizePass(pm.C, boolToUnsigned(allButMain))
}
func (pm PassManager) AddStripDeadPrototypesPass() { C.LLVMAddStripDeadPrototypesPass(pm.C) }

llvm/trunk/bindings/go/llvm/transforms_pmbuilder.go

//===- transforms_pmbuilder.go - Bindings for PassManagerBuilder ----------===//
//
// 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 PassManagerBuilder class.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Transforms/PassManagerBuilder.h"
*/
import "C"
type PassManagerBuilder struct {
C C.LLVMPassManagerBuilderRef
}
func NewPassManagerBuilder() (pmb PassManagerBuilder) {
pmb.C = C.LLVMPassManagerBuilderCreate()
return
}
func (pmb PassManagerBuilder) SetOptLevel(level int) {
C.LLVMPassManagerBuilderSetOptLevel(pmb.C, C.uint(level))
}
func (pmb PassManagerBuilder) SetSizeLevel(level int) {
C.LLVMPassManagerBuilderSetSizeLevel(pmb.C, C.uint(level))
}
func (pmb PassManagerBuilder) Populate(pm PassManager) {
C.LLVMPassManagerBuilderPopulateModulePassManager(pmb.C, pm.C)
}
func (pmb PassManagerBuilder) PopulateFunc(pm PassManager) {
C.LLVMPassManagerBuilderPopulateFunctionPassManager(pmb.C, pm.C)
}
func (pmb PassManagerBuilder) Dispose() {
C.LLVMPassManagerBuilderDispose(pmb.C)
}

llvm/trunk/bindings/go/llvm/transforms_scalar.go

//===- transforms_scalar.go - Bindings for scalaropts ---------------------===//
//
// 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 scalaropts component.
//
//===----------------------------------------------------------------------===//
package llvm
/*
#include "llvm-c/Transforms/Scalar.h"
*/
import "C"
func (pm PassManager) AddAggressiveDCEPass() { C.LLVMAddAggressiveDCEPass(pm.C) }
func (pm PassManager) AddCFGSimplificationPass() { C.LLVMAddCFGSimplificationPass(pm.C) }
func (pm PassManager) AddDeadStoreEliminationPass() { C.LLVMAddDeadStoreEliminationPass(pm.C) }
func (pm PassManager) AddGVNPass() { C.LLVMAddGVNPass(pm.C) }
func (pm PassManager) AddIndVarSimplifyPass() { C.LLVMAddIndVarSimplifyPass(pm.C) }
func (pm PassManager) AddInstructionCombiningPass() { C.LLVMAddInstructionCombiningPass(pm.C) }
func (pm PassManager) AddJumpThreadingPass() { C.LLVMAddJumpThreadingPass(pm.C) }
func (pm PassManager) AddLICMPass() { C.LLVMAddLICMPass(pm.C) }
func (pm PassManager) AddLoopDeletionPass() { C.LLVMAddLoopDeletionPass(pm.C) }
func (pm PassManager) AddLoopRotatePass() { C.LLVMAddLoopRotatePass(pm.C) }
func (pm PassManager) AddLoopUnrollPass() { C.LLVMAddLoopUnrollPass(pm.C) }
func (pm PassManager) AddLoopUnswitchPass() { C.LLVMAddLoopUnswitchPass(pm.C) }
func (pm PassManager) AddMemCpyOptPass() { C.LLVMAddMemCpyOptPass(pm.C) }
func (pm PassManager) AddPromoteMemoryToRegisterPass() { C.LLVMAddPromoteMemoryToRegisterPass(pm.C) }
func (pm PassManager) AddReassociatePass() { C.LLVMAddReassociatePass(pm.C) }
func (pm PassManager) AddSCCPPass() { C.LLVMAddSCCPPass(pm.C) }
func (pm PassManager) AddScalarReplAggregatesPass() { C.LLVMAddScalarReplAggregatesPass(pm.C) }
func (pm PassManager) AddScalarReplAggregatesPassWithThreshold(threshold int) {
C.LLVMAddScalarReplAggregatesPassWithThreshold(pm.C, C.int(threshold))
}
func (pm PassManager) AddSimplifyLibCallsPass() { C.LLVMAddSimplifyLibCallsPass(pm.C) }
func (pm PassManager) AddTailCallEliminationPass() { C.LLVMAddTailCallEliminationPass(pm.C) }
func (pm PassManager) AddConstantPropagationPass() { C.LLVMAddConstantPropagationPass(pm.C) }
func (pm PassManager) AddDemoteMemoryToRegisterPass() { C.LLVMAddDemoteMemoryToRegisterPass(pm.C) }
func (pm PassManager) AddVerifierPass() { C.LLVMAddVerifierPass(pm.C) }

llvm/trunk/bindings/go/llvm/version.go

package llvm
const Version = "3.6.0svn"

llvm/trunk/cmake/config-ix.cmake

Show First 20 Lines • Show All 485 Lines • ▼ Show 20 Linesif (LLVM_ENABLE_SPHINX)
message(STATUS "Sphinx enabled.") message(STATUS "Sphinx enabled.")
find_package(Sphinx REQUIRED) find_package(Sphinx REQUIRED)
if (LLVM_BUILD_DOCS) if (LLVM_BUILD_DOCS)
add_custom_target(sphinx ALL) add_custom_target(sphinx ALL)
endif() endif()
else() else()
message(STATUS "Sphinx disabled.") message(STATUS "Sphinx disabled.")
endif() endif()
set(LLVM_BINDINGS "")
find_program(GO_EXECUTABLE NAMES go DOC "go executable")
if(GO_EXECUTABLE STREQUAL "GO_EXECUTABLE-NOTFOUND")
message(STATUS "Go bindings disabled.")
else()
execute_process(COMMAND ${GO_EXECUTABLE} run ${CMAKE_SOURCE_DIR}/bindings/go/conftest.go
RESULT_VARIABLE GO_CONFTEST)
if(GO_CONFTEST STREQUAL "0")
set(LLVM_BINDINGS "${LLVM_BINDINGS} go")
message(STATUS "Go bindings enabled.")
else()
message(STATUS "Go bindings disabled, need at least Go 1.2.")
endif()
endif()

llvm/trunk/cmake/modules/AddLLVM.cmake

Show First 20 Lines • Show All 645 Lines • ▼ Show 20 Lines if(LLVM_ENABLE_ASSERTIONS AND NOT MSVC_IDE)
set(ENABLE_ASSERTIONS "1") set(ENABLE_ASSERTIONS "1")
else() else()
set(ENABLE_ASSERTIONS "0") set(ENABLE_ASSERTIONS "0")
endif() endif()
set(HOST_OS ${CMAKE_SYSTEM_NAME}) set(HOST_OS ${CMAKE_SYSTEM_NAME})
set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR}) set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
set(HOST_CC "${CMAKE_C_COMPILER}")
set(HOST_CXX "${CMAKE_CXX_COMPILER}")
configure_file(${input} ${output} @ONLY) configure_file(${input} ${output} @ONLY)
endfunction() endfunction()
# A raw function to create a lit target. This is used to implement the testuite # A raw function to create a lit target. This is used to implement the testuite
# management functions. # management functions.
function(add_lit_target target comment) function(add_lit_target target comment)
parse_arguments(ARG "PARAMS;DEPENDS;ARGS" "" ${ARGN}) parse_arguments(ARG "PARAMS;DEPENDS;ARGS" "" ${ARGN})
set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}") set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}")
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/trunk/configure

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 746 Lines • ▼ Show 20 Lines
INSTALL_DATA INSTALL_DATA
BZIP2 BZIP2
CAT CAT
DOXYGEN DOXYGEN
GROFF GROFF
GZIPBIN GZIPBIN
PDFROFF PDFROFF
ZIP ZIP
GO
OCAMLC OCAMLC
OCAMLOPT OCAMLOPT
OCAMLDEP OCAMLDEP
OCAMLDOC OCAMLDOC
GAS GAS
HAVE_LINK_VERSION_SCRIPT HAVE_LINK_VERSION_SCRIPT
EGREP EGREP
NO_VARIADIC_MACROS NO_VARIADIC_MACROS
▲ Show 20 Lines • Show All 6,103 Lines • ▼ Show 20 Linesif test -n "$ZIP"; then
{ echo "$as_me:$LINENO: result: $ZIP" >&5 { echo "$as_me:$LINENO: result: $ZIP" >&5
echo "${ECHO_T}$ZIP" >&6; } echo "${ECHO_T}$ZIP" >&6; }
else else
{ echo "$as_me:$LINENO: result: no" >&5 { echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6; } echo "${ECHO_T}no" >&6; }
fi fi
# Extract the first word of "go", so it can be a program name with args.
set dummy go; ac_word=$2
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
if test "${ac_cv_path_GO+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
case $GO in
[\\/]* | ?:[\\/]*)
ac_cv_path_GO="$GO" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_path_GO="$as_dir/$ac_word$ac_exec_ext"
echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
GO=$ac_cv_path_GO
if test -n "$GO"; then
{ echo "$as_me:$LINENO: result: $GO" >&5
echo "${ECHO_T}$GO" >&6; }
else
{ echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6; }
fi
for ac_prog in ocamlc for ac_prog in ocamlc
do do
# Extract the first word of "$ac_prog", so it can be a program name with args. # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2 set dummy $ac_prog; ac_word=$2
{ echo "$as_me:$LINENO: checking for $ac_word" >&5 { echo "$as_me:$LINENO: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
if test "${ac_cv_path_OCAMLC+set}" = set; then if test "${ac_cv_path_OCAMLC+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6 echo $ECHO_N "(cached) $ECHO_C" >&6
▲ Show 20 Lines • Show All 11,726 Lines • ▼ Show 20 Lines
_ACEOF _ACEOF
if test "$BINDINGS_TO_BUILD" = auto ; then if test "$BINDINGS_TO_BUILD" = auto ; then
BINDINGS_TO_BUILD="" BINDINGS_TO_BUILD=""
if test "x$OCAMLC" != x -a "x$OCAMLDEP" != x ; then if test "x$OCAMLC" != x -a "x$OCAMLDEP" != x ; then
BINDINGS_TO_BUILD="ocaml $BINDINGS_TO_BUILD" BINDINGS_TO_BUILD="ocaml $BINDINGS_TO_BUILD"
fi fi
if test "x$GO" != x ; then
if $GO run ${srcdir}/bindings/go/conftest.go ; then
BINDINGS_TO_BUILD="go $BINDINGS_TO_BUILD"
fi
fi
fi fi
BINDINGS_TO_BUILD=$BINDINGS_TO_BUILD BINDINGS_TO_BUILD=$BINDINGS_TO_BUILD
binding_prereqs_failed=0 binding_prereqs_failed=0
for a_binding in $BINDINGS_TO_BUILD ; do for a_binding in $BINDINGS_TO_BUILD ; do
case "$a_binding" in case "$a_binding" in
ocaml) ocaml)
Show All 23 Lines else
else else
# ocaml stdlib is outside our prefix; use libdir/ocaml # ocaml stdlib is outside our prefix; use libdir/ocaml
OCAML_LIBDIR=${prefix}/lib/ocaml OCAML_LIBDIR=${prefix}/lib/ocaml
fi fi
fi fi
;; ;;
go)
if test "x$GO" = x ; then
{ echo "$as_me:$LINENO: WARNING: --enable-bindings=go specified, but go not found. Try configure GO=/path/to/go" >&5
echo "$as_me: WARNING: --enable-bindings=go specified, but go not found. Try configure GO=/path/to/go" >&2;}
binding_prereqs_failed=1
else
if $GO run ${srcdir}/bindings/go/conftest.go ; then
:
else
{ echo "$as_me:$LINENO: WARNING: --enable-bindings=go specified, but need at least Go 1.2. Try configure GO=/path/to/go" >&5
echo "$as_me: WARNING: --enable-bindings=go specified, but need at least Go 1.2. Try configure GO=/path/to/go" >&2;}
binding_prereqs_failed=1
fi
fi
;;
esac esac
done done
if test "$binding_prereqs_failed" = 1 ; then if test "$binding_prereqs_failed" = 1 ; then
{ { echo "$as_me:$LINENO: error: Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings." >&5 { { echo "$as_me:$LINENO: error: Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings." >&5
echo "$as_me: error: Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings." >&2;} echo "$as_me: error: Prequisites for bindings not satisfied. Fix them or use configure --disable-bindings." >&2;}
{ (exit 1); exit 1; }; } { (exit 1); exit 1; }; }
fi fi
▲ Show 20 Lines • Show All 1,011 Lines • ▼ Show 20 Lines
INSTALL_DATA!$INSTALL_DATA$ac_delim INSTALL_DATA!$INSTALL_DATA$ac_delim
BZIP2!$BZIP2$ac_delim BZIP2!$BZIP2$ac_delim
CAT!$CAT$ac_delim CAT!$CAT$ac_delim
DOXYGEN!$DOXYGEN$ac_delim DOXYGEN!$DOXYGEN$ac_delim
GROFF!$GROFF$ac_delim GROFF!$GROFF$ac_delim
GZIPBIN!$GZIPBIN$ac_delim GZIPBIN!$GZIPBIN$ac_delim
PDFROFF!$PDFROFF$ac_delim PDFROFF!$PDFROFF$ac_delim
ZIP!$ZIP$ac_delim ZIP!$ZIP$ac_delim
GO!$GO$ac_delim
OCAMLC!$OCAMLC$ac_delim OCAMLC!$OCAMLC$ac_delim
OCAMLOPT!$OCAMLOPT$ac_delim OCAMLOPT!$OCAMLOPT$ac_delim
OCAMLDEP!$OCAMLDEP$ac_delim OCAMLDEP!$OCAMLDEP$ac_delim
OCAMLDOC!$OCAMLDOC$ac_delim OCAMLDOC!$OCAMLDOC$ac_delim
GAS!$GAS$ac_delim GAS!$GAS$ac_delim
HAVE_LINK_VERSION_SCRIPT!$HAVE_LINK_VERSION_SCRIPT$ac_delim HAVE_LINK_VERSION_SCRIPT!$HAVE_LINK_VERSION_SCRIPT$ac_delim
EGREP!$EGREP$ac_delim EGREP!$EGREP$ac_delim
NO_VARIADIC_MACROS!$NO_VARIADIC_MACROS$ac_delim NO_VARIADIC_MACROS!$NO_VARIADIC_MACROS$ac_delim
Show All 29 Lines
ENABLE_VISIBILITY_INLINES_HIDDEN!$ENABLE_VISIBILITY_INLINES_HIDDEN$ac_delim ENABLE_VISIBILITY_INLINES_HIDDEN!$ENABLE_VISIBILITY_INLINES_HIDDEN$ac_delim
RPATH!$RPATH$ac_delim RPATH!$RPATH$ac_delim
RDYNAMIC!$RDYNAMIC$ac_delim RDYNAMIC!$RDYNAMIC$ac_delim
program_prefix!$program_prefix$ac_delim program_prefix!$program_prefix$ac_delim
LIBOBJS!$LIBOBJS$ac_delim LIBOBJS!$LIBOBJS$ac_delim
LTLIBOBJS!$LTLIBOBJS$ac_delim LTLIBOBJS!$LTLIBOBJS$ac_delim
_ACEOF _ACEOF
if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 96; then if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
break break
elif $ac_last_try; then elif $ac_last_try; then
{ { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
{ (exit 1); exit 1; }; } { (exit 1); exit 1; }; }
else else
ac_delim="$ac_delim!$ac_delim _$ac_delim!! " ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
fi fi
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

llvm/trunk/test/Bindings/Go/go.test

; RUN: cd %S/../../../bindings/go/llvm && \
; RUN: env CGO_CPPFLAGS="$(llvm-config --cppflags)" \
; RUN: CGO_CXXFLAGS=-std=c++11 \
; RUN: CGO_LDFLAGS="$(llvm-config --ldflags --libs --system-libs \
; RUN: $(../build.sh --print-components))" \
; RUN: %go test -tags byollvm .
; REQUIRES: shell

llvm/trunk/test/Bindings/Go/lit.local.cfg

import distutils.spawn
import os
import pipes
import shlex
if not 'go' in config.root.llvm_bindings:
config.unsupported = True
# Resolve certain symlinks in the first word of compiler.
#
# This is a Go-specific hack. cgo and other Go tools check $CC and $CXX for the
# substring 'clang' to determine if the compiler is Clang. This won't work if
# $CC is cc and cc is a symlink pointing to clang, as it is on Darwin.
def fixup_compiler_path(compiler):
args = shlex.split(compiler)
path = distutils.spawn.find_executable(args[0])
try:
if path.endswith('/cc') and os.readlink(path) == 'clang':
args[0] = path[:len(path)-2] + 'clang'
except OSError:
skip
try:
if path.endswith('/c++') and os.readlink(path) == 'clang++':
args[0] = path[:len(path)-3] + 'clang++'
except OSError:
skip
return ' '.join([pipes.quote(arg) for arg in args])
config.environment['CC'] = fixup_compiler_path(config.host_cc)
config.environment['CXX'] = fixup_compiler_path(config.host_cxx)

llvm/trunk/test/Bindings/Ocaml/lit.local.cfg

config.suffixes = ['.ml'] config.suffixes = ['.ml']
bindings = set([s.strip() for s in config.root.llvm_bindings.split(',')]) if not 'ocaml' in config.root.llvm_bindings:
if not 'ocaml' in bindings:
config.unsupported = True config.unsupported = True

llvm/trunk/test/Makefile

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lineslit.site.cfg: FORCE
@$(ECHOPATH) s=@LLVM_SOURCE_DIR@=$(LLVM_SRC_ROOT)=g >> lit.tmp @$(ECHOPATH) s=@LLVM_SOURCE_DIR@=$(LLVM_SRC_ROOT)=g >> lit.tmp
@$(ECHOPATH) s=@LLVM_BINARY_DIR@=$(LLVM_OBJ_ROOT)=g >> lit.tmp @$(ECHOPATH) s=@LLVM_BINARY_DIR@=$(LLVM_OBJ_ROOT)=g >> lit.tmp
@$(ECHOPATH) s=@LLVM_TOOLS_DIR@=$(ToolDir)=g >> lit.tmp @$(ECHOPATH) s=@LLVM_TOOLS_DIR@=$(ToolDir)=g >> lit.tmp
@$(ECHOPATH) s=@SHLIBDIR@=$(SharedLibDir)=g >> lit.tmp @$(ECHOPATH) s=@SHLIBDIR@=$(SharedLibDir)=g >> lit.tmp
@$(ECHOPATH) s=@SHLIBEXT@=$(SHLIBEXT)=g >> lit.tmp @$(ECHOPATH) s=@SHLIBEXT@=$(SHLIBEXT)=g >> lit.tmp
@$(ECHOPATH) s=@EXEEXT@=$(EXEEXT)=g >> lit.tmp @$(ECHOPATH) s=@EXEEXT@=$(EXEEXT)=g >> lit.tmp
@$(ECHOPATH) s=@PYTHON_EXECUTABLE@=$(PYTHON)=g >> lit.tmp @$(ECHOPATH) s=@PYTHON_EXECUTABLE@=$(PYTHON)=g >> lit.tmp
@$(ECHOPATH) s=@OCAMLOPT@=$(OCAMLOPT) -cc $(subst *,'\\\"',*$(subst =,"\\=",$(CXX_FOR_OCAMLOPT))*) -cclib -L$(LibDir) -I $(LibDir)/ocaml=g >> lit.tmp @$(ECHOPATH) s=@OCAMLOPT@=$(OCAMLOPT) -cc $(subst *,'\\\"',*$(subst =,"\\=",$(CXX_FOR_OCAMLOPT))*) -cclib -L$(LibDir) -I $(LibDir)/ocaml=g >> lit.tmp
@$(ECHOPATH) s=@GO_EXECUTABLE@=$(GO)=g >> lit.tmp
@$(ECHOPATH) s!@HOST_CC@!$(CC)!g >> lit.tmp
@$(ECHOPATH) s!@HOST_CXX@!$(CXX)!g >> lit.tmp
@$(ECHOPATH) s=@ENABLE_SHARED@=$(ENABLE_SHARED)=g >> lit.tmp @$(ECHOPATH) s=@ENABLE_SHARED@=$(ENABLE_SHARED)=g >> lit.tmp
@$(ECHOPATH) s=@ENABLE_ASSERTIONS@=$(ENABLE_ASSERTIONS)=g >> lit.tmp @$(ECHOPATH) s=@ENABLE_ASSERTIONS@=$(ENABLE_ASSERTIONS)=g >> lit.tmp
@$(ECHOPATH) s=@TARGETS_TO_BUILD@=$(TARGETS_TO_BUILD)=g >> lit.tmp @$(ECHOPATH) s=@TARGETS_TO_BUILD@=$(TARGETS_TO_BUILD)=g >> lit.tmp
@$(ECHOPATH) s=@LLVM_BINDINGS@=$(BINDINGS_TO_BUILD)=g >> lit.tmp @$(ECHOPATH) s=@LLVM_BINDINGS@=$(BINDINGS_TO_BUILD)=g >> lit.tmp
@$(ECHOPATH) s=@HOST_OS@=$(HOST_OS)=g >> lit.tmp @$(ECHOPATH) s=@HOST_OS@=$(HOST_OS)=g >> lit.tmp
@$(ECHOPATH) s=@HOST_ARCH@=$(HOST_ARCH)=g >> lit.tmp @$(ECHOPATH) s=@HOST_ARCH@=$(HOST_ARCH)=g >> lit.tmp
@$(ECHOPATH) s=@HAVE_LIBZ@=$(HAVE_LIBZ)=g >> lit.tmp @$(ECHOPATH) s=@HAVE_LIBZ@=$(HAVE_LIBZ)=g >> lit.tmp
@sed -f lit.tmp $(PROJ_SRC_DIR)/lit.site.cfg.in > $@ @sed -f lit.tmp $(PROJ_SRC_DIR)/lit.site.cfg.in > $@
Show All 14 Lines

llvm/trunk/test/lit.cfg

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
# Similarly, have a macro to use llc with DWARF even when the host is win32. # Similarly, have a macro to use llc with DWARF even when the host is win32.
llc_dwarf = 'llc' llc_dwarf = 'llc'
if re.search(r'win32', config.target_triple): if re.search(r'win32', config.target_triple):
llc_dwarf += ' -mtriple='+config.target_triple.replace('-win32', '-mingw32') llc_dwarf += ' -mtriple='+config.target_triple.replace('-win32', '-mingw32')
config.substitutions.append( ('%llc_dwarf', llc_dwarf) ) config.substitutions.append( ('%llc_dwarf', llc_dwarf) )
# Add site-specific substitutions. # Add site-specific substitutions.
config.substitutions.append( ('%ocamlopt', config.ocamlopt_executable) ) config.substitutions.append( ('%ocamlopt', config.ocamlopt_executable) )
config.substitutions.append( ('%go', config.go_executable) )
config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) ) config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) )
config.substitutions.append( ('%shlibext', config.llvm_shlib_ext) ) config.substitutions.append( ('%shlibext', config.llvm_shlib_ext) )
config.substitutions.append( ('%exeext', config.llvm_exe_ext) ) config.substitutions.append( ('%exeext', config.llvm_exe_ext) )
config.substitutions.append( ('%python', config.python_executable) ) config.substitutions.append( ('%python', config.python_executable) )
# For each occurrence of an llvm tool name as its own word, replace it # For each occurrence of an llvm tool name as its own word, replace it
# with the full path to the build directory holding that tool. This # with the full path to the build directory holding that tool. This
# ensures that we are testing the tools just built and not some random # ensures that we are testing the tools just built and not some random
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

llvm/trunk/test/lit.site.cfg.in

import sys import sys
## Autogenerated by LLVM/Clang configuration. ## Autogenerated by LLVM/Clang configuration.
# Do not edit! # Do not edit!
config.host_triple = "@LLVM_HOST_TRIPLE@" config.host_triple = "@LLVM_HOST_TRIPLE@"
config.target_triple = "@TARGET_TRIPLE@" config.target_triple = "@TARGET_TRIPLE@"
config.llvm_src_root = "@LLVM_SOURCE_DIR@" config.llvm_src_root = "@LLVM_SOURCE_DIR@"
config.llvm_obj_root = "@LLVM_BINARY_DIR@" config.llvm_obj_root = "@LLVM_BINARY_DIR@"
config.llvm_tools_dir = "@LLVM_TOOLS_DIR@" config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
config.llvm_shlib_dir = "@SHLIBDIR@" config.llvm_shlib_dir = "@SHLIBDIR@"
config.llvm_shlib_ext = "@SHLIBEXT@" config.llvm_shlib_ext = "@SHLIBEXT@"
config.llvm_exe_ext = "@EXEEXT@" config.llvm_exe_ext = "@EXEEXT@"
config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@" config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
config.python_executable = "@PYTHON_EXECUTABLE@" config.python_executable = "@PYTHON_EXECUTABLE@"
config.ocamlopt_executable = "@OCAMLOPT@" config.ocamlopt_executable = "@OCAMLOPT@"
config.go_executable = "@GO_EXECUTABLE@"
config.enable_shared = @ENABLE_SHARED@ config.enable_shared = @ENABLE_SHARED@
config.enable_assertions = @ENABLE_ASSERTIONS@ config.enable_assertions = @ENABLE_ASSERTIONS@
config.targets_to_build = "@TARGETS_TO_BUILD@" config.targets_to_build = "@TARGETS_TO_BUILD@"
config.llvm_bindings = "@LLVM_BINDINGS@" config.llvm_bindings = "@LLVM_BINDINGS@".split(' ')
config.host_os = "@HOST_OS@" config.host_os = "@HOST_OS@"
config.host_arch = "@HOST_ARCH@" config.host_arch = "@HOST_ARCH@"
config.host_cc = "@HOST_CC@"
config.host_cxx = "@HOST_CXX@"
config.llvm_use_intel_jitevents = "@LLVM_USE_INTEL_JITEVENTS@" config.llvm_use_intel_jitevents = "@LLVM_USE_INTEL_JITEVENTS@"
config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@" config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
config.have_zlib = "@HAVE_LIBZ@" config.have_zlib = "@HAVE_LIBZ@"
config.enable_ffi = "@LLVM_ENABLE_FFI@" config.enable_ffi = "@LLVM_ENABLE_FFI@"
# Support substitution of the tools_dir with user parameters. This is # Support substitution of the tools_dir with user parameters. This is
# used when we can't determine the tool dir at configuration time. # used when we can't determine the tool dir at configuration time.
try: try:
Show All 9 Lines

llvm/trunk/utils/lit/lit/discovery.py

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines def search1(path_in_suite):
cfgpath = os.path.join(source_path, litConfig.local_config_name) cfgpath = os.path.join(source_path, litConfig.local_config_name)
# If not, just reuse the parent config. # If not, just reuse the parent config.
if not os.path.exists(cfgpath): if not os.path.exists(cfgpath):
return parent return parent
# Otherwise, copy the current config and load the local configuration # Otherwise, copy the current config and load the local configuration
# file into it. # file into it.
config = copy.copy(parent) config = copy.deepcopy(parent)
if litConfig.debug: if litConfig.debug:
litConfig.note('loading local config %r' % cfgpath) litConfig.note('loading local config %r' % cfgpath)
config.load_from_path(cfgpath, litConfig) config.load_from_path(cfgpath, litConfig)
return config return config
def search(path_in_suite): def search(path_in_suite):
key = (ts, path_in_suite) key = (ts, path_in_suite)
res = cache.get(key) res = cache.get(key)
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines