Portage HPUX, suite
git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@897 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02master
Xavier Leroy
parent
98b778f975
commit
77ff668587
|
|
@ -291,9 +291,11 @@ let emit_frame fd =
|
|||
let float_constants = ref ([] : (int * string) list)
|
||||
|
||||
let emit_float_constant (lbl, cst) =
|
||||
if hpux
|
||||
then ` .lit\n`
|
||||
else ` .literal8\n`;
|
||||
if hpux then begin
|
||||
` .space $TEXT$\n`;
|
||||
` .subspa $LIT$\n`
|
||||
end else
|
||||
` .literal8\n`;
|
||||
emit_align 8;
|
||||
`{emit_label lbl}: .double {emit_string cst}\n`
|
||||
|
||||
|
|
@ -438,6 +440,7 @@ let rec emit_instr i dslot =
|
|||
` ldo {emit_string low_prefix}{emit_label lbl}(%r1), %r1\n`;
|
||||
` fldds 0(%r1), {emit_reg i.res.(0)}\n`
|
||||
| Lop(Iconst_symbol s) ->
|
||||
use_symbol s;
|
||||
load_symbol_high s;
|
||||
` ldo {emit_symbol_low s}(%r1), {emit_reg i.res.(0)}\n`
|
||||
| Lop(Icall_ind) ->
|
||||
|
|
@ -450,21 +453,23 @@ let rec emit_instr i dslot =
|
|||
record_frame i.live
|
||||
| Lop(Itailcall_ind) ->
|
||||
let n = frame_size() in
|
||||
if !contains_calls then
|
||||
` ldw {emit_int(-n)}(%r30), %r2\n`;
|
||||
` bv 0({emit_reg i.arg.(0)})\n`;
|
||||
` ldo {emit_int(-n)}(%r30), %r30\n` (* in delay slot *)
|
||||
if !contains_calls (* in delay slot *)
|
||||
then ` ldwm {emit_int(-n)}(%r30), %r2\n`
|
||||
else ` ldo {emit_int(-n)}(%r30), %r30\n`
|
||||
| Lop(Itailcall_imm s) ->
|
||||
let n = frame_size() in
|
||||
if s = !function_name then begin
|
||||
` b,n {emit_label !tailrec_entry_point}\n`
|
||||
end else begin
|
||||
if !contains_calls then
|
||||
` ldw {emit_int(-n)}(%r30), %r2\n`;
|
||||
emit_call s "%r0"
|
||||
emit_call s "%r0";
|
||||
if !contains_calls (* in delay slot *)
|
||||
then ` ldwm {emit_int(-n)}(%r30), %r2\n`
|
||||
else ` ldo {emit_int(-n)}(%r30), %r30\n`
|
||||
end
|
||||
| Lop(Iextcall(s, alloc)) ->
|
||||
if alloc then begin
|
||||
call_symbol s;
|
||||
if hpux then begin
|
||||
` ldil LP'{emit_symbol s}, %r22\n`;
|
||||
emit_call "caml_c_call" "%r2";
|
||||
|
|
@ -547,7 +552,7 @@ let rec emit_instr i dslot =
|
|||
` ldil L\`$$divI, %r1\n`;
|
||||
` ble R\`$$divI(4, %r1)\n`
|
||||
end;
|
||||
` nop\n`
|
||||
fill_delay_slot dslot
|
||||
| Lop(Iintop Imod) ->
|
||||
(* Arguments are assumed to be in %r26 and %r25, result in %r29 *)
|
||||
if hpux then
|
||||
|
|
@ -556,7 +561,7 @@ let rec emit_instr i dslot =
|
|||
` ldil L\`$$remI, %r1\n`;
|
||||
` ble R\`$$remI(4, %r1)\n`
|
||||
end;
|
||||
` nop\n`
|
||||
fill_delay_slot dslot
|
||||
| Lop(Iintop Ilsl) ->
|
||||
` subi 31, {emit_reg i.arg.(1)}, %r1\n`;
|
||||
` mtsar %r1\n`;
|
||||
|
|
@ -761,6 +766,7 @@ let rec emit_all i =
|
|||
{desc = Lend} -> ()
|
||||
| {next = {desc = Lop(Icall_imm _)
|
||||
| Lop(Iextcall(_, false))
|
||||
| Lop(Iintop(Idiv | Imod))
|
||||
| Lbranch _
|
||||
| Lsetuptrap _ }}
|
||||
when is_one_instr i ->
|
||||
|
|
@ -888,7 +894,7 @@ let begin_assembly() =
|
|||
` .subspa $CODE$,quad=0,align=8,access=44,code_only\n`;
|
||||
` .import $global$, data\n`;
|
||||
` .import $$divI, millicode\n`;
|
||||
` .import $$modI, millicode\n`
|
||||
` .import $$remI, millicode\n`
|
||||
end;
|
||||
used_symbols := StringSet.empty;
|
||||
defined_symbols := StringSet.empty;
|
||||
|
|
|
|||
|
|
@ -16,11 +16,10 @@
|
|||
|
||||
#ifdef SYS_hpux
|
||||
#define G(x) x
|
||||
#define CODE .code
|
||||
#define CODESPACE .code
|
||||
#define CODE_ALIGN 4
|
||||
#define EXPORT_CODE(x) .export x, entry, priv_lev=3
|
||||
#define EXPORT_DATA(x) .export x, data
|
||||
#define COMM(x,size) x .comm size
|
||||
#define STARTPROC .proc ! .callinfo frame=0, no_calls ! .entry
|
||||
#define ENDPROC .exit ! .procend
|
||||
#define LOADHIGH(x) addil LR%x-$global$, %r27
|
||||
|
|
@ -32,11 +31,10 @@
|
|||
|
||||
#ifdef SYS_nextstep
|
||||
#define G(x) _##x
|
||||
#define CODE .text
|
||||
#define CODESPACE .text
|
||||
#define CODE_ALIGN 2
|
||||
#define EXPORT_CODE(x) .globl x
|
||||
#define EXPORT_DATA(x) .globl x
|
||||
#define COMM(x,size) .comm x, size
|
||||
#define STARTPROC
|
||||
#define ENDPROC
|
||||
#define LOADHIGH(x) ldil L`x, %r1
|
||||
|
|
@ -62,21 +60,33 @@
|
|||
.import mlraise, code
|
||||
.import caml_apply2, code
|
||||
.import caml_apply3, code
|
||||
|
||||
young_limit .comm 8
|
||||
young_ptr .comm 8
|
||||
gc_entry_regs .comm 32 * 4
|
||||
gc_entry_float_regs .comm 32 * 8
|
||||
caml_top_of_stack .comm 8
|
||||
caml_bottom_of_stack .comm 8
|
||||
caml_last_return_address .comm 8
|
||||
caml_exception_pointer .comm 8
|
||||
caml_required_size .comm 8
|
||||
#endif
|
||||
|
||||
COMM(G(young_limit), 8)
|
||||
COMM(G(young_ptr), 8)
|
||||
COMM(G(gc_entry_regs), 32 * 4)
|
||||
COMM(G(gc_entry_float_regs), 32 * 8)
|
||||
COMM(G(caml_top_of_stack), 8)
|
||||
COMM(G(caml_bottom_of_stack), 8)
|
||||
COMM(G(caml_last_return_address), 8)
|
||||
COMM(G(caml_exception_pointer), 8)
|
||||
COMM(G(caml_required_size), 8)
|
||||
#ifdef SYS_nextstep
|
||||
.comm G(young_limit), 8
|
||||
.comm G(young_ptr), 8
|
||||
.comm G(gc_entry_regs), 32 * 4
|
||||
.comm G(gc_entry_float_regs), 32 * 8
|
||||
.comm G(caml_top_of_stack), 8
|
||||
.comm G(caml_bottom_of_stack), 8
|
||||
.comm G(caml_last_return_address), 8
|
||||
.comm G(caml_exception_pointer), 8
|
||||
.comm G(caml_required_size), 8
|
||||
#endif
|
||||
|
||||
; Allocation functions
|
||||
|
||||
CODE
|
||||
CODESPACE
|
||||
.align CODE_ALIGN
|
||||
EXPORT_CODE(G(caml_alloc))
|
||||
G(caml_alloc):
|
||||
|
|
|
|||
|
|
@ -94,6 +94,11 @@ int callback_depth = 0;
|
|||
#define SP_REG asm("27")
|
||||
#define ACCU_REG asm("28")
|
||||
#endif
|
||||
#ifdef __hppa__
|
||||
#define PC_REG asm("%r18")
|
||||
#define SP_REG asm("%r17")
|
||||
#define ACCU_REG asm("%r16")
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* The interpreter itself */
|
||||
|
|
|
|||
|
|
@ -212,11 +212,11 @@ case "$arch" in
|
|||
alpha|mips) asflags='-O2';;
|
||||
sparc)
|
||||
case "$system" in
|
||||
bsd) as='gcc -x assembler-with-cpp -c'; asflags='-DSYS_$(SYSTEM)';;
|
||||
bsd) as='gcc'; asflags='-x assembler-with-cpp -c -DSYS_$(SYSTEM)';;
|
||||
*) asflags='-P -DSYS_$(SYSTEM)';;
|
||||
esac;;
|
||||
i386) asflags='-DSYS_$(SYSTEM)';;
|
||||
hppa) as='gcc'; asflags='-DSYS_$(SYSTEM)';;
|
||||
hppa) as='gcc'; asflags='-c -DSYS_$(SYSTEM)';;
|
||||
power)
|
||||
case "$model" in
|
||||
rs6000) asflags='-u -m pwr -w';;
|
||||
|
|
|
|||
|
|
@ -14,12 +14,12 @@
|
|||
(* Regression test for arithmetic instructions *)
|
||||
|
||||
(function "testarith" ()
|
||||
(let r "r"
|
||||
(let d "d"
|
||||
(let x (load "x" int)
|
||||
(let y (load "y" int)
|
||||
(let f (load "f" float)
|
||||
(let g (load "g" float)
|
||||
(let r "R"
|
||||
(let d "D"
|
||||
(let x (load "X" int)
|
||||
(let y (load "Y" int)
|
||||
(let f (load "F" float)
|
||||
(let g (load "G" float)
|
||||
(addraset r 0 0)
|
||||
(addraset r 1 1)
|
||||
(addraset r 2 -1)
|
||||
|
|
@ -34,15 +34,15 @@
|
|||
(addraset r 10 (+ x 1))
|
||||
(addraset r 11 (+ x -1))
|
||||
|
||||
(addraset r 12 (+a "r" 8))
|
||||
(addraset r 13 (+a "r" y))
|
||||
(addraset r 12 (+a "R" 8))
|
||||
(addraset r 13 (+a "R" y))
|
||||
|
||||
(addraset r 14 (- x y))
|
||||
(addraset r 15 (- x 1))
|
||||
(addraset r 16 (- x -1))
|
||||
|
||||
(addraset r 17 (-a "r" 8))
|
||||
(addraset r 18 (-a "r" y))
|
||||
(addraset r 17 (-a "R" 8))
|
||||
(addraset r 18 (-a "R" y))
|
||||
|
||||
(addraset r 19 ( * x 2))
|
||||
(addraset r 20 ( * 2 x))
|
||||
|
|
@ -194,23 +194,23 @@
|
|||
(floataset d 20 (+f (floatofint x) 1.0))
|
||||
(addraset r 115 (intoffloat (+f f 1.0)))
|
||||
|
||||
(floataset d 21 (+f f (load "g" float)))
|
||||
(floataset d 22 (+f (load "g" float) f))
|
||||
(floataset d 23 (-f f (load "g" float)))
|
||||
(floataset d 24 (-f (load "g" float) f))
|
||||
(floataset d 25 ( *f f (load "g" float)))
|
||||
(floataset d 26 ( *f (load "g" float) f))
|
||||
(floataset d 27 (/f f (load "g" float)))
|
||||
(floataset d 28 (/f (load "g" float) f))
|
||||
(floataset d 21 (+f f (load "G" float)))
|
||||
(floataset d 22 (+f (load "G" float) f))
|
||||
(floataset d 23 (-f f (load "G" float)))
|
||||
(floataset d 24 (-f (load "G" float) f))
|
||||
(floataset d 25 ( *f f (load "G" float)))
|
||||
(floataset d 26 ( *f (load "G" float) f))
|
||||
(floataset d 27 (/f f (load "G" float)))
|
||||
(floataset d 28 (/f (load "G" float) f))
|
||||
|
||||
(floataset d 29 (+f ( *f f 2.0) (load "g" float)))
|
||||
(floataset d 30 (+f (load "g" float) ( *f f 2.0)))
|
||||
(floataset d 31 (-f ( *f f 2.0) (load "g" float)))
|
||||
(floataset d 32 (-f (load "g" float) ( *f f 2.0)))
|
||||
(floataset d 33 ( *f ( +f f 2.0) (load "g" float)))
|
||||
(floataset d 34 ( *f (load "g" float) ( +f f 2.0)))
|
||||
(floataset d 35 (/f ( *f f 2.0) (load "g" float)))
|
||||
(floataset d 36 (/f (load "g" float) ( *f f 2.0)))
|
||||
(floataset d 29 (+f ( *f f 2.0) (load "G" float)))
|
||||
(floataset d 30 (+f (load "G" float) ( *f f 2.0)))
|
||||
(floataset d 31 (-f ( *f f 2.0) (load "G" float)))
|
||||
(floataset d 32 (-f (load "G" float) ( *f f 2.0)))
|
||||
(floataset d 33 ( *f ( +f f 2.0) (load "G" float)))
|
||||
(floataset d 34 ( *f (load "G" float) ( +f f 2.0)))
|
||||
(floataset d 35 (/f ( *f f 2.0) (load "G" float)))
|
||||
(floataset d 36 (/f (load "G" float) ( *f f 2.0)))
|
||||
|
||||
(floataset d 37 (-f f))
|
||||
(floataset d 38 (absf f))
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
#ifdef SYS_hpux
|
||||
#define G(x) x
|
||||
#define CODE .code
|
||||
#define CODESPACE .code
|
||||
#define CODE_ALIGN 4
|
||||
#define EXPORT_CODE(x) .export x, entry, priv_lev=3
|
||||
#define STARTPROC .proc ! .callinfo frame=0, no_calls ! .entry
|
||||
|
|
@ -23,7 +23,7 @@
|
|||
|
||||
#ifdef SYS_nextstep
|
||||
#define G(x) _##x
|
||||
#define CODE .text
|
||||
#define CODESPACE .text
|
||||
#define CODE_ALIGN 2
|
||||
#define EXPORT_CODE(x) .globl x
|
||||
#define STARTPROC
|
||||
|
|
@ -41,7 +41,7 @@
|
|||
.import $$dyncall, millicode
|
||||
#endif
|
||||
|
||||
CODE
|
||||
CODESPACE
|
||||
.align CODE_ALIGN
|
||||
EXPORT_CODE(G(call_gen_code))
|
||||
G(call_gen_code):
|
||||
|
|
@ -93,7 +93,7 @@ G(call_gen_code):
|
|||
copy %r24, %r25
|
||||
copy %r23, %r24
|
||||
fcpy,dbl %fr5, %fr4
|
||||
#ifdef HPUX
|
||||
#ifdef SYS_hpux
|
||||
bl $$dyncall, %r2
|
||||
nop
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -20,34 +20,34 @@ void array_bound_error()
|
|||
exit(2);
|
||||
}
|
||||
|
||||
long r[200];
|
||||
double d[40];
|
||||
long x, y;
|
||||
double f, g;
|
||||
long R[200];
|
||||
double D[40];
|
||||
long X, Y;
|
||||
double F, G;
|
||||
|
||||
#define INTTEST(arg,res) \
|
||||
{ long result = (res); \
|
||||
if (arg != result) \
|
||||
printf("Failed test \"%s == %s\" for x=%ld and y=%ld: result %ld, expected %ld\n", \
|
||||
#arg, #res, x, y, arg, result); \
|
||||
printf("Failed test \"%s == %s\" for X=%ld and Y=%ld: result %ld, expected %ld\n", \
|
||||
#arg, #res, X, Y, arg, result); \
|
||||
}
|
||||
#define INTFLOATTEST(arg,res) \
|
||||
{ long result = (res); \
|
||||
if (arg != result) \
|
||||
printf("Failed test \"%s == %s\" for f=%g and g=%g: result %ld, expected %ld\n", \
|
||||
#arg, #res, f, g, arg, result); \
|
||||
printf("Failed test \"%s == %s\" for F=%g and G=%g: result %ld, expected %ld\n", \
|
||||
#arg, #res, F, G, arg, result); \
|
||||
}
|
||||
#define FLOATTEST(arg,res) \
|
||||
{ double result = (res); \
|
||||
if (arg < result || arg > result) \
|
||||
printf("Failed test \"%s == %s\" for f=%g and g=%g: result %e, expected %e\n", \
|
||||
#arg, #res, f, g, arg, result); \
|
||||
printf("Failed test \"%s == %s\" for F=%g and G=%g: result %e, expected %e\n", \
|
||||
#arg, #res, F, G, arg, result); \
|
||||
}
|
||||
#define FLOATINTTEST(arg,res) \
|
||||
{ double result = (res); \
|
||||
if (arg < result || arg > result) \
|
||||
printf("Failed test \"%s == %s\" for x=%ld and y=%ld: result %e, expected %e\n", \
|
||||
#arg, #res, x, y, arg, result); \
|
||||
printf("Failed test \"%s == %s\" for X=%ld and Y=%ld: result %e, expected %e\n", \
|
||||
#arg, #res, X, Y, arg, result); \
|
||||
}
|
||||
|
||||
extern void call_gen_code();
|
||||
|
|
@ -57,192 +57,192 @@ void do_test()
|
|||
{
|
||||
call_gen_code(testarith);
|
||||
|
||||
INTTEST(r[0], 0);
|
||||
INTTEST(r[1], 1);
|
||||
INTTEST(r[2], -1);
|
||||
INTTEST(r[3], 256);
|
||||
INTTEST(r[4], 65536);
|
||||
INTTEST(r[5], 16777216);
|
||||
INTTEST(r[6], -256);
|
||||
INTTEST(r[7], -65536);
|
||||
INTTEST(r[8], -16777216);
|
||||
INTTEST(R[0], 0);
|
||||
INTTEST(R[1], 1);
|
||||
INTTEST(R[2], -1);
|
||||
INTTEST(R[3], 256);
|
||||
INTTEST(R[4], 65536);
|
||||
INTTEST(R[5], 16777216);
|
||||
INTTEST(R[6], -256);
|
||||
INTTEST(R[7], -65536);
|
||||
INTTEST(R[8], -16777216);
|
||||
|
||||
INTTEST(r[9], (x + y));
|
||||
INTTEST(r[10], (x + 1));
|
||||
INTTEST(r[11], (x + -1));
|
||||
INTTEST(R[9], (X + Y));
|
||||
INTTEST(R[10], (X + 1));
|
||||
INTTEST(R[11], (X + -1));
|
||||
|
||||
INTTEST(r[12], ((long) ((char *)r + 8)));
|
||||
INTTEST(r[13], ((long) ((char *)r + y)));
|
||||
INTTEST(R[12], ((long) ((char *)R + 8)));
|
||||
INTTEST(R[13], ((long) ((char *)R + Y)));
|
||||
|
||||
INTTEST(r[14], (x - y));
|
||||
INTTEST(r[15], (x - 1));
|
||||
INTTEST(r[16], (x - -1));
|
||||
INTTEST(R[14], (X - Y));
|
||||
INTTEST(R[15], (X - 1));
|
||||
INTTEST(R[16], (X - -1));
|
||||
|
||||
INTTEST(r[17], ((long) ((char *)r - 8)));
|
||||
INTTEST(r[18], ((long) ((char *)r - y)));
|
||||
INTTEST(R[17], ((long) ((char *)R - 8)));
|
||||
INTTEST(R[18], ((long) ((char *)R - Y)));
|
||||
|
||||
INTTEST(r[19], (x * 2));
|
||||
INTTEST(r[20], (2 * x));
|
||||
INTTEST(r[21], (x * 16));
|
||||
INTTEST(r[22], (16 * x));
|
||||
INTTEST(r[23], (x * 12345));
|
||||
INTTEST(r[24], (12345 * x));
|
||||
INTTEST(r[25], (x * y));
|
||||
INTTEST(R[19], (X * 2));
|
||||
INTTEST(R[20], (2 * X));
|
||||
INTTEST(R[21], (X * 16));
|
||||
INTTEST(R[22], (16 * X));
|
||||
INTTEST(R[23], (X * 12345));
|
||||
INTTEST(R[24], (12345 * X));
|
||||
INTTEST(R[25], (X * Y));
|
||||
|
||||
INTTEST(r[26], (x / 2));
|
||||
INTTEST(r[27], (x / 16));
|
||||
INTTEST(r[28], (x / 7));
|
||||
INTTEST(r[29], (y != 0 ? x / y : 0));
|
||||
INTTEST(R[26], (X / 2));
|
||||
INTTEST(R[27], (X / 16));
|
||||
INTTEST(R[28], (X / 7));
|
||||
INTTEST(R[29], (Y != 0 ? X / Y : 0));
|
||||
|
||||
INTTEST(r[30], (x % 2));
|
||||
INTTEST(r[31], (x % 16));
|
||||
INTTEST(r[32], (y != 0 ? x % y : 0));
|
||||
INTTEST(R[30], (X % 2));
|
||||
INTTEST(R[31], (X % 16));
|
||||
INTTEST(R[32], (Y != 0 ? X % Y : 0));
|
||||
|
||||
INTTEST(r[33], (x & y));
|
||||
INTTEST(r[34], (x & 3));
|
||||
INTTEST(r[35], (3 & x));
|
||||
INTTEST(R[33], (X & Y));
|
||||
INTTEST(R[34], (X & 3));
|
||||
INTTEST(R[35], (3 & X));
|
||||
|
||||
INTTEST(r[36], (x | y));
|
||||
INTTEST(r[37], (x | 3));
|
||||
INTTEST(r[38], (3 | x));
|
||||
INTTEST(R[36], (X | Y));
|
||||
INTTEST(R[37], (X | 3));
|
||||
INTTEST(R[38], (3 | X));
|
||||
|
||||
INTTEST(r[39], (x ^ y));
|
||||
INTTEST(r[40], (x ^ 3));
|
||||
INTTEST(r[41], (3 ^ x));
|
||||
INTTEST(R[39], (X ^ Y));
|
||||
INTTEST(R[40], (X ^ 3));
|
||||
INTTEST(R[41], (3 ^ X));
|
||||
|
||||
INTTEST(r[42], (x << y));
|
||||
INTTEST(r[43], (x << 1));
|
||||
INTTEST(r[44], (x << 8));
|
||||
INTTEST(R[42], (X << Y));
|
||||
INTTEST(R[43], (X << 1));
|
||||
INTTEST(R[44], (X << 8));
|
||||
|
||||
INTTEST(r[45], ((unsigned long) x >> y));
|
||||
INTTEST(r[46], ((unsigned long) x >> 1));
|
||||
INTTEST(r[47], ((unsigned long) x >> 8));
|
||||
INTTEST(R[45], ((unsigned long) X >> Y));
|
||||
INTTEST(R[46], ((unsigned long) X >> 1));
|
||||
INTTEST(R[47], ((unsigned long) X >> 8));
|
||||
|
||||
INTTEST(r[48], (x >> y));
|
||||
INTTEST(r[49], (x >> 1));
|
||||
INTTEST(r[50], (x >> 8));
|
||||
INTTEST(R[48], (X >> Y));
|
||||
INTTEST(R[49], (X >> 1));
|
||||
INTTEST(R[50], (X >> 8));
|
||||
|
||||
INTTEST(r[51], (x == y));
|
||||
INTTEST(r[52], (x != y));
|
||||
INTTEST(r[53], (x < y));
|
||||
INTTEST(r[54], (x > y));
|
||||
INTTEST(r[55], (x <= y));
|
||||
INTTEST(r[56], (x >= y));
|
||||
INTTEST(r[57], (x == 1));
|
||||
INTTEST(r[58], (x != 1));
|
||||
INTTEST(r[59], (x < 1));
|
||||
INTTEST(r[60], (x > 1));
|
||||
INTTEST(r[61], (x <= 1));
|
||||
INTTEST(r[62], (x >= 1));
|
||||
INTTEST(R[51], (X == Y));
|
||||
INTTEST(R[52], (X != Y));
|
||||
INTTEST(R[53], (X < Y));
|
||||
INTTEST(R[54], (X > Y));
|
||||
INTTEST(R[55], (X <= Y));
|
||||
INTTEST(R[56], (X >= Y));
|
||||
INTTEST(R[57], (X == 1));
|
||||
INTTEST(R[58], (X != 1));
|
||||
INTTEST(R[59], (X < 1));
|
||||
INTTEST(R[60], (X > 1));
|
||||
INTTEST(R[61], (X <= 1));
|
||||
INTTEST(R[62], (X >= 1));
|
||||
|
||||
INTTEST(r[63], ((char *)x == (char *)y));
|
||||
INTTEST(r[64], ((char *)x != (char *)y));
|
||||
INTTEST(r[65], ((char *)x < (char *)y));
|
||||
INTTEST(r[66], ((char *)x > (char *)y));
|
||||
INTTEST(r[67], ((char *)x <= (char *)y));
|
||||
INTTEST(r[68], ((char *)x >= (char *)y));
|
||||
INTTEST(r[69], ((char *)x == (char *)1));
|
||||
INTTEST(r[70], ((char *)x != (char *)1));
|
||||
INTTEST(r[71], ((char *)x < (char *)1));
|
||||
INTTEST(r[72], ((char *)x > (char *)1));
|
||||
INTTEST(r[73], ((char *)x <= (char *)1));
|
||||
INTTEST(r[74], ((char *)x >= (char *)1));
|
||||
INTTEST(R[63], ((char *)X == (char *)Y));
|
||||
INTTEST(R[64], ((char *)X != (char *)Y));
|
||||
INTTEST(R[65], ((char *)X < (char *)Y));
|
||||
INTTEST(R[66], ((char *)X > (char *)Y));
|
||||
INTTEST(R[67], ((char *)X <= (char *)Y));
|
||||
INTTEST(R[68], ((char *)X >= (char *)Y));
|
||||
INTTEST(R[69], ((char *)X == (char *)1));
|
||||
INTTEST(R[70], ((char *)X != (char *)1));
|
||||
INTTEST(R[71], ((char *)X < (char *)1));
|
||||
INTTEST(R[72], ((char *)X > (char *)1));
|
||||
INTTEST(R[73], ((char *)X <= (char *)1));
|
||||
INTTEST(R[74], ((char *)X >= (char *)1));
|
||||
|
||||
INTTEST(r[75], (x + (y << 1)));
|
||||
INTTEST(r[76], (x + (y << 2)));
|
||||
INTTEST(r[77], (x + (y << 3)));
|
||||
INTTEST(r[78], (x - (y << 1)));
|
||||
INTTEST(r[79], (x - (y << 2)));
|
||||
INTTEST(r[80], (x - (y << 3)));
|
||||
INTTEST(R[75], (X + (Y << 1)));
|
||||
INTTEST(R[76], (X + (Y << 2)));
|
||||
INTTEST(R[77], (X + (Y << 3)));
|
||||
INTTEST(R[78], (X - (Y << 1)));
|
||||
INTTEST(R[79], (X - (Y << 2)));
|
||||
INTTEST(R[80], (X - (Y << 3)));
|
||||
|
||||
FLOATTEST(d[0], 0.0);
|
||||
FLOATTEST(d[1], 1.0);
|
||||
FLOATTEST(d[2], -1.0);
|
||||
FLOATTEST(d[3], (f + g));
|
||||
FLOATTEST(d[4], (f - g));
|
||||
FLOATTEST(d[5], (f * g));
|
||||
FLOATTEST(d[6], f / g);
|
||||
FLOATTEST(D[0], 0.0);
|
||||
FLOATTEST(D[1], 1.0);
|
||||
FLOATTEST(D[2], -1.0);
|
||||
FLOATTEST(D[3], (F + G));
|
||||
FLOATTEST(D[4], (F - G));
|
||||
FLOATTEST(D[5], (F * G));
|
||||
FLOATTEST(D[6], F / G);
|
||||
|
||||
FLOATTEST(d[7], (f + (g + 1.0)));
|
||||
FLOATTEST(d[8], (f - (g + 1.0)));
|
||||
FLOATTEST(d[9], (f * (g + 1.0)));
|
||||
FLOATTEST(d[10], f / (g + 1.0));
|
||||
FLOATTEST(D[7], (F + (G + 1.0)));
|
||||
FLOATTEST(D[8], (F - (G + 1.0)));
|
||||
FLOATTEST(D[9], (F * (G + 1.0)));
|
||||
FLOATTEST(D[10], F / (G + 1.0));
|
||||
|
||||
FLOATTEST(d[11], ((f + 1.0) + g));
|
||||
FLOATTEST(d[12], ((f + 1.0) - g));
|
||||
FLOATTEST(d[13], ((f + 1.0) * g));
|
||||
FLOATTEST(d[14], (f + 1.0) / g);
|
||||
FLOATTEST(D[11], ((F + 1.0) + G));
|
||||
FLOATTEST(D[12], ((F + 1.0) - G));
|
||||
FLOATTEST(D[13], ((F + 1.0) * G));
|
||||
FLOATTEST(D[14], (F + 1.0) / G);
|
||||
|
||||
FLOATTEST(d[15], ((f + 1.0) + (g + 1.0)));
|
||||
FLOATTEST(d[16], ((f + 1.0) - (g + 1.0)));
|
||||
FLOATTEST(d[17], ((f + 1.0) * (g + 1.0)));
|
||||
FLOATTEST(d[18], (f + 1.0) / (g + 1.0));
|
||||
FLOATTEST(D[15], ((F + 1.0) + (G + 1.0)));
|
||||
FLOATTEST(D[16], ((F + 1.0) - (G + 1.0)));
|
||||
FLOATTEST(D[17], ((F + 1.0) * (G + 1.0)));
|
||||
FLOATTEST(D[18], (F + 1.0) / (G + 1.0));
|
||||
|
||||
INTFLOATTEST(r[81], (f == g));
|
||||
INTFLOATTEST(r[82], (f != g));
|
||||
INTFLOATTEST(r[83], (f < g));
|
||||
INTFLOATTEST(r[84], (f > g));
|
||||
INTFLOATTEST(r[85], (f <= g));
|
||||
INTFLOATTEST(r[86], (f >= g));
|
||||
INTFLOATTEST(R[81], (F == G));
|
||||
INTFLOATTEST(R[82], (F != G));
|
||||
INTFLOATTEST(R[83], (F < G));
|
||||
INTFLOATTEST(R[84], (F > G));
|
||||
INTFLOATTEST(R[85], (F <= G));
|
||||
INTFLOATTEST(R[86], (F >= G));
|
||||
|
||||
FLOATINTTEST(d[19], (double) x);
|
||||
INTFLOATTEST(r[87], (long) f);
|
||||
FLOATINTTEST(D[19], (double) X);
|
||||
INTFLOATTEST(R[87], (long) F);
|
||||
|
||||
INTTEST(r[88], (x >= 0) && (x < y));
|
||||
INTTEST(r[89], (0 < y));
|
||||
INTTEST(r[90], (5 < y));
|
||||
INTTEST(R[88], (X >= 0) && (X < Y));
|
||||
INTTEST(R[89], (0 < Y));
|
||||
INTTEST(R[90], (5 < Y));
|
||||
|
||||
INTFLOATTEST(r[91], (f == g));
|
||||
INTFLOATTEST(r[92], (f != g));
|
||||
INTFLOATTEST(r[93], (f < g));
|
||||
INTFLOATTEST(r[94], (f > g));
|
||||
INTFLOATTEST(r[95], (f <= g));
|
||||
INTFLOATTEST(r[96], (f >= g));
|
||||
INTFLOATTEST(R[91], (F == G));
|
||||
INTFLOATTEST(R[92], (F != G));
|
||||
INTFLOATTEST(R[93], (F < G));
|
||||
INTFLOATTEST(R[94], (F > G));
|
||||
INTFLOATTEST(R[95], (F <= G));
|
||||
INTFLOATTEST(R[96], (F >= G));
|
||||
|
||||
INTFLOATTEST(r[97], (f + 1.0 == g + 1.0));
|
||||
INTFLOATTEST(r[98], (f + 1.0 != g + 1.0));
|
||||
INTFLOATTEST(r[99], (f + 1.0 < g + 1.0));
|
||||
INTFLOATTEST(r[100], (f + 1.0 > g + 1.0));
|
||||
INTFLOATTEST(r[101], (f + 1.0 <= g + 1.0));
|
||||
INTFLOATTEST(r[102], (f + 1.0 >= g + 1.0));
|
||||
INTFLOATTEST(R[97], (F + 1.0 == G + 1.0));
|
||||
INTFLOATTEST(R[98], (F + 1.0 != G + 1.0));
|
||||
INTFLOATTEST(R[99], (F + 1.0 < G + 1.0));
|
||||
INTFLOATTEST(R[100], (F + 1.0 > G + 1.0));
|
||||
INTFLOATTEST(R[101], (F + 1.0 <= G + 1.0));
|
||||
INTFLOATTEST(R[102], (F + 1.0 >= G + 1.0));
|
||||
|
||||
INTFLOATTEST(r[103], (f == g + 1.0));
|
||||
INTFLOATTEST(r[104], (f != g + 1.0));
|
||||
INTFLOATTEST(r[105], (f < g + 1.0));
|
||||
INTFLOATTEST(r[106], (f > g + 1.0));
|
||||
INTFLOATTEST(r[107], (f <= g + 1.0));
|
||||
INTFLOATTEST(r[108], (f >= g + 1.0));
|
||||
INTFLOATTEST(R[103], (F == G + 1.0));
|
||||
INTFLOATTEST(R[104], (F != G + 1.0));
|
||||
INTFLOATTEST(R[105], (F < G + 1.0));
|
||||
INTFLOATTEST(R[106], (F > G + 1.0));
|
||||
INTFLOATTEST(R[107], (F <= G + 1.0));
|
||||
INTFLOATTEST(R[108], (F >= G + 1.0));
|
||||
|
||||
INTFLOATTEST(r[109], (f + 1.0 == g));
|
||||
INTFLOATTEST(r[110], (f + 1.0 != g));
|
||||
INTFLOATTEST(r[111], (f + 1.0 < g));
|
||||
INTFLOATTEST(r[112], (f + 1.0 > g));
|
||||
INTFLOATTEST(r[113], (f + 1.0 <= g));
|
||||
INTFLOATTEST(r[114], (f + 1.0 >= g));
|
||||
INTFLOATTEST(R[109], (F + 1.0 == G));
|
||||
INTFLOATTEST(R[110], (F + 1.0 != G));
|
||||
INTFLOATTEST(R[111], (F + 1.0 < G));
|
||||
INTFLOATTEST(R[112], (F + 1.0 > G));
|
||||
INTFLOATTEST(R[113], (F + 1.0 <= G));
|
||||
INTFLOATTEST(R[114], (F + 1.0 >= G));
|
||||
|
||||
FLOATINTTEST(d[20], ((double) x) + 1.0);
|
||||
INTFLOATTEST(r[115], (long)(f + 1.0));
|
||||
FLOATINTTEST(D[20], ((double) X) + 1.0);
|
||||
INTFLOATTEST(R[115], (long)(F + 1.0));
|
||||
|
||||
FLOATTEST(d[21], f + g);
|
||||
FLOATTEST(d[22], g + f);
|
||||
FLOATTEST(d[23], f - g);
|
||||
FLOATTEST(d[24], g - f);
|
||||
FLOATTEST(d[25], f * g);
|
||||
FLOATTEST(d[26], g * f);
|
||||
FLOATTEST(d[27], f / g);
|
||||
FLOATTEST(d[28], g / f);
|
||||
FLOATTEST(D[21], F + G);
|
||||
FLOATTEST(D[22], G + F);
|
||||
FLOATTEST(D[23], F - G);
|
||||
FLOATTEST(D[24], G - F);
|
||||
FLOATTEST(D[25], F * G);
|
||||
FLOATTEST(D[26], G * F);
|
||||
FLOATTEST(D[27], F / G);
|
||||
FLOATTEST(D[28], G / F);
|
||||
|
||||
FLOATTEST(d[29], (f * 2.0) + g);
|
||||
FLOATTEST(d[30], g + (f * 2.0));
|
||||
FLOATTEST(d[31], (f * 2.0) - g);
|
||||
FLOATTEST(d[32], g - (f * 2.0));
|
||||
FLOATTEST(d[33], (f + 2.0) * g);
|
||||
FLOATTEST(d[34], g * (f + 2.0));
|
||||
FLOATTEST(d[35], (f * 2.0) / g);
|
||||
FLOATTEST(d[36], g / (f * 2.0));
|
||||
FLOATTEST(D[29], (F * 2.0) + G);
|
||||
FLOATTEST(D[30], G + (F * 2.0));
|
||||
FLOATTEST(D[31], (F * 2.0) - G);
|
||||
FLOATTEST(D[32], G - (F * 2.0));
|
||||
FLOATTEST(D[33], (F + 2.0) * G);
|
||||
FLOATTEST(D[34], G * (F + 2.0));
|
||||
FLOATTEST(D[35], (F * 2.0) / G);
|
||||
FLOATTEST(D[36], G / (F * 2.0));
|
||||
|
||||
FLOATTEST(d[37], - f);
|
||||
FLOATTEST(d[38], fabs(f));
|
||||
FLOATTEST(D[37], - F);
|
||||
FLOATTEST(D[38], fabs(F));
|
||||
}
|
||||
|
||||
#ifdef __i386__
|
||||
|
|
@ -275,32 +275,34 @@ int main(argc, argv)
|
|||
init_ieee_floats();
|
||||
|
||||
if (argc >= 5) {
|
||||
x = atoi(argv[1]);
|
||||
y = atoi(argv[2]);
|
||||
sscanf(argv[3], "%lf", &f);
|
||||
sscanf(argv[4], "%lf", &g);
|
||||
X = atoi(argv[1]);
|
||||
Y = atoi(argv[2]);
|
||||
sscanf(argv[3], "%lf", &F);
|
||||
sscanf(argv[4], "%lf", &G);
|
||||
do_test();
|
||||
return 0;
|
||||
}
|
||||
for(y = -2; y <= 2; y++) {
|
||||
for (x = -2; x <= 2; x++) {
|
||||
f = x; g = y; do_test();
|
||||
for(Y = -2; Y <= 2; Y++) {
|
||||
for (X = -2; X <= 2; X++) {
|
||||
F = X; G = Y; do_test();
|
||||
}
|
||||
}
|
||||
weird[0] = 0.0;
|
||||
weird[1] = 1.0 / weird[0]; /* +infty */
|
||||
weird[2] = -1.0 / weird[0]; /* -infty */
|
||||
weird[3] = 0.0 / weird[0]; /* NaN */
|
||||
for (x = 0; x < 4; x++) {
|
||||
for (y = 0; y < 4; y++) {
|
||||
f = weird[x]; g = weird[y]; do_test();
|
||||
if (!(argc >= 2 && strcmp(argv[1], "noinf"))) {
|
||||
weird[0] = 0.0;
|
||||
weird[1] = 1.0 / weird[0]; /* +infty */
|
||||
weird[2] = -1.0 / weird[0]; /* -infty */
|
||||
weird[3] = 0.0 / weird[0]; /* NaN */
|
||||
for (X = 0; X < 4; X++) {
|
||||
for (Y = 0; Y < 4; Y++) {
|
||||
F = weird[X]; G = weird[Y]; do_test();
|
||||
}
|
||||
}
|
||||
}
|
||||
while(1) {
|
||||
x = rand() & 0x1FFFFFFF - 0x10000000;
|
||||
y = rand() & 0x1FFFFFFF - 0x10000000;
|
||||
f = x / 1e3;
|
||||
g = y / 1e3;
|
||||
X = rand() & 0x1FFFFFFF - 0x10000000;
|
||||
Y = rand() & 0x1FFFFFFF - 0x10000000;
|
||||
F = X / 1e3;
|
||||
G = Y / 1e3;
|
||||
do_test();
|
||||
printf("."); fflush(stdout);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue