Mercurial > jdk8-mips64-public > hotspot / changeset
changeset
8001183: incorrect results of char vectors right shift operaiton
Tue, 23 Oct 2012 13:06:37 -0700
- author
- kvn
- date
- Tue, 23 Oct 2012 13:06:37 -0700
- changeset 4204
- b2c669fd8114
- parent 4203
- fd1d564dd460
- child 4205
- a3ecd773a7b9
8001183: incorrect results of char vectors right shift operaiton
Summary: do vector right shift operation for small int types only after loads
Reviewed-by: jrose, dlong
1.1 --- a/src/cpu/x86/vm/x86.ad Mon Oct 22 16:56:03 2012 -0700 1.2 +++ b/src/cpu/x86/vm/x86.ad Tue Oct 23 13:06:37 2012 -0700 1.3 @@ -4102,9 +4102,158 @@ 1.4 1.5 // ----------------------- LogicalRightShift ----------------------------------- 1.6 1.7 -// Shorts/Chars vector logical right shift produces incorrect Java result 1.8 +// Shorts vector logical right shift produces incorrect Java result 1.9 // for negative data because java code convert short value into int with 1.10 -// sign extension before a shift. 1.11 +// sign extension before a shift. But char vectors are fine since chars are 1.12 +// unsigned values. 1.13 + 1.14 +instruct vsrl2S(vecS dst, vecS shift) %{ 1.15 + predicate(n->as_Vector()->length() == 2); 1.16 + match(Set dst (URShiftVS dst shift)); 1.17 + format %{ "psrlw $dst,$shift\t! logical right shift packed2S" %} 1.18 + ins_encode %{ 1.19 + __ psrlw($dst$$XMMRegister, $shift$$XMMRegister); 1.20 + %} 1.21 + ins_pipe( pipe_slow ); 1.22 +%} 1.23 + 1.24 +instruct vsrl2S_imm(vecS dst, immI8 shift) %{ 1.25 + predicate(n->as_Vector()->length() == 2); 1.26 + match(Set dst (URShiftVS dst shift)); 1.27 + format %{ "psrlw $dst,$shift\t! logical right shift packed2S" %} 1.28 + ins_encode %{ 1.29 + __ psrlw($dst$$XMMRegister, (int)$shift$$constant); 1.30 + %} 1.31 + ins_pipe( pipe_slow ); 1.32 +%} 1.33 + 1.34 +instruct vsrl2S_reg(vecS dst, vecS src, vecS shift) %{ 1.35 + predicate(UseAVX > 0 && n->as_Vector()->length() == 2); 1.36 + match(Set dst (URShiftVS src shift)); 1.37 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed2S" %} 1.38 + ins_encode %{ 1.39 + bool vector256 = false; 1.40 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, $shift$$XMMRegister, vector256); 1.41 + %} 1.42 + ins_pipe( pipe_slow ); 1.43 +%} 1.44 + 1.45 +instruct vsrl2S_reg_imm(vecS dst, vecS src, immI8 shift) %{ 1.46 + predicate(UseAVX > 0 && n->as_Vector()->length() == 2); 1.47 + match(Set dst (URShiftVS src shift)); 1.48 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed2S" %} 1.49 + ins_encode %{ 1.50 + bool vector256 = false; 1.51 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, (int)$shift$$constant, vector256); 1.52 + %} 1.53 + ins_pipe( pipe_slow ); 1.54 +%} 1.55 + 1.56 +instruct vsrl4S(vecD dst, vecS shift) %{ 1.57 + predicate(n->as_Vector()->length() == 4); 1.58 + match(Set dst (URShiftVS dst shift)); 1.59 + format %{ "psrlw $dst,$shift\t! logical right shift packed4S" %} 1.60 + ins_encode %{ 1.61 + __ psrlw($dst$$XMMRegister, $shift$$XMMRegister); 1.62 + %} 1.63 + ins_pipe( pipe_slow ); 1.64 +%} 1.65 + 1.66 +instruct vsrl4S_imm(vecD dst, immI8 shift) %{ 1.67 + predicate(n->as_Vector()->length() == 4); 1.68 + match(Set dst (URShiftVS dst shift)); 1.69 + format %{ "psrlw $dst,$shift\t! logical right shift packed4S" %} 1.70 + ins_encode %{ 1.71 + __ psrlw($dst$$XMMRegister, (int)$shift$$constant); 1.72 + %} 1.73 + ins_pipe( pipe_slow ); 1.74 +%} 1.75 + 1.76 +instruct vsrl4S_reg(vecD dst, vecD src, vecS shift) %{ 1.77 + predicate(UseAVX > 0 && n->as_Vector()->length() == 4); 1.78 + match(Set dst (URShiftVS src shift)); 1.79 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed4S" %} 1.80 + ins_encode %{ 1.81 + bool vector256 = false; 1.82 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, $shift$$XMMRegister, vector256); 1.83 + %} 1.84 + ins_pipe( pipe_slow ); 1.85 +%} 1.86 + 1.87 +instruct vsrl4S_reg_imm(vecD dst, vecD src, immI8 shift) %{ 1.88 + predicate(UseAVX > 0 && n->as_Vector()->length() == 4); 1.89 + match(Set dst (URShiftVS src shift)); 1.90 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed4S" %} 1.91 + ins_encode %{ 1.92 + bool vector256 = false; 1.93 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, (int)$shift$$constant, vector256); 1.94 + %} 1.95 + ins_pipe( pipe_slow ); 1.96 +%} 1.97 + 1.98 +instruct vsrl8S(vecX dst, vecS shift) %{ 1.99 + predicate(n->as_Vector()->length() == 8); 1.100 + match(Set dst (URShiftVS dst shift)); 1.101 + format %{ "psrlw $dst,$shift\t! logical right shift packed8S" %} 1.102 + ins_encode %{ 1.103 + __ psrlw($dst$$XMMRegister, $shift$$XMMRegister); 1.104 + %} 1.105 + ins_pipe( pipe_slow ); 1.106 +%} 1.107 + 1.108 +instruct vsrl8S_imm(vecX dst, immI8 shift) %{ 1.109 + predicate(n->as_Vector()->length() == 8); 1.110 + match(Set dst (URShiftVS dst shift)); 1.111 + format %{ "psrlw $dst,$shift\t! logical right shift packed8S" %} 1.112 + ins_encode %{ 1.113 + __ psrlw($dst$$XMMRegister, (int)$shift$$constant); 1.114 + %} 1.115 + ins_pipe( pipe_slow ); 1.116 +%} 1.117 + 1.118 +instruct vsrl8S_reg(vecX dst, vecX src, vecS shift) %{ 1.119 + predicate(UseAVX > 0 && n->as_Vector()->length() == 8); 1.120 + match(Set dst (URShiftVS src shift)); 1.121 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed8S" %} 1.122 + ins_encode %{ 1.123 + bool vector256 = false; 1.124 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, $shift$$XMMRegister, vector256); 1.125 + %} 1.126 + ins_pipe( pipe_slow ); 1.127 +%} 1.128 + 1.129 +instruct vsrl8S_reg_imm(vecX dst, vecX src, immI8 shift) %{ 1.130 + predicate(UseAVX > 0 && n->as_Vector()->length() == 8); 1.131 + match(Set dst (URShiftVS src shift)); 1.132 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed8S" %} 1.133 + ins_encode %{ 1.134 + bool vector256 = false; 1.135 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, (int)$shift$$constant, vector256); 1.136 + %} 1.137 + ins_pipe( pipe_slow ); 1.138 +%} 1.139 + 1.140 +instruct vsrl16S_reg(vecY dst, vecY src, vecS shift) %{ 1.141 + predicate(UseAVX > 1 && n->as_Vector()->length() == 16); 1.142 + match(Set dst (URShiftVS src shift)); 1.143 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed16S" %} 1.144 + ins_encode %{ 1.145 + bool vector256 = true; 1.146 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, $shift$$XMMRegister, vector256); 1.147 + %} 1.148 + ins_pipe( pipe_slow ); 1.149 +%} 1.150 + 1.151 +instruct vsrl16S_reg_imm(vecY dst, vecY src, immI8 shift) %{ 1.152 + predicate(UseAVX > 1 && n->as_Vector()->length() == 16); 1.153 + match(Set dst (URShiftVS src shift)); 1.154 + format %{ "vpsrlw $dst,$src,$shift\t! logical right shift packed16S" %} 1.155 + ins_encode %{ 1.156 + bool vector256 = true; 1.157 + __ vpsrlw($dst$$XMMRegister, $src$$XMMRegister, (int)$shift$$constant, vector256); 1.158 + %} 1.159 + ins_pipe( pipe_slow ); 1.160 +%} 1.161 1.162 // Integers vector logical right shift 1.163 instruct vsrl2I(vecD dst, vecS shift) %{
2.1 --- a/src/share/vm/opto/superword.cpp Mon Oct 22 16:56:03 2012 -0700 2.2 +++ b/src/share/vm/opto/superword.cpp Tue Oct 23 13:06:37 2012 -0700 2.3 @@ -1776,16 +1776,15 @@ 2.4 set_velt_type(n, container_type(n)); 2.5 } 2.6 2.7 - // Propagate narrowed type backwards through operations 2.8 + // Propagate integer narrowed type backwards through operations 2.9 // that don't depend on higher order bits 2.10 for (int i = _block.length() - 1; i >= 0; i--) { 2.11 Node* n = _block.at(i); 2.12 // Only integer types need be examined 2.13 - const Type* vt = velt_type(n); 2.14 - if (vt->basic_type() == T_INT) { 2.15 + const Type* vtn = velt_type(n); 2.16 + if (vtn->basic_type() == T_INT) { 2.17 uint start, end; 2.18 VectorNode::vector_operands(n, &start, &end); 2.19 - const Type* vt = velt_type(n); 2.20 2.21 for (uint j = start; j < end; j++) { 2.22 Node* in = n->in(j); 2.23 @@ -1801,6 +1800,24 @@ 2.24 } 2.25 } 2.26 if (same_type) { 2.27 + // For right shifts of small integer types (bool, byte, char, short) 2.28 + // we need precise information about sign-ness. Only Load nodes have 2.29 + // this information because Store nodes are the same for signed and 2.30 + // unsigned values. And any arithmetic operation after a load may 2.31 + // expand a value to signed Int so such right shifts can't be used 2.32 + // because vector elements do not have upper bits of Int. 2.33 + const Type* vt = vtn; 2.34 + if (VectorNode::is_shift(in)) { 2.35 + Node* load = in->in(1); 2.36 + if (load->is_Load() && (velt_type(load)->basic_type() == T_INT)) { 2.37 + vt = velt_type(load); 2.38 + } else if (in->Opcode() != Op_LShiftI) { 2.39 + // Widen type to Int to avoid creation of right shift vector 2.40 + // (align + data_size(s1) check in stmts_can_pack() will fail). 2.41 + // Note, left shifts work regardless type. 2.42 + vt = TypeInt::INT; 2.43 + } 2.44 + } 2.45 set_velt_type(in, vt); 2.46 } 2.47 } 2.48 @@ -1841,7 +1858,20 @@ 2.49 // Smallest type containing range of values 2.50 const Type* SuperWord::container_type(Node* n) { 2.51 if (n->is_Mem()) { 2.52 - return Type::get_const_basic_type(n->as_Mem()->memory_type()); 2.53 + BasicType bt = n->as_Mem()->memory_type(); 2.54 + if (n->is_Store() && (bt == T_CHAR)) { 2.55 + // Use T_SHORT type instead of T_CHAR for stored values because any 2.56 + // preceding arithmetic operation extends values to signed Int. 2.57 + bt = T_SHORT; 2.58 + } 2.59 + if (n->Opcode() == Op_LoadUB) { 2.60 + // Adjust type for unsigned byte loads, it is important for right shifts. 2.61 + // T_BOOLEAN is used because there is no basic type representing type 2.62 + // TypeInt::UBYTE. Use of T_BOOLEAN for vectors is fine because only 2.63 + // size (one byte) and sign is important. 2.64 + bt = T_BOOLEAN; 2.65 + } 2.66 + return Type::get_const_basic_type(bt); 2.67 } 2.68 const Type* t = _igvn.type(n); 2.69 if (t->basic_type() == T_INT) {
3.1 --- a/src/share/vm/opto/vectornode.cpp Mon Oct 22 16:56:03 2012 -0700 3.2 +++ b/src/share/vm/opto/vectornode.cpp Tue Oct 23 13:06:37 2012 -0700 3.3 @@ -103,9 +103,9 @@ 3.4 return Op_LShiftVL; 3.5 case Op_RShiftI: 3.6 switch (bt) { 3.7 - case T_BOOLEAN: 3.8 + case T_BOOLEAN:return Op_URShiftVB; // boolean is unsigned value 3.9 + case T_CHAR: return Op_URShiftVS; // char is unsigned value 3.10 case T_BYTE: return Op_RShiftVB; 3.11 - case T_CHAR: 3.12 case T_SHORT: return Op_RShiftVS; 3.13 case T_INT: return Op_RShiftVI; 3.14 } 3.15 @@ -115,10 +115,14 @@ 3.16 return Op_RShiftVL; 3.17 case Op_URShiftI: 3.18 switch (bt) { 3.19 - case T_BOOLEAN: 3.20 - case T_BYTE: return Op_URShiftVB; 3.21 - case T_CHAR: 3.22 - case T_SHORT: return Op_URShiftVS; 3.23 + case T_BOOLEAN:return Op_URShiftVB; 3.24 + case T_CHAR: return Op_URShiftVS; 3.25 + case T_BYTE: 3.26 + case T_SHORT: return 0; // Vector logical right shift for signed short 3.27 + // values produces incorrect Java result for 3.28 + // negative data because java code should convert 3.29 + // a short value into int value with sign 3.30 + // extension before a shift. 3.31 case T_INT: return Op_URShiftVI; 3.32 } 3.33 ShouldNotReachHere();
4.1 --- a/test/compiler/6340864/TestByteVect.java Mon Oct 22 16:56:03 2012 -0700 4.2 +++ b/test/compiler/6340864/TestByteVect.java Tue Oct 23 13:06:37 2012 -0700 4.3 @@ -33,7 +33,7 @@ 4.4 public class TestByteVect { 4.5 private static final int ARRLEN = 997; 4.6 private static final int ITERS = 11000; 4.7 - private static final int ADD_INIT = 0; 4.8 + private static final int ADD_INIT = 63; 4.9 private static final int BIT_MASK = 0xB7; 4.10 private static final int VALUE = 3; 4.11 private static final int SHIFT = 8; 4.12 @@ -76,6 +76,7 @@ 4.13 test_subc(a0, a1); 4.14 test_subv(a0, a1, (byte)VALUE); 4.15 test_suba(a0, a1, a2); 4.16 + 4.17 test_mulc(a0, a1); 4.18 test_mulv(a0, a1, (byte)VALUE); 4.19 test_mula(a0, a1, a2); 4.20 @@ -88,6 +89,7 @@ 4.21 test_divc_n(a0, a1); 4.22 test_divv(a0, a1, (byte)-VALUE); 4.23 test_diva(a0, a1, a3); 4.24 + 4.25 test_andc(a0, a1); 4.26 test_andv(a0, a1, (byte)BIT_MASK); 4.27 test_anda(a0, a1, a4); 4.28 @@ -97,30 +99,49 @@ 4.29 test_xorc(a0, a1); 4.30 test_xorv(a0, a1, (byte)BIT_MASK); 4.31 test_xora(a0, a1, a4); 4.32 + 4.33 test_sllc(a0, a1); 4.34 test_sllv(a0, a1, VALUE); 4.35 test_srlc(a0, a1); 4.36 test_srlv(a0, a1, VALUE); 4.37 test_srac(a0, a1); 4.38 test_srav(a0, a1, VALUE); 4.39 + 4.40 test_sllc_n(a0, a1); 4.41 test_sllv(a0, a1, -VALUE); 4.42 test_srlc_n(a0, a1); 4.43 test_srlv(a0, a1, -VALUE); 4.44 test_srac_n(a0, a1); 4.45 test_srav(a0, a1, -VALUE); 4.46 + 4.47 test_sllc_o(a0, a1); 4.48 test_sllv(a0, a1, SHIFT); 4.49 test_srlc_o(a0, a1); 4.50 test_srlv(a0, a1, SHIFT); 4.51 test_srac_o(a0, a1); 4.52 test_srav(a0, a1, SHIFT); 4.53 + 4.54 test_sllc_on(a0, a1); 4.55 test_sllv(a0, a1, -SHIFT); 4.56 test_srlc_on(a0, a1); 4.57 test_srlv(a0, a1, -SHIFT); 4.58 test_srac_on(a0, a1); 4.59 test_srav(a0, a1, -SHIFT); 4.60 + 4.61 + test_sllc_add(a0, a1); 4.62 + test_sllv_add(a0, a1, ADD_INIT); 4.63 + test_srlc_add(a0, a1); 4.64 + test_srlv_add(a0, a1, ADD_INIT); 4.65 + test_srac_add(a0, a1); 4.66 + test_srav_add(a0, a1, ADD_INIT); 4.67 + 4.68 + test_sllc_and(a0, a1); 4.69 + test_sllv_and(a0, a1, BIT_MASK); 4.70 + test_srlc_and(a0, a1); 4.71 + test_srlv_and(a0, a1, BIT_MASK); 4.72 + test_srac_and(a0, a1); 4.73 + test_srav_and(a0, a1, BIT_MASK); 4.74 + 4.75 test_pack2(p2, a1); 4.76 test_unpack2(a0, p2); 4.77 test_pack2_swap(p2, a1); 4.78 @@ -369,6 +390,60 @@ 4.79 errn += verify("test_srav_on: ", i, a0[i], (byte)((byte)(ADD_INIT+i)>>(-SHIFT))); 4.80 } 4.81 4.82 + test_sllc_add(a0, a1); 4.83 + for (int i=0; i<ARRLEN; i++) { 4.84 + errn += verify("test_sllc_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 4.85 + } 4.86 + test_sllv_add(a0, a1, ADD_INIT); 4.87 + for (int i=0; i<ARRLEN; i++) { 4.88 + errn += verify("test_sllv_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 4.89 + } 4.90 + 4.91 + test_srlc_add(a0, a1); 4.92 + for (int i=0; i<ARRLEN; i++) { 4.93 + errn += verify("test_srlc_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 4.94 + } 4.95 + test_srlv_add(a0, a1, ADD_INIT); 4.96 + for (int i=0; i<ARRLEN; i++) { 4.97 + errn += verify("test_srlv_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 4.98 + } 4.99 + 4.100 + test_srac_add(a0, a1); 4.101 + for (int i=0; i<ARRLEN; i++) { 4.102 + errn += verify("test_srac_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 4.103 + } 4.104 + test_srav_add(a0, a1, ADD_INIT); 4.105 + for (int i=0; i<ARRLEN; i++) { 4.106 + errn += verify("test_srav_add: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 4.107 + } 4.108 + 4.109 + test_sllc_and(a0, a1); 4.110 + for (int i=0; i<ARRLEN; i++) { 4.111 + errn += verify("test_sllc_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 4.112 + } 4.113 + test_sllv_and(a0, a1, BIT_MASK); 4.114 + for (int i=0; i<ARRLEN; i++) { 4.115 + errn += verify("test_sllv_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 4.116 + } 4.117 + 4.118 + test_srlc_and(a0, a1); 4.119 + for (int i=0; i<ARRLEN; i++) { 4.120 + errn += verify("test_srlc_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 4.121 + } 4.122 + test_srlv_and(a0, a1, BIT_MASK); 4.123 + for (int i=0; i<ARRLEN; i++) { 4.124 + errn += verify("test_srlv_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 4.125 + } 4.126 + 4.127 + test_srac_and(a0, a1); 4.128 + for (int i=0; i<ARRLEN; i++) { 4.129 + errn += verify("test_srac_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 4.130 + } 4.131 + test_srav_and(a0, a1, BIT_MASK); 4.132 + for (int i=0; i<ARRLEN; i++) { 4.133 + errn += verify("test_srav_and: ", i, a0[i], (byte)(((byte)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 4.134 + } 4.135 + 4.136 test_pack2(p2, a1); 4.137 for (int i=0; i<ARRLEN/2; i++) { 4.138 errn += verify("test_pack2: ", i, p2[i], (short)(((short)(ADD_INIT+2*i) & 0xFF) | ((short)(ADD_INIT+2*i+1) << 8))); 4.139 @@ -805,6 +880,84 @@ 4.140 4.141 start = System.currentTimeMillis(); 4.142 for (int i=0; i<ITERS; i++) { 4.143 + test_sllc_add(a0, a1); 4.144 + } 4.145 + end = System.currentTimeMillis(); 4.146 + System.out.println("test_sllc_add: " + (end - start)); 4.147 + start = System.currentTimeMillis(); 4.148 + for (int i=0; i<ITERS; i++) { 4.149 + test_sllv_add(a0, a1, ADD_INIT); 4.150 + } 4.151 + end = System.currentTimeMillis(); 4.152 + System.out.println("test_sllv_add: " + (end - start)); 4.153 + 4.154 + start = System.currentTimeMillis(); 4.155 + for (int i=0; i<ITERS; i++) { 4.156 + test_srlc_add(a0, a1); 4.157 + } 4.158 + end = System.currentTimeMillis(); 4.159 + System.out.println("test_srlc_add: " + (end - start)); 4.160 + start = System.currentTimeMillis(); 4.161 + for (int i=0; i<ITERS; i++) { 4.162 + test_srlv_add(a0, a1, ADD_INIT); 4.163 + } 4.164 + end = System.currentTimeMillis(); 4.165 + System.out.println("test_srlv_add: " + (end - start)); 4.166 + 4.167 + start = System.currentTimeMillis(); 4.168 + for (int i=0; i<ITERS; i++) { 4.169 + test_srac_add(a0, a1); 4.170 + } 4.171 + end = System.currentTimeMillis(); 4.172 + System.out.println("test_srac_add: " + (end - start)); 4.173 + start = System.currentTimeMillis(); 4.174 + for (int i=0; i<ITERS; i++) { 4.175 + test_srav_add(a0, a1, ADD_INIT); 4.176 + } 4.177 + end = System.currentTimeMillis(); 4.178 + System.out.println("test_srav_add: " + (end - start)); 4.179 + 4.180 + start = System.currentTimeMillis(); 4.181 + for (int i=0; i<ITERS; i++) { 4.182 + test_sllc_and(a0, a1); 4.183 + } 4.184 + end = System.currentTimeMillis(); 4.185 + System.out.println("test_sllc_and: " + (end - start)); 4.186 + start = System.currentTimeMillis(); 4.187 + for (int i=0; i<ITERS; i++) { 4.188 + test_sllv_and(a0, a1, BIT_MASK); 4.189 + } 4.190 + end = System.currentTimeMillis(); 4.191 + System.out.println("test_sllv_and: " + (end - start)); 4.192 + 4.193 + start = System.currentTimeMillis(); 4.194 + for (int i=0; i<ITERS; i++) { 4.195 + test_srlc_and(a0, a1); 4.196 + } 4.197 + end = System.currentTimeMillis(); 4.198 + System.out.println("test_srlc_and: " + (end - start)); 4.199 + start = System.currentTimeMillis(); 4.200 + for (int i=0; i<ITERS; i++) { 4.201 + test_srlv_and(a0, a1, BIT_MASK); 4.202 + } 4.203 + end = System.currentTimeMillis(); 4.204 + System.out.println("test_srlv_and: " + (end - start)); 4.205 + 4.206 + start = System.currentTimeMillis(); 4.207 + for (int i=0; i<ITERS; i++) { 4.208 + test_srac_and(a0, a1); 4.209 + } 4.210 + end = System.currentTimeMillis(); 4.211 + System.out.println("test_srac_and: " + (end - start)); 4.212 + start = System.currentTimeMillis(); 4.213 + for (int i=0; i<ITERS; i++) { 4.214 + test_srav_and(a0, a1, BIT_MASK); 4.215 + } 4.216 + end = System.currentTimeMillis(); 4.217 + System.out.println("test_srav_and: " + (end - start)); 4.218 + 4.219 + start = System.currentTimeMillis(); 4.220 + for (int i=0; i<ITERS; i++) { 4.221 test_pack2(p2, a1); 4.222 } 4.223 end = System.currentTimeMillis(); 4.224 @@ -1036,6 +1189,26 @@ 4.225 a0[i] = (byte)(a1[i]<<b); 4.226 } 4.227 } 4.228 + static void test_sllc_add(byte[] a0, byte[] a1) { 4.229 + for (int i = 0; i < a0.length; i+=1) { 4.230 + a0[i] = (byte)((a1[i] + ADD_INIT)<<VALUE); 4.231 + } 4.232 + } 4.233 + static void test_sllv_add(byte[] a0, byte[] a1, int b) { 4.234 + for (int i = 0; i < a0.length; i+=1) { 4.235 + a0[i] = (byte)((a1[i] + b)<<VALUE); 4.236 + } 4.237 + } 4.238 + static void test_sllc_and(byte[] a0, byte[] a1) { 4.239 + for (int i = 0; i < a0.length; i+=1) { 4.240 + a0[i] = (byte)((a1[i] & BIT_MASK)<<VALUE); 4.241 + } 4.242 + } 4.243 + static void test_sllv_and(byte[] a0, byte[] a1, int b) { 4.244 + for (int i = 0; i < a0.length; i+=1) { 4.245 + a0[i] = (byte)((a1[i] & b)<<VALUE); 4.246 + } 4.247 + } 4.248 4.249 static void test_srlc(byte[] a0, byte[] a1) { 4.250 for (int i = 0; i < a0.length; i+=1) { 4.251 @@ -1062,6 +1235,26 @@ 4.252 a0[i] = (byte)(a1[i]>>>b); 4.253 } 4.254 } 4.255 + static void test_srlc_add(byte[] a0, byte[] a1) { 4.256 + for (int i = 0; i < a0.length; i+=1) { 4.257 + a0[i] = (byte)((a1[i] + ADD_INIT)>>>VALUE); 4.258 + } 4.259 + } 4.260 + static void test_srlv_add(byte[] a0, byte[] a1, int b) { 4.261 + for (int i = 0; i < a0.length; i+=1) { 4.262 + a0[i] = (byte)((a1[i] + b)>>>VALUE); 4.263 + } 4.264 + } 4.265 + static void test_srlc_and(byte[] a0, byte[] a1) { 4.266 + for (int i = 0; i < a0.length; i+=1) { 4.267 + a0[i] = (byte)((a1[i] & BIT_MASK)>>>VALUE); 4.268 + } 4.269 + } 4.270 + static void test_srlv_and(byte[] a0, byte[] a1, int b) { 4.271 + for (int i = 0; i < a0.length; i+=1) { 4.272 + a0[i] = (byte)((a1[i] & b)>>>VALUE); 4.273 + } 4.274 + } 4.275 4.276 static void test_srac(byte[] a0, byte[] a1) { 4.277 for (int i = 0; i < a0.length; i+=1) { 4.278 @@ -1088,6 +1281,26 @@ 4.279 a0[i] = (byte)(a1[i]>>b); 4.280 } 4.281 } 4.282 + static void test_srac_add(byte[] a0, byte[] a1) { 4.283 + for (int i = 0; i < a0.length; i+=1) { 4.284 + a0[i] = (byte)((a1[i] + ADD_INIT)>>VALUE); 4.285 + } 4.286 + } 4.287 + static void test_srav_add(byte[] a0, byte[] a1, int b) { 4.288 + for (int i = 0; i < a0.length; i+=1) { 4.289 + a0[i] = (byte)((a1[i] + b)>>VALUE); 4.290 + } 4.291 + } 4.292 + static void test_srac_and(byte[] a0, byte[] a1) { 4.293 + for (int i = 0; i < a0.length; i+=1) { 4.294 + a0[i] = (byte)((a1[i] & BIT_MASK)>>VALUE); 4.295 + } 4.296 + } 4.297 + static void test_srav_and(byte[] a0, byte[] a1, int b) { 4.298 + for (int i = 0; i < a0.length; i+=1) { 4.299 + a0[i] = (byte)((a1[i] & b)>>VALUE); 4.300 + } 4.301 + } 4.302 4.303 static void test_pack2(short[] p2, byte[] a1) { 4.304 if (p2.length*2 > a1.length) return;
5.1 --- a/test/compiler/6340864/TestIntVect.java Mon Oct 22 16:56:03 2012 -0700 5.2 +++ b/test/compiler/6340864/TestIntVect.java Tue Oct 23 13:06:37 2012 -0700 5.3 @@ -74,6 +74,7 @@ 5.4 test_subc(a0, a1); 5.5 test_subv(a0, a1, (int)VALUE); 5.6 test_suba(a0, a1, a2); 5.7 + 5.8 test_mulc(a0, a1); 5.9 test_mulv(a0, a1, (int)VALUE); 5.10 test_mula(a0, a1, a2); 5.11 @@ -86,6 +87,7 @@ 5.12 test_divc_n(a0, a1); 5.13 test_divv(a0, a1, (int)-VALUE); 5.14 test_diva(a0, a1, a3); 5.15 + 5.16 test_andc(a0, a1); 5.17 test_andv(a0, a1, (int)BIT_MASK); 5.18 test_anda(a0, a1, a4); 5.19 @@ -95,30 +97,49 @@ 5.20 test_xorc(a0, a1); 5.21 test_xorv(a0, a1, (int)BIT_MASK); 5.22 test_xora(a0, a1, a4); 5.23 + 5.24 test_sllc(a0, a1); 5.25 test_sllv(a0, a1, VALUE); 5.26 test_srlc(a0, a1); 5.27 test_srlv(a0, a1, VALUE); 5.28 test_srac(a0, a1); 5.29 test_srav(a0, a1, VALUE); 5.30 + 5.31 test_sllc_n(a0, a1); 5.32 test_sllv(a0, a1, -VALUE); 5.33 test_srlc_n(a0, a1); 5.34 test_srlv(a0, a1, -VALUE); 5.35 test_srac_n(a0, a1); 5.36 test_srav(a0, a1, -VALUE); 5.37 + 5.38 test_sllc_o(a0, a1); 5.39 test_sllv(a0, a1, SHIFT); 5.40 test_srlc_o(a0, a1); 5.41 test_srlv(a0, a1, SHIFT); 5.42 test_srac_o(a0, a1); 5.43 test_srav(a0, a1, SHIFT); 5.44 + 5.45 test_sllc_on(a0, a1); 5.46 test_sllv(a0, a1, -SHIFT); 5.47 test_srlc_on(a0, a1); 5.48 test_srlv(a0, a1, -SHIFT); 5.49 test_srac_on(a0, a1); 5.50 test_srav(a0, a1, -SHIFT); 5.51 + 5.52 + test_sllc_add(a0, a1); 5.53 + test_sllv_add(a0, a1, ADD_INIT); 5.54 + test_srlc_add(a0, a1); 5.55 + test_srlv_add(a0, a1, ADD_INIT); 5.56 + test_srac_add(a0, a1); 5.57 + test_srav_add(a0, a1, ADD_INIT); 5.58 + 5.59 + test_sllc_and(a0, a1); 5.60 + test_sllv_and(a0, a1, BIT_MASK); 5.61 + test_srlc_and(a0, a1); 5.62 + test_srlv_and(a0, a1, BIT_MASK); 5.63 + test_srac_and(a0, a1); 5.64 + test_srav_and(a0, a1, BIT_MASK); 5.65 + 5.66 test_pack2(p2, a1); 5.67 test_unpack2(a0, p2); 5.68 test_pack2_swap(p2, a1); 5.69 @@ -359,6 +380,60 @@ 5.70 errn += verify("test_srav_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-SHIFT))); 5.71 } 5.72 5.73 + test_sllc_add(a0, a1); 5.74 + for (int i=0; i<ARRLEN; i++) { 5.75 + errn += verify("test_sllc_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 5.76 + } 5.77 + test_sllv_add(a0, a1, ADD_INIT); 5.78 + for (int i=0; i<ARRLEN; i++) { 5.79 + errn += verify("test_sllv_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 5.80 + } 5.81 + 5.82 + test_srlc_add(a0, a1); 5.83 + for (int i=0; i<ARRLEN; i++) { 5.84 + errn += verify("test_srlc_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 5.85 + } 5.86 + test_srlv_add(a0, a1, ADD_INIT); 5.87 + for (int i=0; i<ARRLEN; i++) { 5.88 + errn += verify("test_srlv_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 5.89 + } 5.90 + 5.91 + test_srac_add(a0, a1); 5.92 + for (int i=0; i<ARRLEN; i++) { 5.93 + errn += verify("test_srac_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 5.94 + } 5.95 + test_srav_add(a0, a1, ADD_INIT); 5.96 + for (int i=0; i<ARRLEN; i++) { 5.97 + errn += verify("test_srav_add: ", i, a0[i], (int)(((int)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 5.98 + } 5.99 + 5.100 + test_sllc_and(a0, a1); 5.101 + for (int i=0; i<ARRLEN; i++) { 5.102 + errn += verify("test_sllc_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 5.103 + } 5.104 + test_sllv_and(a0, a1, BIT_MASK); 5.105 + for (int i=0; i<ARRLEN; i++) { 5.106 + errn += verify("test_sllv_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 5.107 + } 5.108 + 5.109 + test_srlc_and(a0, a1); 5.110 + for (int i=0; i<ARRLEN; i++) { 5.111 + errn += verify("test_srlc_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 5.112 + } 5.113 + test_srlv_and(a0, a1, BIT_MASK); 5.114 + for (int i=0; i<ARRLEN; i++) { 5.115 + errn += verify("test_srlv_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 5.116 + } 5.117 + 5.118 + test_srac_and(a0, a1); 5.119 + for (int i=0; i<ARRLEN; i++) { 5.120 + errn += verify("test_srac_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 5.121 + } 5.122 + test_srav_and(a0, a1, BIT_MASK); 5.123 + for (int i=0; i<ARRLEN; i++) { 5.124 + errn += verify("test_srav_and: ", i, a0[i], (int)(((int)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 5.125 + } 5.126 + 5.127 test_pack2(p2, a1); 5.128 for (int i=0; i<ARRLEN/2; i++) { 5.129 errn += verify("test_pack2: ", i, p2[i], ((long)(ADD_INIT+2*i) & 0xFFFFFFFFl) | ((long)(ADD_INIT+2*i+1) << 32)); 5.130 @@ -727,6 +802,84 @@ 5.131 5.132 start = System.currentTimeMillis(); 5.133 for (int i=0; i<ITERS; i++) { 5.134 + test_sllc_add(a0, a1); 5.135 + } 5.136 + end = System.currentTimeMillis(); 5.137 + System.out.println("test_sllc_add: " + (end - start)); 5.138 + start = System.currentTimeMillis(); 5.139 + for (int i=0; i<ITERS; i++) { 5.140 + test_sllv_add(a0, a1, ADD_INIT); 5.141 + } 5.142 + end = System.currentTimeMillis(); 5.143 + System.out.println("test_sllv_add: " + (end - start)); 5.144 + 5.145 + start = System.currentTimeMillis(); 5.146 + for (int i=0; i<ITERS; i++) { 5.147 + test_srlc_add(a0, a1); 5.148 + } 5.149 + end = System.currentTimeMillis(); 5.150 + System.out.println("test_srlc_add: " + (end - start)); 5.151 + start = System.currentTimeMillis(); 5.152 + for (int i=0; i<ITERS; i++) { 5.153 + test_srlv_add(a0, a1, ADD_INIT); 5.154 + } 5.155 + end = System.currentTimeMillis(); 5.156 + System.out.println("test_srlv_add: " + (end - start)); 5.157 + 5.158 + start = System.currentTimeMillis(); 5.159 + for (int i=0; i<ITERS; i++) { 5.160 + test_srac_add(a0, a1); 5.161 + } 5.162 + end = System.currentTimeMillis(); 5.163 + System.out.println("test_srac_add: " + (end - start)); 5.164 + start = System.currentTimeMillis(); 5.165 + for (int i=0; i<ITERS; i++) { 5.166 + test_srav_add(a0, a1, ADD_INIT); 5.167 + } 5.168 + end = System.currentTimeMillis(); 5.169 + System.out.println("test_srav_add: " + (end - start)); 5.170 + 5.171 + start = System.currentTimeMillis(); 5.172 + for (int i=0; i<ITERS; i++) { 5.173 + test_sllc_and(a0, a1); 5.174 + } 5.175 + end = System.currentTimeMillis(); 5.176 + System.out.println("test_sllc_and: " + (end - start)); 5.177 + start = System.currentTimeMillis(); 5.178 + for (int i=0; i<ITERS; i++) { 5.179 + test_sllv_and(a0, a1, BIT_MASK); 5.180 + } 5.181 + end = System.currentTimeMillis(); 5.182 + System.out.println("test_sllv_and: " + (end - start)); 5.183 + 5.184 + start = System.currentTimeMillis(); 5.185 + for (int i=0; i<ITERS; i++) { 5.186 + test_srlc_and(a0, a1); 5.187 + } 5.188 + end = System.currentTimeMillis(); 5.189 + System.out.println("test_srlc_and: " + (end - start)); 5.190 + start = System.currentTimeMillis(); 5.191 + for (int i=0; i<ITERS; i++) { 5.192 + test_srlv_and(a0, a1, BIT_MASK); 5.193 + } 5.194 + end = System.currentTimeMillis(); 5.195 + System.out.println("test_srlv_and: " + (end - start)); 5.196 + 5.197 + start = System.currentTimeMillis(); 5.198 + for (int i=0; i<ITERS; i++) { 5.199 + test_srac_and(a0, a1); 5.200 + } 5.201 + end = System.currentTimeMillis(); 5.202 + System.out.println("test_srac_and: " + (end - start)); 5.203 + start = System.currentTimeMillis(); 5.204 + for (int i=0; i<ITERS; i++) { 5.205 + test_srav_and(a0, a1, BIT_MASK); 5.206 + } 5.207 + end = System.currentTimeMillis(); 5.208 + System.out.println("test_srav_and: " + (end - start)); 5.209 + 5.210 + start = System.currentTimeMillis(); 5.211 + for (int i=0; i<ITERS; i++) { 5.212 test_pack2(p2, a1); 5.213 } 5.214 end = System.currentTimeMillis(); 5.215 @@ -908,6 +1061,26 @@ 5.216 a0[i] = (int)(a1[i]<<b); 5.217 } 5.218 } 5.219 + static void test_sllc_add(int[] a0, int[] a1) { 5.220 + for (int i = 0; i < a0.length; i+=1) { 5.221 + a0[i] = (int)((a1[i] + ADD_INIT)<<VALUE); 5.222 + } 5.223 + } 5.224 + static void test_sllv_add(int[] a0, int[] a1, int b) { 5.225 + for (int i = 0; i < a0.length; i+=1) { 5.226 + a0[i] = (int)((a1[i] + b)<<VALUE); 5.227 + } 5.228 + } 5.229 + static void test_sllc_and(int[] a0, int[] a1) { 5.230 + for (int i = 0; i < a0.length; i+=1) { 5.231 + a0[i] = (int)((a1[i] & BIT_MASK)<<VALUE); 5.232 + } 5.233 + } 5.234 + static void test_sllv_and(int[] a0, int[] a1, int b) { 5.235 + for (int i = 0; i < a0.length; i+=1) { 5.236 + a0[i] = (int)((a1[i] & b)<<VALUE); 5.237 + } 5.238 + } 5.239 5.240 static void test_srlc(int[] a0, int[] a1) { 5.241 for (int i = 0; i < a0.length; i+=1) { 5.242 @@ -934,6 +1107,26 @@ 5.243 a0[i] = (int)(a1[i]>>>b); 5.244 } 5.245 } 5.246 + static void test_srlc_add(int[] a0, int[] a1) { 5.247 + for (int i = 0; i < a0.length; i+=1) { 5.248 + a0[i] = (int)((a1[i] + ADD_INIT)>>>VALUE); 5.249 + } 5.250 + } 5.251 + static void test_srlv_add(int[] a0, int[] a1, int b) { 5.252 + for (int i = 0; i < a0.length; i+=1) { 5.253 + a0[i] = (int)((a1[i] + b)>>>VALUE); 5.254 + } 5.255 + } 5.256 + static void test_srlc_and(int[] a0, int[] a1) { 5.257 + for (int i = 0; i < a0.length; i+=1) { 5.258 + a0[i] = (int)((a1[i] & BIT_MASK)>>>VALUE); 5.259 + } 5.260 + } 5.261 + static void test_srlv_and(int[] a0, int[] a1, int b) { 5.262 + for (int i = 0; i < a0.length; i+=1) { 5.263 + a0[i] = (int)((a1[i] & b)>>>VALUE); 5.264 + } 5.265 + } 5.266 5.267 static void test_srac(int[] a0, int[] a1) { 5.268 for (int i = 0; i < a0.length; i+=1) { 5.269 @@ -960,6 +1153,26 @@ 5.270 a0[i] = (int)(a1[i]>>b); 5.271 } 5.272 } 5.273 + static void test_srac_add(int[] a0, int[] a1) { 5.274 + for (int i = 0; i < a0.length; i+=1) { 5.275 + a0[i] = (int)((a1[i] + ADD_INIT)>>VALUE); 5.276 + } 5.277 + } 5.278 + static void test_srav_add(int[] a0, int[] a1, int b) { 5.279 + for (int i = 0; i < a0.length; i+=1) { 5.280 + a0[i] = (int)((a1[i] + b)>>VALUE); 5.281 + } 5.282 + } 5.283 + static void test_srac_and(int[] a0, int[] a1) { 5.284 + for (int i = 0; i < a0.length; i+=1) { 5.285 + a0[i] = (int)((a1[i] & BIT_MASK)>>VALUE); 5.286 + } 5.287 + } 5.288 + static void test_srav_and(int[] a0, int[] a1, int b) { 5.289 + for (int i = 0; i < a0.length; i+=1) { 5.290 + a0[i] = (int)((a1[i] & b)>>VALUE); 5.291 + } 5.292 + } 5.293 5.294 static void test_pack2(long[] p2, int[] a1) { 5.295 if (p2.length*2 > a1.length) return;
6.1 --- a/test/compiler/6340864/TestLongVect.java Mon Oct 22 16:56:03 2012 -0700 6.2 +++ b/test/compiler/6340864/TestLongVect.java Tue Oct 23 13:06:37 2012 -0700 6.3 @@ -73,6 +73,7 @@ 6.4 test_subc(a0, a1); 6.5 test_subv(a0, a1, (long)VALUE); 6.6 test_suba(a0, a1, a2); 6.7 + 6.8 test_mulc(a0, a1); 6.9 test_mulv(a0, a1, (long)VALUE); 6.10 test_mula(a0, a1, a2); 6.11 @@ -85,6 +86,7 @@ 6.12 test_divc_n(a0, a1); 6.13 test_divv(a0, a1, (long)-VALUE); 6.14 test_diva(a0, a1, a3); 6.15 + 6.16 test_andc(a0, a1); 6.17 test_andv(a0, a1, (long)BIT_MASK); 6.18 test_anda(a0, a1, a4); 6.19 @@ -94,30 +96,48 @@ 6.20 test_xorc(a0, a1); 6.21 test_xorv(a0, a1, (long)BIT_MASK); 6.22 test_xora(a0, a1, a4); 6.23 + 6.24 test_sllc(a0, a1); 6.25 test_sllv(a0, a1, VALUE); 6.26 test_srlc(a0, a1); 6.27 test_srlv(a0, a1, VALUE); 6.28 test_srac(a0, a1); 6.29 test_srav(a0, a1, VALUE); 6.30 + 6.31 test_sllc_n(a0, a1); 6.32 test_sllv(a0, a1, -VALUE); 6.33 test_srlc_n(a0, a1); 6.34 test_srlv(a0, a1, -VALUE); 6.35 test_srac_n(a0, a1); 6.36 test_srav(a0, a1, -VALUE); 6.37 + 6.38 test_sllc_o(a0, a1); 6.39 test_sllv(a0, a1, SHIFT); 6.40 test_srlc_o(a0, a1); 6.41 test_srlv(a0, a1, SHIFT); 6.42 test_srac_o(a0, a1); 6.43 test_srav(a0, a1, SHIFT); 6.44 + 6.45 test_sllc_on(a0, a1); 6.46 test_sllv(a0, a1, -SHIFT); 6.47 test_srlc_on(a0, a1); 6.48 test_srlv(a0, a1, -SHIFT); 6.49 test_srac_on(a0, a1); 6.50 test_srav(a0, a1, -SHIFT); 6.51 + 6.52 + test_sllc_add(a0, a1); 6.53 + test_sllv_add(a0, a1, ADD_INIT); 6.54 + test_srlc_add(a0, a1); 6.55 + test_srlv_add(a0, a1, ADD_INIT); 6.56 + test_srac_add(a0, a1); 6.57 + test_srav_add(a0, a1, ADD_INIT); 6.58 + 6.59 + test_sllc_and(a0, a1); 6.60 + test_sllv_and(a0, a1, BIT_MASK); 6.61 + test_srlc_and(a0, a1); 6.62 + test_srlv_and(a0, a1, BIT_MASK); 6.63 + test_srac_and(a0, a1); 6.64 + test_srav_and(a0, a1, BIT_MASK); 6.65 } 6.66 // Test and verify results 6.67 System.out.println("Verification"); 6.68 @@ -354,6 +374,60 @@ 6.69 errn += verify("test_srav_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT))); 6.70 } 6.71 6.72 + test_sllc_add(a0, a1); 6.73 + for (int i=0; i<ARRLEN; i++) { 6.74 + errn += verify("test_sllc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 6.75 + } 6.76 + test_sllv_add(a0, a1, ADD_INIT); 6.77 + for (int i=0; i<ARRLEN; i++) { 6.78 + errn += verify("test_sllv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 6.79 + } 6.80 + 6.81 + test_srlc_add(a0, a1); 6.82 + for (int i=0; i<ARRLEN; i++) { 6.83 + errn += verify("test_srlc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 6.84 + } 6.85 + test_srlv_add(a0, a1, ADD_INIT); 6.86 + for (int i=0; i<ARRLEN; i++) { 6.87 + errn += verify("test_srlv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 6.88 + } 6.89 + 6.90 + test_srac_add(a0, a1); 6.91 + for (int i=0; i<ARRLEN; i++) { 6.92 + errn += verify("test_srac_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 6.93 + } 6.94 + test_srav_add(a0, a1, ADD_INIT); 6.95 + for (int i=0; i<ARRLEN; i++) { 6.96 + errn += verify("test_srav_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 6.97 + } 6.98 + 6.99 + test_sllc_and(a0, a1); 6.100 + for (int i=0; i<ARRLEN; i++) { 6.101 + errn += verify("test_sllc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 6.102 + } 6.103 + test_sllv_and(a0, a1, BIT_MASK); 6.104 + for (int i=0; i<ARRLEN; i++) { 6.105 + errn += verify("test_sllv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 6.106 + } 6.107 + 6.108 + test_srlc_and(a0, a1); 6.109 + for (int i=0; i<ARRLEN; i++) { 6.110 + errn += verify("test_srlc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 6.111 + } 6.112 + test_srlv_and(a0, a1, BIT_MASK); 6.113 + for (int i=0; i<ARRLEN; i++) { 6.114 + errn += verify("test_srlv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 6.115 + } 6.116 + 6.117 + test_srac_and(a0, a1); 6.118 + for (int i=0; i<ARRLEN; i++) { 6.119 + errn += verify("test_srac_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 6.120 + } 6.121 + test_srav_and(a0, a1, BIT_MASK); 6.122 + for (int i=0; i<ARRLEN; i++) { 6.123 + errn += verify("test_srav_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 6.124 + } 6.125 + 6.126 } 6.127 6.128 if (errn > 0) 6.129 @@ -696,6 +770,84 @@ 6.130 end = System.currentTimeMillis(); 6.131 System.out.println("test_srav_on: " + (end - start)); 6.132 6.133 + start = System.currentTimeMillis(); 6.134 + for (int i=0; i<ITERS; i++) { 6.135 + test_sllc_add(a0, a1); 6.136 + } 6.137 + end = System.currentTimeMillis(); 6.138 + System.out.println("test_sllc_add: " + (end - start)); 6.139 + start = System.currentTimeMillis(); 6.140 + for (int i=0; i<ITERS; i++) { 6.141 + test_sllv_add(a0, a1, ADD_INIT); 6.142 + } 6.143 + end = System.currentTimeMillis(); 6.144 + System.out.println("test_sllv_add: " + (end - start)); 6.145 + 6.146 + start = System.currentTimeMillis(); 6.147 + for (int i=0; i<ITERS; i++) { 6.148 + test_srlc_add(a0, a1); 6.149 + } 6.150 + end = System.currentTimeMillis(); 6.151 + System.out.println("test_srlc_add: " + (end - start)); 6.152 + start = System.currentTimeMillis(); 6.153 + for (int i=0; i<ITERS; i++) { 6.154 + test_srlv_add(a0, a1, ADD_INIT); 6.155 + } 6.156 + end = System.currentTimeMillis(); 6.157 + System.out.println("test_srlv_add: " + (end - start)); 6.158 + 6.159 + start = System.currentTimeMillis(); 6.160 + for (int i=0; i<ITERS; i++) { 6.161 + test_srac_add(a0, a1); 6.162 + } 6.163 + end = System.currentTimeMillis(); 6.164 + System.out.println("test_srac_add: " + (end - start)); 6.165 + start = System.currentTimeMillis(); 6.166 + for (int i=0; i<ITERS; i++) { 6.167 + test_srav_add(a0, a1, ADD_INIT); 6.168 + } 6.169 + end = System.currentTimeMillis(); 6.170 + System.out.println("test_srav_add: " + (end - start)); 6.171 + 6.172 + start = System.currentTimeMillis(); 6.173 + for (int i=0; i<ITERS; i++) { 6.174 + test_sllc_and(a0, a1); 6.175 + } 6.176 + end = System.currentTimeMillis(); 6.177 + System.out.println("test_sllc_and: " + (end - start)); 6.178 + start = System.currentTimeMillis(); 6.179 + for (int i=0; i<ITERS; i++) { 6.180 + test_sllv_and(a0, a1, BIT_MASK); 6.181 + } 6.182 + end = System.currentTimeMillis(); 6.183 + System.out.println("test_sllv_and: " + (end - start)); 6.184 + 6.185 + start = System.currentTimeMillis(); 6.186 + for (int i=0; i<ITERS; i++) { 6.187 + test_srlc_and(a0, a1); 6.188 + } 6.189 + end = System.currentTimeMillis(); 6.190 + System.out.println("test_srlc_and: " + (end - start)); 6.191 + start = System.currentTimeMillis(); 6.192 + for (int i=0; i<ITERS; i++) { 6.193 + test_srlv_and(a0, a1, BIT_MASK); 6.194 + } 6.195 + end = System.currentTimeMillis(); 6.196 + System.out.println("test_srlv_and: " + (end - start)); 6.197 + 6.198 + start = System.currentTimeMillis(); 6.199 + for (int i=0; i<ITERS; i++) { 6.200 + test_srac_and(a0, a1); 6.201 + } 6.202 + end = System.currentTimeMillis(); 6.203 + System.out.println("test_srac_and: " + (end - start)); 6.204 + start = System.currentTimeMillis(); 6.205 + for (int i=0; i<ITERS; i++) { 6.206 + test_srav_and(a0, a1, BIT_MASK); 6.207 + } 6.208 + end = System.currentTimeMillis(); 6.209 + System.out.println("test_srav_and: " + (end - start)); 6.210 + 6.211 return errn; 6.212 } 6.213 6.214 @@ -854,6 +1006,26 @@ 6.215 a0[i] = (long)(a1[i]<<b); 6.216 } 6.217 } 6.218 + static void test_sllc_add(long[] a0, long[] a1) { 6.219 + for (int i = 0; i < a0.length; i+=1) { 6.220 + a0[i] = (long)((a1[i] + ADD_INIT)<<VALUE); 6.221 + } 6.222 + } 6.223 + static void test_sllv_add(long[] a0, long[] a1, long b) { 6.224 + for (int i = 0; i < a0.length; i+=1) { 6.225 + a0[i] = (long)((a1[i] + b)<<VALUE); 6.226 + } 6.227 + } 6.228 + static void test_sllc_and(long[] a0, long[] a1) { 6.229 + for (int i = 0; i < a0.length; i+=1) { 6.230 + a0[i] = (long)((a1[i] & BIT_MASK)<<VALUE); 6.231 + } 6.232 + } 6.233 + static void test_sllv_and(long[] a0, long[] a1, long b) { 6.234 + for (int i = 0; i < a0.length; i+=1) { 6.235 + a0[i] = (long)((a1[i] & b)<<VALUE); 6.236 + } 6.237 + } 6.238 6.239 static void test_srlc(long[] a0, long[] a1) { 6.240 for (int i = 0; i < a0.length; i+=1) { 6.241 @@ -880,6 +1052,26 @@ 6.242 a0[i] = (long)(a1[i]>>>b); 6.243 } 6.244 } 6.245 + static void test_srlc_add(long[] a0, long[] a1) { 6.246 + for (int i = 0; i < a0.length; i+=1) { 6.247 + a0[i] = (long)((a1[i] + ADD_INIT)>>>VALUE); 6.248 + } 6.249 + } 6.250 + static void test_srlv_add(long[] a0, long[] a1, long b) { 6.251 + for (int i = 0; i < a0.length; i+=1) { 6.252 + a0[i] = (long)((a1[i] + b)>>>VALUE); 6.253 + } 6.254 + } 6.255 + static void test_srlc_and(long[] a0, long[] a1) { 6.256 + for (int i = 0; i < a0.length; i+=1) { 6.257 + a0[i] = (long)((a1[i] & BIT_MASK)>>>VALUE); 6.258 + } 6.259 + } 6.260 + static void test_srlv_and(long[] a0, long[] a1, long b) { 6.261 + for (int i = 0; i < a0.length; i+=1) { 6.262 + a0[i] = (long)((a1[i] & b)>>>VALUE); 6.263 + } 6.264 + } 6.265 6.266 static void test_srac(long[] a0, long[] a1) { 6.267 for (int i = 0; i < a0.length; i+=1) { 6.268 @@ -906,6 +1098,26 @@ 6.269 a0[i] = (long)(a1[i]>>b); 6.270 } 6.271 } 6.272 + static void test_srac_add(long[] a0, long[] a1) { 6.273 + for (int i = 0; i < a0.length; i+=1) { 6.274 + a0[i] = (long)((a1[i] + ADD_INIT)>>VALUE); 6.275 + } 6.276 + } 6.277 + static void test_srav_add(long[] a0, long[] a1, long b) { 6.278 + for (int i = 0; i < a0.length; i+=1) { 6.279 + a0[i] = (long)((a1[i] + b)>>VALUE); 6.280 + } 6.281 + } 6.282 + static void test_srac_and(long[] a0, long[] a1) { 6.283 + for (int i = 0; i < a0.length; i+=1) { 6.284 + a0[i] = (long)((a1[i] & BIT_MASK)>>VALUE); 6.285 + } 6.286 + } 6.287 + static void test_srav_and(long[] a0, long[] a1, long b) { 6.288 + for (int i = 0; i < a0.length; i+=1) { 6.289 + a0[i] = (long)((a1[i] & b)>>VALUE); 6.290 + } 6.291 + } 6.292 6.293 static int verify(String text, int i, long elem, long val) { 6.294 if (elem != val) {
7.1 --- a/test/compiler/6340864/TestShortVect.java Mon Oct 22 16:56:03 2012 -0700 7.2 +++ b/test/compiler/6340864/TestShortVect.java Tue Oct 23 13:06:37 2012 -0700 7.3 @@ -75,6 +75,7 @@ 7.4 test_subc(a0, a1); 7.5 test_subv(a0, a1, (short)VALUE); 7.6 test_suba(a0, a1, a2); 7.7 + 7.8 test_mulc(a0, a1); 7.9 test_mulv(a0, a1, (short)VALUE); 7.10 test_mula(a0, a1, a2); 7.11 @@ -87,6 +88,7 @@ 7.12 test_divc_n(a0, a1); 7.13 test_divv(a0, a1, (short)-VALUE); 7.14 test_diva(a0, a1, a3); 7.15 + 7.16 test_andc(a0, a1); 7.17 test_andv(a0, a1, (short)BIT_MASK); 7.18 test_anda(a0, a1, a4); 7.19 @@ -96,30 +98,49 @@ 7.20 test_xorc(a0, a1); 7.21 test_xorv(a0, a1, (short)BIT_MASK); 7.22 test_xora(a0, a1, a4); 7.23 + 7.24 test_sllc(a0, a1); 7.25 test_sllv(a0, a1, VALUE); 7.26 test_srlc(a0, a1); 7.27 test_srlv(a0, a1, VALUE); 7.28 test_srac(a0, a1); 7.29 test_srav(a0, a1, VALUE); 7.30 + 7.31 test_sllc_n(a0, a1); 7.32 test_sllv(a0, a1, -VALUE); 7.33 test_srlc_n(a0, a1); 7.34 test_srlv(a0, a1, -VALUE); 7.35 test_srac_n(a0, a1); 7.36 test_srav(a0, a1, -VALUE); 7.37 + 7.38 test_sllc_o(a0, a1); 7.39 test_sllv(a0, a1, SHIFT); 7.40 test_srlc_o(a0, a1); 7.41 test_srlv(a0, a1, SHIFT); 7.42 test_srac_o(a0, a1); 7.43 test_srav(a0, a1, SHIFT); 7.44 + 7.45 test_sllc_on(a0, a1); 7.46 test_sllv(a0, a1, -SHIFT); 7.47 test_srlc_on(a0, a1); 7.48 test_srlv(a0, a1, -SHIFT); 7.49 test_srac_on(a0, a1); 7.50 test_srav(a0, a1, -SHIFT); 7.51 + 7.52 + test_sllc_add(a0, a1); 7.53 + test_sllv_add(a0, a1, ADD_INIT); 7.54 + test_srlc_add(a0, a1); 7.55 + test_srlv_add(a0, a1, ADD_INIT); 7.56 + test_srac_add(a0, a1); 7.57 + test_srav_add(a0, a1, ADD_INIT); 7.58 + 7.59 + test_sllc_and(a0, a1); 7.60 + test_sllv_and(a0, a1, BIT_MASK); 7.61 + test_srlc_and(a0, a1); 7.62 + test_srlv_and(a0, a1, BIT_MASK); 7.63 + test_srac_and(a0, a1); 7.64 + test_srav_and(a0, a1, BIT_MASK); 7.65 + 7.66 test_pack2(p2, a1); 7.67 test_unpack2(a0, p2); 7.68 test_pack2_swap(p2, a1); 7.69 @@ -364,6 +385,60 @@ 7.70 errn += verify("test_srav_on: ", i, a0[i], (short)((short)(ADD_INIT+i)>>(-SHIFT))); 7.71 } 7.72 7.73 + test_sllc_add(a0, a1); 7.74 + for (int i=0; i<ARRLEN; i++) { 7.75 + errn += verify("test_sllc_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 7.76 + } 7.77 + test_sllv_add(a0, a1, ADD_INIT); 7.78 + for (int i=0; i<ARRLEN; i++) { 7.79 + errn += verify("test_sllv_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 7.80 + } 7.81 + 7.82 + test_srlc_add(a0, a1); 7.83 + for (int i=0; i<ARRLEN; i++) { 7.84 + errn += verify("test_srlc_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 7.85 + } 7.86 + test_srlv_add(a0, a1, ADD_INIT); 7.87 + for (int i=0; i<ARRLEN; i++) { 7.88 + errn += verify("test_srlv_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 7.89 + } 7.90 + 7.91 + test_srac_add(a0, a1); 7.92 + for (int i=0; i<ARRLEN; i++) { 7.93 + errn += verify("test_srac_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 7.94 + } 7.95 + test_srav_add(a0, a1, ADD_INIT); 7.96 + for (int i=0; i<ARRLEN; i++) { 7.97 + errn += verify("test_srav_add: ", i, a0[i], (short)(((short)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 7.98 + } 7.99 + 7.100 + test_sllc_and(a0, a1); 7.101 + for (int i=0; i<ARRLEN; i++) { 7.102 + errn += verify("test_sllc_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 7.103 + } 7.104 + test_sllv_and(a0, a1, BIT_MASK); 7.105 + for (int i=0; i<ARRLEN; i++) { 7.106 + errn += verify("test_sllv_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 7.107 + } 7.108 + 7.109 + test_srlc_and(a0, a1); 7.110 + for (int i=0; i<ARRLEN; i++) { 7.111 + errn += verify("test_srlc_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 7.112 + } 7.113 + test_srlv_and(a0, a1, BIT_MASK); 7.114 + for (int i=0; i<ARRLEN; i++) { 7.115 + errn += verify("test_srlv_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 7.116 + } 7.117 + 7.118 + test_srac_and(a0, a1); 7.119 + for (int i=0; i<ARRLEN; i++) { 7.120 + errn += verify("test_srac_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 7.121 + } 7.122 + test_srav_and(a0, a1, BIT_MASK); 7.123 + for (int i=0; i<ARRLEN; i++) { 7.124 + errn += verify("test_srav_and: ", i, a0[i], (short)(((short)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 7.125 + } 7.126 + 7.127 test_pack2(p2, a1); 7.128 for (int i=0; i<ARRLEN/2; i++) { 7.129 errn += verify("test_pack2: ", i, p2[i], ((int)(ADD_INIT+2*i) & 0xFFFF) | ((int)(ADD_INIT+2*i+1) << 16)); 7.130 @@ -762,6 +837,84 @@ 7.131 7.132 start = System.currentTimeMillis(); 7.133 for (int i=0; i<ITERS; i++) { 7.134 + test_sllc_add(a0, a1); 7.135 + } 7.136 + end = System.currentTimeMillis(); 7.137 + System.out.println("test_sllc_add: " + (end - start)); 7.138 + start = System.currentTimeMillis(); 7.139 + for (int i=0; i<ITERS; i++) { 7.140 + test_sllv_add(a0, a1, ADD_INIT); 7.141 + } 7.142 + end = System.currentTimeMillis(); 7.143 + System.out.println("test_sllv_add: " + (end - start)); 7.144 + 7.145 + start = System.currentTimeMillis(); 7.146 + for (int i=0; i<ITERS; i++) { 7.147 + test_srlc_add(a0, a1); 7.148 + } 7.149 + end = System.currentTimeMillis(); 7.150 + System.out.println("test_srlc_add: " + (end - start)); 7.151 + start = System.currentTimeMillis(); 7.152 + for (int i=0; i<ITERS; i++) { 7.153 + test_srlv_add(a0, a1, ADD_INIT); 7.154 + } 7.155 + end = System.currentTimeMillis(); 7.156 + System.out.println("test_srlv_add: " + (end - start)); 7.157 + 7.158 + start = System.currentTimeMillis(); 7.159 + for (int i=0; i<ITERS; i++) { 7.160 + test_srac_add(a0, a1); 7.161 + } 7.162 + end = System.currentTimeMillis(); 7.163 + System.out.println("test_srac_add: " + (end - start)); 7.164 + start = System.currentTimeMillis(); 7.165 + for (int i=0; i<ITERS; i++) { 7.166 + test_srav_add(a0, a1, ADD_INIT); 7.167 + } 7.168 + end = System.currentTimeMillis(); 7.169 + System.out.println("test_srav_add: " + (end - start)); 7.170 + 7.171 + start = System.currentTimeMillis(); 7.172 + for (int i=0; i<ITERS; i++) { 7.173 + test_sllc_and(a0, a1); 7.174 + } 7.175 + end = System.currentTimeMillis(); 7.176 + System.out.println("test_sllc_and: " + (end - start)); 7.177 + start = System.currentTimeMillis(); 7.178 + for (int i=0; i<ITERS; i++) { 7.179 + test_sllv_and(a0, a1, BIT_MASK); 7.180 + } 7.181 + end = System.currentTimeMillis(); 7.182 + System.out.println("test_sllv_and: " + (end - start)); 7.183 + 7.184 + start = System.currentTimeMillis(); 7.185 + for (int i=0; i<ITERS; i++) { 7.186 + test_srlc_and(a0, a1); 7.187 + } 7.188 + end = System.currentTimeMillis(); 7.189 + System.out.println("test_srlc_and: " + (end - start)); 7.190 + start = System.currentTimeMillis(); 7.191 + for (int i=0; i<ITERS; i++) { 7.192 + test_srlv_and(a0, a1, BIT_MASK); 7.193 + } 7.194 + end = System.currentTimeMillis(); 7.195 + System.out.println("test_srlv_and: " + (end - start)); 7.196 + 7.197 + start = System.currentTimeMillis(); 7.198 + for (int i=0; i<ITERS; i++) { 7.199 + test_srac_and(a0, a1); 7.200 + } 7.201 + end = System.currentTimeMillis(); 7.202 + System.out.println("test_srac_and: " + (end - start)); 7.203 + start = System.currentTimeMillis(); 7.204 + for (int i=0; i<ITERS; i++) { 7.205 + test_srav_and(a0, a1, BIT_MASK); 7.206 + } 7.207 + end = System.currentTimeMillis(); 7.208 + System.out.println("test_srav_and: " + (end - start)); 7.209 + 7.210 + start = System.currentTimeMillis(); 7.211 + for (int i=0; i<ITERS; i++) { 7.212 test_pack2(p2, a1); 7.213 } 7.214 end = System.currentTimeMillis(); 7.215 @@ -968,6 +1121,26 @@ 7.216 a0[i] = (short)(a1[i]<<b); 7.217 } 7.218 } 7.219 + static void test_sllc_add(short[] a0, short[] a1) { 7.220 + for (int i = 0; i < a0.length; i+=1) { 7.221 + a0[i] = (short)((a1[i] + ADD_INIT)<<VALUE); 7.222 + } 7.223 + } 7.224 + static void test_sllv_add(short[] a0, short[] a1, int b) { 7.225 + for (int i = 0; i < a0.length; i+=1) { 7.226 + a0[i] = (short)((a1[i] + b)<<VALUE); 7.227 + } 7.228 + } 7.229 + static void test_sllc_and(short[] a0, short[] a1) { 7.230 + for (int i = 0; i < a0.length; i+=1) { 7.231 + a0[i] = (short)((a1[i] & BIT_MASK)<<VALUE); 7.232 + } 7.233 + } 7.234 + static void test_sllv_and(short[] a0, short[] a1, int b) { 7.235 + for (int i = 0; i < a0.length; i+=1) { 7.236 + a0[i] = (short)((a1[i] & b)<<VALUE); 7.237 + } 7.238 + } 7.239 7.240 static void test_srlc(short[] a0, short[] a1) { 7.241 for (int i = 0; i < a0.length; i+=1) { 7.242 @@ -994,6 +1167,26 @@ 7.243 a0[i] = (short)(a1[i]>>>b); 7.244 } 7.245 } 7.246 + static void test_srlc_add(short[] a0, short[] a1) { 7.247 + for (int i = 0; i < a0.length; i+=1) { 7.248 + a0[i] = (short)((a1[i] + ADD_INIT)>>>VALUE); 7.249 + } 7.250 + } 7.251 + static void test_srlv_add(short[] a0, short[] a1, int b) { 7.252 + for (int i = 0; i < a0.length; i+=1) { 7.253 + a0[i] = (short)((a1[i] + b)>>>VALUE); 7.254 + } 7.255 + } 7.256 + static void test_srlc_and(short[] a0, short[] a1) { 7.257 + for (int i = 0; i < a0.length; i+=1) { 7.258 + a0[i] = (short)((a1[i] & BIT_MASK)>>>VALUE); 7.259 + } 7.260 + } 7.261 + static void test_srlv_and(short[] a0, short[] a1, int b) { 7.262 + for (int i = 0; i < a0.length; i+=1) { 7.263 + a0[i] = (short)((a1[i] & b)>>>VALUE); 7.264 + } 7.265 + } 7.266 7.267 static void test_srac(short[] a0, short[] a1) { 7.268 for (int i = 0; i < a0.length; i+=1) { 7.269 @@ -1020,6 +1213,26 @@ 7.270 a0[i] = (short)(a1[i]>>b); 7.271 } 7.272 } 7.273 + static void test_srac_add(short[] a0, short[] a1) { 7.274 + for (int i = 0; i < a0.length; i+=1) { 7.275 + a0[i] = (short)((a1[i] + ADD_INIT)>>VALUE); 7.276 + } 7.277 + } 7.278 + static void test_srav_add(short[] a0, short[] a1, int b) { 7.279 + for (int i = 0; i < a0.length; i+=1) { 7.280 + a0[i] = (short)((a1[i] + b)>>VALUE); 7.281 + } 7.282 + } 7.283 + static void test_srac_and(short[] a0, short[] a1) { 7.284 + for (int i = 0; i < a0.length; i+=1) { 7.285 + a0[i] = (short)((a1[i] & BIT_MASK)>>VALUE); 7.286 + } 7.287 + } 7.288 + static void test_srav_and(short[] a0, short[] a1, int b) { 7.289 + for (int i = 0; i < a0.length; i+=1) { 7.290 + a0[i] = (short)((a1[i] & b)>>VALUE); 7.291 + } 7.292 + } 7.293 7.294 static void test_pack2(int[] p2, short[] a1) { 7.295 if (p2.length*2 > a1.length) return;
8.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 8.2 +++ b/test/compiler/8001183/TestCharVect.java Tue Oct 23 13:06:37 2012 -0700 8.3 @@ -0,0 +1,1332 @@ 8.4 +/* 8.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. 8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 8.7 + * 8.8 + * This code is free software; you can redistribute it and/or modify it 8.9 + * under the terms of the GNU General Public License version 2 only, as 8.10 + * published by the Free Software Foundation. 8.11 + * 8.12 + * This code is distributed in the hope that it will be useful, but WITHOUT 8.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 8.14 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 8.15 + * version 2 for more details (a copy is included in the LICENSE file that 8.16 + * accompanied this code). 8.17 + * 8.18 + * You should have received a copy of the GNU General Public License version 8.19 + * 2 along with this work; if not, write to the Free Software Foundation, 8.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 8.21 + * 8.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 8.23 + * or visit www.oracle.com if you need additional information or have any 8.24 + * questions. 8.25 + * 8.26 + */ 8.27 + 8.28 +/** 8.29 + * @test 8.30 + * @bug 8001183 8.31 + * @summary incorrect results of char vectors right shift operaiton 8.32 + * 8.33 + * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestCharVect 8.34 + */ 8.35 + 8.36 +public class TestCharVect { 8.37 + private static final int ARRLEN = 997; 8.38 + private static final int ITERS = 11000; 8.39 + private static final int ADD_INIT = Character.MAX_VALUE-500; 8.40 + private static final int BIT_MASK = 0xB731; 8.41 + private static final int VALUE = 7; 8.42 + private static final int SHIFT = 16; 8.43 + 8.44 + public static void main(String args[]) { 8.45 + System.out.println("Testing Char vectors"); 8.46 + int errn = test(); 8.47 + if (errn > 0) { 8.48 + System.err.println("FAILED: " + errn + " errors"); 8.49 + System.exit(97); 8.50 + } 8.51 + System.out.println("PASSED"); 8.52 + } 8.53 + 8.54 + static int test() { 8.55 + char[] a0 = new char[ARRLEN]; 8.56 + char[] a1 = new char[ARRLEN]; 8.57 + short[] a2 = new short[ARRLEN]; 8.58 + short[] a3 = new short[ARRLEN]; 8.59 + short[] a4 = new short[ARRLEN]; 8.60 + int[] p2 = new int[ARRLEN/2]; 8.61 + long[] p4 = new long[ARRLEN/4]; 8.62 + // Initialize 8.63 + int gold_sum = 0; 8.64 + for (int i=0; i<ARRLEN; i++) { 8.65 + char val = (char)(ADD_INIT+i); 8.66 + gold_sum += val; 8.67 + a1[i] = val; 8.68 + a2[i] = VALUE; 8.69 + a3[i] = -VALUE; 8.70 + a4[i] = (short)BIT_MASK; 8.71 + } 8.72 + System.out.println("Warmup"); 8.73 + for (int i=0; i<ITERS; i++) { 8.74 + test_sum(a1); 8.75 + test_addc(a0, a1); 8.76 + test_addv(a0, a1, (char)VALUE); 8.77 + test_adda(a0, a1, a2); 8.78 + test_subc(a0, a1); 8.79 + test_subv(a0, a1, (char)VALUE); 8.80 + test_suba(a0, a1, a2); 8.81 + 8.82 + test_mulc(a0, a1); 8.83 + test_mulv(a0, a1, (char)VALUE); 8.84 + test_mula(a0, a1, a2); 8.85 + test_divc(a0, a1); 8.86 + test_divv(a0, a1, VALUE); 8.87 + test_diva(a0, a1, a2); 8.88 + test_mulc_n(a0, a1); 8.89 + test_mulv(a0, a1, (char)-VALUE); 8.90 + test_mula(a0, a1, a3); 8.91 + test_divc_n(a0, a1); 8.92 + test_divv(a0, a1, -VALUE); 8.93 + test_diva(a0, a1, a3); 8.94 + 8.95 + test_andc(a0, a1); 8.96 + test_andv(a0, a1, (short)BIT_MASK); 8.97 + test_anda(a0, a1, a4); 8.98 + test_orc(a0, a1); 8.99 + test_orv(a0, a1, (short)BIT_MASK); 8.100 + test_ora(a0, a1, a4); 8.101 + test_xorc(a0, a1); 8.102 + test_xorv(a0, a1, (short)BIT_MASK); 8.103 + test_xora(a0, a1, a4); 8.104 + 8.105 + test_sllc(a0, a1); 8.106 + test_sllv(a0, a1, VALUE); 8.107 + test_srlc(a0, a1); 8.108 + test_srlv(a0, a1, VALUE); 8.109 + test_srac(a0, a1); 8.110 + test_srav(a0, a1, VALUE); 8.111 + 8.112 + test_sllc_n(a0, a1); 8.113 + test_sllv(a0, a1, -VALUE); 8.114 + test_srlc_n(a0, a1); 8.115 + test_srlv(a0, a1, -VALUE); 8.116 + test_srac_n(a0, a1); 8.117 + test_srav(a0, a1, -VALUE); 8.118 + 8.119 + test_sllc_o(a0, a1); 8.120 + test_sllv(a0, a1, SHIFT); 8.121 + test_srlc_o(a0, a1); 8.122 + test_srlv(a0, a1, SHIFT); 8.123 + test_srac_o(a0, a1); 8.124 + test_srav(a0, a1, SHIFT); 8.125 + 8.126 + test_sllc_on(a0, a1); 8.127 + test_sllv(a0, a1, -SHIFT); 8.128 + test_srlc_on(a0, a1); 8.129 + test_srlv(a0, a1, -SHIFT); 8.130 + test_srac_on(a0, a1); 8.131 + test_srav(a0, a1, -SHIFT); 8.132 + 8.133 + test_sllc_add(a0, a1); 8.134 + test_sllv_add(a0, a1, ADD_INIT); 8.135 + test_srlc_add(a0, a1); 8.136 + test_srlv_add(a0, a1, ADD_INIT); 8.137 + test_srac_add(a0, a1); 8.138 + test_srav_add(a0, a1, ADD_INIT); 8.139 + 8.140 + test_sllc_and(a0, a1); 8.141 + test_sllv_and(a0, a1, BIT_MASK); 8.142 + test_srlc_and(a0, a1); 8.143 + test_srlv_and(a0, a1, BIT_MASK); 8.144 + test_srac_and(a0, a1); 8.145 + test_srav_and(a0, a1, BIT_MASK); 8.146 + 8.147 + test_pack2(p2, a1); 8.148 + test_unpack2(a0, p2); 8.149 + test_pack2_swap(p2, a1); 8.150 + test_unpack2_swap(a0, p2); 8.151 + test_pack4(p4, a1); 8.152 + test_unpack4(a0, p4); 8.153 + test_pack4_swap(p4, a1); 8.154 + test_unpack4_swap(a0, p4); 8.155 + } 8.156 + // Test and verify results 8.157 + System.out.println("Verification"); 8.158 + int errn = 0; 8.159 + { 8.160 + int sum = test_sum(a1); 8.161 + if (sum != gold_sum) { 8.162 + System.err.println("test_sum: " + sum + " != " + gold_sum); 8.163 + errn++; 8.164 + } 8.165 + 8.166 + test_addc(a0, a1); 8.167 + for (int i=0; i<ARRLEN; i++) { 8.168 + errn += verify("test_addc: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE)); 8.169 + } 8.170 + test_addv(a0, a1, (char)VALUE); 8.171 + for (int i=0; i<ARRLEN; i++) { 8.172 + errn += verify("test_addv: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE)); 8.173 + } 8.174 + test_adda(a0, a1, a2); 8.175 + for (int i=0; i<ARRLEN; i++) { 8.176 + errn += verify("test_adda: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE)); 8.177 + } 8.178 + 8.179 + test_subc(a0, a1); 8.180 + for (int i=0; i<ARRLEN; i++) { 8.181 + errn += verify("test_subc: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE)); 8.182 + } 8.183 + test_subv(a0, a1, (char)VALUE); 8.184 + for (int i=0; i<ARRLEN; i++) { 8.185 + errn += verify("test_subv: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE)); 8.186 + } 8.187 + test_suba(a0, a1, a2); 8.188 + for (int i=0; i<ARRLEN; i++) { 8.189 + errn += verify("test_suba: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE)); 8.190 + } 8.191 + 8.192 + test_mulc(a0, a1); 8.193 + for (int i=0; i<ARRLEN; i++) { 8.194 + errn += verify("test_mulc: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE)); 8.195 + } 8.196 + test_mulv(a0, a1, (char)VALUE); 8.197 + for (int i=0; i<ARRLEN; i++) { 8.198 + errn += verify("test_mulv: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE)); 8.199 + } 8.200 + test_mula(a0, a1, a2); 8.201 + for (int i=0; i<ARRLEN; i++) { 8.202 + errn += verify("test_mula: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE)); 8.203 + } 8.204 + 8.205 + test_divc(a0, a1); 8.206 + for (int i=0; i<ARRLEN; i++) { 8.207 + errn += verify("test_divc: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE)); 8.208 + } 8.209 + test_divv(a0, a1, VALUE); 8.210 + for (int i=0; i<ARRLEN; i++) { 8.211 + errn += verify("test_divv: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE)); 8.212 + } 8.213 + test_diva(a0, a1, a2); 8.214 + for (int i=0; i<ARRLEN; i++) { 8.215 + errn += verify("test_diva: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE)); 8.216 + } 8.217 + 8.218 + test_mulc_n(a0, a1); 8.219 + for (int i=0; i<ARRLEN; i++) { 8.220 + errn += verify("test_mulc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE))); 8.221 + } 8.222 + test_mulv(a0, a1, (char)-VALUE); 8.223 + for (int i=0; i<ARRLEN; i++) { 8.224 + errn += verify("test_mulv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE))); 8.225 + } 8.226 + test_mula(a0, a1, a3); 8.227 + for (int i=0; i<ARRLEN; i++) { 8.228 + errn += verify("test_mula_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE))); 8.229 + } 8.230 + 8.231 + test_divc_n(a0, a1); 8.232 + for (int i=0; i<ARRLEN; i++) { 8.233 + errn += verify("test_divc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE))); 8.234 + } 8.235 + test_divv(a0, a1, -VALUE); 8.236 + for (int i=0; i<ARRLEN; i++) { 8.237 + errn += verify("test_divv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE))); 8.238 + } 8.239 + test_diva(a0, a1, a3); 8.240 + for (int i=0; i<ARRLEN; i++) { 8.241 + errn += verify("test_diva_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE))); 8.242 + } 8.243 + 8.244 + test_andc(a0, a1); 8.245 + for (int i=0; i<ARRLEN; i++) { 8.246 + errn += verify("test_andc: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK)); 8.247 + } 8.248 + test_andv(a0, a1, (short)BIT_MASK); 8.249 + for (int i=0; i<ARRLEN; i++) { 8.250 + errn += verify("test_andv: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK)); 8.251 + } 8.252 + test_anda(a0, a1, a4); 8.253 + for (int i=0; i<ARRLEN; i++) { 8.254 + errn += verify("test_anda: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK)); 8.255 + } 8.256 + 8.257 + test_orc(a0, a1); 8.258 + for (int i=0; i<ARRLEN; i++) { 8.259 + errn += verify("test_orc: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK)); 8.260 + } 8.261 + test_orv(a0, a1, (short)BIT_MASK); 8.262 + for (int i=0; i<ARRLEN; i++) { 8.263 + errn += verify("test_orv: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK)); 8.264 + } 8.265 + test_ora(a0, a1, a4); 8.266 + for (int i=0; i<ARRLEN; i++) { 8.267 + errn += verify("test_ora: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK)); 8.268 + } 8.269 + 8.270 + test_xorc(a0, a1); 8.271 + for (int i=0; i<ARRLEN; i++) { 8.272 + errn += verify("test_xorc: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK)); 8.273 + } 8.274 + test_xorv(a0, a1, (short)BIT_MASK); 8.275 + for (int i=0; i<ARRLEN; i++) { 8.276 + errn += verify("test_xorv: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK)); 8.277 + } 8.278 + test_xora(a0, a1, a4); 8.279 + for (int i=0; i<ARRLEN; i++) { 8.280 + errn += verify("test_xora: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK)); 8.281 + } 8.282 + 8.283 + test_sllc(a0, a1); 8.284 + for (int i=0; i<ARRLEN; i++) { 8.285 + errn += verify("test_sllc: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE)); 8.286 + } 8.287 + test_sllv(a0, a1, VALUE); 8.288 + for (int i=0; i<ARRLEN; i++) { 8.289 + errn += verify("test_sllv: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE)); 8.290 + } 8.291 + 8.292 + test_srlc(a0, a1); 8.293 + for (int i=0; i<ARRLEN; i++) { 8.294 + errn += verify("test_srlc: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE)); 8.295 + } 8.296 + test_srlv(a0, a1, VALUE); 8.297 + for (int i=0; i<ARRLEN; i++) { 8.298 + errn += verify("test_srlv: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE)); 8.299 + } 8.300 + 8.301 + test_srac(a0, a1); 8.302 + for (int i=0; i<ARRLEN; i++) { 8.303 + errn += verify("test_srac: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE)); 8.304 + } 8.305 + test_srav(a0, a1, VALUE); 8.306 + for (int i=0; i<ARRLEN; i++) { 8.307 + errn += verify("test_srav: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE)); 8.308 + } 8.309 + 8.310 + test_sllc_n(a0, a1); 8.311 + for (int i=0; i<ARRLEN; i++) { 8.312 + errn += verify("test_sllc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE))); 8.313 + } 8.314 + test_sllv(a0, a1, -VALUE); 8.315 + for (int i=0; i<ARRLEN; i++) { 8.316 + errn += verify("test_sllv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE))); 8.317 + } 8.318 + 8.319 + test_srlc_n(a0, a1); 8.320 + for (int i=0; i<ARRLEN; i++) { 8.321 + errn += verify("test_srlc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE))); 8.322 + } 8.323 + test_srlv(a0, a1, -VALUE); 8.324 + for (int i=0; i<ARRLEN; i++) { 8.325 + errn += verify("test_srlv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE))); 8.326 + } 8.327 + 8.328 + test_srac_n(a0, a1); 8.329 + for (int i=0; i<ARRLEN; i++) { 8.330 + errn += verify("test_srac_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE))); 8.331 + } 8.332 + test_srav(a0, a1, -VALUE); 8.333 + for (int i=0; i<ARRLEN; i++) { 8.334 + errn += verify("test_srav_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE))); 8.335 + } 8.336 + 8.337 + test_sllc_o(a0, a1); 8.338 + for (int i=0; i<ARRLEN; i++) { 8.339 + errn += verify("test_sllc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT)); 8.340 + } 8.341 + test_sllv(a0, a1, SHIFT); 8.342 + for (int i=0; i<ARRLEN; i++) { 8.343 + errn += verify("test_sllv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT)); 8.344 + } 8.345 + 8.346 + test_srlc_o(a0, a1); 8.347 + for (int i=0; i<ARRLEN; i++) { 8.348 + errn += verify("test_srlc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT)); 8.349 + } 8.350 + test_srlv(a0, a1, SHIFT); 8.351 + for (int i=0; i<ARRLEN; i++) { 8.352 + errn += verify("test_srlv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT)); 8.353 + } 8.354 + 8.355 + test_srac_o(a0, a1); 8.356 + for (int i=0; i<ARRLEN; i++) { 8.357 + errn += verify("test_srac_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT)); 8.358 + } 8.359 + test_srav(a0, a1, SHIFT); 8.360 + for (int i=0; i<ARRLEN; i++) { 8.361 + errn += verify("test_srav_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT)); 8.362 + } 8.363 + 8.364 + test_sllc_on(a0, a1); 8.365 + for (int i=0; i<ARRLEN; i++) { 8.366 + errn += verify("test_sllc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT))); 8.367 + } 8.368 + test_sllv(a0, a1, -SHIFT); 8.369 + for (int i=0; i<ARRLEN; i++) { 8.370 + errn += verify("test_sllv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT))); 8.371 + } 8.372 + 8.373 + test_srlc_on(a0, a1); 8.374 + for (int i=0; i<ARRLEN; i++) { 8.375 + errn += verify("test_srlc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT))); 8.376 + } 8.377 + test_srlv(a0, a1, -SHIFT); 8.378 + for (int i=0; i<ARRLEN; i++) { 8.379 + errn += verify("test_srlv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT))); 8.380 + } 8.381 + 8.382 + test_srac_on(a0, a1); 8.383 + for (int i=0; i<ARRLEN; i++) { 8.384 + errn += verify("test_srac_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT))); 8.385 + } 8.386 + test_srav(a0, a1, -SHIFT); 8.387 + for (int i=0; i<ARRLEN; i++) { 8.388 + errn += verify("test_srav_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT))); 8.389 + } 8.390 + 8.391 + test_sllc_add(a0, a1); 8.392 + for (int i=0; i<ARRLEN; i++) { 8.393 + errn += verify("test_sllc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 8.394 + } 8.395 + test_sllv_add(a0, a1, ADD_INIT); 8.396 + for (int i=0; i<ARRLEN; i++) { 8.397 + errn += verify("test_sllv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE)); 8.398 + } 8.399 + 8.400 + test_srlc_add(a0, a1); 8.401 + for (int i=0; i<ARRLEN; i++) { 8.402 + errn += verify("test_srlc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 8.403 + } 8.404 + test_srlv_add(a0, a1, ADD_INIT); 8.405 + for (int i=0; i<ARRLEN; i++) { 8.406 + errn += verify("test_srlv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE)); 8.407 + } 8.408 + 8.409 + test_srac_add(a0, a1); 8.410 + for (int i=0; i<ARRLEN; i++) { 8.411 + errn += verify("test_srac_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 8.412 + } 8.413 + test_srav_add(a0, a1, ADD_INIT); 8.414 + for (int i=0; i<ARRLEN; i++) { 8.415 + errn += verify("test_srav_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE)); 8.416 + } 8.417 + 8.418 + test_sllc_and(a0, a1); 8.419 + for (int i=0; i<ARRLEN; i++) { 8.420 + errn += verify("test_sllc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 8.421 + } 8.422 + test_sllv_and(a0, a1, BIT_MASK); 8.423 + for (int i=0; i<ARRLEN; i++) { 8.424 + errn += verify("test_sllv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE)); 8.425 + } 8.426 + 8.427 + test_srlc_and(a0, a1); 8.428 + for (int i=0; i<ARRLEN; i++) { 8.429 + errn += verify("test_srlc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 8.430 + } 8.431 + test_srlv_and(a0, a1, BIT_MASK); 8.432 + for (int i=0; i<ARRLEN; i++) { 8.433 + errn += verify("test_srlv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE)); 8.434 + } 8.435 + 8.436 + test_srac_and(a0, a1); 8.437 + for (int i=0; i<ARRLEN; i++) { 8.438 + errn += verify("test_srac_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 8.439 + } 8.440 + test_srav_and(a0, a1, BIT_MASK); 8.441 + for (int i=0; i<ARRLEN; i++) { 8.442 + errn += verify("test_srav_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE)); 8.443 + } 8.444 + 8.445 + test_pack2(p2, a1); 8.446 + for (int i=0; i<ARRLEN/2; i++) { 8.447 + errn += verify("test_pack2: ", i, p2[i], ((int)(ADD_INIT+2*i) & 0xFFFF) | ((int)(ADD_INIT+2*i+1) << 16)); 8.448 + } 8.449 + for (int i=0; i<ARRLEN; i++) { 8.450 + a0[i] = (char)-1; 8.451 + } 8.452 + test_unpack2(a0, p2); 8.453 + for (int i=0; i<(ARRLEN&(-2)); i++) { 8.454 + errn += verify("test_unpack2: ", i, a0[i], (char)(ADD_INIT+i)); 8.455 + } 8.456 + 8.457 + test_pack2_swap(p2, a1); 8.458 + for (int i=0; i<ARRLEN/2; i++) { 8.459 + errn += verify("test_pack2_swap: ", i, p2[i], ((int)(ADD_INIT+2*i+1) & 0xFFFF) | ((int)(ADD_INIT+2*i) << 16)); 8.460 + } 8.461 + for (int i=0; i<ARRLEN; i++) { 8.462 + a0[i] = (char)-1; 8.463 + } 8.464 + test_unpack2_swap(a0, p2); 8.465 + for (int i=0; i<(ARRLEN&(-2)); i++) { 8.466 + errn += verify("test_unpack2_swap: ", i, a0[i], (char)(ADD_INIT+i)); 8.467 + } 8.468 + 8.469 + test_pack4(p4, a1); 8.470 + for (int i=0; i<ARRLEN/4; i++) { 8.471 + errn += verify("test_pack4: ", i, p4[i], ((long)(ADD_INIT+4*i+0) & 0xFFFFl) | 8.472 + (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 16) | 8.473 + (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 32) | 8.474 + (((long)(ADD_INIT+4*i+3) & 0xFFFFl) << 48)); 8.475 + } 8.476 + for (int i=0; i<ARRLEN; i++) { 8.477 + a0[i] = (char)-1; 8.478 + } 8.479 + test_unpack4(a0, p4); 8.480 + for (int i=0; i<(ARRLEN&(-4)); i++) { 8.481 + errn += verify("test_unpack4: ", i, a0[i], (char)(ADD_INIT+i)); 8.482 + } 8.483 + 8.484 + test_pack4_swap(p4, a1); 8.485 + for (int i=0; i<ARRLEN/4; i++) { 8.486 + errn += verify("test_pack4_swap: ", i, p4[i], ((long)(ADD_INIT+4*i+3) & 0xFFFFl) | 8.487 + (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 16) | 8.488 + (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 32) | 8.489 + (((long)(ADD_INIT+4*i+0) & 0xFFFFl) << 48)); 8.490 + } 8.491 + for (int i=0; i<ARRLEN; i++) { 8.492 + a0[i] = (char)-1; 8.493 + } 8.494 + test_unpack4_swap(a0, p4); 8.495 + for (int i=0; i<(ARRLEN&(-4)); i++) { 8.496 + errn += verify("test_unpack4_swap: ", i, a0[i], (char)(ADD_INIT+i)); 8.497 + } 8.498 + 8.499 + } 8.500 + 8.501 + if (errn > 0) 8.502 + return errn; 8.503 + 8.504 + System.out.println("Time"); 8.505 + long start, end; 8.506 + 8.507 + start = System.currentTimeMillis(); 8.508 + for (int i=0; i<ITERS; i++) { 8.509 + test_sum(a1); 8.510 + } 8.511 + end = System.currentTimeMillis(); 8.512 + System.out.println("test_sum: " + (end - start)); 8.513 + 8.514 + start = System.currentTimeMillis(); 8.515 + for (int i=0; i<ITERS; i++) { 8.516 + test_addc(a0, a1); 8.517 + } 8.518 + end = System.currentTimeMillis(); 8.519 + System.out.println("test_addc: " + (end - start)); 8.520 + start = System.currentTimeMillis(); 8.521 + for (int i=0; i<ITERS; i++) { 8.522 + test_addv(a0, a1, (char)VALUE); 8.523 + } 8.524 + end = System.currentTimeMillis(); 8.525 + System.out.println("test_addv: " + (end - start)); 8.526 + start = System.currentTimeMillis(); 8.527 + for (int i=0; i<ITERS; i++) { 8.528 + test_adda(a0, a1, a2); 8.529 + } 8.530 + end = System.currentTimeMillis(); 8.531 + System.out.println("test_adda: " + (end - start)); 8.532 + 8.533 + start = System.currentTimeMillis(); 8.534 + for (int i=0; i<ITERS; i++) { 8.535 + test_subc(a0, a1); 8.536 + } 8.537 + end = System.currentTimeMillis(); 8.538 + System.out.println("test_subc: " + (end - start)); 8.539 + start = System.currentTimeMillis(); 8.540 + for (int i=0; i<ITERS; i++) { 8.541 + test_subv(a0, a1, (char)VALUE); 8.542 + } 8.543 + end = System.currentTimeMillis(); 8.544 + System.out.println("test_subv: " + (end - start)); 8.545 + start = System.currentTimeMillis(); 8.546 + for (int i=0; i<ITERS; i++) { 8.547 + test_suba(a0, a1, a2); 8.548 + } 8.549 + end = System.currentTimeMillis(); 8.550 + System.out.println("test_suba: " + (end - start)); 8.551 + 8.552 + start = System.currentTimeMillis(); 8.553 + for (int i=0; i<ITERS; i++) { 8.554 + test_mulc(a0, a1); 8.555 + } 8.556 + end = System.currentTimeMillis(); 8.557 + System.out.println("test_mulc: " + (end - start)); 8.558 + start = System.currentTimeMillis(); 8.559 + for (int i=0; i<ITERS; i++) { 8.560 + test_mulv(a0, a1, (char)VALUE); 8.561 + } 8.562 + end = System.currentTimeMillis(); 8.563 + System.out.println("test_mulv: " + (end - start)); 8.564 + start = System.currentTimeMillis(); 8.565 + for (int i=0; i<ITERS; i++) { 8.566 + test_mula(a0, a1, a2); 8.567 + } 8.568 + end = System.currentTimeMillis(); 8.569 + System.out.println("test_mula: " + (end - start)); 8.570 + 8.571 + start = System.currentTimeMillis(); 8.572 + for (int i=0; i<ITERS; i++) { 8.573 + test_divc(a0, a1); 8.574 + } 8.575 + end = System.currentTimeMillis(); 8.576 + System.out.println("test_divc: " + (end - start)); 8.577 + start = System.currentTimeMillis(); 8.578 + for (int i=0; i<ITERS; i++) { 8.579 + test_divv(a0, a1, VALUE); 8.580 + } 8.581 + end = System.currentTimeMillis(); 8.582 + System.out.println("test_divv: " + (end - start)); 8.583 + start = System.currentTimeMillis(); 8.584 + for (int i=0; i<ITERS; i++) { 8.585 + test_diva(a0, a1, a2); 8.586 + } 8.587 + end = System.currentTimeMillis(); 8.588 + System.out.println("test_diva: " + (end - start)); 8.589 + 8.590 + start = System.currentTimeMillis(); 8.591 + for (int i=0; i<ITERS; i++) { 8.592 + test_mulc_n(a0, a1); 8.593 + } 8.594 + end = System.currentTimeMillis(); 8.595 + System.out.println("test_mulc_n: " + (end - start)); 8.596 + start = System.currentTimeMillis(); 8.597 + for (int i=0; i<ITERS; i++) { 8.598 + test_mulv(a0, a1, (char)-VALUE); 8.599 + } 8.600 + end = System.currentTimeMillis(); 8.601 + System.out.println("test_mulv_n: " + (end - start)); 8.602 + start = System.currentTimeMillis(); 8.603 + for (int i=0; i<ITERS; i++) { 8.604 + test_mula(a0, a1, a3); 8.605 + } 8.606 + end = System.currentTimeMillis(); 8.607 + System.out.println("test_mula_n: " + (end - start)); 8.608 + 8.609 + start = System.currentTimeMillis(); 8.610 + for (int i=0; i<ITERS; i++) { 8.611 + test_divc_n(a0, a1); 8.612 + } 8.613 + end = System.currentTimeMillis(); 8.614 + System.out.println("test_divc_n: " + (end - start)); 8.615 + start = System.currentTimeMillis(); 8.616 + for (int i=0; i<ITERS; i++) { 8.617 + test_divv(a0, a1, -VALUE); 8.618 + } 8.619 + end = System.currentTimeMillis(); 8.620 + System.out.println("test_divv_n: " + (end - start)); 8.621 + start = System.currentTimeMillis(); 8.622 + for (int i=0; i<ITERS; i++) { 8.623 + test_diva(a0, a1, a3); 8.624 + } 8.625 + end = System.currentTimeMillis(); 8.626 + System.out.println("test_diva_n: " + (end - start)); 8.627 + 8.628 + start = System.currentTimeMillis(); 8.629 + for (int i=0; i<ITERS; i++) { 8.630 + test_andc(a0, a1); 8.631 + } 8.632 + end = System.currentTimeMillis(); 8.633 + System.out.println("test_andc: " + (end - start)); 8.634 + start = System.currentTimeMillis(); 8.635 + for (int i=0; i<ITERS; i++) { 8.636 + test_andv(a0, a1, (short)BIT_MASK); 8.637 + } 8.638 + end = System.currentTimeMillis(); 8.639 + System.out.println("test_andv: " + (end - start)); 8.640 + start = System.currentTimeMillis(); 8.641 + for (int i=0; i<ITERS; i++) { 8.642 + test_anda(a0, a1, a4); 8.643 + } 8.644 + end = System.currentTimeMillis(); 8.645 + System.out.println("test_anda: " + (end - start)); 8.646 + 8.647 + start = System.currentTimeMillis(); 8.648 + for (int i=0; i<ITERS; i++) { 8.649 + test_orc(a0, a1); 8.650 + } 8.651 + end = System.currentTimeMillis(); 8.652 + System.out.println("test_orc: " + (end - start)); 8.653 + start = System.currentTimeMillis(); 8.654 + for (int i=0; i<ITERS; i++) { 8.655 + test_orv(a0, a1, (short)BIT_MASK); 8.656 + } 8.657 + end = System.currentTimeMillis(); 8.658 + System.out.println("test_orv: " + (end - start)); 8.659 + start = System.currentTimeMillis(); 8.660 + for (int i=0; i<ITERS; i++) { 8.661 + test_ora(a0, a1, a4); 8.662 + } 8.663 + end = System.currentTimeMillis(); 8.664 + System.out.println("test_ora: " + (end - start)); 8.665 + 8.666 + start = System.currentTimeMillis(); 8.667 + for (int i=0; i<ITERS; i++) { 8.668 + test_xorc(a0, a1); 8.669 + } 8.670 + end = System.currentTimeMillis(); 8.671 + System.out.println("test_xorc: " + (end - start)); 8.672 + start = System.currentTimeMillis(); 8.673 + for (int i=0; i<ITERS; i++) { 8.674 + test_xorv(a0, a1, (short)BIT_MASK); 8.675 + } 8.676 + end = System.currentTimeMillis(); 8.677 + System.out.println("test_xorv: " + (end - start)); 8.678 + start = System.currentTimeMillis(); 8.679 + for (int i=0; i<ITERS; i++) { 8.680 + test_xora(a0, a1, a4); 8.681 + } 8.682 + end = System.currentTimeMillis(); 8.683 + System.out.println("test_xora: " + (end - start)); 8.684 + 8.685 + start = System.currentTimeMillis(); 8.686 + for (int i=0; i<ITERS; i++) { 8.687 + test_sllc(a0, a1); 8.688 + } 8.689 + end = System.currentTimeMillis(); 8.690 + System.out.println("test_sllc: " + (end - start)); 8.691 + start = System.currentTimeMillis(); 8.692 + for (int i=0; i<ITERS; i++) { 8.693 + test_sllv(a0, a1, VALUE); 8.694 + } 8.695 + end = System.currentTimeMillis(); 8.696 + System.out.println("test_sllv: " + (end - start)); 8.697 + 8.698 + start = System.currentTimeMillis(); 8.699 + for (int i=0; i<ITERS; i++) { 8.700 + test_srlc(a0, a1); 8.701 + } 8.702 + end = System.currentTimeMillis(); 8.703 + System.out.println("test_srlc: " + (end - start)); 8.704 + start = System.currentTimeMillis(); 8.705 + for (int i=0; i<ITERS; i++) { 8.706 + test_srlv(a0, a1, VALUE); 8.707 + } 8.708 + end = System.currentTimeMillis(); 8.709 + System.out.println("test_srlv: " + (end - start)); 8.710 + 8.711 + start = System.currentTimeMillis(); 8.712 + for (int i=0; i<ITERS; i++) { 8.713 + test_srac(a0, a1); 8.714 + } 8.715 + end = System.currentTimeMillis(); 8.716 + System.out.println("test_srac: " + (end - start)); 8.717 + start = System.currentTimeMillis(); 8.718 + for (int i=0; i<ITERS; i++) { 8.719 + test_srav(a0, a1, VALUE); 8.720 + } 8.721 + end = System.currentTimeMillis(); 8.722 + System.out.println("test_srav: " + (end - start)); 8.723 + 8.724 + start = System.currentTimeMillis(); 8.725 + for (int i=0; i<ITERS; i++) { 8.726 + test_sllc_n(a0, a1); 8.727 + } 8.728 + end = System.currentTimeMillis(); 8.729 + System.out.println("test_sllc_n: " + (end - start)); 8.730 + start = System.currentTimeMillis(); 8.731 + for (int i=0; i<ITERS; i++) { 8.732 + test_sllv(a0, a1, -VALUE); 8.733 + } 8.734 + end = System.currentTimeMillis(); 8.735 + System.out.println("test_sllv_n: " + (end - start)); 8.736 + 8.737 + start = System.currentTimeMillis(); 8.738 + for (int i=0; i<ITERS; i++) { 8.739 + test_srlc_n(a0, a1); 8.740 + } 8.741 + end = System.currentTimeMillis(); 8.742 + System.out.println("test_srlc_n: " + (end - start)); 8.743 + start = System.currentTimeMillis(); 8.744 + for (int i=0; i<ITERS; i++) { 8.745 + test_srlv(a0, a1, -VALUE); 8.746 + } 8.747 + end = System.currentTimeMillis(); 8.748 + System.out.println("test_srlv_n: " + (end - start)); 8.749 + 8.750 + start = System.currentTimeMillis(); 8.751 + for (int i=0; i<ITERS; i++) { 8.752 + test_srac_n(a0, a1); 8.753 + } 8.754 + end = System.currentTimeMillis(); 8.755 + System.out.println("test_srac_n: " + (end - start)); 8.756 + start = System.currentTimeMillis(); 8.757 + for (int i=0; i<ITERS; i++) { 8.758 + test_srav(a0, a1, -VALUE); 8.759 + } 8.760 + end = System.currentTimeMillis(); 8.761 + System.out.println("test_srav_n: " + (end - start)); 8.762 + 8.763 + start = System.currentTimeMillis(); 8.764 + for (int i=0; i<ITERS; i++) { 8.765 + test_sllc_o(a0, a1); 8.766 + } 8.767 + end = System.currentTimeMillis(); 8.768 + System.out.println("test_sllc_o: " + (end - start)); 8.769 + start = System.currentTimeMillis(); 8.770 + for (int i=0; i<ITERS; i++) { 8.771 + test_sllv(a0, a1, SHIFT); 8.772 + } 8.773 + end = System.currentTimeMillis(); 8.774 + System.out.println("test_sllv_o: " + (end - start)); 8.775 + 8.776 + start = System.currentTimeMillis(); 8.777 + for (int i=0; i<ITERS; i++) { 8.778 + test_srlc_o(a0, a1); 8.779 + } 8.780 + end = System.currentTimeMillis(); 8.781 + System.out.println("test_srlc_o: " + (end - start)); 8.782 + start = System.currentTimeMillis(); 8.783 + for (int i=0; i<ITERS; i++) { 8.784 + test_srlv(a0, a1, SHIFT); 8.785 + } 8.786 + end = System.currentTimeMillis(); 8.787 + System.out.println("test_srlv_o: " + (end - start)); 8.788 + 8.789 + start = System.currentTimeMillis(); 8.790 + for (int i=0; i<ITERS; i++) { 8.791 + test_srac_o(a0, a1); 8.792 + } 8.793 + end = System.currentTimeMillis(); 8.794 + System.out.println("test_srac_o: " + (end - start)); 8.795 + start = System.currentTimeMillis(); 8.796 + for (int i=0; i<ITERS; i++) { 8.797 + test_srav(a0, a1, SHIFT); 8.798 + } 8.799 + end = System.currentTimeMillis(); 8.800 + System.out.println("test_srav_o: " + (end - start)); 8.801 + 8.802 + start = System.currentTimeMillis(); 8.803 + for (int i=0; i<ITERS; i++) { 8.804 + test_sllc_on(a0, a1); 8.805 + } 8.806 + end = System.currentTimeMillis(); 8.807 + System.out.println("test_sllc_on: " + (end - start)); 8.808 + start = System.currentTimeMillis(); 8.809 + for (int i=0; i<ITERS; i++) { 8.810 + test_sllv(a0, a1, -SHIFT); 8.811 + } 8.812 + end = System.currentTimeMillis(); 8.813 + System.out.println("test_sllv_on: " + (end - start)); 8.814 + 8.815 + start = System.currentTimeMillis(); 8.816 + for (int i=0; i<ITERS; i++) { 8.817 + test_srlc_on(a0, a1); 8.818 + } 8.819 + end = System.currentTimeMillis(); 8.820 + System.out.println("test_srlc_on: " + (end - start)); 8.821 + start = System.currentTimeMillis(); 8.822 + for (int i=0; i<ITERS; i++) { 8.823 + test_srlv(a0, a1, -SHIFT); 8.824 + } 8.825 + end = System.currentTimeMillis(); 8.826 + System.out.println("test_srlv_on: " + (end - start)); 8.827 + 8.828 + start = System.currentTimeMillis(); 8.829 + for (int i=0; i<ITERS; i++) { 8.830 + test_srac_on(a0, a1); 8.831 + } 8.832 + end = System.currentTimeMillis(); 8.833 + System.out.println("test_srac_on: " + (end - start)); 8.834 + start = System.currentTimeMillis(); 8.835 + for (int i=0; i<ITERS; i++) { 8.836 + test_srav(a0, a1, -SHIFT); 8.837 + } 8.838 + end = System.currentTimeMillis(); 8.839 + System.out.println("test_srav_on: " + (end - start)); 8.840 + 8.841 + start = System.currentTimeMillis(); 8.842 + for (int i=0; i<ITERS; i++) { 8.843 + test_sllc_add(a0, a1); 8.844 + } 8.845 + end = System.currentTimeMillis(); 8.846 + System.out.println("test_sllc_add: " + (end - start)); 8.847 + start = System.currentTimeMillis(); 8.848 + for (int i=0; i<ITERS; i++) { 8.849 + test_sllv_add(a0, a1, ADD_INIT); 8.850 + } 8.851 + end = System.currentTimeMillis(); 8.852 + System.out.println("test_sllv_add: " + (end - start)); 8.853 + 8.854 + start = System.currentTimeMillis(); 8.855 + for (int i=0; i<ITERS; i++) { 8.856 + test_srlc_add(a0, a1); 8.857 + } 8.858 + end = System.currentTimeMillis(); 8.859 + System.out.println("test_srlc_add: " + (end - start)); 8.860 + start = System.currentTimeMillis(); 8.861 + for (int i=0; i<ITERS; i++) { 8.862 + test_srlv_add(a0, a1, ADD_INIT); 8.863 + } 8.864 + end = System.currentTimeMillis(); 8.865 + System.out.println("test_srlv_add: " + (end - start)); 8.866 + 8.867 + start = System.currentTimeMillis(); 8.868 + for (int i=0; i<ITERS; i++) { 8.869 + test_srac_add(a0, a1); 8.870 + } 8.871 + end = System.currentTimeMillis(); 8.872 + System.out.println("test_srac_add: " + (end - start)); 8.873 + start = System.currentTimeMillis(); 8.874 + for (int i=0; i<ITERS; i++) { 8.875 + test_srav_add(a0, a1, ADD_INIT); 8.876 + } 8.877 + end = System.currentTimeMillis(); 8.878 + System.out.println("test_srav_add: " + (end - start)); 8.879 + 8.880 + start = System.currentTimeMillis(); 8.881 + for (int i=0; i<ITERS; i++) { 8.882 + test_sllc_and(a0, a1); 8.883 + } 8.884 + end = System.currentTimeMillis(); 8.885 + System.out.println("test_sllc_and: " + (end - start)); 8.886 + start = System.currentTimeMillis(); 8.887 + for (int i=0; i<ITERS; i++) { 8.888 + test_sllv_and(a0, a1, BIT_MASK); 8.889 + } 8.890 + end = System.currentTimeMillis(); 8.891 + System.out.println("test_sllv_and: " + (end - start)); 8.892 + 8.893 + start = System.currentTimeMillis(); 8.894 + for (int i=0; i<ITERS; i++) { 8.895 + test_srlc_and(a0, a1); 8.896 + } 8.897 + end = System.currentTimeMillis(); 8.898 + System.out.println("test_srlc_and: " + (end - start)); 8.899 + start = System.currentTimeMillis(); 8.900 + for (int i=0; i<ITERS; i++) { 8.901 + test_srlv_and(a0, a1, BIT_MASK); 8.902 + } 8.903 + end = System.currentTimeMillis(); 8.904 + System.out.println("test_srlv_and: " + (end - start)); 8.905 + 8.906 + start = System.currentTimeMillis(); 8.907 + for (int i=0; i<ITERS; i++) { 8.908 + test_srac_and(a0, a1); 8.909 + } 8.910 + end = System.currentTimeMillis(); 8.911 + System.out.println("test_srac_and: " + (end - start)); 8.912 + start = System.currentTimeMillis(); 8.913 + for (int i=0; i<ITERS; i++) { 8.914 + test_srav_and(a0, a1, BIT_MASK); 8.915 + } 8.916 + end = System.currentTimeMillis(); 8.917 + System.out.println("test_srav_and: " + (end - start)); 8.918 + 8.919 + start = System.currentTimeMillis(); 8.920 + for (int i=0; i<ITERS; i++) { 8.921 + test_pack2(p2, a1); 8.922 + } 8.923 + end = System.currentTimeMillis(); 8.924 + System.out.println("test_pack2: " + (end - start)); 8.925 + start = System.currentTimeMillis(); 8.926 + for (int i=0; i<ITERS; i++) { 8.927 + test_unpack2(a0, p2); 8.928 + } 8.929 + end = System.currentTimeMillis(); 8.930 + System.out.println("test_unpack2: " + (end - start)); 8.931 + start = System.currentTimeMillis(); 8.932 + for (int i=0; i<ITERS; i++) { 8.933 + test_pack2_swap(p2, a1); 8.934 + } 8.935 + end = System.currentTimeMillis(); 8.936 + System.out.println("test_pack2_swap: " + (end - start)); 8.937 + start = System.currentTimeMillis(); 8.938 + for (int i=0; i<ITERS; i++) { 8.939 + test_unpack2_swap(a0, p2); 8.940 + } 8.941 + end = System.currentTimeMillis(); 8.942 + System.out.println("test_unpack2_swap: " + (end - start)); 8.943 + 8.944 + start = System.currentTimeMillis(); 8.945 + for (int i=0; i<ITERS; i++) { 8.946 + test_pack4(p4, a1); 8.947 + } 8.948 + end = System.currentTimeMillis(); 8.949 + System.out.println("test_pack4: " + (end - start)); 8.950 + start = System.currentTimeMillis(); 8.951 + for (int i=0; i<ITERS; i++) { 8.952 + test_unpack4(a0, p4); 8.953 + } 8.954 + end = System.currentTimeMillis(); 8.955 + System.out.println("test_unpack4: " + (end - start)); 8.956 + start = System.currentTimeMillis(); 8.957 + for (int i=0; i<ITERS; i++) { 8.958 + test_pack4_swap(p4, a1); 8.959 + } 8.960 + end = System.currentTimeMillis(); 8.961 + System.out.println("test_pack4_swap: " + (end - start)); 8.962 + start = System.currentTimeMillis(); 8.963 + for (int i=0; i<ITERS; i++) { 8.964 + test_unpack4_swap(a0, p4); 8.965 + } 8.966 + end = System.currentTimeMillis(); 8.967 + System.out.println("test_unpack4_swap: " + (end - start)); 8.968 + 8.969 + return errn; 8.970 + } 8.971 + 8.972 + static int test_sum(char[] a1) { 8.973 + int sum = 0; 8.974 + for (int i = 0; i < a1.length; i+=1) { 8.975 + sum += a1[i]; 8.976 + } 8.977 + return sum; 8.978 + } 8.979 + 8.980 + static void test_addc(char[] a0, char[] a1) { 8.981 + for (int i = 0; i < a0.length; i+=1) { 8.982 + a0[i] = (char)(a1[i]+VALUE); 8.983 + } 8.984 + } 8.985 + static void test_addv(char[] a0, char[] a1, char b) { 8.986 + for (int i = 0; i < a0.length; i+=1) { 8.987 + a0[i] = (char)(a1[i]+b); 8.988 + } 8.989 + } 8.990 + static void test_adda(char[] a0, char[] a1, short[] a2) { 8.991 + for (int i = 0; i < a0.length; i+=1) { 8.992 + a0[i] = (char)(a1[i]+a2[i]); 8.993 + } 8.994 + } 8.995 + 8.996 + static void test_subc(char[] a0, char[] a1) { 8.997 + for (int i = 0; i < a0.length; i+=1) { 8.998 + a0[i] = (char)(a1[i]-VALUE); 8.999 + } 8.1000 + } 8.1001 + static void test_subv(char[] a0, char[] a1, char b) { 8.1002 + for (int i = 0; i < a0.length; i+=1) { 8.1003 + a0[i] = (char)(a1[i]-b); 8.1004 + } 8.1005 + } 8.1006 + static void test_suba(char[] a0, char[] a1, short[] a2) { 8.1007 + for (int i = 0; i < a0.length; i+=1) { 8.1008 + a0[i] = (char)(a1[i]-a2[i]); 8.1009 + } 8.1010 + } 8.1011 + 8.1012 + static void test_mulc(char[] a0, char[] a1) { 8.1013 + for (int i = 0; i < a0.length; i+=1) { 8.1014 + a0[i] = (char)(a1[i]*VALUE); 8.1015 + } 8.1016 + } 8.1017 + static void test_mulc_n(char[] a0, char[] a1) { 8.1018 + for (int i = 0; i < a0.length; i+=1) { 8.1019 + a0[i] = (char)(a1[i]*(-VALUE)); 8.1020 + } 8.1021 + } 8.1022 + static void test_mulv(char[] a0, char[] a1, char b) { 8.1023 + for (int i = 0; i < a0.length; i+=1) { 8.1024 + a0[i] = (char)(a1[i]*b); 8.1025 + } 8.1026 + } 8.1027 + static void test_mula(char[] a0, char[] a1, short[] a2) { 8.1028 + for (int i = 0; i < a0.length; i+=1) { 8.1029 + a0[i] = (char)(a1[i]*a2[i]); 8.1030 + } 8.1031 + } 8.1032 + 8.1033 + static void test_divc(char[] a0, char[] a1) { 8.1034 + for (int i = 0; i < a0.length; i+=1) { 8.1035 + a0[i] = (char)(a1[i]/VALUE); 8.1036 + } 8.1037 + } 8.1038 + static void test_divc_n(char[] a0, char[] a1) { 8.1039 + for (int i = 0; i < a0.length; i+=1) { 8.1040 + a0[i] = (char)(a1[i]/(-VALUE)); 8.1041 + } 8.1042 + } 8.1043 + static void test_divv(char[] a0, char[] a1, int b) { 8.1044 + for (int i = 0; i < a0.length; i+=1) { 8.1045 + a0[i] = (char)(a1[i]/b); 8.1046 + } 8.1047 + } 8.1048 + static void test_diva(char[] a0, char[] a1, short[] a2) { 8.1049 + for (int i = 0; i < a0.length; i+=1) { 8.1050 + a0[i] = (char)(a1[i]/a2[i]); 8.1051 + } 8.1052 + } 8.1053 + 8.1054 + static void test_andc(char[] a0, char[] a1) { 8.1055 + for (int i = 0; i < a0.length; i+=1) { 8.1056 + a0[i] = (char)(a1[i]&BIT_MASK); 8.1057 + } 8.1058 + } 8.1059 + static void test_andv(char[] a0, char[] a1, short b) { 8.1060 + for (int i = 0; i < a0.length; i+=1) { 8.1061 + a0[i] = (char)(a1[i]&b); 8.1062 + } 8.1063 + } 8.1064 + static void test_anda(char[] a0, char[] a1, short[] a2) { 8.1065 + for (int i = 0; i < a0.length; i+=1) { 8.1066 + a0[i] = (char)(a1[i]&a2[i]); 8.1067 + } 8.1068 + } 8.1069 + 8.1070 + static void test_orc(char[] a0, char[] a1) { 8.1071 + for (int i = 0; i < a0.length; i+=1) { 8.1072 + a0[i] = (char)(a1[i]|BIT_MASK); 8.1073 + } 8.1074 + } 8.1075 + static void test_orv(char[] a0, char[] a1, short b) { 8.1076 + for (int i = 0; i < a0.length; i+=1) { 8.1077 + a0[i] = (char)(a1[i]|b); 8.1078 + } 8.1079 + } 8.1080 + static void test_ora(char[] a0, char[] a1, short[] a2) { 8.1081 + for (int i = 0; i < a0.length; i+=1) { 8.1082 + a0[i] = (char)(a1[i]|a2[i]); 8.1083 + } 8.1084 + } 8.1085 + 8.1086 + static void test_xorc(char[] a0, char[] a1) { 8.1087 + for (int i = 0; i < a0.length; i+=1) { 8.1088 + a0[i] = (char)(a1[i]^BIT_MASK); 8.1089 + } 8.1090 + } 8.1091 + static void test_xorv(char[] a0, char[] a1, short b) { 8.1092 + for (int i = 0; i < a0.length; i+=1) { 8.1093 + a0[i] = (char)(a1[i]^b); 8.1094 + } 8.1095 + } 8.1096 + static void test_xora(char[] a0, char[] a1, short[] a2) { 8.1097 + for (int i = 0; i < a0.length; i+=1) { 8.1098 + a0[i] = (char)(a1[i]^a2[i]); 8.1099 + } 8.1100 + } 8.1101 + 8.1102 + static void test_sllc(char[] a0, char[] a1) { 8.1103 + for (int i = 0; i < a0.length; i+=1) { 8.1104 + a0[i] = (char)(a1[i]<<VALUE); 8.1105 + } 8.1106 + } 8.1107 + static void test_sllc_n(char[] a0, char[] a1) { 8.1108 + for (int i = 0; i < a0.length; i+=1) { 8.1109 + a0[i] = (char)(a1[i]<<(-VALUE)); 8.1110 + } 8.1111 + } 8.1112 + static void test_sllc_o(char[] a0, char[] a1) { 8.1113 + for (int i = 0; i < a0.length; i+=1) { 8.1114 + a0[i] = (char)(a1[i]<<SHIFT); 8.1115 + } 8.1116 + } 8.1117 + static void test_sllc_on(char[] a0, char[] a1) { 8.1118 + for (int i = 0; i < a0.length; i+=1) { 8.1119 + a0[i] = (char)(a1[i]<<(-SHIFT)); 8.1120 + } 8.1121 + } 8.1122 + static void test_sllv(char[] a0, char[] a1, int b) { 8.1123 + for (int i = 0; i < a0.length; i+=1) { 8.1124 + a0[i] = (char)(a1[i]<<b); 8.1125 + } 8.1126 + } 8.1127 + static void test_sllc_add(char[] a0, char[] a1) { 8.1128 + for (int i = 0; i < a0.length; i+=1) { 8.1129 + a0[i] = (char)((a1[i] + ADD_INIT)<<VALUE); 8.1130 + } 8.1131 + } 8.1132 + static void test_sllv_add(char[] a0, char[] a1, int b) { 8.1133 + for (int i = 0; i < a0.length; i+=1) { 8.1134 + a0[i] = (char)((a1[i] + b)<<VALUE); 8.1135 + } 8.1136 + } 8.1137 + static void test_sllc_and(char[] a0, char[] a1) { 8.1138 + for (int i = 0; i < a0.length; i+=1) { 8.1139 + a0[i] = (char)((a1[i] & BIT_MASK)<<VALUE); 8.1140 + } 8.1141 + } 8.1142 + static void test_sllv_and(char[] a0, char[] a1, int b) { 8.1143 + for (int i = 0; i < a0.length; i+=1) { 8.1144 + a0[i] = (char)((a1[i] & b)<<VALUE); 8.1145 + } 8.1146 + } 8.1147 + 8.1148 + static void test_srlc(char[] a0, char[] a1) { 8.1149 + for (int i = 0; i < a0.length; i+=1) { 8.1150 + a0[i] = (char)(a1[i]>>>VALUE); 8.1151 + } 8.1152 + } 8.1153 + static void test_srlc_n(char[] a0, char[] a1) { 8.1154 + for (int i = 0; i < a0.length; i+=1) { 8.1155 + a0[i] = (char)(a1[i]>>>(-VALUE)); 8.1156 + } 8.1157 + } 8.1158 + static void test_srlc_o(char[] a0, char[] a1) { 8.1159 + for (int i = 0; i < a0.length; i+=1) { 8.1160 + a0[i] = (char)(a1[i]>>>SHIFT); 8.1161 + } 8.1162 + } 8.1163 + static void test_srlc_on(char[] a0, char[] a1) { 8.1164 + for (int i = 0; i < a0.length; i+=1) { 8.1165 + a0[i] = (char)(a1[i]>>>(-SHIFT)); 8.1166 + } 8.1167 + } 8.1168 + static void test_srlv(char[] a0, char[] a1, int b) { 8.1169 + for (int i = 0; i < a0.length; i+=1) { 8.1170 + a0[i] = (char)(a1[i]>>>b); 8.1171 + } 8.1172 + } 8.1173 + static void test_srlc_add(char[] a0, char[] a1) { 8.1174 + for (int i = 0; i < a0.length; i+=1) { 8.1175 + a0[i] = (char)((a1[i] + ADD_INIT)>>>VALUE); 8.1176 + } 8.1177 + } 8.1178 + static void test_srlv_add(char[] a0, char[] a1, int b) { 8.1179 + for (int i = 0; i < a0.length; i+=1) { 8.1180 + a0[i] = (char)((a1[i] + b)>>>VALUE); 8.1181 + } 8.1182 + } 8.1183 + static void test_srlc_and(char[] a0, char[] a1) { 8.1184 + for (int i = 0; i < a0.length; i+=1) { 8.1185 + a0[i] = (char)((a1[i] & BIT_MASK)>>>VALUE); 8.1186 + } 8.1187 + } 8.1188 + static void test_srlv_and(char[] a0, char[] a1, int b) { 8.1189 + for (int i = 0; i < a0.length; i+=1) { 8.1190 + a0[i] = (char)((a1[i] & b)>>>VALUE); 8.1191 + } 8.1192 + } 8.1193 + 8.1194 + static void test_srac(char[] a0, char[] a1) { 8.1195 + for (int i = 0; i < a0.length; i+=1) { 8.1196 + a0[i] = (char)(a1[i]>>VALUE); 8.1197 + } 8.1198 + } 8.1199 + static void test_srac_n(char[] a0, char[] a1) { 8.1200 + for (int i = 0; i < a0.length; i+=1) { 8.1201 + a0[i] = (char)(a1[i]>>(-VALUE)); 8.1202 + } 8.1203 + } 8.1204 + static void test_srac_o(char[] a0, char[] a1) { 8.1205 + for (int i = 0; i < a0.length; i+=1) { 8.1206 + a0[i] = (char)(a1[i]>>SHIFT); 8.1207 + } 8.1208 + } 8.1209 + static void test_srac_on(char[] a0, char[] a1) { 8.1210 + for (int i = 0; i < a0.length; i+=1) { 8.1211 + a0[i] = (char)(a1[i]>>(-SHIFT)); 8.1212 + } 8.1213 + } 8.1214 + static void test_srav(char[] a0, char[] a1, int b) { 8.1215 + for (int i = 0; i < a0.length; i+=1) { 8.1216 + a0[i] = (char)(a1[i]>>b); 8.1217 + } 8.1218 + } 8.1219 + static void test_srac_add(char[] a0, char[] a1) { 8.1220 + for (int i = 0; i < a0.length; i+=1) { 8.1221 + a0[i] = (char)((a1[i] + ADD_INIT)>>VALUE); 8.1222 + } 8.1223 + } 8.1224 + static void test_srav_add(char[] a0, char[] a1, int b) { 8.1225 + for (int i = 0; i < a0.length; i+=1) { 8.1226 + a0[i] = (char)((a1[i] + b)>>VALUE); 8.1227 + } 8.1228 + } 8.1229 + static void test_srac_and(char[] a0, char[] a1) { 8.1230 + for (int i = 0; i < a0.length; i+=1) { 8.1231 + a0[i] = (char)((a1[i] & BIT_MASK)>>VALUE); 8.1232 + } 8.1233 + } 8.1234 + static void test_srav_and(char[] a0, char[] a1, int b) { 8.1235 + for (int i = 0; i < a0.length; i+=1) { 8.1236 + a0[i] = (char)((a1[i] & b)>>VALUE); 8.1237 + } 8.1238 + } 8.1239 + 8.1240 + static void test_pack2(int[] p2, char[] a1) { 8.1241 + if (p2.length*2 > a1.length) return; 8.1242 + for (int i = 0; i < p2.length; i+=1) { 8.1243 + int l0 = (int)a1[i*2+0]; 8.1244 + int l1 = (int)a1[i*2+1]; 8.1245 + p2[i] = (l1 << 16) | (l0 & 0xFFFF); 8.1246 + } 8.1247 + } 8.1248 + static void test_unpack2(char[] a0, int[] p2) { 8.1249 + if (p2.length*2 > a0.length) return; 8.1250 + for (int i = 0; i < p2.length; i+=1) { 8.1251 + int l = p2[i]; 8.1252 + a0[i*2+0] = (char)(l & 0xFFFF); 8.1253 + a0[i*2+1] = (char)(l >> 16); 8.1254 + } 8.1255 + } 8.1256 + static void test_pack2_swap(int[] p2, char[] a1) { 8.1257 + if (p2.length*2 > a1.length) return; 8.1258 + for (int i = 0; i < p2.length; i+=1) { 8.1259 + int l0 = (int)a1[i*2+0]; 8.1260 + int l1 = (int)a1[i*2+1]; 8.1261 + p2[i] = (l0 << 16) | (l1 & 0xFFFF); 8.1262 + } 8.1263 + } 8.1264 + static void test_unpack2_swap(char[] a0, int[] p2) { 8.1265 + if (p2.length*2 > a0.length) return; 8.1266 + for (int i = 0; i < p2.length; i+=1) { 8.1267 + int l = p2[i]; 8.1268 + a0[i*2+0] = (char)(l >> 16); 8.1269 + a0[i*2+1] = (char)(l & 0xFFFF); 8.1270 + } 8.1271 + } 8.1272 + 8.1273 + static void test_pack4(long[] p4, char[] a1) { 8.1274 + if (p4.length*4 > a1.length) return; 8.1275 + for (int i = 0; i < p4.length; i+=1) { 8.1276 + long l0 = (long)a1[i*4+0]; 8.1277 + long l1 = (long)a1[i*4+1]; 8.1278 + long l2 = (long)a1[i*4+2]; 8.1279 + long l3 = (long)a1[i*4+3]; 8.1280 + p4[i] = (l0 & 0xFFFFl) | 8.1281 + ((l1 & 0xFFFFl) << 16) | 8.1282 + ((l2 & 0xFFFFl) << 32) | 8.1283 + ((l3 & 0xFFFFl) << 48); 8.1284 + } 8.1285 + } 8.1286 + static void test_unpack4(char[] a0, long[] p4) { 8.1287 + if (p4.length*4 > a0.length) return; 8.1288 + for (int i = 0; i < p4.length; i+=1) { 8.1289 + long l = p4[i]; 8.1290 + a0[i*4+0] = (char)(l & 0xFFFFl); 8.1291 + a0[i*4+1] = (char)(l >> 16); 8.1292 + a0[i*4+2] = (char)(l >> 32); 8.1293 + a0[i*4+3] = (char)(l >> 48); 8.1294 + } 8.1295 + } 8.1296 + static void test_pack4_swap(long[] p4, char[] a1) { 8.1297 + if (p4.length*4 > a1.length) return; 8.1298 + for (int i = 0; i < p4.length; i+=1) { 8.1299 + long l0 = (long)a1[i*4+0]; 8.1300 + long l1 = (long)a1[i*4+1]; 8.1301 + long l2 = (long)a1[i*4+2]; 8.1302 + long l3 = (long)a1[i*4+3]; 8.1303 + p4[i] = (l3 & 0xFFFFl) | 8.1304 + ((l2 & 0xFFFFl) << 16) | 8.1305 + ((l1 & 0xFFFFl) << 32) | 8.1306 + ((l0 & 0xFFFFl) << 48); 8.1307 + } 8.1308 + } 8.1309 + static void test_unpack4_swap(char[] a0, long[] p4) { 8.1310 + if (p4.length*4 > a0.length) return; 8.1311 + for (int i = 0; i < p4.length; i+=1) { 8.1312 + long l = p4[i]; 8.1313 + a0[i*4+0] = (char)(l >> 48); 8.1314 + a0[i*4+1] = (char)(l >> 32); 8.1315 + a0[i*4+2] = (char)(l >> 16); 8.1316 + a0[i*4+3] = (char)(l & 0xFFFFl); 8.1317 + } 8.1318 + } 8.1319 + 8.1320 + static int verify(String text, int i, int elem, int val) { 8.1321 + if (elem != val) { 8.1322 + System.err.println(text + "[" + i + "] = " + elem + " != " + val); 8.1323 + return 1; 8.1324 + } 8.1325 + return 0; 8.1326 + } 8.1327 + 8.1328 + static int verify(String text, int i, long elem, long val) { 8.1329 + if (elem != val) { 8.1330 + System.err.println(text + "[" + i + "] = " + Long.toHexString(elem) + " != " + Long.toHexString(val)); 8.1331 + return 1; 8.1332 + } 8.1333 + return 0; 8.1334 + } 8.1335 +}
