gollvm: fix up unit tests Rewrite the back end unit tests to use the correct interfaces for global/implicit variable creation (rolled out in CL 322129), which use a flags value instead of discrete booleans for var properties. Fixes golang/go#47471. Change-Id: I077d9b31d76708d5b10b382e915e5e0fc03b3e33 Reviewed-on: https://go-review.googlesource.com/c/gollvm/+/339773 Trust: Than McIntosh <thanm@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
diff --git a/unittests/BackendCore/BackendArrayStruct.cpp b/unittests/BackendCore/BackendArrayStruct.cpp index bdbd2ae..5d10538 100644 --- a/unittests/BackendCore/BackendArrayStruct.cpp +++ b/unittests/BackendCore/BackendArrayStruct.cpp
@@ -503,17 +503,12 @@ // Construct a struct with a global var field // var x int32 // global // var t = T{x} // global - Bvariable *x = be->global_variable("x", "x", bi32t, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - loc); + unsigned int emptyflags = 0; + Bvariable *x = be->global_variable("x", "x", bi32t, emptyflags, loc); Bexpression *xvex = be->var_expression(x, loc); std::vector<Bexpression *> vals1 = {xvex}; Bexpression *scon1 = be->constructor_expression(s1t, vals1, loc); - Bvariable *t = be->global_variable("t", "t", s1t, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - loc); + Bvariable *t = be->global_variable("t", "t", s1t, emptyflags, loc); Bexpression *tvex = be->var_expression(t, loc); h.mkAssign(tvex, scon1); @@ -777,10 +772,8 @@ Bexpression *aex1 = be->address_expression(fex1, loc); h.mkLocal("a1", bpi32t, aex1); - Bvariable *t2 = be->global_variable("t2", "t2", s1t, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - loc); + unsigned int t2flags = 0; + Bvariable *t2 = be->global_variable("t2", "t2", s1t, t2flags, loc); Bexpression *t2vex = be->var_expression(t2, loc); Bexpression *fex2 = be->struct_field_expression(t2vex, 0, loc); Bexpression *aex2 = be->address_expression(fex2, loc);
diff --git a/unittests/BackendCore/BackendCoreTests.cpp b/unittests/BackendCore/BackendCoreTests.cpp index ba7d97a..cf132a5 100644 --- a/unittests/BackendCore/BackendCoreTests.cpp +++ b/unittests/BackendCore/BackendCoreTests.cpp
@@ -429,11 +429,9 @@ Btype *sqt = mkBackendStruct(be, s3t, "f0", phst1, "f1", nullptr); // Create a global variable using this type + unsigned int emptyflags = 0; Bvariable *g1 = - be->global_variable("gv", "gv", sqt, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - loc); + be->global_variable("gv", "gv", sqt, emptyflags, loc); // Create initializers using the various types. Note: the initial // value for "f0" (non-placeholder type) is created using the
diff --git a/unittests/BackendCore/BackendDebugEmit.cpp b/unittests/BackendCore/BackendDebugEmit.cpp index 38e98de..9cd92ff 100644 --- a/unittests/BackendCore/BackendDebugEmit.cpp +++ b/unittests/BackendCore/BackendDebugEmit.cpp
@@ -230,13 +230,10 @@ Llvm_backend *be = h.be(); Location loc = h.loc(); + unsigned int barflags = Backend::variable_is_external; Btype *bi32t = be->integer_type(false, 32); Bvariable *g1 = - be->global_variable("_bar", "bar", bi32t, - true, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - loc); + be->global_variable("_bar", "bar", bi32t, barflags, loc); be->global_variable_set_init(g1, mkInt32Const(be, 101)); bool broken = h.finish(PreserveDebugInfo);
diff --git a/unittests/BackendCore/BackendVarTests.cpp b/unittests/BackendCore/BackendVarTests.cpp index 93b9908..4ae8bb6 100644 --- a/unittests/BackendCore/BackendVarTests.cpp +++ b/unittests/BackendCore/BackendVarTests.cpp
@@ -116,11 +116,9 @@ std::unique_ptr<Backend> be(go_get_backend(C, cc)); Btype *bi32t = be->integer_type(false, 32); + unsigned int g1flags = 0; Bvariable *g1 = - be->global_variable("varname", "asmname", bi32t, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - Location()); + be->global_variable("varname", "asmname", bi32t, g1flags, Location()); ASSERT_TRUE(g1 != nullptr); Value *g1val = g1->value(); ASSERT_TRUE(g1val != nullptr); @@ -136,11 +134,9 @@ EXPECT_EQ(ve1->value(), g1->value()); // error case + unsigned int anonflags = 0; Bvariable *gerr = - be->global_variable("", "", be->error_type(), false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - Location()); + be->global_variable("", "", be->error_type(), anonflags, Location()); EXPECT_TRUE(gerr == be->error_variable()); } @@ -188,8 +184,10 @@ for (auto common : is_common) { if (hidden && common) continue; + unsigned int flags = (hidden ? Backend::variable_is_hidden : 0) | + (common ? Backend::variable_is_common : 0); Bvariable *ims = - be->immutable_struct("name", "asmname", hidden, common, bst, loc); + be->immutable_struct("name", "asmname", flags, bst, loc); ASSERT_TRUE(ims != nullptr); Value *ival = ims->value(); ASSERT_TRUE(ival != nullptr); @@ -203,8 +201,9 @@ } // error case + unsigned int emptyflags = 0; Bvariable *gerr = - be->immutable_struct("", "", false, false, be->error_type(), Location()); + be->immutable_struct("", "", emptyflags, be->error_type(), Location()); EXPECT_TRUE(gerr == be->error_variable()); bool broken = h.finish(PreserveDebugInfo); @@ -229,9 +228,11 @@ for (auto iscon : is_constant) { if (hidden && common) continue; + unsigned int flags = (hidden ? Backend::variable_is_hidden : 0) | + (common ? Backend::variable_is_common : 0) | + (iscon ? Backend::variable_is_constant : 0); Bvariable *ims = - be->implicit_variable("name", "asmname", bst, hidden, iscon, - common, 8); + be->implicit_variable("name", "asmname", bst, flags, 8); ASSERT_TRUE(ims != nullptr); Value *ival = ims->value(); ASSERT_TRUE(ival != nullptr); @@ -246,8 +247,9 @@ } // error case + unsigned emptyflags = 0; Bvariable *gerr = - be->implicit_variable("", "", be->error_type(), false, false, false, 0); + be->implicit_variable("", "", be->error_type(), emptyflags, 0); EXPECT_TRUE(gerr == be->error_variable()); } @@ -287,16 +289,16 @@ Btype *pbt = be->pointer_type(bt); Btype *uintptrt = be->integer_type(true, be->type_size(pbt)*8); Btype *desct = mkBackendStruct(be, uintptrt, "x", nullptr); - Bvariable *ims = be->immutable_struct("desc", "desc", - true, false, desct, loc); + unsigned int descflags = Backend::variable_is_hidden; + Bvariable *ims = be->immutable_struct("desc", "desc", descflags, desct, loc); Bexpression *fp = be->function_code_expression(func, loc); Bexpression *confp = be->convert_expression(uintptrt, fp, loc); std::vector<Bexpression *> vals; vals.push_back(confp); Bexpression *scon = be->constructor_expression(desct, vals, loc); - be->immutable_struct_set_init(ims, "", false, false, - desct, loc, scon); + unsigned int emptyflags = 0; + be->immutable_struct_set_init(ims, "", emptyflags, desct, loc, scon); { DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT( @@ -308,9 +310,9 @@ EXPECT_TRUE(isOK && "Value does not have expected contents"); } - Bvariable *ims2 = be->immutable_struct("xyz", "abc", - false, true, desct, loc); - be->immutable_struct_set_init(ims2, "", false, true, + unsigned int xyzflags = Backend::variable_is_common; + Bvariable *ims2 = be->immutable_struct("xyz", "abc", xyzflags, desct, loc); + be->immutable_struct_set_init(ims2, "", xyzflags, desct, loc, be->zero_expression(desct)); { @@ -323,9 +325,9 @@ } // check that these don't crash - be->immutable_struct_set_init(be->error_variable(), "", false, false, + be->immutable_struct_set_init(be->error_variable(), "", emptyflags, desct, loc, scon); - be->immutable_struct_set_init(ims, "", false, false, + be->immutable_struct_set_init(ims, "", emptyflags, desct, loc, be->error_expression()); bool broken = h.finish(PreserveDebugInfo); @@ -343,11 +345,9 @@ // Create an immutable_struct and an immutable_struct_reference // with same name. They should refer to the same global variable. - - bool hidden = false; - bool common = false; + unsigned int emptyflags = 0; Bvariable *ims = - be->immutable_struct("name", "asmname", hidden, common, bst, loc); + be->immutable_struct("name", "asmname", emptyflags, bst, loc); ASSERT_TRUE(ims != nullptr); Bvariable *imsr = be->immutable_struct_reference("name", "asmname", bst, loc); @@ -370,19 +370,14 @@ Btype *bst = mkTwoFieldStruct(be, bi32t, bi32t); // Case 1: non-common, concrete init value. - bool isConst = false; - bool isHidden = false; - bool isCommon = false; - + unsigned int firstflags = 0; Bvariable *ims1 = - be->implicit_variable("first", "v1", bst, - isHidden, isConst, isCommon, 8); + be->implicit_variable("first", "v1", bst, firstflags, 8); std::vector<Bexpression *> vals1; vals1.push_back(mkInt32Const(be, 101)); vals1.push_back(mkInt32Const(be, 202)); Bexpression *con1 = be->constructor_expression(bst, vals1, loc); - be->implicit_variable_set_init(ims1, "x", bst, - isHidden, isConst, isCommon, con1); + be->implicit_variable_set_init(ims1, "x", bst, firstflags, con1); DECLARE_EXPECTED_OUTPUT(exp1, R"RAW_RESULT( @v1 = global { i32, i32 } { i32 101, i32 202 }, align 8 @@ -392,12 +387,10 @@ EXPECT_TRUE(isOK1 && "Value does not have expected contents"); // Case 2: const, common, no init value. - isConst = true; - isCommon = true; - Bvariable *ims2 = be->implicit_variable("second", "v2", bst, - isHidden, isConst, isCommon, 8); - be->implicit_variable_set_init(ims2, "x", bst, - isHidden, isConst, isCommon, nullptr); + unsigned int secondflags = (Backend::variable_is_constant | + Backend::variable_is_common); + Bvariable *ims2 = be->implicit_variable("second", "v2", bst, secondflags, 8); + be->implicit_variable_set_init(ims2, "x", bst, secondflags, nullptr); DECLARE_EXPECTED_OUTPUT(exp2, R"RAW_RESULT( @v2 = weak constant { i32, i32 } zeroinitializer, comdat, align 8 @@ -407,11 +400,11 @@ EXPECT_TRUE(isOK2 && "Value does not have expected contents"); // check that these don't crash + unsigned int iniflags = secondflags; be->implicit_variable_set_init(be->error_variable(), "x", bst, - isHidden, isConst, isCommon, nullptr); + iniflags, nullptr); be->implicit_variable_set_init(be->error_variable(), "x", bst, - isHidden, isConst, isCommon, - be->error_expression()); + iniflags, be->error_expression()); bool broken = h.finish(PreserveDebugInfo); EXPECT_FALSE(broken && "Module failed to verify."); @@ -427,11 +420,9 @@ Btype *pbt = be->pointer_type(bt); Btype *bi32t = be->integer_type(false, 32); Btype *s2t = mkBackendStruct(be.get(), pbt, "f1", bi32t, "f2", nullptr); + unsigned int g1flags = 0; Bvariable *g1 = - be->global_variable("gv", "gv", s2t, false, /* is_external */ - false, /* is_hidden */ - false, /* unique_section */ - Location()); + be->global_variable("gv", "gv", s2t, g1flags, Location()); std::vector<Bexpression *> vals; vals.push_back(be->zero_expression(pbt)); @@ -457,19 +448,15 @@ // They should refer to the same underlying global var. // declare x as external int32 - bool hidden = false; - bool common = false; - bool external = true; + unsigned int xflags = Backend::variable_is_external; Bvariable *gvdecl = - be->global_variable("x", "x", bi32t, external, - hidden, common, loc); + be->global_variable("x", "x", bi32t, xflags, loc); ASSERT_TRUE(gvdecl != nullptr); // define x as non-external struct - external = false; + xflags = 0; // no longer external Bvariable *gv = - be->global_variable("x", "x", bst, external, - hidden, common, loc); + be->global_variable("x", "x", bst, xflags, loc); ASSERT_TRUE(gv != nullptr); EXPECT_TRUE(isa<GlobalVariable>(gv->value())); EXPECT_EQ(repr(gv->value()), "@x = global { i32 } zeroinitializer"); @@ -479,17 +466,15 @@ // Create them in the other order: definition first, // then external declaration. // define y as non-external struct - external = false; + unsigned int yflags = 0; Bvariable *gv2 = - be->global_variable("y", "y", bst, external, - hidden, common, loc); + be->global_variable("y", "y", bst, yflags, loc); ASSERT_TRUE(gv2 != nullptr); // declare y as external int32 - external = true; + yflags = Backend::variable_is_external; Bvariable *gvdecl2 = - be->global_variable("y", "y", bi32t, external, - hidden, common, loc); + be->global_variable("y", "y", bi32t, yflags, loc); ASSERT_TRUE(gvdecl2 != nullptr); EXPECT_TRUE(isa<GlobalVariable>(gv2->value())); EXPECT_EQ(repr(gv2->value()), "@y = global { i32 } zeroinitializer"); @@ -587,23 +572,16 @@ Btype *bi32t = be->integer_type(false, 32); Btype *atint0 = be->array_type(bi32t, val0); - bool isExternal = false; - bool isHidden = false; - bool uniqueSection = false; - // define globals with the types above + unsigned int emptyflags = 0; Bvariable *gs1 = - be->global_variable("emptystruct", "", best, - isExternal, isHidden, uniqueSection, loc); + be->global_variable("emptystruct", "", best, emptyflags, loc); Bvariable *gs2 = - be->global_variable("emptys2f", "", bef2, - isExternal, isHidden, uniqueSection, loc); + be->global_variable("emptys2f", "", bef2, emptyflags, loc); Bvariable *ga1 = - be->global_variable("emptyar", "", ats1, - isExternal, isHidden, uniqueSection, loc); + be->global_variable("emptyar", "", ats1, emptyflags, loc); Bvariable *ga2 = - be->global_variable("emptyintar", "", atint0, - isExternal, isHidden, uniqueSection, loc); + be->global_variable("emptyintar", "", atint0, emptyflags, loc); // Create initializers for these odd beasties.