// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Google Mock - a framework for writing C++ mock classes.
//
// This file tests the built-in matchers generated by a script.

#include "gmock/gmock-generated-matchers.h"

#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "gtest/gtest-spi.h"

namespace {

using std::list;
using std::map;
using std::pair;
using std::set;
using std::stringstream;
using std::vector;
using testing::get;
using testing::make_tuple;
using testing::tuple;
using testing::_;
using testing::Args;
using testing::Contains;
using testing::ElementsAre;
using testing::ElementsAreArray;
using testing::Eq;
using testing::Ge;
using testing::Gt;
using testing::Le;
using testing::Lt;
using testing::MakeMatcher;
using testing::Matcher;
using testing::MatcherInterface;
using testing::MatchResultListener;
using testing::Ne;
using testing::Not;
using testing::Pointee;
using testing::PrintToString;
using testing::Ref;
using testing::StaticAssertTypeEq;
using testing::StrEq;
using testing::Value;
using testing::internal::ElementsAreArrayMatcher;
using testing::internal::string;

// Returns the description of the given matcher.
template <typename T>
string Describe(const Matcher<T>& m) {
  stringstream ss;
  m.DescribeTo(&ss);
  return ss.str();
}

// Returns the description of the negation of the given matcher.
template <typename T>
string DescribeNegation(const Matcher<T>& m) {
  stringstream ss;
  m.DescribeNegationTo(&ss);
  return ss.str();
}

// Returns the reason why x matches, or doesn't match, m.
template <typename MatcherType, typename Value>
string Explain(const MatcherType& m, const Value& x) {
  stringstream ss;
  m.ExplainMatchResultTo(x, &ss);
  return ss.str();
}

// Tests Args<k0, ..., kn>(m).

TEST(ArgsTest, AcceptsZeroTemplateArg) {
  const tuple<int, bool> t(5, true);
  EXPECT_THAT(t, Args<>(Eq(tuple<>())));
  EXPECT_THAT(t, Not(Args<>(Ne(tuple<>()))));
}

TEST(ArgsTest, AcceptsOneTemplateArg) {
  const tuple<int, bool> t(5, true);
  EXPECT_THAT(t, Args<0>(Eq(make_tuple(5))));
  EXPECT_THAT(t, Args<1>(Eq(make_tuple(true))));
  EXPECT_THAT(t, Not(Args<1>(Eq(make_tuple(false)))));
}

TEST(ArgsTest, AcceptsTwoTemplateArgs) {
  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT

  EXPECT_THAT(t, (Args<0, 1>(Lt())));
  EXPECT_THAT(t, (Args<1, 2>(Lt())));
  EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
}

TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
  EXPECT_THAT(t, (Args<0, 0>(Eq())));
  EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
}

TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
  EXPECT_THAT(t, (Args<2, 0>(Gt())));
  EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
}

// The MATCHER*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma.  Therefore
// we suppress them here.
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif

MATCHER(SumIsZero, "") {
  return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0;
}

TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
  EXPECT_THAT(make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
  EXPECT_THAT(make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
}

TEST(ArgsTest, CanBeNested) {
  const tuple<short, int, long, int> t(4, 5, 6L, 6);  // NOLINT
  EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
  EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
}

TEST(ArgsTest, CanMatchTupleByValue) {
  typedef tuple<char, int, int> Tuple3;
  const Matcher<Tuple3> m = Args<1, 2>(Lt());
  EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2)));
  EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2)));
}

TEST(ArgsTest, CanMatchTupleByReference) {
  typedef tuple<char, char, int> Tuple3;
  const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
  EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2)));
  EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2)));
}

// Validates that arg is printed as str.
MATCHER_P(PrintsAs, str, "") {
  return testing::PrintToString(arg) == str;
}

TEST(ArgsTest, AcceptsTenTemplateArgs) {
  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
              (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
                  PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
              Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
                      PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
}

TEST(ArgsTest, DescirbesSelfCorrectly) {
  const Matcher<tuple<int, bool, char> > m = Args<2, 0>(Lt());
  EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where "
            "the first < the second",
            Describe(m));
}

TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
  const Matcher<const tuple<int, bool, char, int>&> m =
      Args<0, 2, 3>(Args<2, 0>(Lt()));
  EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple "
            "whose fields (#2, #0) are a pair where the first < the second",
            Describe(m));
}

TEST(ArgsTest, DescribesNegationCorrectly) {
  const Matcher<tuple<int, char> > m = Args<1, 0>(Gt());
  EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair "
            "where the first > the second",
            DescribeNegation(m));
}

TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
  const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq());
  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
            Explain(m, make_tuple(false, 42, 42)));
  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
            Explain(m, make_tuple(false, 42, 43)));
}

// For testing Args<>'s explanation.
class LessThanMatcher : public MatcherInterface<tuple<char, int> > {
 public:
  virtual void DescribeTo(::std::ostream* os) const {}

  virtual bool MatchAndExplain(tuple<char, int> value,
                               MatchResultListener* listener) const {
    const int diff = get<0>(value) - get<1>(value);
    if (diff > 0) {
      *listener << "where the first value is " << diff
                << " more than the second";
    }
    return diff < 0;
  }
};

Matcher<tuple<char, int> > LessThan() {
  return MakeMatcher(new LessThanMatcher);
}

TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
  const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan());
  EXPECT_EQ("whose fields (#0, #2) are ('a' (97, 0x61), 42), "
            "where the first value is 55 more than the second",
            Explain(m, make_tuple('a', 42, 42)));
  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
            Explain(m, make_tuple('\0', 42, 43)));
}

// For testing ExplainMatchResultTo().
class GreaterThanMatcher : public MatcherInterface<int> {
 public:
  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}

  virtual void DescribeTo(::std::ostream* os) const {
    *os << "is greater than " << rhs_;
  }

  virtual bool MatchAndExplain(int lhs,
                               MatchResultListener* listener) const {
    const int diff = lhs - rhs_;
    if (diff > 0) {
      *listener << "which is " << diff << " more than " << rhs_;
    } else if (diff == 0) {
      *listener << "which is the same as " << rhs_;
    } else {
      *listener << "which is " << -diff << " less than " << rhs_;
    }

    return lhs > rhs_;
  }

 private:
  int rhs_;
};

Matcher<int> GreaterThan(int n) {
  return MakeMatcher(new GreaterThanMatcher(n));
}

// Tests for ElementsAre().

TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
  Matcher<const vector<int>&> m = ElementsAre();
  EXPECT_EQ("is empty", Describe(m));
}

TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
  Matcher<vector<int> > m = ElementsAre(Gt(5));
  EXPECT_EQ("has 1 element that is > 5", Describe(m));
}

TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
  Matcher<list<string> > m = ElementsAre(StrEq("one"), "two");
  EXPECT_EQ("has 2 elements where\n"
            "element #0 is equal to \"one\",\n"
            "element #1 is equal to \"two\"", Describe(m));
}

TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
  Matcher<vector<int> > m = ElementsAre();
  EXPECT_EQ("isn't empty", DescribeNegation(m));
}

TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) {
  Matcher<const list<int>& > m = ElementsAre(Gt(5));
  EXPECT_EQ("doesn't have 1 element, or\n"
            "element #0 isn't > 5", DescribeNegation(m));
}

TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
  Matcher<const list<string>& > m = ElementsAre("one", "two");
  EXPECT_EQ("doesn't have 2 elements, or\n"
            "element #0 isn't equal to \"one\", or\n"
            "element #1 isn't equal to \"two\"", DescribeNegation(m));
}

TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
  Matcher<const list<int>& > m = ElementsAre(1, Ne(2));

  list<int> test_list;
  test_list.push_back(1);
  test_list.push_back(3);
  EXPECT_EQ("", Explain(m, test_list));  // No need to explain anything.
}

TEST(ElementsAreTest, ExplainsNonTrivialMatch) {
  Matcher<const vector<int>& > m =
      ElementsAre(GreaterThan(1), 0, GreaterThan(2));

  const int a[] = { 10, 0, 100 };
  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n"
            "and whose element #2 matches, which is 98 more than 2",
            Explain(m, test_vector));
}

TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
  Matcher<const list<int>& > m = ElementsAre(1, 3);

  list<int> test_list;
  // No need to explain when the container is empty.
  EXPECT_EQ("", Explain(m, test_list));

  test_list.push_back(1);
  EXPECT_EQ("which has 1 element", Explain(m, test_list));
}

TEST(ElementsAreTest, CanExplainMismatchRightSize) {
  Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5));

  vector<int> v;
  v.push_back(2);
  v.push_back(1);
  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));

  v[0] = 1;
  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
            Explain(m, v));
}

TEST(ElementsAreTest, MatchesOneElementVector) {
  vector<string> test_vector;
  test_vector.push_back("test string");

  EXPECT_THAT(test_vector, ElementsAre(StrEq("test string")));
}

TEST(ElementsAreTest, MatchesOneElementList) {
  list<string> test_list;
  test_list.push_back("test string");

  EXPECT_THAT(test_list, ElementsAre("test string"));
}

TEST(ElementsAreTest, MatchesThreeElementVector) {
  vector<string> test_vector;
  test_vector.push_back("one");
  test_vector.push_back("two");
  test_vector.push_back("three");

  EXPECT_THAT(test_vector, ElementsAre("one", StrEq("two"), _));
}

TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
  vector<int> test_vector;
  test_vector.push_back(4);

  EXPECT_THAT(test_vector, ElementsAre(Eq(4)));
}

TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
  vector<int> test_vector;
  test_vector.push_back(4);

  EXPECT_THAT(test_vector, ElementsAre(_));
}

TEST(ElementsAreTest, MatchesOneElementValue) {
  vector<int> test_vector;
  test_vector.push_back(4);

  EXPECT_THAT(test_vector, ElementsAre(4));
}

TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) {
  vector<int> test_vector;
  test_vector.push_back(1);
  test_vector.push_back(2);
  test_vector.push_back(3);

  EXPECT_THAT(test_vector, ElementsAre(1, Eq(2), _));
}

TEST(ElementsAreTest, MatchesTenElementVector) {
  const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));

  EXPECT_THAT(test_vector,
              // The element list can contain values and/or matchers
              // of different types.
              ElementsAre(0, Ge(0), _, 3, 4, Ne(2), Eq(6), 7, 8, _));
}

TEST(ElementsAreTest, DoesNotMatchWrongSize) {
  vector<string> test_vector;
  test_vector.push_back("test string");
  test_vector.push_back("test string");

  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
  EXPECT_FALSE(m.Matches(test_vector));
}

TEST(ElementsAreTest, DoesNotMatchWrongValue) {
  vector<string> test_vector;
  test_vector.push_back("other string");

  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
  EXPECT_FALSE(m.Matches(test_vector));
}

TEST(ElementsAreTest, DoesNotMatchWrongOrder) {
  vector<string> test_vector;
  test_vector.push_back("one");
  test_vector.push_back("three");
  test_vector.push_back("two");

  Matcher<vector<string> > m = ElementsAre(
    StrEq("one"), StrEq("two"), StrEq("three"));
  EXPECT_FALSE(m.Matches(test_vector));
}

TEST(ElementsAreTest, WorksForNestedContainer) {
  const char* strings[] = {
    "Hi",
    "world"
  };

  vector<list<char> > nested;
  for (size_t i = 0; i < GTEST_ARRAY_SIZE_(strings); i++) {
    nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
  }

  EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')),
                                  ElementsAre('w', 'o', _, _, 'd')));
  EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'),
                                      ElementsAre('w', 'o', _, _, 'd'))));
}

TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
  int a[] = { 0, 1, 2 };
  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));

  EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2])));
  EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2]))));
}

TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) {
  int a[] = { 0, 1, 2 };
  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));

  EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _)));
  EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3))));
}

TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
  int array[] = { 0, 1, 2 };
  EXPECT_THAT(array, ElementsAre(0, 1, _));
  EXPECT_THAT(array, Not(ElementsAre(1, _, _)));
  EXPECT_THAT(array, Not(ElementsAre(0, _)));
}

class NativeArrayPassedAsPointerAndSize {
 public:
  NativeArrayPassedAsPointerAndSize() {}

  MOCK_METHOD2(Helper, void(int* array, int size));

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
};

TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
  int array[] = { 0, 1 };
  ::testing::tuple<int*, size_t> array_as_tuple(array, 2);
  EXPECT_THAT(array_as_tuple, ElementsAre(0, 1));
  EXPECT_THAT(array_as_tuple, Not(ElementsAre(0)));

  NativeArrayPassedAsPointerAndSize helper;
  EXPECT_CALL(helper, Helper(_, _))
      .With(ElementsAre(0, 1));
  helper.Helper(array, 2);
}

TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) {
  const char a2[][3] = { "hi", "lo" };
  EXPECT_THAT(a2, ElementsAre(ElementsAre('h', 'i', '\0'),
                              ElementsAre('l', 'o', '\0')));
  EXPECT_THAT(a2, ElementsAre(StrEq("hi"), StrEq("lo")));
  EXPECT_THAT(a2, ElementsAre(Not(ElementsAre('h', 'o', '\0')),
                              ElementsAre('l', 'o', '\0')));
}

