mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-12-17 08:36:52 +00:00
CellSPU:
- Fix (brcond (setq ...)) bug, where BRNZ should have been used vice BRZ. - Kill unused/unnecessary nodes in SPUNodes.td - Beef out the i64operations.c test harness to use a lot of unaligned loads, test loops and LLVM loop/basic block optimizations; run the test harness successfully on real Cell hardware. llvm-svn: 61664
This commit is contained in:
Scott Michel
parent
5616407df7
commit
0d9d939406
@ -22,6 +22,9 @@
|
||||
// 4. v2i64 setcc results are v4i32, which can be converted to a FSM mask (TODO)
|
||||
// [Note: this may be moot, since gb produces v4i32 or r32.]
|
||||
//
|
||||
// 5. The code sequences for r64 and v2i64 are probably overly conservative,
|
||||
// compared to the code that gcc produces.
|
||||
//
|
||||
// M00$E B!tes Kan be Pretty N@sTi!!!!! (appologies to Monty!)
|
||||
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
|
||||
|
||||
@ -41,18 +44,23 @@ class I64SETCCNegCond<PatFrag cond, CodeFrag compare>:
|
||||
Pat<(cond R64C:$rA, R64C:$rB),
|
||||
(XORIr32 compare.Fragment, -1)>;
|
||||
|
||||
// The generic i64 select pattern, which assumes that the comparison result
|
||||
// is in a 32-bit register that contains a select mask pattern (i.e., gather
|
||||
// bits result):
|
||||
|
||||
def : Pat<(select R32C:$rC, R64C:$rB, R64C:$rA),
|
||||
(SELBr64_cond R64C:$rA, R64C:$rB, (FSMr32 R32C:$rC))>;
|
||||
|
||||
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
|
||||
// The i64 seteq fragment that does the scalar->vector conversion and
|
||||
// comparison:
|
||||
def CEQr64compare:
|
||||
CodeFrag<(CGTIv4i32 (GBv4i32 (CEQv4i32 (ORv2i64_i64 R64C:$rA),
|
||||
(ORv2i64_i64 R64C:$rB))),
|
||||
0x0000000c)>;
|
||||
|
||||
(ORv2i64_i64 R64C:$rB))), 0xb)>;
|
||||
|
||||
// The i64 seteq fragment that does the vector comparison
|
||||
def CEQv2i64compare:
|
||||
CodeFrag<(CGTIv4i32 (GBv4i32 (CEQv4i32 VECREG:$rA, VECREG:$rB)),
|
||||
0x0000000f)>;
|
||||
CodeFrag<(CEQIv4i32 (GBv4i32 (CEQv4i32 VECREG:$rA, VECREG:$rB)), 0xf)>;
|
||||
|
||||
// i64 seteq (equality): the setcc result is i32, which is converted to a
|
||||
// vector FSM mask when used in a select pattern.
|
||||
@ -73,11 +81,52 @@ defm I64EQ: CompareEqual64;
|
||||
def : Pat<(seteq R64C:$rA, R64C:$rB), I64EQr64.Fragment>;
|
||||
def : Pat<(seteq (v2i64 VECREG:$rA), (v2i64 VECREG:$rB)), I64EQv2i64.Fragment>;
|
||||
|
||||
def : Pat<(select R32C:$rC, R64C:$rB, R64C:$rA),
|
||||
(SELBr64_cond R64C:$rA, R64C:$rB, (FSMr32 R32C:$rC))>;
|
||||
|
||||
// i64 setne:
|
||||
def : I64SETCCNegCond<setne, I64EQr64>;
|
||||
def : I64SELECTNegCond<setne, I64EQr64>;
|
||||
|
||||
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
|
||||
// i64 setugt:
|
||||
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
|
||||
|
||||
def CLGTr64ugt:
|
||||
CodeFrag<(CLGTv4i32 (ORv2i64_i64 R64C:$rA), (ORv2i64_i64 R64C:$rB))>;
|
||||
|
||||
def CLGTr64eq:
|
||||
CodeFrag<(CEQv4i32 (ORv2i64_i64 R64C:$rA), (ORv2i64_i64 R64C:$rB))>;
|
||||
|
||||
def CLGTr64compare:
|
||||
CodeFrag<(SELBv2i64 CLGTr64ugt.Fragment,
|
||||
(XSWDv2i64 CLGTr64ugt.Fragment),
|
||||
CLGTr64eq.Fragment)>;
|
||||
|
||||
def CLGTv2i64ugt:
|
||||
CodeFrag<(CLGTv4i32 VECREG:$rA, VECREG:$rB)>;
|
||||
|
||||
def CLGTv2i64eq:
|
||||
CodeFrag<(CEQv4i32 VECREG:$rA, VECREG:$rB)>;
|
||||
|
||||
def CLGTv2i64compare:
|
||||
CodeFrag<(SELBv2i64 CLGTv2i64ugt.Fragment,
|
||||
(XSWDv2i64 CLGTr64ugt.Fragment),
|
||||
CLGTv2i64eq.Fragment)>;
|
||||
|
||||
multiclass CompareLogicalGreaterThan64 {
|
||||
// Plain old comparison, converts back to i32 scalar
|
||||
def r64: CodeFrag<(ORi32_v4i32 CLGTr64compare.Fragment)>;
|
||||
def v2i64: CodeFrag<CLGTv2i64compare.Fragment>;
|
||||
|
||||
// SELB mask from FSM:
|
||||
def r64mask: CodeFrag<(ORi32_v4i32 (FSMv4i32 CLGTr64compare.Fragment))>;
|
||||
def v2i64mask: CodeFrag<(ORi32_v4i32 (FSMv4i32 CLGTv2i64compare.Fragment))>;
|
||||
}
|
||||
|
||||
defm I64LGT: CompareLogicalGreaterThan64;
|
||||
|
||||
def : Pat<(setugt R64C:$rA, R64C:$rB), I64LGTr64.Fragment>;
|
||||
def : Pat<(setugt (v2i64 VECREG:$rA), (v2i64 VECREG:$rB)),
|
||||
I64LGTv2i64.Fragment>;
|
||||
|
||||
// i64 setult:
|
||||
def : I64SETCCNegCond<setule, I64LGTr64>;
|
||||
def : I64SELECTNegCond<setule, I64LGTr64>;
|
||||
|
||||
@ -1176,23 +1176,31 @@ def XSHWr16:
|
||||
"xshw\t$rDst, $rSrc", IntegerOp,
|
||||
[(set R32C:$rDst, (sext R16C:$rSrc))]>;
|
||||
|
||||
def XSWDvec:
|
||||
RRForm_1<0b01100101010, (outs VECREG:$rDst), (ins VECREG:$rSrc),
|
||||
"xswd\t$rDst, $rSrc", IntegerOp,
|
||||
[(set (v2i64 VECREG:$rDst), (sext (v4i32 VECREG:$rSrc)))]>;
|
||||
// Sign-extend words to doublewords (32->64 bits)
|
||||
|
||||
def XSWDr64:
|
||||
RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R64C:$rSrc),
|
||||
class XSWDInst<dag OOL, dag IOL, list<dag> pattern>:
|
||||
RRForm_1<0b01100101010, OOL, IOL,
|
||||
"xswd\t$rDst, $rSrc", IntegerOp,
|
||||
[(set R64C:$rDst, (sext_inreg R64C:$rSrc, i32))]>;
|
||||
pattern>;
|
||||
|
||||
class XSWDVecInst<ValueType in_vectype, ValueType out_vectype>:
|
||||
XSWDInst<(outs VECREG:$rDst), (ins VECREG:$rSrc),
|
||||
[(set (out_vectype VECREG:$rDst),
|
||||
(sext (out_vectype VECREG:$rSrc)))]>;
|
||||
|
||||
class XSWDRegInst<RegisterClass in_rclass, RegisterClass out_rclass>:
|
||||
XSWDInst<(outs out_rclass:$rDst), (ins in_rclass:$rSrc),
|
||||
[(set out_rclass:$rDst, (sext in_rclass:$rSrc))]>;
|
||||
|
||||
multiclass ExtendWordToDoubleWord {
|
||||
def v2i64: XSWDVecInst<v4i32, v2i64>;
|
||||
def r64: XSWDRegInst<R32C, R64C>;
|
||||
|
||||
def r64_inreg: XSWDInst<(outs R64C:$rDst), (ins R64C:$rSrc),
|
||||
[(set R64C:$rDst, (sext_inreg R64C:$rSrc, i32))]>;
|
||||
}
|
||||
|
||||
def XSWDr32:
|
||||
RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R32C:$rSrc),
|
||||
"xswd\t$rDst, $rSrc", IntegerOp,
|
||||
[(set R64C:$rDst, (SPUsext32_to_64 R32C:$rSrc))]>;
|
||||
|
||||
def : Pat<(sext R32C:$inp),
|
||||
(XSWDr32 R32C:$inp)>;
|
||||
defm XSWD : ExtendWordToDoubleWord;
|
||||
|
||||
// AND operations
|
||||
|
||||
@ -3511,7 +3519,7 @@ let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
|
||||
def BI:
|
||||
BIForm<0b00010101100, "bi\t$func", [(brind R32C:$func)]>;
|
||||
|
||||
// Various branches:
|
||||
// Conditional branches:
|
||||
class BRNZInst<dag IOL, list<dag> pattern>:
|
||||
RI16Form<0b010000100, (outs), IOL, "brnz\t$rCond,$dest",
|
||||
BranchResolv, pattern>;
|
||||
@ -3651,8 +3659,8 @@ multiclass BranchCondEQ<PatFrag cond, SPUInstr brinst16, SPUInstr brinst32>
|
||||
(brinst32 (CEQr32 R32C:$rA, R32C:$rB), bb:$dest)>;
|
||||
}
|
||||
|
||||
defm BRCONDeq : BranchCondEQ<seteq, BRHZr16, BRZr32>;
|
||||
defm BRCONDne : BranchCondEQ<setne, BRHNZr16, BRNZr32>;
|
||||
defm BRCONDeq : BranchCondEQ<seteq, BRHNZr16, BRNZr32>;
|
||||
defm BRCONDne : BranchCondEQ<setne, BRHZr16, BRZr32>;
|
||||
|
||||
multiclass BranchCondLGT<PatFrag cond, SPUInstr brinst16, SPUInstr brinst32>
|
||||
{
|
||||
|
||||
@ -137,16 +137,6 @@ def SPUaform : SDNode<"SPUISD::AFormAddr", SDTIntBinOp, []>;
|
||||
// Indirect [D-Form "imm($reg)" and X-Form "$reg($reg)"] addresses
|
||||
def SPUindirect : SDNode<"SPUISD::IndirectAddr", SDTIntBinOp, []>;
|
||||
|
||||
// SPU 32-bit sign-extension to 64-bits
|
||||
def SPUsext32_to_64: SDNode<"SPUISD::SEXT32TO64", SDTIntExtendOp, []>;
|
||||
|
||||
// Branches:
|
||||
|
||||
def SPUbrnz : SDNode<"SPUISD::BR_NOTZERO", SDTBrcond, [SDNPHasChain]>;
|
||||
def SPUbrz : SDNode<"SPUISD::BR_ZERO", SDTBrcond, [SDNPHasChain]>;
|
||||
/* def SPUbinz : SDNode<"SPUISD::BR_NOTZERO", SDTBrind, [SDNPHasChain]>;
|
||||
def SPUbiz : SDNode<"SPUISD::BR_ZERO", SPUBrind, [SDNPHasChain]>; */
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Constraints: (taken from PPCInstrInfo.td)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@ -1,10 +1,11 @@
|
||||
; RUN: llvm-as -o - %s | llc -march=cellspu > %t1.s
|
||||
; RUN: grep ceq %t1.s | count 4
|
||||
; RUN: grep ceq %t1.s | count 6
|
||||
; RUN: grep cgti %t1.s | count 4
|
||||
; RUN: grep clgt %t1.s | count 2
|
||||
; RUN: grep gb %t1.s | count 4
|
||||
; RUN: grep fsm %t1.s | count 2
|
||||
; RUN: grep fsm %t1.s | count 3
|
||||
; RUN: grep xori %t1.s | count 1
|
||||
; RUN: grep selb %t1.s | count 2
|
||||
; RUN: grep selb %t1.s | count 5
|
||||
|
||||
target datalayout = "E-p:32:32:128-f64:64:128-f32:32:128-i64:32:128-i32:32:128-i16:16:128-i8:8:128-i1:8:128-a0:0:128-v128:128:128-s0:128:128"
|
||||
target triple = "spu"
|
||||
@ -39,19 +40,19 @@ entry:
|
||||
ret i1 %A
|
||||
}
|
||||
|
||||
;; define i64 @icmp_ugt_select_i64(i64 %arg1, i64 %arg2, i64 %val1, i64 %val2) nounwind {
|
||||
;; entry:
|
||||
;; %A = icmp ugt i64 %arg1, %arg2
|
||||
;; %B = select i1 %A, i64 %val1, i64 %val2
|
||||
;; ret i64 %B
|
||||
;; }
|
||||
;;
|
||||
;; define i1 @icmp_ugt_setcc_i64(i64 %arg1, i64 %arg2, i64 %val1, i64 %val2) nounwind {
|
||||
;; entry:
|
||||
;; %A = icmp ugt i64 %arg1, %arg2
|
||||
;; ret i1 %A
|
||||
;; }
|
||||
;;
|
||||
define i64 @icmp_ugt_select_i64(i64 %arg1, i64 %arg2, i64 %val1, i64 %val2) nounwind {
|
||||
entry:
|
||||
%A = icmp ugt i64 %arg1, %arg2
|
||||
%B = select i1 %A, i64 %val1, i64 %val2
|
||||
ret i64 %B
|
||||
}
|
||||
|
||||
define i1 @icmp_ugt_setcc_i64(i64 %arg1, i64 %arg2, i64 %val1, i64 %val2) nounwind {
|
||||
entry:
|
||||
%A = icmp ugt i64 %arg1, %arg2
|
||||
ret i1 %A
|
||||
}
|
||||
|
||||
;; define i64 @icmp_uge_select_i64(i64 %arg1, i64 %arg2, i64 %val1, i64 %val2) nounwind {
|
||||
;; entry:
|
||||
;; %A = icmp uge i64 %arg1, %arg2
|
||||
|
||||
@ -1,71 +1,293 @@
|
||||
#include <stdio.h>
|
||||
|
||||
typedef unsigned long long int uint64_t;
|
||||
typedef long long int int64_t;
|
||||
#define TRUE_VAL (!0)
|
||||
#define FALSE_VAL 0
|
||||
#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
|
||||
|
||||
const char *boolstring(int val) {
|
||||
return val ? "true" : "false";
|
||||
}
|
||||
typedef unsigned long long int uint64_t;
|
||||
typedef long long int int64_t;
|
||||
|
||||
int i64_eq(int64_t a, int64_t b) {
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
int64_t a = 1234567890003LL;
|
||||
int64_t b = 2345678901235LL;
|
||||
int64_t c = 1234567890001LL;
|
||||
int64_t d = 10001LL;
|
||||
int64_t e = 10000LL;
|
||||
int64_t f = -1068103409991LL;
|
||||
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
int
|
||||
i64_eq(int64_t a, int64_t b)
|
||||
{
|
||||
return (a == b);
|
||||
}
|
||||
|
||||
int i64_neq(int64_t a, int64_t b) {
|
||||
int
|
||||
i64_neq(int64_t a, int64_t b)
|
||||
{
|
||||
return (a != b);
|
||||
}
|
||||
|
||||
int64_t i64_eq_select(int64_t a, int64_t b, int64_t c, int64_t d) {
|
||||
int
|
||||
i64_ugt(uint64_t a, uint64_t b)
|
||||
{
|
||||
return (a > b);
|
||||
}
|
||||
|
||||
int
|
||||
i64_ule(uint64_t a, uint64_t b)
|
||||
{
|
||||
return (a <= b);
|
||||
}
|
||||
|
||||
int64_t
|
||||
i64_eq_select(int64_t a, int64_t b, int64_t c, int64_t d)
|
||||
{
|
||||
return ((a == b) ? c : d);
|
||||
}
|
||||
|
||||
int64_t i64_neq_select(int64_t a, int64_t b, int64_t c, int64_t d) {
|
||||
int64_t
|
||||
i64_neq_select(int64_t a, int64_t b, int64_t c, int64_t d)
|
||||
{
|
||||
return ((a != b) ? c : d);
|
||||
}
|
||||
|
||||
struct pred_s {
|
||||
const char *name;
|
||||
int (*predfunc)(int64_t, int64_t);
|
||||
int64_t (*selfunc)(int64_t, int64_t, int64_t, int64_t);
|
||||
uint64_t
|
||||
i64_ugt_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d)
|
||||
{
|
||||
return ((a > b) ? c : d);
|
||||
}
|
||||
|
||||
uint64_t
|
||||
i64_ule_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d)
|
||||
{
|
||||
return ((a <= b) ? c : d);
|
||||
}
|
||||
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
struct harness_int64_pred {
|
||||
const char *fmt_string;
|
||||
int64_t *lhs;
|
||||
int64_t *rhs;
|
||||
int64_t *select_a;
|
||||
int64_t *select_b;
|
||||
int expected;
|
||||
int64_t *select_expected;
|
||||
};
|
||||
|
||||
struct pred_s preds[] = {
|
||||
{ "eq", i64_eq, i64_eq_select },
|
||||
{ "neq", i64_neq, i64_neq_select }
|
||||
struct harness_uint64_pred {
|
||||
const char *fmt_string;
|
||||
uint64_t *lhs;
|
||||
uint64_t *rhs;
|
||||
uint64_t *select_a;
|
||||
uint64_t *select_b;
|
||||
int expected;
|
||||
uint64_t *select_expected;
|
||||
};
|
||||
|
||||
uint64_t i64_shl_const(uint64_t a) {
|
||||
struct int64_pred_s {
|
||||
const char *name;
|
||||
int (*predfunc) (int64_t, int64_t);
|
||||
int64_t (*selfunc) (int64_t, int64_t, int64_t, int64_t);
|
||||
struct harness_int64_pred *tests;
|
||||
int n_tests;
|
||||
};
|
||||
|
||||
struct uint64_pred_s {
|
||||
const char *name;
|
||||
int (*predfunc) (uint64_t, uint64_t);
|
||||
uint64_t (*selfunc) (uint64_t, uint64_t, uint64_t, uint64_t);
|
||||
struct harness_uint64_pred *tests;
|
||||
int n_tests;
|
||||
};
|
||||
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
struct harness_int64_pred int64_tests_eq[] = {
|
||||
{"a %s a", &a, &a, &c, &d, TRUE_VAL, &c},
|
||||
{"a %s b", &a, &b, &c, &d, FALSE_VAL, &d},
|
||||
{"a %s c", &a, &c, &c, &d, FALSE_VAL, &d},
|
||||
{"d %s e", &d, &e, &c, &d, FALSE_VAL, &d},
|
||||
{"e %s e", &e, &e, &c, &d, TRUE_VAL, &c}
|
||||
};
|
||||
|
||||
struct harness_int64_pred int64_tests_neq[] = {
|
||||
{"a %s a", &a, &a, &c, &d, FALSE_VAL, &d},
|
||||
{"a %s b", &a, &b, &c, &d, TRUE_VAL, &c},
|
||||
{"a %s c", &a, &c, &c, &d, TRUE_VAL, &c},
|
||||
{"d %s e", &d, &e, &c, &d, TRUE_VAL, &c},
|
||||
{"e %s e", &e, &e, &c, &d, FALSE_VAL, &d}
|
||||
};
|
||||
|
||||
struct int64_pred_s int64_preds[] = {
|
||||
{"eq", i64_eq, i64_eq_select,
|
||||
int64_tests_eq, ARR_SIZE(int64_tests_eq)},
|
||||
{"neq", i64_neq, i64_neq_select,
|
||||
int64_tests_neq, ARR_SIZE(int64_tests_neq)}
|
||||
};
|
||||
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
struct harness_uint64_pred uint64_tests_ugt[] = {
|
||||
{"a %s a", (uint64_t *) &a, (uint64_t *) &a, (uint64_t *) &c,
|
||||
(uint64_t *) &d, FALSE_VAL, (uint64_t *) &d},
|
||||
{"a %s b", (uint64_t *) &a, (uint64_t *) &b, (uint64_t *) &c,
|
||||
(uint64_t *) &d, FALSE_VAL, (uint64_t *) &d },
|
||||
{"a %s c", (uint64_t *) &a, (uint64_t *) &c, (uint64_t *) &c,
|
||||
(uint64_t *) &d, TRUE_VAL, (uint64_t *) &c },
|
||||
{"d %s e", (uint64_t *) &d, (uint64_t *) &e, (uint64_t *) &c,
|
||||
(uint64_t *) &d, TRUE_VAL, (uint64_t *) &c },
|
||||
{"e %s e", (uint64_t *) &e, (uint64_t *) &e, (uint64_t *) &c,
|
||||
(uint64_t *) &d, FALSE_VAL, (uint64_t *) &d }
|
||||
};
|
||||
|
||||
struct harness_uint64_pred uint64_tests_ule[] = {
|
||||
{"a %s a", (uint64_t *) &a, (uint64_t *) &a, (uint64_t *) &c,
|
||||
(uint64_t *) &d, TRUE_VAL, (uint64_t *) &c},
|
||||
{"a %s b", (uint64_t *) &a, (uint64_t *) &b, (uint64_t *) &c,
|
||||
(uint64_t *) &d, TRUE_VAL, (uint64_t *) &c},
|
||||
{"a %s c", (uint64_t *) &a, (uint64_t *) &c, (uint64_t *) &c,
|
||||
(uint64_t *) &d, FALSE_VAL, (uint64_t *) &d},
|
||||
{"d %s e", (uint64_t *) &d, (uint64_t *) &e, (uint64_t *) &c,
|
||||
(uint64_t *) &d, FALSE_VAL, (uint64_t *) &d},
|
||||
{"e %s e", (uint64_t *) &e, (uint64_t *) &e, (uint64_t *) &c,
|
||||
(uint64_t *) &d, TRUE_VAL, (uint64_t *) &c}
|
||||
};
|
||||
|
||||
struct uint64_pred_s uint64_preds[] = {
|
||||
{"ugt", i64_ugt, i64_ugt_select,
|
||||
uint64_tests_ugt, ARR_SIZE(uint64_tests_ugt)},
|
||||
{"ule", i64_ule, i64_ule_select,
|
||||
uint64_tests_ule, ARR_SIZE(uint64_tests_ule)}
|
||||
};
|
||||
|
||||
int
|
||||
compare_expect_int64(const struct int64_pred_s * pred)
|
||||
{
|
||||
int j, failed = 0;
|
||||
|
||||
for (j = 0; j < pred->n_tests; ++j) {
|
||||
int pred_result =
|
||||
(*pred->predfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs);
|
||||
|
||||
if (pred_result != pred->tests[j].expected) {
|
||||
char str[64];
|
||||
|
||||
sprintf(str, pred->tests[j].fmt_string, pred->name);
|
||||
printf("%s: returned value is %d, expecting %d\n", str,
|
||||
pred_result, pred->tests[j].expected);
|
||||
printf(" lhs = %19lld (0x%016llx)\n", *pred->tests[j].lhs, *pred->tests[j].lhs);
|
||||
printf(" rhs = %19lld (0x%016llx)\n", *pred->tests[j].rhs, *pred->tests[j].rhs);
|
||||
++failed;
|
||||
} else {
|
||||
int64_t selresult = (pred->selfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs,
|
||||
*pred->tests[j].select_a, *pred->tests[j].select_b);
|
||||
if (selresult != *pred->tests[j].select_expected) {
|
||||
char str[64];
|
||||
|
||||
sprintf(str, pred->tests[j].fmt_string, pred->name);
|
||||
printf("%s select: returned value is %d, expecting %d\n", str,
|
||||
pred_result, pred->tests[j].expected);
|
||||
printf(" lhs = %19lld (0x%016llx)\n", *pred->tests[j].lhs, *pred->tests[j].lhs);
|
||||
printf(" rhs = %19lld (0x%016llx)\n", *pred->tests[j].rhs, *pred->tests[j].rhs);
|
||||
printf(" true = %19lld (0x%016llx)\n", *pred->tests[j].select_a, *pred->tests[j].select_a);
|
||||
printf(" false = %19lld (0x%016llx)\n", *pred->tests[j].select_b, *pred->tests[j].select_b);
|
||||
++failed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return failed;
|
||||
}
|
||||
|
||||
int
|
||||
compare_expect_uint64(const struct uint64_pred_s * pred)
|
||||
{
|
||||
int j, failed = 0;
|
||||
|
||||
for (j = 0; j < pred->n_tests; ++j) {
|
||||
int pred_result = (*pred->predfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs);
|
||||
|
||||
if (pred_result != pred->tests[j].expected) {
|
||||
char str[64];
|
||||
|
||||
sprintf(str, pred->tests[j].fmt_string, pred->name);
|
||||
printf("%s: returned value is %d, expecting %d\n", str,
|
||||
pred_result, pred->tests[j].expected);
|
||||
printf(" lhs = %19llu (0x%016llx)\n", *pred->tests[j].lhs, *pred->tests[j].lhs);
|
||||
printf(" rhs = %19llu (0x%016llx)\n", *pred->tests[j].rhs, *pred->tests[j].rhs);
|
||||
++failed;
|
||||
} else {
|
||||
uint64_t selresult = (pred->selfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs,
|
||||
*pred->tests[j].select_a, *pred->tests[j].select_b);
|
||||
if (selresult != *pred->tests[j].select_expected) {
|
||||
char str[64];
|
||||
|
||||
sprintf(str, pred->tests[j].fmt_string, pred->name);
|
||||
printf("%s select: returned value is %d, expecting %d\n", str,
|
||||
pred_result, pred->tests[j].expected);
|
||||
printf(" lhs = %19llu (0x%016llx)\n", *pred->tests[j].lhs, *pred->tests[j].lhs);
|
||||
printf(" rhs = %19llu (0x%016llx)\n", *pred->tests[j].rhs, *pred->tests[j].rhs);
|
||||
printf(" true = %19llu (0x%016llx)\n", *pred->tests[j].select_a, *pred->tests[j].select_a);
|
||||
printf(" false = %19llu (0x%016llx)\n", *pred->tests[j].select_b, *pred->tests[j].select_b);
|
||||
++failed;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return failed;
|
||||
}
|
||||
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
uint64_t
|
||||
i64_shl_const(uint64_t a)
|
||||
{
|
||||
return a << 10;
|
||||
}
|
||||
|
||||
uint64_t i64_shl(uint64_t a, int amt) {
|
||||
uint64_t
|
||||
i64_shl(uint64_t a, int amt)
|
||||
{
|
||||
return a << amt;
|
||||
}
|
||||
|
||||
uint64_t i64_srl_const(uint64_t a) {
|
||||
uint64_t
|
||||
i64_srl_const(uint64_t a)
|
||||
{
|
||||
return a >> 10;
|
||||
}
|
||||
|
||||
uint64_t i64_srl(uint64_t a, int amt) {
|
||||
uint64_t
|
||||
i64_srl(uint64_t a, int amt)
|
||||
{
|
||||
return a >> amt;
|
||||
}
|
||||
|
||||
int64_t i64_sra_const(int64_t a) {
|
||||
int64_t
|
||||
i64_sra_const(int64_t a)
|
||||
{
|
||||
return a >> 10;
|
||||
}
|
||||
|
||||
int64_t i64_sra(int64_t a, int amt) {
|
||||
int64_t
|
||||
i64_sra(int64_t a, int amt)
|
||||
{
|
||||
return a >> amt;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
int i;
|
||||
int64_t a = 1234567890003LL;
|
||||
int64_t b = 2345678901235LL;
|
||||
int64_t c = 1234567890001LL;
|
||||
int64_t d = 10001LL;
|
||||
int64_t e = 10000LL;
|
||||
int64_t f = -1068103409991LL;
|
||||
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
int i, j, failed = 0;
|
||||
const char *something_failed = " %d tests failed.\n";
|
||||
const char *all_tests_passed = " All tests passed.\n";
|
||||
|
||||
printf("a = %16lld (0x%016llx)\n", a, a);
|
||||
printf("b = %16lld (0x%016llx)\n", b, b);
|
||||
@ -75,28 +297,35 @@ int main(void) {
|
||||
printf("f = %16lld (0x%016llx)\n", f, f);
|
||||
printf("----------------------------------------\n");
|
||||
|
||||
for (i = 0; i < sizeof(preds)/sizeof(preds[0]); ++i) {
|
||||
printf("a %s a = %s\n", preds[i].name, boolstring((*preds[i].predfunc)(a, a)));
|
||||
printf("a %s b = %s\n", preds[i].name, boolstring((*preds[i].predfunc)(a, b)));
|
||||
printf("a %s c = %s\n", preds[i].name, boolstring((*preds[i].predfunc)(a, c)));
|
||||
printf("d %s e = %s\n", preds[i].name, boolstring((*preds[i].predfunc)(d, e)));
|
||||
printf("e %s e = %s\n", preds[i].name, boolstring((*preds[i].predfunc)(e, e)));
|
||||
for (i = 0; i < ARR_SIZE(int64_preds); ++i) {
|
||||
printf("%s series:\n", int64_preds[i].name);
|
||||
if ((failed = compare_expect_int64(int64_preds + i)) > 0) {
|
||||
printf(something_failed, failed);
|
||||
} else {
|
||||
printf(all_tests_passed);
|
||||
}
|
||||
|
||||
printf("a %s a ? c : d = %lld\n", preds[i].name, (*preds[i].selfunc)(a, a, c, d));
|
||||
printf("a %s a ? c : d == c (%s)\n", preds[i].name, boolstring((*preds[i].selfunc)(a, a, c, d) == c));
|
||||
printf("a %s b ? c : d = %lld\n", preds[i].name, (*preds[i].selfunc)(a, b, c, d));
|
||||
printf("a %s b ? c : d == d (%s)\n", preds[i].name, boolstring((*preds[i].selfunc)(a, b, c, d) == d));
|
||||
printf("----------------------------------------\n");
|
||||
}
|
||||
|
||||
for (i = 0; i < ARR_SIZE(uint64_preds); ++i) {
|
||||
printf("%s series:\n", uint64_preds[i].name);
|
||||
if ((failed = compare_expect_uint64(uint64_preds + i)) > 0) {
|
||||
printf(something_failed, failed);
|
||||
} else {
|
||||
printf(all_tests_passed);
|
||||
}
|
||||
|
||||
printf("----------------------------------------\n");
|
||||
}
|
||||
|
||||
printf("a = 0x%016llx\n", a);
|
||||
printf("i64_shl_const(a) = 0x%016llx\n", i64_shl_const(a));
|
||||
printf("i64_shl(a) = 0x%016llx\n", i64_shl(a, 5));
|
||||
printf("i64_shl(a) = 0x%016llx\n", i64_shl(a, 10));
|
||||
printf("i64_srl_const(a) = 0x%016llx\n", i64_srl_const(a));
|
||||
printf("i64_srl(a) = 0x%016llx\n", i64_srl(a, 5));
|
||||
printf("i64_srl(a) = 0x%016llx\n", i64_srl(a, 10));
|
||||
printf("i64_sra_const(a) = 0x%016llx\n", i64_sra_const(a));
|
||||
printf("i64_sra(a) = 0x%016llx\n", i64_sra(a, 5));
|
||||
printf("i64_sra(a) = 0x%016llx\n", i64_sra(a, 10));
|
||||
printf("----------------------------------------\n");
|
||||
|
||||
printf("f = 0x%016llx\n", f);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user