unittests/BackendCore/BackendCoreTests.cpp - gollvm - Git at Google

 //===- llvm/tools/gollvm/unittests/BackendCore/BackendCoreTests.cpp -----===//
 //
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
 //===----------------------------------------------------------------------===//

 #include "TestUtils.h"
 #include "go-llvm-backend.h"
 #include "gtest/gtest.h"

 using namespace llvm;
 using namespace goBackendUnitTests;

 namespace {

 TEST(BackendCoreTests, MakeBackend) {
   LLVMContext C;

   std::unique_ptr<Backend> makeit(go_get_backend(C));
 }

 TEST(BackendCoreTests, ScalarTypes) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));

   Btype *et = be->error_type();
   EXPECT_TRUE(et != nullptr);
   Btype *vt = be->void_type();
   EXPECT_TRUE(vt != nullptr);
   EXPECT_TRUE(vt != et);
   Btype *bt = be->bool_type();
   EXPECT_TRUE(bt != nullptr);
   Btype *pbt = be->pointer_type(bt);
   ASSERT_TRUE(pbt != nullptr);
   EXPECT_TRUE(pbt->type()->isPointerTy());

   std::vector<bool> isuns = {false, true};
   std::vector<int> ibits = {8, 16, 32, 64, 128};
   for (auto uns : isuns) {
     for (auto nbits : ibits) {
       Btype *it = be->integer_type(uns, nbits);
       ASSERT_TRUE(it != nullptr);
       EXPECT_TRUE(it->type()->isIntegerTy());
     }
   }

   std::vector<int> fbits = {32, 64, 128};
   for (auto nbits : fbits) {
     Btype *ft = be->float_type(nbits);
     ASSERT_TRUE(ft != nullptr);
     EXPECT_TRUE(ft->type()->isFloatingPointTy());
   }
 }

 TEST(BackendCoreTests, StructTypes) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));

   // Empty struct
   std::vector<Backend::Btyped_identifier> nofields;
   Btype *emptyst = be->struct_type(nofields);
   SmallVector<Type *, 3> smv_empty(0);
   Type *llvm_emptyst = StructType::get(C, smv_empty);
   ASSERT_TRUE(llvm_emptyst != nullptr);
   ASSERT_TRUE(emptyst != nullptr);
   EXPECT_EQ(llvm_emptyst, emptyst->type());

   // Three-field struct
   Btype *best = mkBackendThreeFieldStruct(be.get());
   Type *llst = mkLlvmThreeFieldStruct(C);
   ASSERT_TRUE(best != nullptr);
   ASSERT_TRUE(llst != nullptr);
   EXPECT_EQ(llst, best->type());
   EXPECT_EQ(repr(best->type()), "{ i8, float*, i64 }");

   // If a field has error type, entire struct has error type
   std::vector<Backend::Btyped_identifier> fields = {
       Backend::Btyped_identifier("f1", be->bool_type(), Location()),
       Backend::Btyped_identifier("fe", be->error_type(), Location())};
   Btype *badst = be->struct_type(fields);
   EXPECT_TRUE(badst != nullptr);
   EXPECT_EQ(badst, be->error_type());

   // Llvm_backend should be caching and reusing anonymous types
   Btype *st1 = mkBackendThreeFieldStruct(be.get());
   Btype *st2 = mkBackendThreeFieldStruct(be.get());
   EXPECT_EQ(st1, st2);
 }

 TEST(BackendCoreTests, TypeHashAndCompare) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));

   Btype *st1 = mkBackendThreeFieldStruct(be.get());
   Btype *st2 = mkBackendThreeFieldStruct(be.get());
   EXPECT_EQ(st1->hash(), st2->hash());
   EXPECT_TRUE(st1->equal(*st1));
 }

 TEST(BackendCoreTests, ComplexTypes) {
   LLVMContext C;

   Type *ft = Type::getFloatTy(C);
   Type *dt = Type::getDoubleTy(C);

   std::unique_ptr<Backend> be(go_get_backend(C));
   Btype *c32 = be->complex_type(64);
   ASSERT_TRUE(c32 != nullptr);
   EXPECT_EQ(c32->type(), mkTwoFieldLLvmStruct(C, ft, ft));
   Btype *c64 = be->complex_type(128);
   ASSERT_TRUE(c64 != nullptr);
   EXPECT_EQ(c64->type(), mkTwoFieldLLvmStruct(C, dt, dt));
 }

 TEST(BackendCoreTests, FunctionTypes) {
   LLVMContext C;

   Type *i64t = IntegerType::get(C, 64);

   std::unique_ptr<Backend> be(go_get_backend(C));

   // func foo() {}
   Btype *emptyf = mkFuncTyp(be.get(), L_END);
   Type *llemptyf = mkLLFuncTyp(&C, L_END);
   ASSERT_TRUE(llemptyf != nullptr && emptyf != nullptr);
   EXPECT_TRUE(llemptyf == emptyf->type());

   {
     // func (Blah) foo() {}
     Btype *pt = be->pointer_type(mkBackendThreeFieldStruct(be.get()));
     Btype *befn =
         mkFuncTyp(be.get(), L_RCV, pt, L_END);
     llvm::PointerType *llpt =
         llvm::PointerType::get(mkLlvmThreeFieldStruct(C), 0);
     Type *llfn = mkLLFuncTyp(&C, L_RCV, llpt, L_END);
     ASSERT_TRUE(befn != nullptr && llfn != nullptr);
     EXPECT_TRUE(befn->type() == llfn);
   }

   {
     // func foo(x int64) {}
     Btype *befn =
         mkFuncTyp(be.get(), L_PARM, be->integer_type(false, 64), L_END);
     Type *llfn = mkLLFuncTyp(&C, L_PARM, i64t, L_END);
     ASSERT_TRUE(befn != nullptr && llfn != nullptr);
     EXPECT_TRUE(befn->type() == llfn);
   }

   {
     // func foo() int64 {}
     Btype *befn =
         mkFuncTyp(be.get(), L_RES, be->integer_type(false, 64), L_END);
     Type *llfn = mkLLFuncTyp(&C, L_RES, i64t, L_END);
     ASSERT_TRUE(befn != nullptr && llfn != nullptr);
     EXPECT_TRUE(befn->type() == llfn);
   }
 }

 TEST(BackendCoreTests, PlaceholderTypes) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));

   // Create a placeholder pointer type
   Location loc;
   Btype *phpt1 = be->placeholder_pointer_type("ph1", loc, false);
   ASSERT_TRUE(phpt1 != nullptr);
   EXPECT_TRUE(phpt1->type()->isPointerTy());

   // Placeholder pointer types should not be cached
   Btype *phpt2 = be->placeholder_pointer_type("ph", loc, false);
   Btype *phpt3 = be->placeholder_pointer_type("ph", loc, false);
   ASSERT_TRUE(phpt2 != phpt3);
   EXPECT_TRUE(phpt2->type() != phpt3->type());

   // Replace placeholder pointer type
   Btype *pst = be->pointer_type(mkBackendThreeFieldStruct(be.get()));
   be->set_placeholder_pointer_type(phpt1, pst);
   ASSERT_TRUE(phpt1->type()->isPointerTy());
   PointerType *llpt = cast<PointerType>(phpt1->type());
   EXPECT_TRUE(llpt->getElementType()->isStructTy());

   // Placeholder struct type
   Btype *phst1 = be->placeholder_struct_type("ph", loc);
   ASSERT_TRUE(phpt1 != nullptr);

   // Named version of above
   Btype *nt = be->named_type("named_ph", phst1, loc);

   // Replace placeholder struct type
   std::vector<Backend::Btyped_identifier> fields = {
       Backend::Btyped_identifier("f1", be->integer_type(false, 64), Location()),
       Backend::Btyped_identifier("f2", be->integer_type(false, 64),
                                  Location())};
   be->set_placeholder_struct_type(phst1, fields);
   Type *i64t = IntegerType::get(C, 64);
   EXPECT_TRUE(llvmTypesEquiv(phst1->type(),
                              mkTwoFieldLLvmStruct(C, i64t, i64t)));
   EXPECT_TRUE(llvmTypesEquiv(nt->type(),
                              mkTwoFieldLLvmStruct(C, i64t, i64t)));

   // Placeholder array type
   Btype *phat1 = be->placeholder_array_type("pha", loc);
   ASSERT_TRUE(phat1 != nullptr);

   // Replace placeholder array type
   Btype *bi64t = be->integer_type(false, 64);
   Bexpression *val10 = mkInt64Const(be.get(), int64_t(10));
   Btype *at10 = be->array_type(bi64t, val10);
   ASSERT_TRUE(at10 != nullptr);
   be->set_placeholder_array_type(phat1, bi64t, val10);
   EXPECT_TRUE(phat1->type() == at10->type());

   // Circular pointer support
   Btype *php4 = be->placeholder_pointer_type("ph", loc, false);
   Btype *cpt = be->circular_pointer_type(php4, false);
   Btype *cpt2 = be->circular_pointer_type(php4, false);
   EXPECT_EQ(cpt, cpt2);
   be->set_placeholder_pointer_type(php4, cpt);
   EXPECT_EQ(php4->type(), cpt->type());
 }

 TEST(BackendCoreTests, ArrayTypes) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));
   Location loc;

   // Very basic tests of array type creation: array of integers
   Btype *bi32t = be->integer_type(false, 32);
   Btype *bi64t = be->integer_type(false, 64);
   Bexpression *val10 = mkInt64Const(be.get(), int64_t(10));
   Btype *at10 = be->array_type(bi64t, val10);
   ASSERT_TRUE(at10 != nullptr);
   EXPECT_EQ(at10->type(), llvm::ArrayType::get(bi64t->type(), 10));

   // Array of structs
   Bexpression *val1023 = mkUint64Const(be.get(), uint64_t(1023));
   Btype *st = mkTwoFieldStruct(be.get(), bi32t, bi64t);
   Btype *at1023 = be->array_type(st, val1023);
   ASSERT_TRUE(at1023 != nullptr);
   llvm::Type *lst = mkTwoFieldLLvmStruct(C, bi32t->type(), bi64t->type());
   EXPECT_EQ(at1023->type(), llvm::ArrayType::get(lst, 1023));

   // Zero sized array
   Bexpression *val0 = mkInt64Const(be.get(), 0);
   Btype *at0 = be->array_type(bi64t, val0);
   ASSERT_TRUE(at0 != nullptr);

   // Error cases
   Bexpression *badval = be->error_expression();
   Btype *badt1 = be->array_type(bi64t, badval);
   EXPECT_EQ(badt1, be->error_type());
   Btype *badt2 = be->array_type(be->error_type(), val10);
   EXPECT_EQ(badt2, be->error_type());
 }

 TEST(BackendCoreTests, NamedTypes) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));
   Location loc;
   Btype *nt = be->named_type("named_int32", be->integer_type(false, 32), loc);
   ASSERT_TRUE(nt != nullptr);
   Btype *nt2 =
       be->named_type("another_int32", be->integer_type(false, 32), loc);
   ASSERT_TRUE(nt2 != nullptr);
   EXPECT_TRUE(nt != nt2);
   EXPECT_TRUE(nt->equivalent(*nt2));
 }

 TEST(BackendCoreTests, TypeUtils) {
   LLVMContext C;
   Location loc;

   // Type size and alignment. Size and align are in bytes.
   std::unique_ptr<Backend> be(go_get_backend(C));
   Btype *i8t = be->integer_type(false, 8);
   Btype *bs1f = mkBackendStruct(be.get(), i8t, "f1", nullptr);
   EXPECT_EQ(be->type_size(i8t), int64_t(1));
   EXPECT_EQ(be->type_alignment(i8t), 1);
   EXPECT_EQ(be->type_alignment(bs1f), 1);

   // Slightly more complicated example
   Btype *u64 = be->integer_type(true, 64);
   Btype *st = mkTwoFieldStruct(be.get(), u64, u64);
   EXPECT_EQ(be->type_size(st), int64_t(16));
   EXPECT_EQ(be->type_alignment(st), 8);

   // Strictly speaking, one should be asking for the size
   // of a pointer-to-function type, not a function type, however
   // it does appear that this needs to be supported.
   Btype *emptyf = mkFuncTyp(be.get(), L_END);
   EXPECT_EQ(be->type_size(emptyf), be->type_size(be->pointer_type(u64)));

   // We need to support type size queries on types that are not fully
   // resolved, specifically struct types that incorporate unresolved
   // placeholder pointer fields.
   Btype *pvt = be->pointer_type(be->void_type());
   Btype *phpt = be->placeholder_pointer_type("ph1", loc, false);
   Btype *ptphpt = be->pointer_type(phpt);
   Btype *phst = be->placeholder_struct_type("ph2", loc);
   std::vector<Backend::Btyped_identifier> fields = {
     Backend::Btyped_identifier("f1", phpt, loc),
     Backend::Btyped_identifier("f2", ptphpt, loc)};
   be->set_placeholder_struct_type(phst, fields);
   Btype *rst = mkTwoFieldStruct(be.get(), pvt, pvt);
   EXPECT_EQ(be->type_size(rst), be->type_size(phst));
   EXPECT_EQ(be->type_field_offset(rst,1), be->type_field_offset(phst,1));

   // type field alignment
   Btype *u32 = be->integer_type(true, 32);
   EXPECT_EQ(be->type_field_alignment(u32), 4);
 }

 TEST(BackendCoreTests, TestTypeEquivalence) {
   LLVMContext C;

   std::unique_ptr<Backend> be(go_get_backend(C));

   // Two structs with same field type but different field names
   Btype *bi32t = be->integer_type(false, 32);
   Btype *pbi32t = be->pointer_type(bi32t);
   Btype *s1t = mkBackendStruct(be.get(), pbi32t, "f1", bi32t, "f2", nullptr);
   Btype *s2t = mkBackendStruct(be.get(), pbi32t, "f2", bi32t, "f1", nullptr);

   // Neither ::equal nor ::equivalent
   EXPECT_FALSE(s1t->equal(*s2t));
   EXPECT_FALSE(s1t->equivalent(*s2t));

   // Structs created via placholders
   Location loc;
   Btype *phst1 = be->placeholder_struct_type("ph1", loc);
   std::vector<Backend::Btyped_identifier> fields1 = {
     Backend::Btyped_identifier("f1", s1t, loc),
     Backend::Btyped_identifier("f2", s2t, loc)};
   be->set_placeholder_struct_type(phst1, fields1);

   Btype *phst2 = be->placeholder_struct_type("ph2", loc);
   std::vector<Backend::Btyped_identifier> fields2 = {
     Backend::Btyped_identifier("f1", s1t, loc),
     Backend::Btyped_identifier("f2", s2t, loc)};
   be->set_placeholder_struct_type(phst2, fields2);

   EXPECT_FALSE(phst1->equal(*phst2));
   EXPECT_TRUE(phst1->equivalent(*phst2));
 }

 TEST(BackendCoreTests, TestFcnPointerCompatible) {

   FcnTestHarness h("foo");
   Llvm_backend *be = h.be();
   TypeManager *tm = be->typeManager();
   Location loc;

   // Create a struct that looks like
   //
   //  struct S { int8, void(int8)*, *S }
   //
   Btype *pht = be->placeholder_pointer_type("ph", loc, false);
   Btype *bi8t = be->integer_type(false, 8);
   BFunctionType *befty1 = mkFuncTyp(be, L_PARM, bi8t, L_END);
   Btype *pft = be->pointer_type(befty1);
   Btype *s1t = mkBackendStruct(be, bi8t, "f1", pft, "f2", pht, "n", nullptr);
   Btype *ps1t = be->pointer_type(s1t);
   be->set_placeholder_pointer_type(pht, ps1t);
   h.mkLocal("y", s1t);

   // Create a struct that looks like
   //
   //  struct S { int8, void*, *S }
   //
   Btype *pht2 = be->placeholder_pointer_type("ph", loc, false);
   Btype *pvt = be->pointer_type(be->void_type());
   Btype *s2t = mkBackendStruct(be, bi8t, "f1", pvt, "f2", pht2, "n", nullptr);
   Btype *ps2t = be->pointer_type(s2t);
   be->set_placeholder_pointer_type(pht2, ps2t);
   h.mkLocal("x", s2t);

   // These two types are not structurally equivalent
   EXPECT_FALSE(pht2->equal(*pht));

   // However the underlying LLVM types should be considered
   // assignment-compatible.
   std::set<llvm::Type *> visited;
   bool equiv = tm->fcnPointerCompatible(pht->type(), pht2->type(), visited);
   EXPECT_TRUE(equiv);

   bool broken = h.finish(PreserveDebugInfo);
   EXPECT_FALSE(broken && "Module failed to verify.");
 }

 TEST(BackendCoreTests, TestCompositeInitGvarConvert) {

   FcnTestHarness h("foo");
   Llvm_backend *be = h.be();
   Location loc;

   // Regular struct of type { i8, *i8, i32 }
   Btype *bt = be->bool_type();
   Btype *pbt = be->pointer_type(bt);
   Btype *bi32t = be->integer_type(false, 32);
   Btype *s3t = mkBackendStruct(be, bt, "f0", pbt, "f1", bi32t, "f2", nullptr);

   // Placeholder version of type { i8, *i8, i32 }
   Btype *phst1 = be->placeholder_struct_type("ph", loc);
   std::vector<Backend::Btyped_identifier> fields = {
       Backend::Btyped_identifier("f0", bt, loc),
       Backend::Btyped_identifier("f1", pbt, loc),
       Backend::Btyped_identifier("f3", bi32t, loc)};
   be->set_placeholder_struct_type(phst1, fields);

   // Another struct that uses the both types above as fields
   Btype *sqt = mkBackendStruct(be, s3t, "f0", phst1, "f1", nullptr);

   // Create a global variable using this type
   Bvariable *g1 =
       be->global_variable("gv", "gv", sqt, false, /* is_external */
                           false,                  /* is_hidden */
                           false, /* unique_section */
                           loc);

   // Create initializers using the various types.  Note: the initial
   // value for "f0" (non-placeholder type) is created using the
   // corresponding placeholder and vice versa -- the intent is to
   // make sure the conversion is handled properly.
   Bexpression *f1con, *f2con, *topcon;
   {
     std::vector<Bexpression *> vals;
     vals.push_back(be->zero_expression(bt));
     vals.push_back(be->zero_expression(pbt));
     vals.push_back(mkInt32Const(be, int32_t(101)));
     f1con = be->constructor_expression(s3t, vals, loc);
   }
   {
     std::vector<Bexpression *> vals;
     vals.push_back(be->zero_expression(bt));
     vals.push_back(be->zero_expression(pbt));
     vals.push_back(mkInt32Const(be, int32_t(101)));
     f2con = be->constructor_expression(phst1, vals, loc);
   }
   {
     std::vector<Bexpression *> vals;
     Bexpression *bc1 = be->convert_expression(phst1, f1con, loc);
     vals.push_back(bc1);
     Bexpression *bc2 = be->convert_expression(s3t, f2con, loc);
     vals.push_back(bc2);
     topcon = be->constructor_expression(sqt, vals, loc);
   }

   // Set initializer
   be->global_variable_set_init(g1, topcon);

   bool broken = h.finish(StripDebugInfo);
   EXPECT_FALSE(broken && "Module failed to verify.");

   bool ok = h.expectModuleDumpContains("@gv = global { { i8, i8*, i32 }, %ph.0 } { { i8, i8*, i32 } { i8 0, i8* null, i32 101 }, %ph.0 { i8 0, i8* null, i32 101 } }");
   EXPECT_TRUE(ok);

 }

 }
	//===- llvm/tools/gollvm/unittests/BackendCore/BackendCoreTests.cpp -----===//
	//
	// Copyright 2018 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.
	//
	//===----------------------------------------------------------------------===//

	#include "TestUtils.h"
	#include "go-llvm-backend.h"
	#include "gtest/gtest.h"

	using namespace llvm;
	using namespace goBackendUnitTests;

	namespace {

	TEST(BackendCoreTests, MakeBackend) {
	LLVMContext C;

	std::unique_ptr<Backend> makeit(go_get_backend(C));
	}

	TEST(BackendCoreTests, ScalarTypes) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));

	Btype *et = be->error_type();
	EXPECT_TRUE(et != nullptr);
	Btype *vt = be->void_type();
	EXPECT_TRUE(vt != nullptr);
	EXPECT_TRUE(vt != et);
	Btype *bt = be->bool_type();
	EXPECT_TRUE(bt != nullptr);
	Btype *pbt = be->pointer_type(bt);
	ASSERT_TRUE(pbt != nullptr);
	EXPECT_TRUE(pbt->type()->isPointerTy());

	std::vector<bool> isuns = {false, true};
	std::vector<int> ibits = {8, 16, 32, 64, 128};
	for (auto uns : isuns) {
	for (auto nbits : ibits) {
	Btype *it = be->integer_type(uns, nbits);
	ASSERT_TRUE(it != nullptr);
	EXPECT_TRUE(it->type()->isIntegerTy());
	}
	}

	std::vector<int> fbits = {32, 64, 128};
	for (auto nbits : fbits) {
	Btype *ft = be->float_type(nbits);
	ASSERT_TRUE(ft != nullptr);
	EXPECT_TRUE(ft->type()->isFloatingPointTy());
	}
	}

	TEST(BackendCoreTests, StructTypes) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));

	// Empty struct
	std::vector<Backend::Btyped_identifier> nofields;
	Btype *emptyst = be->struct_type(nofields);
	SmallVector<Type *, 3> smv_empty(0);
	Type *llvm_emptyst = StructType::get(C, smv_empty);
	ASSERT_TRUE(llvm_emptyst != nullptr);
	ASSERT_TRUE(emptyst != nullptr);
	EXPECT_EQ(llvm_emptyst, emptyst->type());

	// Three-field struct
	Btype *best = mkBackendThreeFieldStruct(be.get());
	Type *llst = mkLlvmThreeFieldStruct(C);
	ASSERT_TRUE(best != nullptr);
	ASSERT_TRUE(llst != nullptr);
	EXPECT_EQ(llst, best->type());
	EXPECT_EQ(repr(best->type()), "{ i8, float*, i64 }");

	// If a field has error type, entire struct has error type
	std::vector<Backend::Btyped_identifier> fields = {
	Backend::Btyped_identifier("f1", be->bool_type(), Location()),
	Backend::Btyped_identifier("fe", be->error_type(), Location())};
	Btype *badst = be->struct_type(fields);
	EXPECT_TRUE(badst != nullptr);
	EXPECT_EQ(badst, be->error_type());

	// Llvm_backend should be caching and reusing anonymous types
	Btype *st1 = mkBackendThreeFieldStruct(be.get());
	Btype *st2 = mkBackendThreeFieldStruct(be.get());
	EXPECT_EQ(st1, st2);
	}

	TEST(BackendCoreTests, TypeHashAndCompare) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));

	Btype *st1 = mkBackendThreeFieldStruct(be.get());
	Btype *st2 = mkBackendThreeFieldStruct(be.get());
	EXPECT_EQ(st1->hash(), st2->hash());
	EXPECT_TRUE(st1->equal(*st1));
	}

	TEST(BackendCoreTests, ComplexTypes) {
	LLVMContext C;

	Type *ft = Type::getFloatTy(C);
	Type *dt = Type::getDoubleTy(C);

	std::unique_ptr<Backend> be(go_get_backend(C));
	Btype *c32 = be->complex_type(64);
	ASSERT_TRUE(c32 != nullptr);
	EXPECT_EQ(c32->type(), mkTwoFieldLLvmStruct(C, ft, ft));
	Btype *c64 = be->complex_type(128);
	ASSERT_TRUE(c64 != nullptr);
	EXPECT_EQ(c64->type(), mkTwoFieldLLvmStruct(C, dt, dt));
	}

	TEST(BackendCoreTests, FunctionTypes) {
	LLVMContext C;

	Type *i64t = IntegerType::get(C, 64);

	std::unique_ptr<Backend> be(go_get_backend(C));

	// func foo() {}
	Btype *emptyf = mkFuncTyp(be.get(), L_END);
	Type *llemptyf = mkLLFuncTyp(&C, L_END);
	ASSERT_TRUE(llemptyf != nullptr && emptyf != nullptr);
	EXPECT_TRUE(llemptyf == emptyf->type());

	{
	// func (Blah) foo() {}
	Btype *pt = be->pointer_type(mkBackendThreeFieldStruct(be.get()));
	Btype *befn =
	mkFuncTyp(be.get(), L_RCV, pt, L_END);
	llvm::PointerType *llpt =
	llvm::PointerType::get(mkLlvmThreeFieldStruct(C), 0);
	Type *llfn = mkLLFuncTyp(&C, L_RCV, llpt, L_END);
	ASSERT_TRUE(befn != nullptr && llfn != nullptr);
	EXPECT_TRUE(befn->type() == llfn);
	}

	{
	// func foo(x int64) {}
	Btype *befn =
	mkFuncTyp(be.get(), L_PARM, be->integer_type(false, 64), L_END);
	Type *llfn = mkLLFuncTyp(&C, L_PARM, i64t, L_END);
	ASSERT_TRUE(befn != nullptr && llfn != nullptr);
	EXPECT_TRUE(befn->type() == llfn);
	}

	{
	// func foo() int64 {}
	Btype *befn =
	mkFuncTyp(be.get(), L_RES, be->integer_type(false, 64), L_END);
	Type *llfn = mkLLFuncTyp(&C, L_RES, i64t, L_END);
	ASSERT_TRUE(befn != nullptr && llfn != nullptr);
	EXPECT_TRUE(befn->type() == llfn);
	}
	}

	TEST(BackendCoreTests, PlaceholderTypes) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));

	// Create a placeholder pointer type
	Location loc;
	Btype *phpt1 = be->placeholder_pointer_type("ph1", loc, false);
	ASSERT_TRUE(phpt1 != nullptr);
	EXPECT_TRUE(phpt1->type()->isPointerTy());

	// Placeholder pointer types should not be cached
	Btype *phpt2 = be->placeholder_pointer_type("ph", loc, false);
	Btype *phpt3 = be->placeholder_pointer_type("ph", loc, false);
	ASSERT_TRUE(phpt2 != phpt3);
	EXPECT_TRUE(phpt2->type() != phpt3->type());

	// Replace placeholder pointer type
	Btype *pst = be->pointer_type(mkBackendThreeFieldStruct(be.get()));
	be->set_placeholder_pointer_type(phpt1, pst);
	ASSERT_TRUE(phpt1->type()->isPointerTy());
	PointerType *llpt = cast<PointerType>(phpt1->type());
	EXPECT_TRUE(llpt->getElementType()->isStructTy());

	// Placeholder struct type
	Btype *phst1 = be->placeholder_struct_type("ph", loc);
	ASSERT_TRUE(phpt1 != nullptr);

	// Named version of above
	Btype *nt = be->named_type("named_ph", phst1, loc);

	// Replace placeholder struct type
	std::vector<Backend::Btyped_identifier> fields = {
	Backend::Btyped_identifier("f1", be->integer_type(false, 64), Location()),
	Backend::Btyped_identifier("f2", be->integer_type(false, 64),
	Location())};
	be->set_placeholder_struct_type(phst1, fields);
	Type *i64t = IntegerType::get(C, 64);
	EXPECT_TRUE(llvmTypesEquiv(phst1->type(),
	mkTwoFieldLLvmStruct(C, i64t, i64t)));
	EXPECT_TRUE(llvmTypesEquiv(nt->type(),
	mkTwoFieldLLvmStruct(C, i64t, i64t)));

	// Placeholder array type
	Btype *phat1 = be->placeholder_array_type("pha", loc);
	ASSERT_TRUE(phat1 != nullptr);

	// Replace placeholder array type
	Btype *bi64t = be->integer_type(false, 64);
	Bexpression *val10 = mkInt64Const(be.get(), int64_t(10));
	Btype *at10 = be->array_type(bi64t, val10);
	ASSERT_TRUE(at10 != nullptr);
	be->set_placeholder_array_type(phat1, bi64t, val10);
	EXPECT_TRUE(phat1->type() == at10->type());

	// Circular pointer support
	Btype *php4 = be->placeholder_pointer_type("ph", loc, false);
	Btype *cpt = be->circular_pointer_type(php4, false);
	Btype *cpt2 = be->circular_pointer_type(php4, false);
	EXPECT_EQ(cpt, cpt2);
	be->set_placeholder_pointer_type(php4, cpt);
	EXPECT_EQ(php4->type(), cpt->type());
	}

	TEST(BackendCoreTests, ArrayTypes) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));
	Location loc;

	// Very basic tests of array type creation: array of integers
	Btype *bi32t = be->integer_type(false, 32);
	Btype *bi64t = be->integer_type(false, 64);
	Bexpression *val10 = mkInt64Const(be.get(), int64_t(10));
	Btype *at10 = be->array_type(bi64t, val10);
	ASSERT_TRUE(at10 != nullptr);
	EXPECT_EQ(at10->type(), llvm::ArrayType::get(bi64t->type(), 10));

	// Array of structs
	Bexpression *val1023 = mkUint64Const(be.get(), uint64_t(1023));
	Btype *st = mkTwoFieldStruct(be.get(), bi32t, bi64t);
	Btype *at1023 = be->array_type(st, val1023);
	ASSERT_TRUE(at1023 != nullptr);
	llvm::Type *lst = mkTwoFieldLLvmStruct(C, bi32t->type(), bi64t->type());
	EXPECT_EQ(at1023->type(), llvm::ArrayType::get(lst, 1023));

	// Zero sized array
	Bexpression *val0 = mkInt64Const(be.get(), 0);
	Btype *at0 = be->array_type(bi64t, val0);
	ASSERT_TRUE(at0 != nullptr);

	// Error cases
	Bexpression *badval = be->error_expression();
	Btype *badt1 = be->array_type(bi64t, badval);
	EXPECT_EQ(badt1, be->error_type());
	Btype *badt2 = be->array_type(be->error_type(), val10);
	EXPECT_EQ(badt2, be->error_type());
	}

	TEST(BackendCoreTests, NamedTypes) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));
	Location loc;
	Btype *nt = be->named_type("named_int32", be->integer_type(false, 32), loc);
	ASSERT_TRUE(nt != nullptr);
	Btype *nt2 =
	be->named_type("another_int32", be->integer_type(false, 32), loc);
	ASSERT_TRUE(nt2 != nullptr);
	EXPECT_TRUE(nt != nt2);
	EXPECT_TRUE(nt->equivalent(*nt2));
	}

	TEST(BackendCoreTests, TypeUtils) {
	LLVMContext C;
	Location loc;

	// Type size and alignment. Size and align are in bytes.
	std::unique_ptr<Backend> be(go_get_backend(C));
	Btype *i8t = be->integer_type(false, 8);
	Btype *bs1f = mkBackendStruct(be.get(), i8t, "f1", nullptr);
	EXPECT_EQ(be->type_size(i8t), int64_t(1));
	EXPECT_EQ(be->type_alignment(i8t), 1);
	EXPECT_EQ(be->type_alignment(bs1f), 1);

	// Slightly more complicated example
	Btype *u64 = be->integer_type(true, 64);
	Btype *st = mkTwoFieldStruct(be.get(), u64, u64);
	EXPECT_EQ(be->type_size(st), int64_t(16));
	EXPECT_EQ(be->type_alignment(st), 8);

	// Strictly speaking, one should be asking for the size
	// of a pointer-to-function type, not a function type, however
	// it does appear that this needs to be supported.
	Btype *emptyf = mkFuncTyp(be.get(), L_END);
	EXPECT_EQ(be->type_size(emptyf), be->type_size(be->pointer_type(u64)));

	// We need to support type size queries on types that are not fully
	// resolved, specifically struct types that incorporate unresolved
	// placeholder pointer fields.
	Btype *pvt = be->pointer_type(be->void_type());
	Btype *phpt = be->placeholder_pointer_type("ph1", loc, false);
	Btype *ptphpt = be->pointer_type(phpt);
	Btype *phst = be->placeholder_struct_type("ph2", loc);
	std::vector<Backend::Btyped_identifier> fields = {
	Backend::Btyped_identifier("f1", phpt, loc),
	Backend::Btyped_identifier("f2", ptphpt, loc)};
	be->set_placeholder_struct_type(phst, fields);
	Btype *rst = mkTwoFieldStruct(be.get(), pvt, pvt);
	EXPECT_EQ(be->type_size(rst), be->type_size(phst));
	EXPECT_EQ(be->type_field_offset(rst,1), be->type_field_offset(phst,1));

	// type field alignment
	Btype *u32 = be->integer_type(true, 32);
	EXPECT_EQ(be->type_field_alignment(u32), 4);
	}

	TEST(BackendCoreTests, TestTypeEquivalence) {
	LLVMContext C;

	std::unique_ptr<Backend> be(go_get_backend(C));

	// Two structs with same field type but different field names
	Btype *bi32t = be->integer_type(false, 32);
	Btype *pbi32t = be->pointer_type(bi32t);
	Btype *s1t = mkBackendStruct(be.get(), pbi32t, "f1", bi32t, "f2", nullptr);
	Btype *s2t = mkBackendStruct(be.get(), pbi32t, "f2", bi32t, "f1", nullptr);

	// Neither ::equal nor ::equivalent
	EXPECT_FALSE(s1t->equal(*s2t));
	EXPECT_FALSE(s1t->equivalent(*s2t));

	// Structs created via placholders
	Location loc;
	Btype *phst1 = be->placeholder_struct_type("ph1", loc);
	std::vector<Backend::Btyped_identifier> fields1 = {
	Backend::Btyped_identifier("f1", s1t, loc),
	Backend::Btyped_identifier("f2", s2t, loc)};
	be->set_placeholder_struct_type(phst1, fields1);

	Btype *phst2 = be->placeholder_struct_type("ph2", loc);
	std::vector<Backend::Btyped_identifier> fields2 = {
	Backend::Btyped_identifier("f1", s1t, loc),
	Backend::Btyped_identifier("f2", s2t, loc)};
	be->set_placeholder_struct_type(phst2, fields2);

	EXPECT_FALSE(phst1->equal(*phst2));
	EXPECT_TRUE(phst1->equivalent(*phst2));
	}

	TEST(BackendCoreTests, TestFcnPointerCompatible) {

	FcnTestHarness h("foo");
	Llvm_backend *be = h.be();
	TypeManager *tm = be->typeManager();
	Location loc;

	// Create a struct that looks like
	//
	// struct S { int8, void(int8), S }
	//
	Btype *pht = be->placeholder_pointer_type("ph", loc, false);
	Btype *bi8t = be->integer_type(false, 8);
	BFunctionType *befty1 = mkFuncTyp(be, L_PARM, bi8t, L_END);
	Btype *pft = be->pointer_type(befty1);
	Btype *s1t = mkBackendStruct(be, bi8t, "f1", pft, "f2", pht, "n", nullptr);
	Btype *ps1t = be->pointer_type(s1t);
	be->set_placeholder_pointer_type(pht, ps1t);
	h.mkLocal("y", s1t);

	// Create a struct that looks like
	//
	// struct S { int8, void, S }
	//
	Btype *pht2 = be->placeholder_pointer_type("ph", loc, false);
	Btype *pvt = be->pointer_type(be->void_type());
	Btype *s2t = mkBackendStruct(be, bi8t, "f1", pvt, "f2", pht2, "n", nullptr);
	Btype *ps2t = be->pointer_type(s2t);
	be->set_placeholder_pointer_type(pht2, ps2t);
	h.mkLocal("x", s2t);

	// These two types are not structurally equivalent
	EXPECT_FALSE(pht2->equal(*pht));

	// However the underlying LLVM types should be considered
	// assignment-compatible.
	std::set<llvm::Type *> visited;
	bool equiv = tm->fcnPointerCompatible(pht->type(), pht2->type(), visited);
	EXPECT_TRUE(equiv);

	bool broken = h.finish(PreserveDebugInfo);
	EXPECT_FALSE(broken && "Module failed to verify.");
	}

	TEST(BackendCoreTests, TestCompositeInitGvarConvert) {

	FcnTestHarness h("foo");
	Llvm_backend *be = h.be();
	Location loc;

	// Regular struct of type { i8, *i8, i32 }
	Btype *bt = be->bool_type();
	Btype *pbt = be->pointer_type(bt);
	Btype *bi32t = be->integer_type(false, 32);
	Btype *s3t = mkBackendStruct(be, bt, "f0", pbt, "f1", bi32t, "f2", nullptr);

	// Placeholder version of type { i8, *i8, i32 }
	Btype *phst1 = be->placeholder_struct_type("ph", loc);
	std::vector<Backend::Btyped_identifier> fields = {
	Backend::Btyped_identifier("f0", bt, loc),
	Backend::Btyped_identifier("f1", pbt, loc),
	Backend::Btyped_identifier("f3", bi32t, loc)};
	be->set_placeholder_struct_type(phst1, fields);

	// Another struct that uses the both types above as fields
	Btype *sqt = mkBackendStruct(be, s3t, "f0", phst1, "f1", nullptr);

	// Create a global variable using this type
	Bvariable *g1 =
	be->global_variable("gv", "gv", sqt, false, /* is_external */
	false, /* is_hidden */
	false, /* unique_section */
	loc);

	// Create initializers using the various types. Note: the initial
	// value for "f0" (non-placeholder type) is created using the
	// corresponding placeholder and vice versa -- the intent is to
	// make sure the conversion is handled properly.
	Bexpression f1con, f2con, *topcon;
	{
	std::vector<Bexpression *> vals;
	vals.push_back(be->zero_expression(bt));
	vals.push_back(be->zero_expression(pbt));
	vals.push_back(mkInt32Const(be, int32_t(101)));
	f1con = be->constructor_expression(s3t, vals, loc);
	}
	{
	std::vector<Bexpression *> vals;
	vals.push_back(be->zero_expression(bt));
	vals.push_back(be->zero_expression(pbt));
	vals.push_back(mkInt32Const(be, int32_t(101)));
	f2con = be->constructor_expression(phst1, vals, loc);
	}
	{
	std::vector<Bexpression *> vals;
	Bexpression *bc1 = be->convert_expression(phst1, f1con, loc);
	vals.push_back(bc1);
	Bexpression *bc2 = be->convert_expression(s3t, f2con, loc);
	vals.push_back(bc2);
	topcon = be->constructor_expression(sqt, vals, loc);
	}

	// Set initializer
	be->global_variable_set_init(g1, topcon);

	bool broken = h.finish(StripDebugInfo);
	EXPECT_FALSE(broken && "Module failed to verify.");

	bool ok = h.expectModuleDumpContains("@gv = global { { i8, i8, i32 }, %ph.0 } { { i8, i8, i32 } { i8 0, i8* null, i32 101 }, %ph.0 { i8 0, i8* null, i32 101 } }");
	EXPECT_TRUE(ok);

	}

	}