TEST(ElementsAreTest, AcceptsStringLiteral) {
  string array[] = { "hi", "one", "two" };
  EXPECT_THAT(array, ElementsAre("hi", "one", "two"));
  EXPECT_THAT(array, Not(ElementsAre("hi", "one", "too")));
}

#ifndef _MSC_VER

// The following test passes a value of type const char[] to a
// function template that expects const T&.  Some versions of MSVC
// generates a compiler error C2665 for that.  We believe it's a bug
// in MSVC.  Therefore this test is #if-ed out for MSVC.

// Declared here with the size unknown.  Defined AFTER the following test.
extern const char kHi[];

TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) {
  // The size of kHi is not known in this test, but ElementsAre() should
  // still accept it.

  string array1[] = { "hi" };
  EXPECT_THAT(array1, ElementsAre(kHi));

  string array2[] = { "ho" };
  EXPECT_THAT(array2, Not(ElementsAre(kHi)));
}

const char kHi[] = "hi";

#endif  // _MSC_VER

TEST(ElementsAreTest, MakesCopyOfArguments) {
  int x = 1;
  int y = 2;
  // This should make a copy of x and y.
  ::testing::internal::ElementsAreMatcher<testing::tuple<int, int> >
          polymorphic_matcher = ElementsAre(x, y);
  // Changing x and y now shouldn't affect the meaning of the above matcher.
  x = y = 0;
  const int array1[] = { 1, 2 };
  EXPECT_THAT(array1, polymorphic_matcher);
  const int array2[] = { 0, 0 };
  EXPECT_THAT(array2, Not(polymorphic_matcher));
}


// Tests for ElementsAreArray().  Since ElementsAreArray() shares most
// of the implementation with ElementsAre(), we don't test it as
// thoroughly here.

TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) {
  const int a[] = { 1, 2, 3 };

  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_THAT(test_vector, ElementsAreArray(a));

  test_vector[2] = 0;
  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
}

TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) {
  const char* a[] = { "one", "two", "three" };

  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_THAT(test_vector, ElementsAreArray(a, GTEST_ARRAY_SIZE_(a)));

  const char** p = a;
  test_vector[0] = "1";
  EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GTEST_ARRAY_SIZE_(a))));
}

TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) {
  const char* a[] = { "one", "two", "three" };

  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_THAT(test_vector, ElementsAreArray(a));

  test_vector[0] = "1";
  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
}

TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) {
  const Matcher<string> kMatcherArray[] =
    { StrEq("one"), StrEq("two"), StrEq("three") };

  vector<string> test_vector;
  test_vector.push_back("one");
  test_vector.push_back("two");
  test_vector.push_back("three");
  EXPECT_THAT(test_vector, ElementsAreArray(kMatcherArray));

  test_vector.push_back("three");
  EXPECT_THAT(test_vector, Not(ElementsAreArray(kMatcherArray)));
}

TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
  const int a[] = { 1, 2, 3 };
  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_THAT(test_vector, ElementsAreArray(expected));
  test_vector.push_back(4);
  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
}

#if GTEST_HAS_STD_INITIALIZER_LIST_

TEST(ElementsAreArrayTest, TakesInitializerList) {
  const int a[5] = { 1, 2, 3, 4, 5 };
  EXPECT_THAT(a, ElementsAreArray({ 1, 2, 3, 4, 5 }));
  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 5, 4 })));
  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 4, 6 })));
}

TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) {
  const string a[5] = { "a", "b", "c", "d", "e" };
  EXPECT_THAT(a, ElementsAreArray({ "a", "b", "c", "d", "e" }));
  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "e", "d" })));
  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "d", "ef" })));
}

TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
  const int a[5] = { 1, 2, 3, 4, 5 };
  EXPECT_THAT(a, ElementsAreArray(
      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(5) }));
  EXPECT_THAT(a, Not(ElementsAreArray(
      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(6) })));
}

TEST(ElementsAreArrayTest,
     TakesInitializerListOfDifferentTypedMatchers) {
  const int a[5] = { 1, 2, 3, 4, 5 };
  // The compiler cannot infer the type of the initializer list if its
  // elements have different types.  We must explicitly specify the
  // unified element type in this case.
  EXPECT_THAT(a, ElementsAreArray<Matcher<int> >(
      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(5) }));
  EXPECT_THAT(a, Not(ElementsAreArray<Matcher<int> >(
      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) })));
}

#endif  // GTEST_HAS_STD_INITIALIZER_LIST_

TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
  const int a[] = { 1, 2, 3 };
  const Matcher<int> kMatchers[] = { Eq(1), Eq(2), Eq(3) };
  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  const vector<Matcher<int> > expected(
      kMatchers, kMatchers + GTEST_ARRAY_SIZE_(kMatchers));
  EXPECT_THAT(test_vector, ElementsAreArray(expected));
  test_vector.push_back(4);
  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
}

TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
  const int a[] = { 1, 2, 3 };
  const vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
  EXPECT_THAT(test_vector, ElementsAreArray(expected.begin(), expected.end()));
  // Pointers are iterators, too.
  EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a)));
  // The empty range of NULL pointers should also be okay.
  int* const null_int = NULL;
  EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int)));
  EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int));
}

// Since ElementsAre() and ElementsAreArray() share much of the
// implementation, we only do a sanity test for native arrays here.
TEST(ElementsAreArrayTest, WorksWithNativeArray) {
  ::std::string a[] = { "hi", "ho" };
  ::std::string b[] = { "hi", "ho" };

  EXPECT_THAT(a, ElementsAreArray(b));
  EXPECT_THAT(a, ElementsAreArray(b, 2));
  EXPECT_THAT(a, Not(ElementsAreArray(b, 1)));
}

TEST(ElementsAreArrayTest, SourceLifeSpan) {
  const int a[] = { 1, 2, 3 };
  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
  vector<int> expect(a, a + GTEST_ARRAY_SIZE_(a));
  ElementsAreArrayMatcher<int> matcher_maker =
      ElementsAreArray(expect.begin(), expect.end());
  EXPECT_THAT(test_vector, matcher_maker);
  // Changing in place the values that initialized matcher_maker should not
  // affect matcher_maker anymore. It should have made its own copy of them.
  typedef vector<int>::iterator Iter;
  for (Iter it = expect.begin(); it != expect.end(); ++it) { *it += 10; }
  EXPECT_THAT(test_vector, matcher_maker);
  test_vector.push_back(3);
  EXPECT_THAT(test_vector, Not(matcher_maker));
}

// Tests for the MATCHER*() macro family.

// Tests that a simple MATCHER() definition works.

MATCHER(IsEven, "") { return (arg % 2) == 0; }

TEST(MatcherMacroTest, Works) {
  const Matcher<int> m = IsEven();
  EXPECT_TRUE(m.Matches(6));
  EXPECT_FALSE(m.Matches(7));

  EXPECT_EQ("is even", Describe(m));
  EXPECT_EQ("not (is even)", DescribeNegation(m));
  EXPECT_EQ("", Explain(m, 6));
  EXPECT_EQ("", Explain(m, 7));
}

// This also tests that the description string can reference 'negation'.
MATCHER(IsEven2, negation ? "is odd" : "is even") {
  if ((arg % 2) == 0) {
    // Verifies that we can stream to result_listener, a listener
    // supplied by the MATCHER macro implicitly.
    *result_listener << "OK";
    return true;
  } else {
    *result_listener << "% 2 == " << (arg % 2);
    return false;
  }
}

// This also tests that the description string can reference matcher
// parameters.
MATCHER_P2(EqSumOf, x, y,
           string(negation ? "doesn't equal" : "equals") + " the sum of " +
           PrintToString(x) + " and " + PrintToString(y)) {
  if (arg == (x + y)) {
    *result_listener << "OK";
    return true;
  } else {
    // Verifies that we can stream to the underlying stream of
    // result_listener.
    if (result_listener->stream() != NULL) {
      *result_listener->stream() << "diff == " << (x + y - arg);
    }
    return false;
  }
}

// Tests that the matcher description can reference 'negation' and the
// matcher parameters.
TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
  const Matcher<int> m1 = IsEven2();
  EXPECT_EQ("is even", Describe(m1));
  EXPECT_EQ("is odd", DescribeNegation(m1));

  const Matcher<int> m2 = EqSumOf(5, 9);
  EXPECT_EQ("equals the sum of 5 and 9", Describe(m2));
  EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2));
}

// Tests explaining match result in a MATCHER* macro.
TEST(MatcherMacroTest, CanExplainMatchResult) {
  const Matcher<int> m1 = IsEven2();
  EXPECT_EQ("OK", Explain(m1, 4));
  EXPECT_EQ("% 2 == 1", Explain(m1, 5));

  const Matcher<int> m2 = EqSumOf(1, 2);
  EXPECT_EQ("OK", Explain(m2, 3));
  EXPECT_EQ("diff == -1", Explain(m2, 4));
}

// Tests that the body of MATCHER() can reference the type of the
// value being matched.

MATCHER(IsEmptyString, "") {
  StaticAssertTypeEq< ::std::string, arg_type>();
  return arg == "";
}

MATCHER(IsEmptyStringByRef, "") {
  StaticAssertTypeEq<const ::std::string&, arg_type>();
  return arg == "";
}

TEST(MatcherMacroTest, CanReferenceArgType) {
  const Matcher< ::std::string> m1 = IsEmptyString();
  EXPECT_TRUE(m1.Matches(""));

  const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
  EXPECT_TRUE(m2.Matches(""));
}

// Tests that MATCHER() can be used in a namespace.

namespace matcher_test {
MATCHER(IsOdd, "") { return (arg % 2) != 0; }
}  // namespace matcher_test

TEST(MatcherMacroTest, WorksInNamespace) {
  Matcher<int> m = matcher_test::IsOdd();
  EXPECT_FALSE(m.Matches(4));
  EXPECT_TRUE(m.Matches(5));
}

// Tests that Value() can be used to compose matchers.
MATCHER(IsPositiveOdd, "") {
  return Value(arg, matcher_test::IsOdd()) && arg > 0;
}

TEST(MatcherMacroTest, CanBeComposedUsingValue) {
  EXPECT_THAT(3, IsPositiveOdd());
  EXPECT_THAT(4, Not(IsPositiveOdd()));
  EXPECT_THAT(-1, Not(IsPositiveOdd()));
}

// Tests that a simple MATCHER_P() definition works.

MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }

TEST(MatcherPMacroTest, Works) {
  const Matcher<int> m = IsGreaterThan32And(5);
  EXPECT_TRUE(m.Matches(36));
  EXPECT_FALSE(m.Matches(5));

  EXPECT_EQ("is greater than 32 and 5", Describe(m));
  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
  EXPECT_EQ("", Explain(m, 36));
  EXPECT_EQ("", Explain(m, 5));
}

// Tests that the description is calculated correctly from the matcher name.
MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }

TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
  const Matcher<int> m = _is_Greater_Than32and_(5);

  EXPECT_EQ("is greater than 32 and 5", Describe(m));
  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
  EXPECT_EQ("", Explain(m, 36));
  EXPECT_EQ("", Explain(m, 5));
}

// Tests that a MATCHER_P matcher can be explicitly instantiated with
// a reference parameter type.

class UncopyableFoo {
 public:
  explicit UncopyableFoo(char value) : value_(value) {}
 private:
  UncopyableFoo(const UncopyableFoo&);
  void operator=(const UncopyableFoo&);

  char value_;
};

MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }

TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
  UncopyableFoo foo1('1'), foo2('2');
  const Matcher<const UncopyableFoo&> m =
      ReferencesUncopyable<const UncopyableFoo&>(foo1);

  EXPECT_TRUE(m.Matches(foo1));
  EXPECT_FALSE(m.Matches(foo2));

  // We don't want the address of the parameter printed, as most
  // likely it will just annoy the user.  If the address is
  // interesting, the user should consider passing the parameter by
  // pointer instead.
  EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m));
}


// Tests that the body of MATCHER_Pn() can reference the parameter
// types.

MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") {
  StaticAssertTypeEq<int, foo_type>();
  StaticAssertTypeEq<long, bar_type>();  // NOLINT
  StaticAssertTypeEq<char, baz_type>();
  return arg == 0;
}

TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
  EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a'));
}

// Tests that a MATCHER_Pn matcher can be explicitly instantiated with
// reference parameter types.

MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
  return &arg == &variable1 || &arg == &variable2;
}

TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
  UncopyableFoo foo1('1'), foo2('2'), foo3('3');
  const Matcher<const UncopyableFoo&> m =
      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);

  EXPECT_TRUE(m.Matches(foo1));
  EXPECT_TRUE(m.Matches(foo2));
  EXPECT_FALSE(m.Matches(foo3));
}

