blob: 98561e86f857fe03a5a5e85e33cc02ad527fd206 [file] [log] [blame]
//==- llvm/tools/gollvm/unittests/BackendCore/BackendCABIOracleTests.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-cabi-oracle.h"
#include "go-llvm-backend.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Function.h"
#include "gtest/gtest.h"
using namespace llvm;
using namespace goBackendUnitTests;
namespace {
class BackendCABIOracleTests
: public testing::TestWithParam<llvm::CallingConv::ID> {};
INSTANTIATE_TEST_CASE_P(
UnitTest, BackendCABIOracleTests,
goBackendUnitTests::CConvs,
[](const testing::TestParamInfo<BackendCABIOracleTests::ParamType> &info) {
std::string name = goBackendUnitTests::ccName(info.param);
return name;
});
TEST_P(BackendCABIOracleTests, Basic) {
LLVMContext C;
auto cc = GetParam();
std::unique_ptr<Llvm_backend> bep(
new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), cc));
Llvm_backend *be = bep.get();
Btype *bi8t = be->integer_type(false, 8);
Btype *bu8t = be->integer_type(true, 8);
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *st0 = mkBackendStruct(be, nullptr);
Btype *st1 = mkBackendStruct(be, bi8t, "a", bu8t, "b", bf32t, "c", nullptr);
Btype *st2 = mkBackendStruct(be, bf64t, "f1", bf64t, "f2", nullptr);
{
BFunctionType *befty1 = mkFuncTyp(be,
L_PARM, bi8t,
L_PARM, bf32t,
L_PARM, st0,
L_PARM, st1,
L_RES, st2,
L_END);
CABIOracle cab(befty1, be->typeManager());
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
Return: Direct { { double, double } } sigOffset: -1
Param 1: Direct AttrNest { i8* } sigOffset: 0
Param 2: Direct AttrSext { i8 } sigOffset: 1
Param 3: Direct { float } sigOffset: 2
Param 4: Ignore { void } sigOffset: -1
Param 5: Direct { i64 } sigOffset: 3
)RAW_RESULT");
std::string reason;
bool equal = difftokens(exp.content, cab.toString(), reason);
EXPECT_EQ("pass", equal ? "pass" : reason);
EXPECT_EQ(repr(cab.getFunctionTypeForABI()),
"{ double, double } (i8*, i8, float, i64)");
}
}
TEST(BackendCABIOracleTests, ExtendedAmd64) {
LLVMContext C;
std::unique_ptr<Llvm_backend> bep(
new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), llvm::CallingConv::X86_64_SysV));
Llvm_backend *be = bep.get();
Btype *bi8t = be->integer_type(false, 8);
Btype *bu8t = be->integer_type(true, 8);
Btype *bu64t = be->integer_type(true, 64);
Btype *bu32t = be->integer_type(true, 32);
Btype *bi16t = be->integer_type(false, 16);
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *bpu64t = be->pointer_type(bu64t);
Btype *bpf64t = be->pointer_type(bf64t);
Btype *st0 = mkBackendStruct(be, nullptr);
Btype *st1 = mkBackendStruct(be, bi8t, "a", bu8t, "b", bf32t, "c", nullptr);
Btype *st2 = mkBackendStruct(be, bf64t, "f1", bf64t, "f2", nullptr);
Btype *st3 = mkBackendStruct(be, st2, "f1", bi8t, "f2", nullptr);
Btype *st4 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2", nullptr);
Btype *st5 = mkBackendStruct(be, bf32t, "f1", nullptr);
Btype *st6 = mkBackendStruct(be, bf32t, "f1", bi8t, "a", bu8t, "b",
bu64t, "c", nullptr);
Btype *st7 = mkBackendStruct(be, bf32t, "f1", bu32t, "f2", nullptr);
Btype *st8 = mkBackendStruct(be, bi8t, "f1", bi16t, "f2", st7, "f3", nullptr);
Btype *stii = mkBackendStruct(be, bu64t, "a", bu64t, "b", nullptr);
Btype *stip = mkBackendStruct(be, bu64t, "a", bpu64t, "b", nullptr);
Btype *stpi = mkBackendStruct(be, bpu64t, "a", bu64t, "b", nullptr);
Btype *stpp = mkBackendStruct(be, bpu64t, "a", bpu64t, "b", nullptr);
Btype *at0 = be->array_type(bu32t, mkInt64Const(be, int64_t(0)));
Btype *at1 = be->array_type(bu32t, mkInt64Const(be, int64_t(1)));
Btype *at2 = be->array_type(bu32t, mkInt64Const(be, int64_t(3)));
Btype *at3 = be->array_type(bu8t, mkInt64Const(be, int64_t(16)));
struct FcnItem {
FcnItem(const std::vector<Btype*> &r,
const std::vector<Btype*> &p,
const char *d, const char *t)
: results(r), parms(p), expDump(d), expTyp(t) { }
std::vector<Btype*> results;
std::vector<Btype*> parms;
const char *expDump;
const char *expTyp;
};
Btype *nt = nullptr;
std::vector<FcnItem> items = {
// 1
FcnItem( { }, { },
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0",
"void (i8*)"),
// 2
FcnItem( { bi8t }, { },
"Return: Direct AttrSext { i8 } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0",
"i8 (i8*)"),
// 3
FcnItem( { }, { bi8t },
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct AttrSext { i8 } sigOffset: 1",
"void (i8*, i8)"),
// 4
FcnItem( { }, { st5, bpf64t },
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { float } sigOffset: 1 "
"Param 3: Direct { double* } sigOffset: 2",
"void (i8*, float, double*)"),
// 5
FcnItem({ bi8t, bf64t }, { bi8t, bu8t, st0 },
"Return: Direct { { i8, double } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct AttrSext { i8 } sigOffset: 1 "
"Param 3: Direct AttrZext { i8 } sigOffset: 2 "
"Param 4: Ignore { void } sigOffset: -1",
"{ i8, double } (i8*, i8, i8)"),
// 6
FcnItem({ st2 }, { st2, st0, st4, st1 },
"Return: Direct { { double, double } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { double, double } sigOffset: 1 "
"Param 3: Ignore { void } sigOffset: -1 "
"Param 4: Direct { <2 x float> } sigOffset: 3 "
"Param 5: Direct { i64 } sigOffset: 4 ",
"{ double, double } (i8*, double, double, <2 x float>, i64)"),
// 7
FcnItem({ st3 }, { st3, st0, bu8t },
"Return: Indirect AttrStructReturn { { { double, double }, i8 }* } sigOffset: 0 "
"Param 1: Direct AttrNest { i8* } sigOffset: 1 "
"Param 2: Indirect AttrByVal { { { double, double }, i8 }* } sigOffset: 2 "
"Param 3: Ignore { void } sigOffset: -1 "
"Param 4: Direct AttrZext { i8 } sigOffset: 3 ",
"void ({ { double, double }, i8 }*, i8*, "
"{ { double, double }, i8 }*, i8)"),
// 8
FcnItem( { st6 }, { st6, st6 },
"Return: Direct { { i64, i64 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1 "
"Param 3: Direct { i64, i64 } sigOffset: 3",
"{ i64, i64 } (i8*, i64, i64, i64, i64)"),
// 9
FcnItem( { st8 }, { st8 },
"Return: Direct { { i64, i32 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i32 } sigOffset: 1",
"{ i64, i32 } (i8*, i64, i32)"),
// 10
FcnItem( { at0 }, { at1 },
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i32 } sigOffset: 1",
"void (i8*, i32)"),
// 11
FcnItem( { at2 }, { at3 },
"Return: Direct { { i64, i32 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1",
"{ i64, i32 } (i8*, i64, i64)"),
// 12
// Make sure pointerness is preserved.
FcnItem( { stip }, { stii, stpp, stpi },
"Return: Direct { { i64, i8* } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1 "
"Param 3: Direct { i8*, i8* } sigOffset: 3 "
"Param 4: Direct { i8*, i64 } sigOffset: 5",
"{ i64, i8* } (i8*, i64, i64, i8*, i8*, i8*, i64)"),
};
unsigned count = 1;
for (auto &item : items) {
std::vector<Backend::Btyped_identifier> results;
std::vector<Backend::Btyped_identifier> params;
for (auto &r : item.results)
results.push_back(mkid(r));
for (auto &p : item.parms)
params.push_back(mkid(p));
Btype *rt = nullptr;
if (results.size() > 1)
rt = be->struct_type(results);
Btype *t = be->function_type(mkid(nt), params, results, rt, Location());
BFunctionType *bft = t->castToBFunctionType();
CABIOracle cab(bft, be->typeManager());
{
std::string reason;
bool equal = difftokens(item.expDump, cab.toString(), reason);
EXPECT_EQ("pass", equal ? "pass" : reason);
if (!equal) {
std::cerr << "count: " << count << "\n";
std::cerr << "exp:\n" << item.expDump << "\n";
std::cerr << "act:\n" << cab.toString() << "\n";
}
}
{
std::string reason;
std::string result(repr(cab.getFunctionTypeForABI()));
bool equal = difftokens(item.expTyp, result, reason);
EXPECT_EQ("pass", equal ? "pass" : reason);
if (!equal) {
std::cerr << "count: " << count << "\n";
std::cerr << "exp:\n" << item.expTyp << "\n";
std::cerr << "act:\n" << result << "\n";
}
}
count++;
}
}
TEST(BackendCABIOracleTests, ExtendedArm64) {
LLVMContext C;
std::unique_ptr<Llvm_backend> bep(
new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), llvm::CallingConv::ARM_AAPCS));
Llvm_backend *be = bep.get();
Btype *bi8t = be->integer_type(false, 8);
Btype *bu8t = be->integer_type(true, 8);
Btype *bu64t = be->integer_type(true, 64);
Btype *bu32t = be->integer_type(true, 32);
Btype *bi16t = be->integer_type(false, 16);
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *bpu64t = be->pointer_type(bu64t);
Btype *bpf64t = be->pointer_type(bf64t);
Btype *st0 = mkBackendStruct(be, nullptr);
Btype *st1 = mkBackendStruct(be, bi8t, "a", bu8t, "b", bf32t, "c", nullptr);
Btype *st2 = mkBackendStruct(be, bf64t, "f1", bf64t, "f2", nullptr);
Btype *st3 = mkBackendStruct(be, st2, "f1", bi8t, "f2", nullptr);
Btype *st4 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2", nullptr);
Btype *st5 = mkBackendStruct(be, bf32t, "f1", nullptr);
Btype *st6 = mkBackendStruct(be, bf32t, "f1", bi8t, "a", bu8t, "b", bu64t,
"c", nullptr);
Btype *st7 = mkBackendStruct(be, bf32t, "f1", bu32t, "f2", nullptr);
Btype *st8 = mkBackendStruct(be, bi8t, "f1", bi16t, "f2", st7, "f3", nullptr);
Btype *stii = mkBackendStruct(be, bu64t, "a", bu64t, "b", nullptr);
Btype *stip = mkBackendStruct(be, bu64t, "a", bpu64t, "b", nullptr);
Btype *stpi = mkBackendStruct(be, bpu64t, "a", bu64t, "b", nullptr);
Btype *stpp = mkBackendStruct(be, bpu64t, "a", bpu64t, "b", nullptr);
Btype *at0 = be->array_type(bu32t, mkInt64Const(be, int64_t(0)));
Btype *at1 = be->array_type(bu32t, mkInt64Const(be, int64_t(1)));
Btype *at2 = be->array_type(bu32t, mkInt64Const(be, int64_t(3)));
Btype *at3 = be->array_type(bu8t, mkInt64Const(be, int64_t(16)));
struct FcnItem {
FcnItem(const std::vector<Btype *> &r, const std::vector<Btype *> &p,
const char *d, const char *t)
: results(r), parms(p), expDump(d), expTyp(t) {}
std::vector<Btype *> results;
std::vector<Btype *> parms;
const char *expDump;
const char *expTyp;
};
Btype *nt = nullptr;
std::vector<FcnItem> items = {
// 1
FcnItem({}, {},
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0",
"void (i8*)"),
// 2
FcnItem({bi8t}, {},
"Return: Direct AttrSext { i8 } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0",
"i8 (i8*)"),
// 3
FcnItem({}, {bi8t},
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct AttrSext { i8 } sigOffset: 1",
"void (i8*, i8)"),
// 4
FcnItem({}, {st5, bpf64t},
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { float } sigOffset: 1 "
"Param 3: Direct { double* } sigOffset: 2",
"void (i8*, float, double*)"),
// 5
FcnItem({bi8t, bf64t}, {bi8t, bu8t, st0},
"Return: Direct { { i64, i64 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct AttrSext { i8 } sigOffset: 1 "
"Param 3: Direct AttrZext { i8 } sigOffset: 2 "
"Param 4: Ignore { void } sigOffset: -1",
"{ i64, i64 } (i8*, i8, i8)"),
// 6
FcnItem({st2}, {st2, st0, st4, st1},
"Return: Direct { { double, double } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { [2 x double] } sigOffset: 1 "
"Param 3: Ignore { void } sigOffset: -1 "
"Param 4: Direct { [2 x float] } sigOffset: 2 "
"Param 5: Direct { i64 } sigOffset: 3",
"{ double, double } (i8*, [2 x double], [2 x float], i64)"),
// 7
FcnItem({st3}, {st3, st0, bu8t},
"Return: Indirect AttrStructReturn { { { double, double }, i8 "
"}* } sigOffset: 0 "
"Param 1: Direct AttrNest { i8* } sigOffset: 1 "
"Param 2: Indirect AttrDoCopy { { { double, double }, i8 }* } "
"sigOffset: 2 "
"Param 3: Ignore { void } sigOffset: -1 "
"Param 4: Direct AttrZext { i8 } sigOffset: 3 ",
"void ({ { double, double }, i8 }*, i8*, "
"{ { double, double }, i8 }*, i8)"),
// 8
FcnItem({st6}, {st6, st6},
"Return: Direct { { i64, i64 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1 "
"Param 3: Direct { i64, i64 } sigOffset: 3",
"{ i64, i64 } (i8*, i64, i64, i64, i64)"),
// 9
FcnItem({st8}, {st8},
"Return: Direct { { i64, i32 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i32 } sigOffset: 1",
"{ i64, i32 } (i8*, i64, i32)"),
// 10
FcnItem({at0}, {at1},
"Return: Ignore { void } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i32 } sigOffset: 1",
"void (i8*, i32)"),
// 11
FcnItem({at2}, {at3},
"Return: Direct { { i64, i32 } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1",
"{ i64, i32 } (i8*, i64, i64)"),
// 12
// Make sure pointerness is preserved.
FcnItem({stip}, {stii, stpp, stpi},
"Return: Direct { { i64, i8* } } sigOffset: -1 "
"Param 1: Direct AttrNest { i8* } sigOffset: 0 "
"Param 2: Direct { i64, i64 } sigOffset: 1 "
"Param 3: Direct { i8*, i8* } sigOffset: 3 "
"Param 4: Direct { i8*, i64 } sigOffset: 5",
"{ i64, i8* } (i8*, i64, i64, i8*, i8*, i8*, i64)"),
};
unsigned count = 1;
for (auto &item : items) {
std::vector<Backend::Btyped_identifier> results;
std::vector<Backend::Btyped_identifier> params;
for (auto &r : item.results)
results.push_back(mkid(r));
for (auto &p : item.parms)
params.push_back(mkid(p));
Btype *rt = nullptr;
if (results.size() > 1)
rt = be->struct_type(results);
Btype *t = be->function_type(mkid(nt), params, results, rt, Location());
BFunctionType *bft = t->castToBFunctionType();
CABIOracle cab(bft, be->typeManager());
{
std::string reason;
bool equal = difftokens(item.expDump, cab.toString(), reason);
EXPECT_EQ("pass", equal ? "pass" : reason);
if (!equal) {
std::cerr << "count: " << count << "\n";
std::cerr << "exp:\n" << item.expDump << "\n";
std::cerr << "act:\n" << cab.toString() << "\n";
}
}
{
std::string reason;
std::string result(repr(cab.getFunctionTypeForABI()));
bool equal = difftokens(item.expTyp, result, reason);
EXPECT_EQ("pass", equal ? "pass" : reason);
if (!equal) {
std::cerr << "count: " << count << "\n";
std::cerr << "exp:\n" << item.expTyp << "\n";
std::cerr << "act:\n" << result << "\n";
}
}
count++;
}
}
TEST(BackendCABIOracleTests, RecursiveCall1Amd64) {
FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
Llvm_backend *be = h.be();
// type s1 struct {
// f1, f2 float32
// i1, i2, i3 int16
// }
// type s2 struct {
// k float64
// f1, f2 float32
// }
// type s3 struct {
// f1, s1
// f2, s2
// }
// type s4 struct {
// }
// func foo(x s1, y s2, z s4, sm1 uint8, sm2 int8, w s3) s2 {
// if (sm1 == 0) {
// return y
// }
// return foo(x, y, z, sm1-1, sm2, w)
// }
//
// Create struct types
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *bi16t = be->integer_type(false, 16);
Btype *bi8t = be->integer_type(false, 8);
Btype *bu8t = be->integer_type(true, 8);
Btype *s1 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2",
bi16t, "i1", bi16t, "i2", bi16t, "i3", nullptr);
Btype *s2 = mkBackendStruct(be, bf64t, "k", bf32t, "f1", bf32t, "f2",
nullptr);
Btype *s3 = mkBackendStruct(be, s1, "f1", s2, "f2", nullptr);
Btype *s4 = mkBackendStruct(be, nullptr);
// Create function type
BFunctionType *befty1 = mkFuncTyp(be,
L_PARM, s1,
L_PARM, s2,
L_PARM, s4,
L_PARM, bu8t,
L_PARM, bi8t,
L_PARM, s3,
L_RES, s2,
L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// sm1 == 0
Bvariable *p3 = func->getNthParamVar(3);
Location loc;
Bexpression *vex = be->var_expression(p3, loc);
Bexpression *c0 = be->convert_expression(bu8t, mkInt32Const(be, 0), loc);
Bexpression *eq = be->binary_expression(OPERATOR_EQEQ, vex, c0, loc);
// call
Bexpression *fn = be->function_code_expression(func, loc);
std::vector<Bexpression *> args;
Bvariable *p0 = func->getNthParamVar(0);
args.push_back(be->var_expression(p0, loc));
Bvariable *p1 = func->getNthParamVar(1);
args.push_back(be->var_expression(p1, loc));
Bvariable *p2 = func->getNthParamVar(2);
args.push_back(be->var_expression(p2, loc));
Bvariable *p3x = func->getNthParamVar(3);
Bexpression *vex3 = be->var_expression(p3x, loc);
Bexpression *c1 = be->convert_expression(bu8t, mkInt32Const(be, 1), loc);
Bexpression *minus = be->binary_expression(OPERATOR_MINUS, vex3, c1, loc);
args.push_back(minus);
Bvariable *p4 = func->getNthParamVar(4);
args.push_back(be->var_expression(p4, loc));
Bvariable *p5 = func->getNthParamVar(5);
args.push_back(be->var_expression(p5, loc));
Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
// return y
std::vector<Bexpression *> rvals1;
rvals1.push_back(be->var_expression(p1, loc));
Bstatement *rst1 = h.mkReturn(rvals1, FcnTestHarness::NoAppend);
// return call
std::vector<Bexpression *> rvals2;
rvals2.push_back(call);
Bstatement *rst2 = h.mkReturn(rvals2, FcnTestHarness::NoAppend);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%p3.ld.0 = load i8, i8* %p3.addr, align 1
%sub.0 = sub i8 %p3.ld.0, 1
%p4.ld.0 = load i8, i8* %p4.addr, align 1
%cast.1 = bitcast { float, float, i16, i16, i16 }* %p0.addr to { <2 x float>, i48 }*
%field0.0 = getelementptr inbounds { <2 x float>, i48 }, { <2 x float>, i48 }* %cast.1, i32 0, i32 0
%ld.1 = load <2 x float>, <2 x float>* %field0.0, align 8
%field1.0 = getelementptr inbounds { <2 x float>, i48 }, { <2 x float>, i48 }* %cast.1, i32 0, i32 1
%ld.2 = load i48, i48* %field1.0, align 8
%cast.2 = bitcast { double, float, float }* %p1.addr to { double, <2 x float> }*
%field0.1 = getelementptr inbounds { double, <2 x float> }, { double, <2 x float> }* %cast.2, i32 0, i32 0
%ld.3 = load double, double* %field0.1, align 8
%field1.1 = getelementptr inbounds { double, <2 x float> }, { double, <2 x float> }* %cast.2, i32 0, i32 1
%ld.4 = load <2 x float>, <2 x float>* %field1.1, align 8
%call.0 = call addrspace(0) { double, <2 x float> } @foo(i8* nest undef, <2 x float> %ld.1, i48 %ld.2, double %ld.3, <2 x float> %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, { { float, float, i16, i16, i16 }, { double, float, float } }* byval %p5)
%cast.3 = bitcast { double, float, float }* %sret.actual.0 to { double, <2 x float> }*
store { double, <2 x float> } %call.0, { double, <2 x float> }* %cast.3, align 8
%cast.4 = bitcast { double, float, float }* %sret.actual.0 to { double, <2 x float> }*
%ld.5 = load { double, <2 x float> }, { double, <2 x float> }* %cast.4, align 8
ret { double, <2 x float> } %ld.5
)RAW_RESULT");
bool isOK = h.expectStmt(rst2, exp);
EXPECT_TRUE(isOK && "Statement does not have expected contents");
// if statement
h.mkIf(eq, rst1, rst2);
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST(BackendCABIOracleTests, RecursiveCall1Arm64) {
FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
Llvm_backend *be = h.be();
// type s1 struct {
// f1, f2 float32
// i1, i2, i3 int16
// }
// type s2 struct {
// k float64
// f1, f2 float32
// }
// type s3 struct {
// f1, s1
// f2, s2
// }
// type s4 struct {
// }
// func foo(x s1, y s2, z s4, sm1 uint8, sm2 int8, w s3) s2 {
// if (sm1 == 0) {
// return y
// }
// return foo(x, y, z, sm1-1, sm2, w)
// }
//
// Create struct types
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *bi16t = be->integer_type(false, 16);
Btype *bi8t = be->integer_type(false, 8);
Btype *bu8t = be->integer_type(true, 8);
Btype *s1 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2", bi16t, "i1", bi16t,
"i2", bi16t, "i3", nullptr);
Btype *s2 =
mkBackendStruct(be, bf64t, "k", bf32t, "f1", bf32t, "f2", nullptr);
Btype *s3 = mkBackendStruct(be, s1, "f1", s2, "f2", nullptr);
Btype *s4 = mkBackendStruct(be, nullptr);
// Create function type
BFunctionType *befty1 =
mkFuncTyp(be, L_PARM, s1, L_PARM, s2, L_PARM, s4, L_PARM, bu8t, L_PARM,
bi8t, L_PARM, s3, L_RES, s2, L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// sm1 == 0
Bvariable *p3 = func->getNthParamVar(3);
Location loc;
Bexpression *vex = be->var_expression(p3, loc);
Bexpression *c0 = be->convert_expression(bu8t, mkInt32Const(be, 0), loc);
Bexpression *eq = be->binary_expression(OPERATOR_EQEQ, vex, c0, loc);
// call
Bexpression *fn = be->function_code_expression(func, loc);
std::vector<Bexpression *> args;
Bvariable *p0 = func->getNthParamVar(0);
args.push_back(be->var_expression(p0, loc));
Bvariable *p1 = func->getNthParamVar(1);
args.push_back(be->var_expression(p1, loc));
Bvariable *p2 = func->getNthParamVar(2);
args.push_back(be->var_expression(p2, loc));
Bvariable *p3x = func->getNthParamVar(3);
Bexpression *vex3 = be->var_expression(p3x, loc);
Bexpression *c1 = be->convert_expression(bu8t, mkInt32Const(be, 1), loc);
Bexpression *minus = be->binary_expression(OPERATOR_MINUS, vex3, c1, loc);
args.push_back(minus);
Bvariable *p4 = func->getNthParamVar(4);
args.push_back(be->var_expression(p4, loc));
Bvariable *p5 = func->getNthParamVar(5);
args.push_back(be->var_expression(p5, loc));
Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
// return y
std::vector<Bexpression *> rvals1;
rvals1.push_back(be->var_expression(p1, loc));
Bstatement *rst1 = h.mkReturn(rvals1, FcnTestHarness::NoAppend);
// return call
std::vector<Bexpression *> rvals2;
rvals2.push_back(call);
Bstatement *rst2 = h.mkReturn(rvals2, FcnTestHarness::NoAppend);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%p3.ld.0 = load i8, i8* %p3.addr, align 1
%sub.0 = sub i8 %p3.ld.0, 1
%p4.ld.0 = load i8, i8* %p4.addr, align 1
%cast.1 = bitcast { float, float, i16, i16, i16 }* %p0.addr to { i64, i48 }*
%field0.0 = getelementptr inbounds { i64, i48 }, { i64, i48 }* %cast.1, i32 0, i32 0
%ld.1 = load i64, i64* %field0.0, align 8
%field1.0 = getelementptr inbounds { i64, i48 }, { i64, i48 }* %cast.1, i32 0, i32 1
%ld.2 = load i48, i48* %field1.0, align 8
%cast.2 = bitcast { double, float, float }* %p1.addr to { i64, i64 }*
%field0.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %cast.2, i32 0, i32 0
%ld.3 = load i64, i64* %field0.1, align 8
%field1.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %cast.2, i32 0, i32 1
%ld.4 = load i64, i64* %field1.1, align 8
%cast.3 = bitcast { { float, float, i16, i16, i16 }, { double, float, float } }* %doCopy.addr.0 to i8*
%cast.4 = bitcast { { float, float, i16, i16, i16 }, { double, float, float } }* %p5 to i8*
call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.3, i8* align 8 %cast.4, i64 32, i1 false)
%call.0 = call addrspace(0) { i64, i64 } @foo(i8* nest undef, i64 %ld.1, i48 %ld.2, i64 %ld.3, i64 %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, { { float, float, i16, i16, i16 }, { double, float, float } }* %doCopy.addr.0)
%cast.5 = bitcast { double, float, float }* %sret.actual.0 to { i64, i64 }*
store { i64, i64 } %call.0, { i64, i64 }* %cast.5, align 8
%cast.6 = bitcast { double, float, float }* %sret.actual.0 to { i64, i64 }*
%ld.5 = load { i64, i64 }, { i64, i64 }* %cast.6, align 8
ret { i64, i64 } %ld.5
)RAW_RESULT");
bool isOK = h.expectStmt(rst2, exp);
EXPECT_TRUE(isOK && "Statement does not have expected contents");
// if statement
h.mkIf(eq, rst1, rst2);
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST(BackendCABIOracleTests, PassAndReturnArraysAmd64) {
FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
Llvm_backend *be = h.be();
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *at2f = be->array_type(bf32t, mkInt64Const(be, int64_t(2)));
Btype *at3d = be->array_type(bf64t, mkInt64Const(be, int64_t(3)));
// func foo(fp [2]float32) [3]float64
BFunctionType *befty1 = mkFuncTyp(be,
L_PARM, at2f,
L_RES, at3d,
L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// foo(fp)
Location loc;
Bvariable *p0 = func->getNthParamVar(0);
Bexpression *vex = be->var_expression(p0, loc);
Bexpression *fn = be->function_code_expression(func, loc);
std::vector<Bexpression *> args;
args.push_back(vex);
Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
// return foo(fp)
std::vector<Bexpression *> rvals;
rvals.push_back(call);
h.mkReturn(rvals);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%cast.0 = bitcast [2 x float]* %p0.addr to <2 x float>*
%ld.0 = load <2 x float>, <2 x float>* %cast.0, align 8
call addrspace(0) void @foo([3 x double]* sret "go_sret" %sret.actual.0, i8* nest undef, <2 x float> %ld.0)
%cast.1 = bitcast [3 x double]* %sret.formal.0 to i8*
%cast.2 = bitcast [3 x double]* %sret.actual.0 to i8*
call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 %cast.2, i64 24, i1 false)
ret void
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST(BackendCABIOracleTests, PassAndReturnArraysArm64) {
FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
Llvm_backend *be = h.be();
Btype *bf32t = be->float_type(32);
Btype *bf64t = be->float_type(64);
Btype *at2f = be->array_type(bf32t, mkInt64Const(be, int64_t(2)));
Btype *at3d = be->array_type(bf64t, mkInt64Const(be, int64_t(3)));
// func foo(fp [2]float32) [3]float64
BFunctionType *befty1 = mkFuncTyp(be, L_PARM, at2f, L_RES, at3d, L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// foo(fp)
Location loc;
Bvariable *p0 = func->getNthParamVar(0);
Bexpression *vex = be->var_expression(p0, loc);
Bexpression *fn = be->function_code_expression(func, loc);
std::vector<Bexpression *> args;
args.push_back(vex);
Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
// return foo(fp)
std::vector<Bexpression *> rvals;
rvals.push_back(call);
h.mkReturn(rvals);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%ld.0 = load [2 x float], [2 x float]* %p0.addr, align 4
%call.0 = call addrspace(0) { double, double, double } @foo(i8* nest undef, [2 x float] %ld.0)
%cast.1 = bitcast [3 x double]* %sret.actual.0 to { double, double, double }*
store { double, double, double } %call.0, { double, double, double }* %cast.1, align 8
%cast.2 = bitcast [3 x double]* %sret.actual.0 to { double, double, double }*
%ld.1 = load { double, double, double }, { double, double, double }* %cast.2, align 8
ret { double, double, double } %ld.1
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST_P(BackendCABIOracleTests, EmptyStructParamsAndReturns) {
auto cc = GetParam();
FcnTestHarness h(cc);
Llvm_backend *be = h.be();
Btype *bi32t = be->integer_type(false, 32);
Btype *set = mkBackendStruct(be, nullptr); // struct with no fields
// func foo(f1 empty, f2 empty, f3 int32, f4 empty) empty
BFunctionType *befty1 = mkFuncTyp(be,
L_RES, set,
L_PARM, set,
L_PARM, set,
L_PARM, bi32t,
L_PARM, set,
L_PARM, set,
L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// foo(f1, f1, 4, f1, f1)
Location loc;
Bexpression *fn = be->function_code_expression(func, loc);
Bvariable *p0 = func->getNthParamVar(0);
std::vector<Bexpression *> args;
args.push_back(be->var_expression(p0, loc));
args.push_back(be->var_expression(p0, loc));
args.push_back(mkInt32Const(be, 4));
args.push_back(be->var_expression(p0, loc));
args.push_back(be->var_expression(p0, loc));
Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
// return the call above
std::vector<Bexpression *> rvals;
rvals.push_back(call);
h.mkReturn(rvals);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
call addrspace(0) void @foo(i8* nest undef, i32 4)
ret void
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST_P(BackendCABIOracleTests, CallBuiltinFunction) {
auto cc = GetParam();
FcnTestHarness h(cc, "foo");
Llvm_backend *be = h.be();
Bfunction *func = h.func();
Bfunction *tfunc = be->lookup_builtin("__builtin_trap");
// trap()
Location loc;
Bexpression *fn = be->function_code_expression(tfunc, loc);
std::vector<Bexpression *> args;
h.mkExprStmt(be->call_expression(func, fn, args, nullptr, h.loc()));
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
call addrspace(0) void @llvm.trap()
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST(BackendCABIOracleTests, PassAndReturnComplexAmd64) {
FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
Llvm_backend *be = h.be();
Btype *bc64t = be->complex_type(64);
Btype *bc128t = be->complex_type(128);
// func foo(x complex64, y complex128) complex64
BFunctionType *befty1 = mkFuncTyp(be,
L_PARM, bc64t,
L_PARM, bc128t,
L_RES, bc64t,
L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// z = foo(x, y)
Location loc;
Bvariable *x = func->getNthParamVar(0);
Bvariable *y = func->getNthParamVar(1);
Bexpression *xvex = be->var_expression(x, loc);
Bexpression *yvex = be->var_expression(y, loc);
Bexpression *fn1 = be->function_code_expression(func, loc);
std::vector<Bexpression *> args1 = {xvex, yvex};
Bexpression *call1 = be->call_expression(func, fn1, args1, nullptr, h.loc());
h.mkLocal("z", bc64t, call1);
// Call with constant args
// foo(1+2i, 3+4i)
mpc_t mpc_val1, mpc_val2;
mpc_init2(mpc_val1, 256);
mpc_set_d_d(mpc_val1, 1.0, 2.0, GMP_RNDN);
mpc_init2(mpc_val2, 256);
mpc_set_d_d(mpc_val2, 3.0, 4.0, GMP_RNDN);
Bexpression *ccon1 = be->complex_constant_expression(bc64t, mpc_val1);
Bexpression *ccon2 = be->complex_constant_expression(bc128t, mpc_val2);
mpc_clear(mpc_val1);
mpc_clear(mpc_val2);
Bexpression *fn2 = be->function_code_expression(func, loc);
std::vector<Bexpression *> args2 = {ccon1, ccon2};
Bexpression *call2 = be->call_expression(func, fn2, args2, nullptr, h.loc());
// return the call expr above
std::vector<Bexpression *> rvals = {call2};
h.mkReturn(rvals);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%cast.0 = bitcast { float, float }* %p0.addr to <2 x float>*
%ld.0 = load <2 x float>, <2 x float>* %cast.0, align 8
%field0.0 = getelementptr inbounds { double, double }, { double, double }* %p1.addr, i32 0, i32 0
%ld.1 = load double, double* %field0.0, align 8
%field1.0 = getelementptr inbounds { double, double }, { double, double }* %p1.addr, i32 0, i32 1
%ld.2 = load double, double* %field1.0, align 8
%call.0 = call addrspace(0) <2 x float> @foo(i8* nest undef, <2 x float> %ld.0, double %ld.1, double %ld.2)
%cast.2 = bitcast { float, float }* %sret.actual.0 to <2 x float>*
store <2 x float> %call.0, <2 x float>* %cast.2, align 8
%cast.3 = bitcast { float, float }* %z to i8*
%cast.4 = bitcast { float, float }* %sret.actual.0 to i8*
call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 8, i1 false)
%ld.3 = load <2 x float>, <2 x float>* bitcast ({ float, float }* @const.0 to <2 x float>*), align 8
%ld.4 = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @const.1, i32 0, i32 0), align 8
%ld.5 = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @const.1, i32 0, i32 1), align 8
%call.1 = call addrspace(0) <2 x float> @foo(i8* nest undef, <2 x float> %ld.3, double %ld.4, double %ld.5)
%cast.7 = bitcast { float, float }* %sret.actual.1 to <2 x float>*
store <2 x float> %call.1, <2 x float>* %cast.7, align 8
%cast.8 = bitcast { float, float }* %sret.actual.1 to <2 x float>*
%ld.6 = load <2 x float>, <2 x float>* %cast.8, align 8
ret <2 x float> %ld.6
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
TEST(BackendCABIOracleTests, PassAndReturnComplexArm64) {
FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
Llvm_backend *be = h.be();
Btype *bc64t = be->complex_type(64);
Btype *bc128t = be->complex_type(128);
// func foo(x complex64, y complex128) complex64
BFunctionType *befty1 =
mkFuncTyp(be, L_PARM, bc64t, L_PARM, bc128t, L_RES, bc64t, L_END);
Bfunction *func = h.mkFunction("foo", befty1);
// z = foo(x, y)
Location loc;
Bvariable *x = func->getNthParamVar(0);
Bvariable *y = func->getNthParamVar(1);
Bexpression *xvex = be->var_expression(x, loc);
Bexpression *yvex = be->var_expression(y, loc);
Bexpression *fn1 = be->function_code_expression(func, loc);
std::vector<Bexpression *> args1 = {xvex, yvex};
Bexpression *call1 = be->call_expression(func, fn1, args1, nullptr, h.loc());
h.mkLocal("z", bc64t, call1);
// Call with constant args
// foo(1+2i, 3+4i)
mpc_t mpc_val1, mpc_val2;
mpc_init2(mpc_val1, 256);
mpc_set_d_d(mpc_val1, 1.0, 2.0, GMP_RNDN);
mpc_init2(mpc_val2, 256);
mpc_set_d_d(mpc_val2, 3.0, 4.0, GMP_RNDN);
Bexpression *ccon1 = be->complex_constant_expression(bc64t, mpc_val1);
Bexpression *ccon2 = be->complex_constant_expression(bc128t, mpc_val2);
mpc_clear(mpc_val1);
mpc_clear(mpc_val2);
Bexpression *fn2 = be->function_code_expression(func, loc);
std::vector<Bexpression *> args2 = {ccon1, ccon2};
Bexpression *call2 = be->call_expression(func, fn2, args2, nullptr, h.loc());
// return the call expr above
std::vector<Bexpression *> rvals = {call2};
h.mkReturn(rvals);
DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
%cast.0 = bitcast { float, float }* %p0.addr to [2 x float]*
%ld.0 = load [2 x float], [2 x float]* %cast.0, align 4
%cast.1 = bitcast { double, double }* %p1.addr to [2 x double]*
%ld.1 = load [2 x double], [2 x double]* %cast.1, align 8
%call.0 = call addrspace(0) { float, float } @foo(i8* nest undef, [2 x float] %ld.0, [2 x double] %ld.1)
store { float, float } %call.0, { float, float }* %sret.actual.0, align 4
%cast.3 = bitcast { float, float }* %z to i8*
%cast.4 = bitcast { float, float }* %sret.actual.0 to i8*
call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 8, i1 false)
%ld.2 = load [2 x float], [2 x float]* bitcast ({ float, float }* @const.0 to [2 x float]*), align 4
%ld.3 = load [2 x double], [2 x double]* bitcast ({ double, double }* @const.1 to [2 x double]*), align 8
%call.1 = call addrspace(0) { float, float } @foo(i8* nest undef, [2 x float] %ld.2, [2 x double] %ld.3)
store { float, float } %call.1, { float, float }* %sret.actual.1, align 4
%ld.4 = load { float, float }, { float, float }* %sret.actual.1, align 4
ret { float, float } %ld.4
)RAW_RESULT");
bool isOK = h.expectBlock(exp);
EXPECT_TRUE(isOK && "Block does not have expected contents");
bool broken = h.finish(PreserveDebugInfo);
EXPECT_FALSE(broken && "Module failed to verify.");
}
} // namespace