TEST(MatcherPnMacroTest,
     GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
  UncopyableFoo foo1('1'), foo2('2');
  const Matcher<const UncopyableFoo&> m =
      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);

  // We don't want the addresses of the parameters printed, as most
  // likely they will just annoy the user.  If the addresses are
  // interesting, the user should consider passing the parameters by
  // pointers instead.
  EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)",
            Describe(m));
}

// Tests that a simple MATCHER_P2() definition works.

MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }

TEST(MatcherPnMacroTest, Works) {
  const Matcher<const long&> m = IsNotInClosedRange(10, 20);  // NOLINT
  EXPECT_TRUE(m.Matches(36L));
  EXPECT_FALSE(m.Matches(15L));

  EXPECT_EQ("is not in closed range (10, 20)", Describe(m));
  EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m));
  EXPECT_EQ("", Explain(m, 36L));
  EXPECT_EQ("", Explain(m, 15L));
}

// Tests that MATCHER*() definitions can be overloaded on the number
// of parameters; also tests MATCHER_Pn() where n >= 3.

MATCHER(EqualsSumOf, "") { return arg == 0; }
MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
  return arg == a + b + c + d + e + f;
}
MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
  return arg == a + b + c + d + e + f + g;
}
MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
  return arg == a + b + c + d + e + f + g + h;
}
MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
  return arg == a + b + c + d + e + f + g + h + i;
}
MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") {
  return arg == a + b + c + d + e + f + g + h + i + j;
}

TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
  EXPECT_THAT(0, EqualsSumOf());
  EXPECT_THAT(1, EqualsSumOf(1));
  EXPECT_THAT(12, EqualsSumOf(10, 2));
  EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
  EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
  EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
  EXPECT_THAT("abcdef",
              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'));
  EXPECT_THAT("abcdefg",
              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g'));
  EXPECT_THAT("abcdefgh",
              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                          "h"));
  EXPECT_THAT("abcdefghi",
              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                          "h", 'i'));
  EXPECT_THAT("abcdefghij",
              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                          "h", 'i', ::std::string("j")));

  EXPECT_THAT(1, Not(EqualsSumOf()));
  EXPECT_THAT(-1, Not(EqualsSumOf(1)));
  EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
  EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
  EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
  EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
  EXPECT_THAT("abcdef ",
              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')));
  EXPECT_THAT("abcdefg ",
              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f',
                              'g')));
  EXPECT_THAT("abcdefgh ",
              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                              "h")));
  EXPECT_THAT("abcdefghi ",
              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                              "h", 'i')));
  EXPECT_THAT("abcdefghij ",
              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
                              "h", 'i', ::std::string("j"))));
}

// Tests that a MATCHER_Pn() definition can be instantiated with any
// compatible parameter types.
TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
  EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3)));
  EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d"));

  EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
  EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
}

// Tests that the matcher body can promote the parameter types.

MATCHER_P2(EqConcat, prefix, suffix, "") {
  // The following lines promote the two parameters to desired types.
  std::string prefix_str(prefix);
  char suffix_char = static_cast<char>(suffix);
  return arg == prefix_str + suffix_char;
}

TEST(MatcherPnMacroTest, SimpleTypePromotion) {
  Matcher<std::string> no_promo =
      EqConcat(std::string("foo"), 't');
  Matcher<const std::string&> promo =
      EqConcat("foo", static_cast<int>('t'));
  EXPECT_FALSE(no_promo.Matches("fool"));
  EXPECT_FALSE(promo.Matches("fool"));
  EXPECT_TRUE(no_promo.Matches("foot"));
  EXPECT_TRUE(promo.Matches("foot"));
}

// Verifies the type of a MATCHER*.

TEST(MatcherPnMacroTest, TypesAreCorrect) {
  // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable.
  EqualsSumOfMatcher a0 = EqualsSumOf();

  // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable.
  EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);

  // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk
  // variable, and so on.
  EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2');
  EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3');
  EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4');
  EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
      EqualsSumOf(1, 2, 3, 4, '5');
  EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
      EqualsSumOf(1, 2, 3, 4, 5, '6');
  EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
      EqualsSumOf(1, 2, 3, 4, 5, 6, '7');
  EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8');
  EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9');
  EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');

  // Avoid "unused variable" warnings.
  (void)a0;
  (void)a1;
  (void)a2;
  (void)a3;
  (void)a4;
  (void)a5;
  (void)a6;
  (void)a7;
  (void)a8;
  (void)a9;
  (void)a10;
}

// Tests that matcher-typed parameters can be used in Value() inside a
// MATCHER_Pn definition.

// Succeeds if arg matches exactly 2 of the 3 matchers.
MATCHER_P3(TwoOf, m1, m2, m3, "") {
  const int count = static_cast<int>(Value(arg, m1))
      + static_cast<int>(Value(arg, m2)) + static_cast<int>(Value(arg, m3));
  return count == 2;
}

TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
  EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
  EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
}

// Tests Contains().

TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
  list<int> some_list;
  some_list.push_back(3);
  some_list.push_back(1);
  some_list.push_back(2);
  EXPECT_THAT(some_list, Contains(1));
  EXPECT_THAT(some_list, Contains(Gt(2.5)));
  EXPECT_THAT(some_list, Contains(Eq(2.0f)));

  list<string> another_list;
  another_list.push_back("fee");
  another_list.push_back("fie");
  another_list.push_back("foe");
  another_list.push_back("fum");
  EXPECT_THAT(another_list, Contains(string("fee")));
}

TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) {
  list<int> some_list;
  some_list.push_back(3);
  some_list.push_back(1);
  EXPECT_THAT(some_list, Not(Contains(4)));
}

TEST(ContainsTest, SetMatchesWhenElementIsInContainer) {
  set<int> some_set;
  some_set.insert(3);
  some_set.insert(1);
  some_set.insert(2);
  EXPECT_THAT(some_set, Contains(Eq(1.0)));
  EXPECT_THAT(some_set, Contains(Eq(3.0f)));
  EXPECT_THAT(some_set, Contains(2));

  set<const char*> another_set;
  another_set.insert("fee");
  another_set.insert("fie");
  another_set.insert("foe");
  another_set.insert("fum");
  EXPECT_THAT(another_set, Contains(Eq(string("fum"))));
}

TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
  set<int> some_set;
  some_set.insert(3);
  some_set.insert(1);
  EXPECT_THAT(some_set, Not(Contains(4)));

  set<const char*> c_string_set;
  c_string_set.insert("hello");
  EXPECT_THAT(c_string_set, Not(Contains(string("hello").c_str())));
}

TEST(ContainsTest, ExplainsMatchResultCorrectly) {
  const int a[2] = { 1, 2 };
  Matcher<const int (&)[2]> m = Contains(2);
  EXPECT_EQ("whose element #1 matches", Explain(m, a));

  m = Contains(3);
  EXPECT_EQ("", Explain(m, a));

  m = Contains(GreaterThan(0));
  EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a));

  m = Contains(GreaterThan(10));
  EXPECT_EQ("", Explain(m, a));
}

TEST(ContainsTest, DescribesItselfCorrectly) {
  Matcher<vector<int> > m = Contains(1);
  EXPECT_EQ("contains at least one element that is equal to 1", Describe(m));

  Matcher<vector<int> > m2 = Not(m);
  EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2));
}

TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
  map<const char*, int> my_map;
  const char* bar = "a string";
  my_map[bar] = 2;
  EXPECT_THAT(my_map, Contains(pair<const char* const, int>(bar, 2)));

  map<string, int> another_map;
  another_map["fee"] = 1;
  another_map["fie"] = 2;
  another_map["foe"] = 3;
  another_map["fum"] = 4;
  EXPECT_THAT(another_map, Contains(pair<const string, int>(string("fee"), 1)));
  EXPECT_THAT(another_map, Contains(pair<const string, int>("fie", 2)));
}

TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) {
  map<int, int> some_map;
  some_map[1] = 11;
  some_map[2] = 22;
  EXPECT_THAT(some_map, Not(Contains(pair<const int, int>(2, 23))));
}

TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
  const char* string_array[] = { "fee", "fie", "foe", "fum" };
  EXPECT_THAT(string_array, Contains(Eq(string("fum"))));
}

TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
  int int_array[] = { 1, 2, 3, 4 };
  EXPECT_THAT(int_array, Not(Contains(5)));
}

TEST(ContainsTest, AcceptsMatcher) {
  const int a[] = { 1, 2, 3 };
  EXPECT_THAT(a, Contains(Gt(2)));
  EXPECT_THAT(a, Not(Contains(Gt(4))));
}

TEST(ContainsTest, WorksForNativeArrayAsTuple) {
  const int a[] = { 1, 2 };
  const int* const pointer = a;
  EXPECT_THAT(make_tuple(pointer, 2), Contains(1));
  EXPECT_THAT(make_tuple(pointer, 2), Not(Contains(Gt(3))));
}

TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
  int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
  EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6)));
  EXPECT_THAT(a, Contains(Contains(5)));
  EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5))));
  EXPECT_THAT(a, Contains(Not(Contains(5))));
}

TEST(AllOfTest, HugeMatcher) {
  // Verify that using AllOf with many arguments doesn't cause
  // the compiler to exceed template instantiation depth limit.
  EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _,
                                testing::AllOf(_, _, _, _, _, _, _, _, _, _)));
}

TEST(AnyOfTest, HugeMatcher) {
  // Verify that using AnyOf with many arguments doesn't cause
  // the compiler to exceed template instantiation depth limit.
  EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _,
                                testing::AnyOf(_, _, _, _, _, _, _, _, _, _)));
}

namespace adl_test {

// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf
// don't issue unqualified recursive calls.  If they do, the argument dependent
// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found
// as a candidate and the compilation will break due to an ambiguous overload.

// The matcher must be in the same namespace as AllOf/AnyOf to make argument
// dependent lookup find those.
MATCHER(M, "") { return true; }

template <typename T1, typename T2>
bool AllOf(const T1& t1, const T2& t2) { return true; }

TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
  EXPECT_THAT(42, testing::AllOf(
      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
}

template <typename T1, typename T2> bool
AnyOf(const T1& t1, const T2& t2) { return true; }

TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
  EXPECT_THAT(42, testing::AnyOf(
      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
}

}  // namespace adl_test

#ifdef _MSC_VER
# pragma warning(pop)
#endif

}  // namespace
/a>
<a id='n1147' href='#n1147'>1147</a>
<a id='n1148' href='#n1148'>1148</a>
<a id='n1149' href='#n1149'>1149</a>
<a id='n1150' href='#n1150'>1150</a>
<a id='n1151' href='#n1151'>1151</a>
<a id='n1152' href='#n1152'>1152</a>
<a id='n1153' href='#n1153'>1153</a>
<a id='n1154' href='#n1154'>1154</a>
<a id='n1155' href='#n1155'>1155</a>
<a id='n1156' href='#n1156'>1156</a>
<a id='n1157' href='#n1157'>1157</a>
<a id='n1158' href='#n1158'>1158</a>
<a id='n1159' href='#n1159'>1159</a>
<a id='n1160' href='#n1160'>1160</a>
<a id='n1161' href='#n1161'>1161</a>
<a id='n1162' href='#n1162'>1162</a>
<a id='n1163' href='#n1163'>1163</a>
<a id='n1164' href='#n1164'>1164</a>
<a id='n1165' href='#n1165'>1165</a>
<a id='n1166' href='#n1166'>1166</a>
<a id='n1167' href='#n1167'>1167</a>
<a id='n1168' href='#n1168'>1168</a>
<a id='n1169' href='#n1169'>1169</a>
<a id='n1170' href='#n1170'>1170</a>
<a id='n1171' href='#n1171'>1171</a>
<a id='n1172' href='#n1172'>1172</a>
<a id='n1173' href='#n1173'>1173</a>
<a id='n1174' href='#n1174'>1174</a>
<a id='n1175' href='#n1175'>1175</a>
<a id='n1176' href='#n1176'>1176</a>
<a id='n1177' href='#n1177'>1177</a>
<a id='n1178' href='#n1178'>1178</a>
<a id='n1179' href='#n1179'>1179</a>
<a id='n1180' href='#n1180'>1180</a>
<a id='n1181' href='#n1181'>1181</a>
<a id='n1182' href='#n1182'>1182</a>
<a id='n1183' href='#n1183'>1183</a>
<a id='n1184' href='#n1184'>1184</a>
<a id='n1185' href='#n1185'>1185</a>
<a id='n1186' href='#n1186'>1186</a>
<a id='n1187' href='#n1187'>1187</a>
<a id='n1188' href='#n1188'>1188</a>
<a id='n1189' href='#n1189'>1189</a>
<a id='n1190' href='#n1190'>1190</a>
<a id='n1191' href='#n1191'>1191</a>
<a id='n1192' href='#n1192'>1192</a>
<a id='n1193' href='#n1193'>1193</a>
</pre></td>
<td class='lines'><pre><code><style>pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="c1">--  LLVM binding</span>
<span class="c1">--  Copyright (C) 2014 Tristan Gingold</span>
<span class="c1">--</span>
<span class="c1">--  GHDL is free software; you can redistribute it and/or modify it under</span>
<span class="c1">--  the terms of the GNU General Public License as published by the Free</span>
<span class="c1">--  Software Foundation; either version 2, or (at your option) any later</span>
<span class="c1">--  version.</span>
<span class="c1">--</span>
<span class="c1">--  GHDL is distributed in the hope that it will be useful, but WITHOUT ANY</span>
<span class="c1">--  WARRANTY; without even the implied warranty of MERCHANTABILITY or</span>
<span class="c1">--  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License</span>
<span class="c1">--  for more details.</span>
<span class="c1">--</span>
<span class="c1">--  You should have received a copy of the GNU General Public License</span>
<span class="c1">--  along with GHDL; see the file COPYING.  If not, write to the Free</span>
<span class="c1">--  Software Foundation, 59 Temple Place - Suite 330, Boston, MA</span>
<span class="c1">--  02111-1307, USA.</span>
<span class="kn">with</span> <span class="nn">System</span><span class="p">;</span>
<span class="kn">with</span> <span class="nn">Interfaces.C</span><span class="p">;</span> <span class="kn">use</span> <span class="nn">Interfaces.C</span><span class="p">;</span>
<span class="kn">use</span> <span class="nn">Interfaces</span><span class="p">;</span>

<span class="kd">package</span> <span class="nc">LLVM.Core</span> <span class="kr">is</span>

   <span class="kd">subtype</span> <span class="kt">Cstring</span> <span class="kr">is</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">&quot;=&quot;</span> <span class="p">(</span><span class="nv">L</span><span class="p">,</span> <span class="nv">R</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="kt">Boolean</span> <span class="kr">renames</span> <span class="n">System</span><span class="p">.</span><span class="s">&quot;=&quot;</span><span class="p">;</span>
   <span class="c1">--  Null_Cstring : constant Cstring := Null_Address;</span>
   <span class="no">Nul</span> <span class="p">:</span> <span class="kr">constant</span> <span class="kt">String</span> <span class="p">:=</span> <span class="p">(</span><span class="mi">1</span> <span class="p">=&gt;</span> <span class="kt">Character</span><span class="p">&#39;</span><span class="na">Val</span> <span class="p">(</span><span class="mi">0</span><span class="p">));</span>
   <span class="no">Empty_Cstring</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">Cstring</span> <span class="p">:=</span> <span class="n">Nul</span><span class="p">&#39;</span><span class="na">Address</span><span class="p">;</span>

   <span class="c1">--  The top-level container for all LLVM global data. See the LLVMContext</span>
   <span class="c1">--  class.</span>
   <span class="kd">type</span> <span class="kt">ContextRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>

   <span class="c1">--  The top-level container for all other LLVM Intermediate</span>
   <span class="c1">--  Representation (IR) objects. See the llvm::Module class.</span>
   <span class="kd">type</span> <span class="kt">ModuleRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>

   <span class="kd">subtype</span> <span class="kt">Bool</span> <span class="kr">is</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">--  Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type</span>
   <span class="c1">--  class.</span>
   <span class="kd">type</span> <span class="kt">TypeRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>
   <span class="no">Null_TypeRef</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">TypeRef</span> <span class="p">:=</span> <span class="n">TypeRef</span> <span class="p">(</span><span class="n">System</span><span class="p">.</span><span class="n">Null_Address</span><span class="p">);</span>
   <span class="kd">type</span> <span class="kt">TypeRefArray</span> <span class="kr">is</span> <span class="kr">array</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="kr">range</span> <span class="p">&lt;&gt;)</span> <span class="kr">of</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">TypeRefArray</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">ValueRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>
   <span class="no">Null_ValueRef</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">ValueRef</span> <span class="p">:=</span> <span class="n">ValueRef</span> <span class="p">(</span><span class="n">System</span><span class="p">.</span><span class="n">Null_Address</span><span class="p">);</span>
   <span class="kd">type</span> <span class="kt">ValueRefArray</span> <span class="kr">is</span> <span class="kr">array</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="kr">range</span> <span class="p">&lt;&gt;)</span> <span class="kr">of</span> <span class="n">ValueRef</span><span class="p">;</span> <span class="c1">-- Ada</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ValueRefArray</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">BasicBlockRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>
   <span class="no">Null_BasicBlockRef</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">BasicBlockRef</span> <span class="p">:=</span>
     <span class="n">BasicBlockRef</span> <span class="p">(</span><span class="n">System</span><span class="p">.</span><span class="n">Null_Address</span><span class="p">);</span>
   <span class="kd">type</span> <span class="kt">BasicBlockRefArray</span> <span class="kr">is</span>
     <span class="kr">array</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="kr">range</span> <span class="p">&lt;&gt;)</span> <span class="kr">of</span> <span class="n">BasicBlockRef</span><span class="p">;</span> <span class="c1">-- Ada</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">BasicBlockRefArray</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">BuilderRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>

   <span class="c1">--  Used to provide a module to JIT or interpreter.</span>
   <span class="c1">--  See the llvm::MemoryBuffer class.</span>
   <span class="kd">type</span> <span class="kt">MemoryBufferRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>

   <span class="c1">--  See the llvm::PassManagerBase class.</span>
   <span class="kd">type</span> <span class="kt">PassManagerRef</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">System</span><span class="p">.</span><span class="kt">Address</span><span class="p">;</span>

   <span class="kd">type</span> <span class="kt">Attribute</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="no">ZExtAttribute</span>            <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">0</span><span class="p">;</span>
   <span class="no">SExtAttribute</span>            <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">1</span><span class="p">;</span>
   <span class="no">NoReturnAttribute</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">2</span><span class="p">;</span>
   <span class="no">InRegAttribute</span>           <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">3</span><span class="p">;</span>
   <span class="no">StructRetAttribute</span>       <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">4</span><span class="p">;</span>
   <span class="no">NoUnwindAttribute</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">5</span><span class="p">;</span>
   <span class="no">NoAliasAttribute</span>         <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">6</span><span class="p">;</span>
   <span class="no">ByValAttribute</span>           <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">7</span><span class="p">;</span>
   <span class="no">NestAttribute</span>            <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">8</span><span class="p">;</span>
   <span class="no">ReadNoneAttribute</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">9</span><span class="p">;</span>
   <span class="no">ReadOnlyAttribute</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">10</span><span class="p">;</span>
   <span class="no">NoInlineAttribute</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">11</span><span class="p">;</span>
   <span class="no">AlwaysInlineAttribute</span>    <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">12</span><span class="p">;</span>
   <span class="no">OptimizeForSizeAttribute</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">13</span><span class="p">;</span>
   <span class="no">StackProtectAttribute</span>    <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">14</span><span class="p">;</span>
   <span class="no">StackProtectReqAttribute</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">15</span><span class="p">;</span>
   <span class="no">Alignment</span>                <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">31</span> <span class="o">*</span> <span class="mi">2</span><span class="o">**</span><span class="mi">16</span><span class="p">;</span>
   <span class="no">NoCaptureAttribute</span>       <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">21</span><span class="p">;</span>
   <span class="no">NoRedZoneAttribute</span>       <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">22</span><span class="p">;</span>
   <span class="no">NoImplicitFloatAttribute</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">23</span><span class="p">;</span>
   <span class="no">NakedAttribute</span>           <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">24</span><span class="p">;</span>
   <span class="no">InlineHintAttribute</span>      <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">25</span><span class="p">;</span>
   <span class="no">StackAlignment</span>           <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">7</span> <span class="o">*</span> <span class="mi">2</span><span class="o">**</span><span class="mi">26</span><span class="p">;</span>
   <span class="no">ReturnsTwice</span>             <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">29</span><span class="p">;</span>
   <span class="no">UWTable</span>                  <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">30</span><span class="p">;</span>
   <span class="no">NonLazyBind</span>              <span class="p">:</span> <span class="kr">constant</span> <span class="n">Attribute</span> <span class="p">:=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">31</span><span class="p">;</span>

   <span class="kd">type</span> <span class="kt">TypeKind</span> <span class="kr">is</span>
     <span class="p">(</span>
      <span class="nv">VoidTypeKind</span><span class="p">,</span>        <span class="c1">--  type with no size</span>
      <span class="nv">HalfTypeKind</span><span class="p">,</span>        <span class="c1">--  16 bit floating point type</span>
      <span class="nv">FloatTypeKind</span><span class="p">,</span>       <span class="c1">--  32 bit floating point type</span>
      <span class="nv">DoubleTypeKind</span><span class="p">,</span>      <span class="c1">--  64 bit floating point type</span>
      <span class="nv">X86_FP80TypeKind</span><span class="p">,</span>    <span class="c1">--  80 bit floating point type (X87)</span>
      <span class="nv">FP128TypeKind</span><span class="p">,</span>       <span class="c1">--  128 bit floating point type (112-bit mantissa)</span>
      <span class="nv">PPC_FP128TypeKind</span><span class="p">,</span>   <span class="c1">--  128 bit floating point type (two 64-bits)</span>
      <span class="nv">LabelTypeKind</span><span class="p">,</span>       <span class="c1">--  Labels</span>
      <span class="nv">IntegerTypeKind</span><span class="p">,</span>     <span class="c1">--  Arbitrary bit width integers</span>
      <span class="nv">FunctionTypeKind</span><span class="p">,</span>    <span class="c1">--  Functions</span>
      <span class="nv">StructTypeKind</span><span class="p">,</span>      <span class="c1">--  Structures</span>
      <span class="nv">ArrayTypeKind</span><span class="p">,</span>       <span class="c1">--  Arrays</span>
      <span class="nv">PointerTypeKind</span><span class="p">,</span>     <span class="c1">--  Pointers</span>
      <span class="nv">VectorTypeKind</span><span class="p">,</span>      <span class="c1">--  SIMD &#39;packed&#39; format, or other vector type</span>
      <span class="nv">MetadataTypeKind</span><span class="p">,</span>    <span class="c1">--  Metadata</span>
      <span class="nv">X86_MMXTypeKind</span>      <span class="c1">--  X86 MMX</span>
     <span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">TypeKind</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">Linkage</span> <span class="kr">is</span>
     <span class="p">(</span>
      <span class="nv">ExternalLinkage</span><span class="p">,</span>    <span class="c1">--  Externally visible function</span>
      <span class="nv">AvailableExternallyLinkage</span><span class="p">,</span>
      <span class="nv">LinkOnceAnyLinkage</span><span class="p">,</span> <span class="c1">--  Keep one copy of function when linking (inline)</span>
      <span class="nv">LinkOnceODRLinkage</span><span class="p">,</span> <span class="c1">--  Same, but only replaced by someth equivalent.</span>
      <span class="nv">LinkOnceODRAutoHideLinkage</span><span class="p">,</span> <span class="c1">--  Obsolete</span>
      <span class="nv">WeakAnyLinkage</span><span class="p">,</span>     <span class="c1">--  Keep one copy of function when linking (weak)</span>
      <span class="nv">WeakODRLinkage</span><span class="p">,</span>     <span class="c1">--  Same, but only replaced by someth equivalent.</span>
      <span class="nv">AppendingLinkage</span><span class="p">,</span>   <span class="c1">--  Special purpose, only applies to global arrays</span>
      <span class="nv">InternalLinkage</span><span class="p">,</span>    <span class="c1">--  Rename collisions when linking (static func)</span>
      <span class="nv">PrivateLinkage</span><span class="p">,</span>     <span class="c1">--  Like Internal, but omit from symbol table</span>
      <span class="nv">DLLImportLinkage</span><span class="p">,</span>   <span class="c1">--  Obsolete</span>
      <span class="nv">DLLExportLinkage</span><span class="p">,</span>   <span class="c1">--  Obsolete</span>
      <span class="nv">ExternalWeakLinkage</span><span class="p">,</span><span class="c1">--  ExternalWeak linkage description</span>
      <span class="nv">GhostLinkage</span><span class="p">,</span>       <span class="c1">--  Obsolete</span>
      <span class="nv">CommonLinkage</span><span class="p">,</span>      <span class="c1">--  Tentative definitions</span>
      <span class="nv">LinkerPrivateLinkage</span><span class="p">,</span> <span class="c1">--  Like Private, but linker removes.</span>
      <span class="nv">LinkerPrivateWeakLinkage</span> <span class="c1">--  Like LinkerPrivate, but is weak.</span>
     <span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Linkage</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">Visibility</span> <span class="kr">is</span>
     <span class="p">(</span>
      <span class="nv">DefaultVisibility</span><span class="p">,</span>  <span class="c1">--  The GV is visible</span>
      <span class="nv">HiddenVisibility</span><span class="p">,</span>   <span class="c1">--  The GV is hidden</span>
      <span class="nv">ProtectedVisibility</span> <span class="c1">--  The GV is protected</span>
     <span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Convention</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Visibility</span><span class="p">);</span>

   <span class="kd">type</span> <span class="kt">CallConv</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="no">CCallConv</span>           <span class="p">:</span> <span class="kr">constant</span> <span class="n">CallConv</span> <span class="p">:=</span> <span class="mi">0</span><span class="p">;</span>
   <span class="no">FastCallConv</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">CallConv</span> <span class="p">:=</span> <span class="mi">8</span><span class="p">;</span>
   <span class="no">ColdCallConv</span>        <span class="p">:</span> <span class="kr">constant</span> <span class="n">CallConv</span> <span class="p">:=</span> <span class="mi">9</span><span class="p">;</span>
   <span class="no">X86StdcallCallConv</span>  <span class="p">:</span> <span class="kr">constant</span> <span class="n">CallConv</span> <span class="p">:=</span> <span class="mi">64</span><span class="p">;</span>
   <span class="no">X86FastcallCallConv</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">CallConv</span> <span class="p">:=</span> <span class="mi">6</span><span class="p">;</span>

   <span class="kd">type</span> <span class="kt">IntPredicate</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="no">IntEQ</span>  <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">32</span><span class="p">;</span> <span class="c1">-- equal</span>
   <span class="no">IntNE</span>  <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">33</span><span class="p">;</span> <span class="c1">-- not equal</span>
   <span class="no">IntUGT</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">34</span><span class="p">;</span> <span class="c1">-- unsigned greater than</span>
   <span class="no">IntUGE</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">35</span><span class="p">;</span> <span class="c1">-- unsigned greater or equal</span>
   <span class="no">IntULT</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">36</span><span class="p">;</span> <span class="c1">-- unsigned less than</span>
   <span class="no">IntULE</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">37</span><span class="p">;</span> <span class="c1">-- unsigned less or equal</span>
   <span class="no">IntSGT</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">38</span><span class="p">;</span> <span class="c1">-- signed greater than</span>
   <span class="no">IntSGE</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">39</span><span class="p">;</span> <span class="c1">-- signed greater or equal</span>
   <span class="no">IntSLT</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">40</span><span class="p">;</span> <span class="c1">-- signed less than</span>
   <span class="no">IntSLE</span> <span class="p">:</span> <span class="kr">constant</span> <span class="n">IntPredicate</span> <span class="p">:=</span> <span class="mi">41</span><span class="p">;</span> <span class="c1">-- signed less or equal</span>

   <span class="kd">type</span> <span class="kt">RealPredicate</span> <span class="kr">is</span>
     <span class="p">(</span>
      <span class="nv">RealPredicateFalse</span><span class="p">,</span> <span class="c1">--  Always false (always folded)</span>
      <span class="nv">RealOEQ</span><span class="p">,</span>            <span class="c1">--  True if ordered and equal</span>
      <span class="nv">RealOGT</span><span class="p">,</span>            <span class="c1">--  True if ordered and greater than</span>
      <span class="nv">RealOGE</span><span class="p">,</span>            <span class="c1">--  True if ordered and greater than or equal</span>
      <span class="nv">RealOLT</span><span class="p">,</span>            <span class="c1">--  True if ordered and less than</span>
      <span class="nv">RealOLE</span><span class="p">,</span>            <span class="c1">--  True if ordered and less than or equal</span>
      <span class="nv">RealONE</span><span class="p">,</span>            <span class="c1">--  True if ordered and operands are unequal</span>
      <span class="nv">RealORD</span><span class="p">,</span>            <span class="c1">--  True if ordered (no nans)</span>
      <span class="nv">RealUNO</span><span class="p">,</span>            <span class="c1">--  True if unordered: isnan(X) | isnan(Y)</span>
      <span class="nv">RealUEQ</span><span class="p">,</span>            <span class="c1">--  True if unordered or equal</span>
      <span class="nv">RealUGT</span><span class="p">,</span>            <span class="c1">--  True if unordered or greater than</span>
      <span class="nv">RealUGE</span><span class="p">,</span>            <span class="c1">--  True if unordered, greater than, or equal</span>
      <span class="nv">RealULT</span><span class="p">,</span>            <span class="c1">--  True if unordered or less than</span>
      <span class="nv">RealULE</span><span class="p">,</span>            <span class="c1">--  True if unordered, less than, or equal</span>
      <span class="nv">RealUNE</span><span class="p">,</span>            <span class="c1">--  True if unordered or not equal</span>
      <span class="nv">RealPredicateTrue</span>   <span class="c1">--  Always true (always folded)</span>
     <span class="p">);</span>

   <span class="c1">-- Error handling ----------------------------------------------------</span>

   <span class="kd">procedure</span> <span class="nf">DisposeMessage</span> <span class="p">(</span><span class="nv">Message</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>


   <span class="c1">--  Context</span>

   <span class="c1">--  Create a new context.</span>
   <span class="c1">--  Every call to this function should be paired with a call to</span>
   <span class="c1">-- LLVMContextDispose() or the context will leak memory.</span>
   <span class="kd">function</span> <span class="nf">ContextCreate</span> <span class="nf">return</span> <span class="nf">ContextRef</span><span class="p">;</span>

   <span class="c1">--  Obtain the global context instance.</span>
   <span class="kd">function</span> <span class="nf">GetGlobalContext</span> <span class="nf">return</span> <span class="nf">ContextRef</span><span class="p">;</span>

   <span class="c1">--  Destroy a context instance.</span>
   <span class="c1">--  This should be called for every call to LLVMContextCreate() or memory</span>
   <span class="c1">--  will be leaked.</span>
   <span class="kd">procedure</span> <span class="nf">ContextDispose</span> <span class="p">(</span><span class="nv">C</span> <span class="p">: </span><span class="nv">ContextRef</span><span class="p">);</span>

   <span class="c1">-- Modules -----------------------------------------------------------</span>

   <span class="c1">-- Create and destroy modules.</span>
   <span class="c1">-- See llvm::Module::Module.</span>
   <span class="kd">function</span> <span class="nf">ModuleCreateWithName</span> <span class="p">(</span><span class="nv">ModuleID</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ModuleRef</span><span class="p">;</span>

   <span class="c1">-- See llvm::Module::~Module.</span>
   <span class="kd">procedure</span> <span class="nf">DisposeModule</span> <span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">);</span>

   <span class="c1">-- Data layout. See Module::getDataLayout.</span>
   <span class="kd">function</span> <span class="nf">GetDataLayout</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Cstring</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetDataLayout</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Triple</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>

   <span class="c1">-- Target triple. See Module::getTargetTriple.</span>
   <span class="kd">function</span> <span class="nf">GetTarget</span> <span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Cstring</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetTarget</span> <span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Triple</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>

   <span class="c1">-- See Module::dump.</span>
   <span class="kd">procedure</span> <span class="nf">DumpModule</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">);</span>

   <span class="c1">--  Print a representation of a module to a file. The ErrorMessage needs to</span>
   <span class="c1">--  be disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.</span>
   <span class="c1">--</span>
   <span class="c1">--  @see Module::print()</span>
   <span class="kd">function</span> <span class="nf">PrintModuleToFile</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span>
                              <span class="nv">Filename</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">;</span>
                              <span class="nv">ErrorMessage</span> <span class="p">: </span><span class="nv">access</span> <span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Bool</span><span class="p">;</span>


   <span class="c1">-- Types -------------------------------------------------------------</span>

   <span class="c1">-- LLVM types conform to the following hierarchy:</span>
   <span class="c1">--</span>
   <span class="c1">--   types:</span>
   <span class="c1">--     integer type</span>
   <span class="c1">--     real type</span>
   <span class="c1">--     function type</span>
   <span class="c1">--     sequence types:</span>
   <span class="c1">--       array type</span>
   <span class="c1">--       pointer type</span>
   <span class="c1">--       vector type</span>
   <span class="c1">--     void type</span>
   <span class="c1">--     label type</span>
   <span class="c1">--     opaque type</span>

   <span class="c1">-- See llvm::LLVMTypeKind::getTypeID.</span>
   <span class="kd">function</span> <span class="nf">GetTypeKind</span> <span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeKind</span><span class="p">;</span>

   <span class="c1">-- Operations on integer types</span>
   <span class="kd">function</span> <span class="nf">Int1Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">Int8Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">Int16Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">Int32Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">Int64Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">IntType</span><span class="p">(</span><span class="nv">NumBits</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetIntTypeWidth</span><span class="p">(</span><span class="nv">IntegerTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">MetadataType</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>

   <span class="c1">-- Operations on real types</span>
   <span class="kd">function</span> <span class="nf">FloatType</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">DoubleType</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">X86FP80Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">FP128Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">PPCFP128Type</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>

   <span class="c1">-- Operations on function types</span>
   <span class="kd">function</span> <span class="nf">FunctionType</span><span class="p">(</span><span class="nv">ReturnType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span>
                         <span class="nv">ParamTypes</span> <span class="p">: </span><span class="nv">TypeRefArray</span><span class="p">;</span>
                         <span class="nv">ParamCount</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span>
                         <span class="nv">IsVarArg</span> <span class="p">: </span><span class="nv">int</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">IsFunctionVarArg</span><span class="p">(</span><span class="nv">FunctionTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetReturnType</span><span class="p">(</span><span class="nv">FunctionTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">CountParamTypes</span><span class="p">(</span><span class="nv">FunctionTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">GetParamTypes</span><span class="p">(</span><span class="nv">FunctionTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Dest</span> <span class="p">: </span><span class="nv">out</span> <span class="nv">TypeRefArray</span><span class="p">);</span>

   <span class="c1">-- Operations on struct types</span>
   <span class="kd">function</span> <span class="nf">StructType</span><span class="p">(</span><span class="nv">ElementTypes</span> <span class="p">: </span><span class="nv">TypeRefArray</span><span class="p">;</span>
                       <span class="nv">ElementCount</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span>
                       <span class="nv">Packed</span> <span class="p">: </span><span class="nv">Bool</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">StructCreateNamed</span><span class="p">(</span><span class="nv">C</span> <span class="p">: </span><span class="nv">ContextRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">StructSetBody</span><span class="p">(</span><span class="nv">StructTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span>
                           <span class="nv">ElementTypes</span> <span class="p">: </span><span class="nv">TypeRefArray</span><span class="p">;</span>
                           <span class="nv">ElementCount</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span>
                           <span class="nv">Packed</span> <span class="p">: </span><span class="nv">Bool</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">CountStructElementTypes</span><span class="p">(</span><span class="nv">StructTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">GetStructElementTypes</span><span class="p">(</span><span class="nv">StructTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span>
                                   <span class="nv">Dest</span> <span class="p">: </span><span class="nv">out</span> <span class="nv">TypeRefArray</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">IsPackedStruct</span><span class="p">(</span><span class="nv">StructTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Bool</span><span class="p">;</span>


   <span class="c1">-- Operations on array, pointer, and vector types (sequence types)</span>
   <span class="kd">function</span> <span class="nf">ArrayType</span><span class="p">(</span><span class="nv">ElementType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">ElementCount</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">PointerType</span><span class="p">(</span><span class="nv">ElementType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">AddressSpace</span> <span class="p">: </span><span class="nv">unsigned</span> <span class="p">:=</span> <span class="nv">0</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">VectorType</span><span class="p">(</span><span class="nv">ElementType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">ElementCount</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">GetElementType</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetArrayLength</span><span class="p">(</span><span class="nv">ArrayTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPointerAddressSpace</span><span class="p">(</span><span class="nv">PointerTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetVectorSize</span><span class="p">(</span><span class="nv">VectorTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>

   <span class="c1">-- Operations on other types.</span>
   <span class="kd">function</span> <span class="nf">VoidType</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">LabelType</span> <span class="nf">return</span> <span class="nf">TypeRef</span><span class="p">;</span>

   <span class="c1">-- See Module::dump.</span>
   <span class="kd">procedure</span> <span class="nf">DumpType</span><span class="p">(</span><span class="nv">T</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">);</span>

   <span class="c1">-- Values ------------------------------------------------------------</span>
   <span class="c1">-- The bulk of LLVM&#39;s object model consists of values, which comprise a very</span>
   <span class="c1">-- rich type hierarchy.</span>
   <span class="c1">--</span>
   <span class="c1">--   values:</span>
   <span class="c1">--     constants:</span>
   <span class="c1">--       scalar constants</span>
   <span class="c1">--       composite contants</span>
   <span class="c1">--       globals:</span>
   <span class="c1">--         global variable</span>
   <span class="c1">--         function</span>
   <span class="c1">--         alias</span>
   <span class="c1">--       basic blocks</span>

   <span class="c1">-- Operations on all values</span>
   <span class="kd">function</span> <span class="nf">TypeOf</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">TypeRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetValueName</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Cstring</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetValueName</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">DumpValue</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>

   <span class="c1">-- Operations on constants of any type</span>
   <span class="kd">function</span> <span class="nf">ConstNull</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span> <span class="c1">--  All zero</span>
   <span class="kd">function</span> <span class="nf">ConstAllOnes</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span> <span class="c1">-- Int or Vec</span>
   <span class="kd">function</span> <span class="nf">GetUndef</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">IsConstant</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">IsNull</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">IsUndef</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">--  Convert value instances between types.</span>
   <span class="c1">--</span>
   <span class="c1">--  Internally, an LLVMValueRef is &quot;pinned&quot; to a specific type. This</span>
   <span class="c1">--  series of functions allows you to cast an instance to a specific</span>
   <span class="c1">--  type.</span>
   <span class="c1">--</span>
   <span class="c1">--  If the cast is not valid for the specified type, NULL is returned.</span>
   <span class="c1">--</span>
   <span class="c1">-- @see llvm::dyn_cast_or_null&lt;&gt;</span>
   <span class="kd">function</span> <span class="nf">IsAInstruction</span> <span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Operations on scalar constants</span>
   <span class="kd">function</span> <span class="nf">ConstInt</span><span class="p">(</span><span class="nv">IntTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">N</span> <span class="p">: </span><span class="nv">Unsigned_64</span><span class="p">;</span> <span class="nv">SignExtend</span> <span class="p">: </span><span class="nv">int</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstReal</span><span class="p">(</span><span class="nv">RealTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">N</span> <span class="p">: </span><span class="nv">double</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstRealOfString</span><span class="p">(</span><span class="nv">RealTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Text</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                             <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>


   <span class="c1">-- Obtain the zero extended value for an integer constant value.</span>
   <span class="c1">-- @see llvm::ConstantInt::getZExtValue()</span>
   <span class="kd">function</span> <span class="nf">ConstIntGetZExtValue</span> <span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Unsigned_64</span><span class="p">;</span>

   <span class="c1">-- Operations on composite constants</span>
   <span class="kd">function</span> <span class="nf">ConstString</span><span class="p">(</span><span class="nv">Str</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">;</span>
                        <span class="nv">Length</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">DontNullTerminate</span> <span class="p">: </span><span class="nv">int</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstArray</span><span class="p">(</span><span class="nv">ElementTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span>
                       <span class="nv">ConstantVals</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span> <span class="nv">Length</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstStruct</span><span class="p">(</span><span class="nv">ConstantVals</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span>
                        <span class="nv">Count</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">packed</span> <span class="p">: </span><span class="nv">int</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">--  Create a non-anonymous ConstantStruct from values.</span>
   <span class="c1">--  @see llvm::ConstantStruct::get()</span>
   <span class="kd">function</span> <span class="nf">ConstNamedStruct</span><span class="p">(</span><span class="nv">StructTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span>
                             <span class="nv">ConstantVals</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span>
                             <span class="nv">Count</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">ConstVector</span><span class="p">(</span><span class="nv">ScalarConstantVals</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span> <span class="nv">Size</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Constant expressions</span>
   <span class="kd">function</span> <span class="nf">SizeOf</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">AlignOf</span><span class="p">(</span><span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">ConstNeg</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstNot</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstAdd</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstSub</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstMul</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstUDiv</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstSDiv</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFDiv</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstURem</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstSRem</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFRem</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstAnd</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstOr</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                   <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstXor</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstICmp</span><span class="p">(</span><span class="nv">Predicate</span> <span class="p">: </span><span class="nv">IntPredicate</span><span class="p">;</span>
                      <span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFCmp</span><span class="p">(</span><span class="nv">Predicate</span> <span class="p">: </span><span class="nv">RealPredicate</span><span class="p">;</span>
                      <span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstShl</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstLShr</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstAShr</span><span class="p">(</span><span class="nv">LHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHSConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstGEP</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                     <span class="nv">ConstantIndices</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span> <span class="nv">NumIndices</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstTrunc</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstSExt</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstZExt</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFPTrunc</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                        <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFPExt</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstUIToFP</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstSIToFP</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFPToUI</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstFPToSI</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstPtrToInt</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                         <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstIntToPtr</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                         <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstBitCast</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                        <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">ConstTruncOrBitCast</span><span class="p">(</span><span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ToType</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                               <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">ConstSelect</span><span class="p">(</span><span class="nv">ConstantCondition</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">ConstantIfTrue</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">ConstantIfFalse</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstExtractElement</span><span class="p">(</span><span class="nv">VectorConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                                <span class="nv">IndexConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstInsertElement</span><span class="p">(</span><span class="nv">VectorConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">ElementValueConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">IndexConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ConstShuffleVector</span><span class="p">(</span><span class="nv">VectorAConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">VectorBConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">MaskConstant</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Operations on global variables, functions, and aliases (globals)</span>
   <span class="kd">function</span> <span class="nf">GetGlobalParent</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ModuleRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">IsDeclaration</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLinkage</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Linkage</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetLinkage</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Link</span> <span class="p">: </span><span class="nv">Linkage</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetSection</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Cstring</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetSection</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Section</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetVisibility</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Visibility</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetVisibility</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Viz</span> <span class="p">: </span><span class="nv">Visibility</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetAlignment</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetAlignment</span><span class="p">(</span><span class="nv">Global</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Bytes</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">);</span>

   <span class="c1">-- Operations on global variables</span>
   <span class="kd">function</span> <span class="nf">AddGlobal</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNamedGlobal</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetFirstGlobal</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLastGlobal</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNextGlobal</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPreviousGlobal</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">DeleteGlobal</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetInitializer</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetInitializer</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">ConstantVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">IsThreadLocal</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetThreadLocal</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">IsThreadLocal</span> <span class="p">: </span><span class="nv">int</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">IsGlobalConstant</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetGlobalConstant</span><span class="p">(</span><span class="nv">GlobalVar</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">IsConstant</span> <span class="p">: </span><span class="nv">int</span><span class="p">);</span>

   <span class="c1">-- Operations on functions</span>
   <span class="kd">function</span> <span class="nf">AddFunction</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">;</span> <span class="nv">FunctionTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNamedFunction</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetFirstFunction</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLastFunction</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNextFunction</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPreviousFunction</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">DeleteFunction</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetIntrinsicID</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetFunctionCallConv</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">CallConv</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetFunctionCallConv</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">CC</span> <span class="p">: </span><span class="nv">CallConv</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetGC</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Cstring</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetGC</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>

   <span class="c1">--  Add an attribute to a function.</span>
   <span class="c1">--  @see llvm::Function::addAttribute()</span>
   <span class="kd">procedure</span> <span class="nf">AddFunctionAttr</span> <span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">PA</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>

   <span class="c1">--  Add a target-dependent attribute to a fuction</span>
   <span class="c1">--  @see llvm::AttrBuilder::addAttribute()</span>
   <span class="kd">procedure</span> <span class="nf">AddTargetDependentFunctionAttr</span>
     <span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">A</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">;</span> <span class="nv">V</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">);</span>

   <span class="c1">--  Obtain an attribute from a function.</span>
   <span class="c1">--  @see llvm::Function::getAttributes()</span>
   <span class="kd">function</span> <span class="nf">GetFunctionAttr</span> <span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Attribute</span><span class="p">;</span>

   <span class="c1">--  Remove an attribute from a function.</span>
   <span class="kd">procedure</span> <span class="nf">RemoveFunctionAttr</span> <span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">PA</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>

   <span class="c1">-- Operations on parameters</span>
   <span class="kd">function</span> <span class="nf">CountParams</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">GetParams</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Params</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetParam</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetParamParent</span><span class="p">(</span><span class="nv">Inst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetFirstParam</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLastParam</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNextParam</span><span class="p">(</span><span class="nv">Arg</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPreviousParam</span><span class="p">(</span><span class="nv">Arg</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">AddAttribute</span><span class="p">(</span><span class="nv">Arg</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">PA</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">RemoveAttribute</span><span class="p">(</span><span class="nv">Arg</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">PA</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">SetParamAlignment</span><span class="p">(</span><span class="nv">Arg</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">align</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">);</span>

   <span class="c1">-- Operations on basic blocks</span>
   <span class="kd">function</span> <span class="nf">BasicBlockAsValue</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ValueIsBasicBlock</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">ValueAsBasicBlock</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetBasicBlockParent</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">CountBasicBlocks</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">GetBasicBlocks</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">BasicBlocks</span> <span class="p">: </span><span class="nv">BasicBlockRefArray</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetFirstBasicBlock</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLastBasicBlock</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNextBasicBlock</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPreviousBasicBlock</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetEntryBasicBlock</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">AppendBasicBlock</span><span class="p">(</span><span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                            <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">InsertBasicBlock</span><span class="p">(</span><span class="nv">InsertBeforeBB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span>
                             <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">DeleteBasicBlock</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">);</span>

   <span class="c1">-- Operations on instructions</span>

   <span class="c1">--  Determine whether an instruction has any metadata attached.</span>
   <span class="kd">function</span> <span class="nf">HasMetadata</span><span class="p">(</span><span class="nv">Val</span><span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">Bool</span><span class="p">;</span>

   <span class="c1">--  Return metadata associated with an instruction value.</span>
   <span class="kd">function</span> <span class="nf">GetMetadata</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">KindID</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">--  Set metadata associated with an instruction value.</span>
   <span class="kd">procedure</span> <span class="nf">SetMetadata</span><span class="p">(</span><span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">KindID</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">Node</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>

   <span class="kd">function</span> <span class="nf">GetInstructionParent</span><span class="p">(</span><span class="nv">Inst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetFirstInstruction</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetLastInstruction</span><span class="p">(</span><span class="nv">BB</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetNextInstruction</span><span class="p">(</span><span class="nv">Inst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetPreviousInstruction</span><span class="p">(</span><span class="nv">Inst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Operations on call sites</span>
   <span class="kd">procedure</span> <span class="nf">SetInstructionCallConv</span><span class="p">(</span><span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">CC</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetInstructionCallConv</span><span class="p">(</span><span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">AddInstrAttribute</span><span class="p">(</span><span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">Attr</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">RemoveInstrAttribute</span><span class="p">(</span><span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                                 <span class="nv">index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">Attr</span> <span class="p">: </span><span class="nv">Attribute</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">SetInstrParamAlignment</span><span class="p">(</span><span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                                    <span class="nv">index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">align</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">);</span>

   <span class="c1">-- Operations on call instructions (only)</span>
   <span class="kd">function</span> <span class="nf">IsTailCall</span><span class="p">(</span><span class="nv">CallInst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">SetTailCall</span><span class="p">(</span><span class="nv">CallInst</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">IsTailCall</span> <span class="p">: </span><span class="nv">int</span><span class="p">);</span>

   <span class="c1">-- Operations on phi nodes</span>
   <span class="kd">procedure</span> <span class="nf">AddIncoming</span><span class="p">(</span><span class="nv">PhiNode</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">IncomingValues</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span>
                        <span class="nv">IncomingBlocks</span> <span class="p">: </span><span class="nv">BasicBlockRefArray</span><span class="p">;</span> <span class="nv">Count</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">CountIncoming</span><span class="p">(</span><span class="nv">PhiNode</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">unsigned</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetIncomingValue</span><span class="p">(</span><span class="nv">PhiNode</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                            <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">GetIncomingBlock</span><span class="p">(</span><span class="nv">PhiNode</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Index</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                            <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>

   <span class="c1">-- Instruction builders ----------------------------------------------</span>
   <span class="c1">--  An instruction builder represents a point within a basic block,</span>
   <span class="c1">--  and is the exclusive means of building instructions using the C</span>
   <span class="c1">--  interface.</span>

   <span class="kd">function</span> <span class="nf">CreateBuilder</span> <span class="nf">return</span> <span class="nf">BuilderRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">PositionBuilder</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                             <span class="nv">Block</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span> <span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">PositionBuilderBefore</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Instr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">);</span>
   <span class="kd">procedure</span> <span class="nf">PositionBuilderAtEnd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Block</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">);</span>
   <span class="kd">function</span> <span class="nf">GetInsertBlock</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">BasicBlockRef</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">DisposeBuilder</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">);</span>

   <span class="c1">-- Terminators</span>
   <span class="kd">function</span> <span class="nf">BuildRetVoid</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildRet</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">V</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildBr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Dest</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span>
                   <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildCondBr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">If_Br</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Then_Br</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span> <span class="nv">Else_Br</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSwitch</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">V</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Else_Br</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span> <span class="nv">NumCases</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildInvoke</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Args</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span>
                        <span class="nv">NumArgs</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span>
                        <span class="nv">Then_Br</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span>
                        <span class="nv">Catch</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">;</span>
                        <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildUnwind</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildUnreachable</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Add a case to the switch instruction</span>
   <span class="kd">procedure</span> <span class="nf">AddCase</span><span class="p">(</span><span class="nv">Switch</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                     <span class="nv">OnVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Dest</span> <span class="p">: </span><span class="nv">BasicBlockRef</span><span class="p">);</span>

   <span class="c1">-- Arithmetic</span>
   <span class="kd">function</span> <span class="nf">BuildAdd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNSWAdd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNUWAdd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFAdd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">BuildSub</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNSWSub</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNUWSub</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFSub</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">BuildMul</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFMul</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="kd">function</span> <span class="nf">BuildUDiv</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSDiv</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFDiv</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildURem</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSRem</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFRem</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildShl</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildLShr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildAShr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildAnd</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildOr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                    <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                   <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildXor</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNeg</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">V</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFNeg</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">V</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildNot</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">V</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Memory</span>
   <span class="kd">function</span> <span class="nf">BuildMalloc</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildArrayMalloc</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                             <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                            <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildAlloca</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildArrayAlloca</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                             <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                            <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFree</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">PointerVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildLoad</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">PointerVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                           <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildStore</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Ptr</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildGEP</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                     <span class="nv">Pointer</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                     <span class="nv">Indices</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span>
                     <span class="nv">NumIndices</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Casts</span>
   <span class="kd">function</span> <span class="nf">BuildTrunc</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                       <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildZExt</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSExt</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFPToUI</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFPToSI</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildUIToFP</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSIToFP</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                       <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFPTrunc</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                         <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                        <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFPExt</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                       <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildPtrToInt</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                          <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                         <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildIntToPtr</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                          <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                         <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildBitCast</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                         <span class="nv">Val</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">DestTy</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                        <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Comparisons</span>
   <span class="kd">function</span> <span class="nf">BuildICmp</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">Op</span> <span class="p">: </span><span class="nv">IntPredicate</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildFCmp</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">Op</span> <span class="p">: </span><span class="nv">RealPredicate</span><span class="p">;</span>
                      <span class="nv">LHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">RHS</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Miscellaneous instructions</span>
   <span class="kd">function</span> <span class="nf">BuildPhi</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span> <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                    <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildCall</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                      <span class="nv">Fn</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                      <span class="nv">Args</span> <span class="p">: </span><span class="nv">ValueRefArray</span><span class="p">;</span> <span class="nv">NumArgs</span> <span class="p">: </span><span class="nv">unsigned</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                     <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildSelect</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                        <span class="nv">If_Sel</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Then_Sel</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Else_Sel</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                        <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildVAArg</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                       <span class="nv">List</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span> <span class="nv">Ty</span> <span class="p">: </span><span class="nv">TypeRef</span><span class="p">;</span> <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span>
                      <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildExtractElement</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                                <span class="nv">VecVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                                <span class="nv">Index</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                                <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildInsertElement</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                               <span class="nv">VecVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">EltVal</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">Index</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">BuildShuffleVector</span><span class="p">(</span><span class="nv">Builder</span> <span class="p">: </span><span class="nv">BuilderRef</span><span class="p">;</span>
                               <span class="nv">V1</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">V2</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">Mask</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">;</span>
                               <span class="nv">Name</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">ValueRef</span><span class="p">;</span>

   <span class="c1">-- Memory buffers ----------------------------------------------------</span>

   <span class="kd">function</span> <span class="nf">CreateMemoryBufferWithContentsOfFile</span>
     <span class="p">(</span><span class="nv">Path</span> <span class="p">: </span><span class="nv">Cstring</span><span class="p">;</span>
      <span class="nv">OutMemBuf</span> <span class="p">: </span><span class="nv">access</span> <span class="nv">MemoryBufferRef</span><span class="p">;</span>
      <span class="nv">OutMessage</span> <span class="p">: </span><span class="nv">access</span> <span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">function</span> <span class="nf">CreateMemoryBufferWithSTDIN</span>
     <span class="p">(</span><span class="nv">OutMemBuf</span> <span class="p">: </span><span class="nv">access</span> <span class="nv">MemoryBufferRef</span><span class="p">;</span>
      <span class="nv">OutMessage</span> <span class="p">: </span><span class="nv">access</span> <span class="nv">Cstring</span><span class="p">)</span> <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>
   <span class="kd">procedure</span> <span class="nf">DisposeMemoryBuffer</span><span class="p">(</span><span class="nv">MemBuf</span> <span class="p">: </span><span class="nv">MemoryBufferRef</span><span class="p">);</span>


   <span class="c1">-- Pass Managers -----------------------------------------------------</span>

   <span class="c1">-- Constructs a new whole-module pass pipeline. This type of pipeline is</span>
   <span class="c1">-- suitable for link-time optimization and whole-module transformations.</span>
   <span class="c1">-- See llvm::PassManager::PassManager.</span>
   <span class="kd">function</span> <span class="nf">CreatePassManager</span> <span class="nf">return</span> <span class="nf">PassManagerRef</span><span class="p">;</span>

   <span class="c1">-- Constructs a new function-by-function pass pipeline over the module</span>
   <span class="c1">-- provider. It does not take ownership of the module provider. This type of</span>
   <span class="c1">-- pipeline is suitable for code generation and JIT compilation tasks.</span>
   <span class="c1">-- See llvm::FunctionPassManager::FunctionPassManager.</span>
   <span class="kd">function</span> <span class="nf">CreateFunctionPassManagerForModule</span><span class="p">(</span><span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span>
                                              <span class="kr">return</span> <span class="n">PassManagerRef</span><span class="p">;</span>

   <span class="c1">-- Initializes, executes on the provided module, and finalizes all of the</span>
   <span class="c1">-- passes scheduled in the pass manager. Returns 1 if any of the passes</span>
   <span class="c1">-- modified the module, 0 otherwise. See llvm::PassManager::run(Module&amp;).</span>
   <span class="kd">function</span> <span class="nf">RunPassManager</span><span class="p">(</span><span class="nv">PM</span> <span class="p">: </span><span class="nv">PassManagerRef</span><span class="p">;</span> <span class="nv">M</span> <span class="p">: </span><span class="nv">ModuleRef</span><span class="p">)</span>
                          <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">-- Initializes all of the function passes scheduled in the function pass</span>
   <span class="c1">-- manager. Returns 1 if any of the passes modified the module, 0 otherwise.</span>
   <span class="c1">-- See llvm::FunctionPassManager::doInitialization.</span>
   <span class="kd">function</span> <span class="nf">InitializeFunctionPassManager</span><span class="p">(</span><span class="nv">FPM</span> <span class="p">: </span><span class="nv">PassManagerRef</span><span class="p">)</span>
                                         <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">--  Executes all of the function passes scheduled in the function</span>
   <span class="c1">--  pass manager on the provided function. Returns 1 if any of the</span>
   <span class="c1">--  passes modified the function, false otherwise.</span>
   <span class="c1">-- See llvm::FunctionPassManager::run(Function&amp;).</span>
   <span class="kd">function</span> <span class="nf">RunFunctionPassManager</span> <span class="p">(</span><span class="nv">FPM</span> <span class="p">: </span><span class="nv">PassManagerRef</span><span class="p">;</span> <span class="nv">F</span> <span class="p">: </span><span class="nv">ValueRef</span><span class="p">)</span>
                                   <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">-- Finalizes all of the function passes scheduled in in the function pass</span>
   <span class="c1">-- manager. Returns 1 if any of the passes modified the module, 0 otherwise.</span>
   <span class="c1">-- See llvm::FunctionPassManager::doFinalization.</span>
   <span class="kd">function</span> <span class="nf">FinalizeFunctionPassManager</span><span class="p">(</span><span class="nv">FPM</span> <span class="p">: </span><span class="nv">PassManagerRef</span><span class="p">)</span>
                                       <span class="kr">return</span> <span class="n">int</span><span class="p">;</span>

   <span class="c1">--  Frees the memory of a pass pipeline. For function pipelines,</span>
   <span class="c1">--  does not free the module provider.</span>
   <span class="c1">-- See llvm::PassManagerBase::~PassManagerBase.</span>
   <span class="kd">procedure</span> <span class="nf">DisposePassManager</span><span class="p">(</span><span class="nv">PM</span> <span class="p">: </span><span class="nv">PassManagerRef</span><span class="p">);</span>

<span class="kd">private</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ContextCreate</span><span class="p">,</span> <span class="s">&quot;LLVMContextCreate&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetGlobalContext</span><span class="p">,</span> <span class="s">&quot;LLVMGetGlobalContext&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ContextDispose</span><span class="p">,</span> <span class="s">&quot;LLVMContextDispose&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DisposeMessage</span><span class="p">,</span> <span class="s">&quot;LLVMDisposeMessage&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ModuleCreateWithName</span><span class="p">,</span> <span class="s">&quot;LLVMModuleCreateWithName&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DisposeModule</span><span class="p">,</span> <span class="s">&quot;LLVMDisposeModule&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetDataLayout</span><span class="p">,</span> <span class="s">&quot;LLVMGetDataLayout&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetDataLayout</span><span class="p">,</span> <span class="s">&quot;LLVMSetDataLayout&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetTarget</span><span class="p">,</span> <span class="s">&quot;LLVMGetTarget&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetTarget</span><span class="p">,</span> <span class="s">&quot;LLVMSetTarget&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DumpModule</span><span class="p">,</span> <span class="s">&quot;LLVMDumpModule&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PrintModuleToFile</span><span class="p">,</span> <span class="s">&quot;LLVMPrintModuleToFile&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetTypeKind</span><span class="p">,</span> <span class="s">&quot;LLVMGetTypeKind&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Int1Type</span><span class="p">,</span> <span class="s">&quot;LLVMInt1Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Int8Type</span><span class="p">,</span> <span class="s">&quot;LLVMInt8Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Int16Type</span><span class="p">,</span> <span class="s">&quot;LLVMInt16Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Int32Type</span><span class="p">,</span> <span class="s">&quot;LLVMInt32Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">Int64Type</span><span class="p">,</span> <span class="s">&quot;LLVMInt64Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IntType</span><span class="p">,</span> <span class="s">&quot;LLVMIntType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetIntTypeWidth</span><span class="p">,</span> <span class="s">&quot;LLVMGetIntTypeWidth&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">MetadataType</span><span class="p">,</span> <span class="s">&quot;LLVMMetadataType_extra&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">FloatType</span><span class="p">,</span> <span class="s">&quot;LLVMFloatType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DoubleType</span><span class="p">,</span> <span class="s">&quot;LLVMDoubleType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">X86FP80Type</span><span class="p">,</span> <span class="s">&quot;LLVMX86FP80Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">FP128Type</span><span class="p">,</span> <span class="s">&quot;LLVMFP128Type&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PPCFP128Type</span><span class="p">,</span> <span class="s">&quot;LLVMPPCFP128Type&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="kd">Function</span><span class="nf">Type</span><span class="p">,</span> <span class="nf">&quot;LLVMFunctionType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsFunctionVarArg</span><span class="p">,</span> <span class="s">&quot;LLVMIsFunctionVarArg&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetReturnType</span><span class="p">,</span> <span class="s">&quot;LLVMGetReturnType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CountParamTypes</span><span class="p">,</span> <span class="s">&quot;LLVMCountParamTypes&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetParamTypes</span><span class="p">,</span> <span class="s">&quot;LLVMGetParamTypes&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">StructType</span><span class="p">,</span> <span class="s">&quot;LLVMStructType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">StructCreateNamed</span><span class="p">,</span> <span class="s">&quot;LLVMStructCreateNamed&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">StructSetBody</span><span class="p">,</span> <span class="s">&quot;LLVMStructSetBody&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CountStructElementTypes</span><span class="p">,</span> <span class="s">&quot;LLVMCountStructElementTypes&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetStructElementTypes</span><span class="p">,</span> <span class="s">&quot;LLVMGetStructElementTypes&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsPackedStruct</span><span class="p">,</span> <span class="s">&quot;LLVMIsPackedStruct&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ArrayType</span><span class="p">,</span> <span class="s">&quot;LLVMArrayType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PointerType</span><span class="p">,</span> <span class="s">&quot;LLVMPointerType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">VectorType</span><span class="p">,</span> <span class="s">&quot;LLVMVectorType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetElementType</span><span class="p">,</span> <span class="s">&quot;LLVMGetElementType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetArrayLength</span><span class="p">,</span> <span class="s">&quot;LLVMGetArrayLength&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPointerAddressSpace</span><span class="p">,</span> <span class="s">&quot;LLVMGetPointerAddressSpace&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetVectorSize</span><span class="p">,</span> <span class="s">&quot;LLVMGetVectorSize&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">VoidType</span><span class="p">,</span> <span class="s">&quot;LLVMVoidType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">LabelType</span><span class="p">,</span> <span class="s">&quot;LLVMLabelType&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DumpType</span><span class="p">,</span> <span class="s">&quot;LLVMDumpType&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">TypeOf</span><span class="p">,</span> <span class="s">&quot;LLVMTypeOf&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetValueName</span><span class="p">,</span> <span class="s">&quot;LLVMGetValueName&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetValueName</span><span class="p">,</span> <span class="s">&quot;LLVMSetValueName&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DumpValue</span><span class="p">,</span> <span class="s">&quot;LLVMDumpValue&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstNull</span><span class="p">,</span> <span class="s">&quot;LLVMConstNull&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstAllOnes</span><span class="p">,</span> <span class="s">&quot;LLVMConstAllOnes&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetUndef</span><span class="p">,</span> <span class="s">&quot;LLVMGetUndef&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsConstant</span><span class="p">,</span> <span class="s">&quot;LLVMIsConstant&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsNull</span><span class="p">,</span> <span class="s">&quot;LLVMIsNull&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsUndef</span><span class="p">,</span> <span class="s">&quot;LLVMIsUndef&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsAInstruction</span><span class="p">,</span> <span class="s">&quot;LLVMIsAInstruction&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstInt</span><span class="p">,</span> <span class="s">&quot;LLVMConstInt&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstReal</span><span class="p">,</span> <span class="s">&quot;LLVMConstReal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstIntGetZExtValue</span><span class="p">,</span> <span class="s">&quot;LLVMConstIntGetZExtValue&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstRealOfString</span><span class="p">,</span> <span class="s">&quot;LLVMConstRealOfString&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstString</span><span class="p">,</span> <span class="s">&quot;LLVMConstString&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstArray</span><span class="p">,</span> <span class="s">&quot;LLVMConstArray&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstStruct</span><span class="p">,</span> <span class="s">&quot;LLVMConstStruct&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstNamedStruct</span><span class="p">,</span> <span class="s">&quot;LLVMConstNamedStruct&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstVector</span><span class="p">,</span> <span class="s">&quot;LLVMConstVector&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SizeOf</span><span class="p">,</span> <span class="s">&quot;LLVMSizeOf&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AlignOf</span><span class="p">,</span> <span class="s">&quot;LLVMAlignOf&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstNeg</span><span class="p">,</span> <span class="s">&quot;LLVMConstNeg&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstNot</span><span class="p">,</span> <span class="s">&quot;LLVMConstNot&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstAdd</span><span class="p">,</span> <span class="s">&quot;LLVMConstAdd&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSub</span><span class="p">,</span> <span class="s">&quot;LLVMConstSub&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstMul</span><span class="p">,</span> <span class="s">&quot;LLVMConstMul&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstUDiv</span><span class="p">,</span> <span class="s">&quot;LLVMConstUDiv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSDiv</span><span class="p">,</span> <span class="s">&quot;LLVMConstSDiv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFDiv</span><span class="p">,</span> <span class="s">&quot;LLVMConstFDiv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstURem</span><span class="p">,</span> <span class="s">&quot;LLVMConstURem&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSRem</span><span class="p">,</span> <span class="s">&quot;LLVMConstSRem&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFRem</span><span class="p">,</span> <span class="s">&quot;LLVMConstFRem&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstAnd</span><span class="p">,</span> <span class="s">&quot;LLVMConstAnd&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstOr</span><span class="p">,</span> <span class="s">&quot;LLVMConstOr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstXor</span><span class="p">,</span> <span class="s">&quot;LLVMConstXor&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstICmp</span><span class="p">,</span> <span class="s">&quot;LLVMConstICmp&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFCmp</span><span class="p">,</span> <span class="s">&quot;LLVMConstFCmp&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstShl</span><span class="p">,</span> <span class="s">&quot;LLVMConstShl&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstLShr</span><span class="p">,</span> <span class="s">&quot;LLVMConstLShr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstAShr</span><span class="p">,</span> <span class="s">&quot;LLVMConstAShr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstGEP</span><span class="p">,</span> <span class="s">&quot;LLVMConstGEP&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstTrunc</span><span class="p">,</span> <span class="s">&quot;LLVMConstTrunc&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSExt</span><span class="p">,</span> <span class="s">&quot;LLVMConstSExt&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstZExt</span><span class="p">,</span> <span class="s">&quot;LLVMConstZExt&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFPTrunc</span><span class="p">,</span> <span class="s">&quot;LLVMConstFPTrunc&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFPExt</span><span class="p">,</span> <span class="s">&quot;LLVMConstFPExt&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstUIToFP</span><span class="p">,</span> <span class="s">&quot;LLVMConstUIToFP&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSIToFP</span><span class="p">,</span> <span class="s">&quot;LLVMConstSIToFP&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFPToUI</span><span class="p">,</span> <span class="s">&quot;LLVMConstFPToUI&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstFPToSI</span><span class="p">,</span> <span class="s">&quot;LLVMConstFPToSI&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstPtrToInt</span><span class="p">,</span> <span class="s">&quot;LLVMConstPtrToInt&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstIntToPtr</span><span class="p">,</span> <span class="s">&quot;LLVMConstIntToPtr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstBitCast</span><span class="p">,</span> <span class="s">&quot;LLVMConstBitCast&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstTruncOrBitCast</span><span class="p">,</span> <span class="s">&quot;LLVMConstTruncOrBitCast&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstSelect</span><span class="p">,</span> <span class="s">&quot;LLVMConstSelect&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstExtractElement</span><span class="p">,</span> <span class="s">&quot;LLVMConstExtractElement&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstInsertElement</span><span class="p">,</span> <span class="s">&quot;LLVMConstInsertElement&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ConstShuffleVector</span><span class="p">,</span> <span class="s">&quot;LLVMConstShuffleVector&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetGlobalParent</span><span class="p">,</span> <span class="s">&quot;LLVMGetGlobalParent&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsDeclaration</span><span class="p">,</span> <span class="s">&quot;LLVMIsDeclaration&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLinkage</span><span class="p">,</span> <span class="s">&quot;LLVMGetLinkage&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetLinkage</span><span class="p">,</span> <span class="s">&quot;LLVMSetLinkage&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetSection</span><span class="p">,</span> <span class="s">&quot;LLVMGetSection&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetSection</span><span class="p">,</span> <span class="s">&quot;LLVMSetSection&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetVisibility</span><span class="p">,</span> <span class="s">&quot;LLVMGetVisibility&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetVisibility</span><span class="p">,</span> <span class="s">&quot;LLVMSetVisibility&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetAlignment</span><span class="p">,</span> <span class="s">&quot;LLVMGetAlignment&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetAlignment</span><span class="p">,</span> <span class="s">&quot;LLVMSetAlignment&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMAddGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNamedGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMGetNamedGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFirstGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMGetFirstGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLastGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMGetLastGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNextGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMGetNextGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPreviousGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMGetPreviousGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DeleteGlobal</span><span class="p">,</span> <span class="s">&quot;LLVMDeleteGlobal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetInitializer</span><span class="p">,</span> <span class="s">&quot;LLVMGetInitializer&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetInitializer</span><span class="p">,</span> <span class="s">&quot;LLVMSetInitializer&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsThreadLocal</span><span class="p">,</span> <span class="s">&quot;LLVMIsThreadLocal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetThreadLocal</span><span class="p">,</span> <span class="s">&quot;LLVMSetThreadLocal&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsGlobalConstant</span><span class="p">,</span> <span class="s">&quot;LLVMIsGlobalConstant&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetGlobalConstant</span><span class="p">,</span> <span class="s">&quot;LLVMSetGlobalConstant&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddFunction</span><span class="p">,</span> <span class="s">&quot;LLVMAddFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNamedFunction</span><span class="p">,</span> <span class="s">&quot;LLVMGetNamedFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFirstFunction</span><span class="p">,</span> <span class="s">&quot;LLVMGetFirstFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLastFunction</span><span class="p">,</span> <span class="s">&quot;LLVMGetLastFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNextFunction</span><span class="p">,</span> <span class="s">&quot;LLVMGetNextFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPreviousFunction</span><span class="p">,</span> <span class="s">&quot;LLVMGetPreviousFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DeleteFunction</span><span class="p">,</span> <span class="s">&quot;LLVMDeleteFunction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetIntrinsicID</span><span class="p">,</span> <span class="s">&quot;LLVMGetIntrinsicID&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFunctionCallConv</span><span class="p">,</span> <span class="s">&quot;LLVMGetFunctionCallConv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetFunctionCallConv</span><span class="p">,</span> <span class="s">&quot;LLVMSetFunctionCallConv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetGC</span><span class="p">,</span> <span class="s">&quot;LLVMGetGC&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetGC</span><span class="p">,</span> <span class="s">&quot;LLVMSetGC&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddFunctionAttr</span><span class="p">,</span> <span class="s">&quot;LLVMAddFunctionAttr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddTargetDependentFunctionAttr</span><span class="p">,</span>
                  <span class="s">&quot;LLVMAddTargetDependentFunctionAttr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFunctionAttr</span><span class="p">,</span> <span class="s">&quot;LLVMGetFunctionAttr&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">RemoveFunctionAttr</span><span class="p">,</span> <span class="s">&quot;LLVMRemoveFunctionAttr&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CountParams</span><span class="p">,</span> <span class="s">&quot;LLVMCountParams&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetParams</span><span class="p">,</span> <span class="s">&quot;LLVMGetParams&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetParam</span><span class="p">,</span> <span class="s">&quot;LLVMGetParam&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetParamParent</span><span class="p">,</span> <span class="s">&quot;LLVMGetParamParent&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFirstParam</span><span class="p">,</span> <span class="s">&quot;LLVMGetFirstParam&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLastParam</span><span class="p">,</span> <span class="s">&quot;LLVMGetLastParam&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNextParam</span><span class="p">,</span> <span class="s">&quot;LLVMGetNextParam&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPreviousParam</span><span class="p">,</span> <span class="s">&quot;LLVMGetPreviousParam&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddAttribute</span><span class="p">,</span> <span class="s">&quot;LLVMAddAttribute&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">RemoveAttribute</span><span class="p">,</span> <span class="s">&quot;LLVMRemoveAttribute&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetParamAlignment</span><span class="p">,</span> <span class="s">&quot;LLVMSetParamAlignment&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">BasicBlockAsValue</span><span class="p">,</span> <span class="s">&quot;LLVMBasicBlockAsValue&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ValueIsBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMValueIsBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">ValueAsBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMValueAsBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetBasicBlockParent</span><span class="p">,</span> <span class="s">&quot;LLVMGetBasicBlockParent&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CountBasicBlocks</span><span class="p">,</span> <span class="s">&quot;LLVMCountBasicBlocks&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetBasicBlocks</span><span class="p">,</span> <span class="s">&quot;LLVMGetBasicBlocks&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFirstBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetFirstBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLastBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetLastBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNextBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetNextBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPreviousBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetPreviousBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetEntryBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetEntryBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AppendBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMAppendBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">InsertBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMInsertBasicBlock&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">DeleteBasicBlock</span><span class="p">,</span> <span class="s">&quot;LLVMDeleteBasicBlock&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">HasMetadata</span><span class="p">,</span> <span class="s">&quot;LLVMHasMetadata&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetMetadata</span><span class="p">,</span> <span class="s">&quot;LLVMGetMetadata&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetMetadata</span><span class="p">,</span> <span class="s">&quot;LLVMSetMetadata&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetInstructionParent</span><span class="p">,</span> <span class="s">&quot;LLVMGetInstructionParent&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetFirstInstruction</span><span class="p">,</span> <span class="s">&quot;LLVMGetFirstInstruction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetLastInstruction</span><span class="p">,</span> <span class="s">&quot;LLVMGetLastInstruction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetNextInstruction</span><span class="p">,</span> <span class="s">&quot;LLVMGetNextInstruction&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetPreviousInstruction</span><span class="p">,</span> <span class="s">&quot;LLVMGetPreviousInstruction&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetInstructionCallConv</span><span class="p">,</span> <span class="s">&quot;LLVMSetInstructionCallConv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetInstructionCallConv</span><span class="p">,</span> <span class="s">&quot;LLVMGetInstructionCallConv&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddInstrAttribute</span><span class="p">,</span> <span class="s">&quot;LLVMAddInstrAttribute&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">RemoveInstrAttribute</span><span class="p">,</span> <span class="s">&quot;LLVMRemoveInstrAttribute&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetInstrParamAlignment</span><span class="p">,</span> <span class="s">&quot;LLVMSetInstrParamAlignment&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">IsTailCall</span><span class="p">,</span> <span class="s">&quot;LLVMIsTailCall&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">SetTailCall</span><span class="p">,</span> <span class="s">&quot;LLVMSetTailCall&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">AddIncoming</span><span class="p">,</span> <span class="s">&quot;LLVMAddIncoming&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CountIncoming</span><span class="p">,</span> <span class="s">&quot;LLVMCountIncoming&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetIncomingValue</span><span class="p">,</span> <span class="s">&quot;LLVMGetIncomingValue&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetIncomingBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetIncomingBlock&quot;</span><span class="p">);</span>

   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">CreateBuilder</span><span class="p">,</span> <span class="s">&quot;LLVMCreateBuilder&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PositionBuilder</span><span class="p">,</span> <span class="s">&quot;LLVMPositionBuilder&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PositionBuilderBefore</span><span class="p">,</span> <span class="s">&quot;LLVMPositionBuilderBefore&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">PositionBuilderAtEnd</span><span class="p">,</span> <span class="s">&quot;LLVMPositionBuilderAtEnd&quot;</span><span class="p">);</span>
   <span class="kr">pragma</span> <span class="cp">Import</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="n">GetInsertBlock</span><span class="p">,</span> <span class="s">&quot;LLVMGetInsertBlock&quot;</span><span class="p">);</span>