Home | History | Annotate | Download | only in src 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 public class Main {
     18 
     19   public static void assertIntEquals(int expected, int actual) {
     20     if (expected != actual) {
     21       throw new Error("Expected: " + expected + ", found: " + actual);
     22     }
     23   }
     24 
     25   public static void assertLongEquals(long expected, long actual) {
     26     if (expected != actual) {
     27       throw new Error("Expected: " + expected + ", found: " + actual);
     28     }
     29   }
     30 
     31   public static void main(String args[]) throws Exception {
     32     test_Integer_right_v_csubv();
     33     test_Long_right_v_csubv();
     34 
     35     test_Integer_right_constant_v();
     36     test_Long_right_constant_v();
     37 
     38     test_Integer_left_csubv_v();
     39     test_Long_left_csubv_v();
     40 
     41     test_Integer_right_v_negv();
     42     test_Long_right_v_negv();
     43 
     44     test_Integer_left_negv_v();
     45     test_Long_left_negv_v();
     46 
     47     test_Integer_left_constant_v();
     48     test_Long_left_constant_v();
     49   }
     50 
     51   public static boolean doThrow = false;
     52 
     53   public static int $noinline$rotate_int_right_reg_v_csubv(int value, int distance) {
     54     if (doThrow) {
     55       throw new Error();
     56     }
     57     return (value >>> distance) | (value << (32 - distance));
     58   }
     59 
     60   public static void test_Integer_right_v_csubv() throws Exception {
     61     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, 0), 0x11);
     62 
     63     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, 1), 0x80000008);
     64     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, Integer.SIZE - 1), 0x22);
     65     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, Integer.SIZE), 0x11);
     66     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, Integer.SIZE + 1), 0x80000008);
     67 
     68     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, -1), 0x22);
     69     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, -(Integer.SIZE - 1)), 0x80000008);
     70     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, -Integer.SIZE), 0x11);
     71     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x11, -(Integer.SIZE + 1)), 0x22);
     72 
     73     assertIntEquals($noinline$rotate_int_right_reg_v_csubv(0x80000000, 1), 0x40000000);
     74   }
     75 
     76   public static long $noinline$rotate_long_right_reg_v_csubv(long value, int distance) {
     77     if (doThrow) {
     78       throw new Error();
     79     }
     80     return (value >>> distance) | (value << (64 - distance));
     81   }
     82 
     83   public static void test_Long_right_v_csubv() throws Exception {
     84     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, 0), 0x11);
     85 
     86     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, 1), 0x8000000000000008L);
     87     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, Long.SIZE - 1), 0x22);
     88     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, Long.SIZE), 0x11);
     89     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, Long.SIZE + 1), 0x8000000000000008L);
     90 
     91     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, -1), 0x22);
     92     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, -(Long.SIZE - 1)), 0x8000000000000008L);
     93     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, -Long.SIZE), 0x11);
     94     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x11, -(Long.SIZE + 1)), 0x22);
     95 
     96     assertLongEquals($noinline$rotate_long_right_reg_v_csubv(0x8000000000000000L, 1), 0x4000000000000000L);
     97   }
     98 
     99   public static int $noinline$rotate_int_left_reg_csubv_v(int value, int distance) {
    100     if (doThrow) {
    101       throw new Error();
    102     }
    103     return (value >>> (32 - distance)) | (value << distance);
    104   }
    105 
    106   public static void test_Integer_left_csubv_v() throws Exception {
    107     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, 0), 0x11);
    108 
    109     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, 1), 0x22);
    110     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, Integer.SIZE - 1), 0x80000008);
    111     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, Integer.SIZE), 0x11);
    112     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, Integer.SIZE + 1), 0x22);
    113 
    114     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, -1), 0x80000008);
    115     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, -(Integer.SIZE - 1)), 0x22);
    116     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, -Integer.SIZE), 0x11);
    117     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0x11, -(Integer.SIZE + 1)), 0x80000008);
    118 
    119     assertIntEquals($noinline$rotate_int_left_reg_csubv_v(0xC0000000, 1), 0x80000001);
    120   }
    121 
    122   public static long $noinline$rotate_long_left_reg_csubv_v(long value, int distance) {
    123     if (doThrow) {
    124       throw new Error();
    125     }
    126     return (value >>> (64 - distance)) | (value << distance);
    127   }
    128 
    129   public static void test_Long_left_csubv_v() throws Exception {
    130     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, 0), 0x11);
    131 
    132     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, 1), 0x22);
    133     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, Long.SIZE - 1), 0x8000000000000008L);
    134     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, Long.SIZE), 0x11);
    135     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, Long.SIZE + 1), 0x22);
    136 
    137     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, -1), 0x8000000000000008L);
    138     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, -(Long.SIZE - 1)), 0x22);
    139     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, -Long.SIZE), 0x11);
    140     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0x11, -(Long.SIZE + 1)), 0x8000000000000008L);
    141 
    142     assertLongEquals($noinline$rotate_long_left_reg_csubv_v(0xC000000000000000L, 1), 0x8000000000000001L);
    143   }
    144 
    145   public static int $noinline$rotate_int_right_reg_v_negv(int value, int distance) {
    146     if (doThrow) {
    147       throw new Error();
    148     }
    149     return (value >>> distance) | (value << -distance);
    150   }
    151 
    152   public static void test_Integer_right_v_negv() throws Exception {
    153     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, 0), 0x11);
    154 
    155     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, 1), 0x80000008);
    156     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, Integer.SIZE - 1), 0x22);
    157     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, Integer.SIZE), 0x11);
    158     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, Integer.SIZE + 1), 0x80000008);
    159 
    160     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, -1), 0x22);
    161     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, -(Integer.SIZE - 1)), 0x80000008);
    162     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, -Integer.SIZE), 0x11);
    163     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x11, -(Integer.SIZE + 1)), 0x22);
    164 
    165     assertIntEquals($noinline$rotate_int_right_reg_v_negv(0x80000000, 1), 0x40000000);
    166   }
    167 
    168   public static long $noinline$rotate_long_right_reg_v_negv(long value, int distance) {
    169     if (doThrow) {
    170       throw new Error();
    171     }
    172     return (value >>> distance) | (value << -distance);
    173   }
    174 
    175   public static void test_Long_right_v_negv() throws Exception {
    176     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, 0), 0x11);
    177 
    178     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, 1), 0x8000000000000008L);
    179     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, Long.SIZE - 1), 0x22);
    180     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, Long.SIZE), 0x11);
    181     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, Long.SIZE + 1), 0x8000000000000008L);
    182 
    183     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, -1), 0x22);
    184     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, -(Long.SIZE - 1)), 0x8000000000000008L);
    185     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, -Long.SIZE), 0x11);
    186     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x11, -(Long.SIZE + 1)), 0x22);
    187 
    188     assertLongEquals($noinline$rotate_long_right_reg_v_negv(0x8000000000000000L, 1), 0x4000000000000000L);
    189   }
    190 
    191   public static int $noinline$rotate_int_left_reg_negv_v(int value, int distance) {
    192     if (doThrow) {
    193       throw new Error();
    194     }
    195     return (value >>> -distance) | (value << distance);
    196   }
    197 
    198   public static void test_Integer_left_negv_v() throws Exception {
    199     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, 0), 0x11);
    200 
    201     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, 1), 0x22);
    202     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, Integer.SIZE - 1), 0x80000008);
    203     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, Integer.SIZE), 0x11);
    204     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, Integer.SIZE + 1), 0x22);
    205 
    206     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, -1), 0x80000008);
    207     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, -(Integer.SIZE - 1)), 0x22);
    208     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, -Integer.SIZE), 0x11);
    209     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0x11, -(Integer.SIZE + 1)), 0x80000008);
    210 
    211     assertIntEquals($noinline$rotate_int_left_reg_negv_v(0xC0000000, 1), 0x80000001);
    212   }
    213 
    214   public static long $noinline$rotate_long_left_reg_negv_v(long value, int distance) {
    215     if (doThrow) {
    216       throw new Error();
    217     }
    218     return (value >>> -distance) | (value << distance);
    219   }
    220 
    221   public static void test_Long_left_negv_v() throws Exception {
    222     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, 0), 0x11);
    223 
    224     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, 1), 0x22);
    225     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, Long.SIZE - 1), 0x8000000000000008L);
    226     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, Long.SIZE), 0x11);
    227     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, Long.SIZE + 1), 0x22);
    228 
    229     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, -1), 0x8000000000000008L);
    230     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, -(Long.SIZE - 1)), 0x22);
    231     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, -Long.SIZE), 0x11);
    232     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0x11, -(Long.SIZE + 1)), 0x8000000000000008L);
    233 
    234     assertLongEquals($noinline$rotate_long_left_reg_negv_v(0xC000000000000000L, 1), 0x8000000000000001L);
    235   }
    236 
    237   public static int $noinline$rotate_int_right_constant_0(int value) {
    238     if (doThrow) {
    239       throw new Error();
    240     }
    241     return (value >>> 0) | (value << 0);
    242   }
    243 
    244   public static int $noinline$rotate_int_right_constant_1(int value) {
    245     if (doThrow) {
    246       throw new Error();
    247     }
    248     return (value >>> 1) | (value << -1);
    249   }
    250 
    251   public static int $noinline$rotate_int_right_constant_m1(int value) {
    252     if (doThrow) {
    253       throw new Error();
    254     }
    255     return (value >>> -1) | (value << 1);
    256   }
    257 
    258   public static int $noinline$rotate_int_right_constant_16(int value) {
    259     if (doThrow) {
    260       throw new Error();
    261     }
    262     return (value >>> 16) | (value << -16);
    263   }
    264 
    265   public static void test_Integer_right_constant_v() throws Exception {
    266     assertIntEquals($noinline$rotate_int_right_constant_0(0x11), 0x11);
    267     assertIntEquals($noinline$rotate_int_right_constant_1(0x11), 0x80000008);
    268     assertIntEquals($noinline$rotate_int_right_constant_m1(0x11), 0x22);
    269     assertIntEquals($noinline$rotate_int_right_constant_16(0x11), 0x110000);
    270   }
    271 
    272   public static long $noinline$rotate_long_right_constant_0(long value) {
    273     if (doThrow) {
    274       throw new Error();
    275     }
    276     return (value >>> 0) | (value << 0);
    277   }
    278 
    279   public static long $noinline$rotate_long_right_constant_1(long value) {
    280     if (doThrow) {
    281       throw new Error();
    282     }
    283     return (value >>> 1) | (value << -1);
    284   }
    285 
    286   public static long $noinline$rotate_long_right_constant_m1(long value) {
    287     if (doThrow) {
    288       throw new Error();
    289     }
    290     return (value >>> -1) | (value << 1);
    291   }
    292 
    293   public static long $noinline$rotate_long_right_constant_16(long value) {
    294     if (doThrow) {
    295       throw new Error();
    296     }
    297     return (value >>> 16) | (value << -16);
    298   }
    299 
    300   public static long $noinline$rotate_long_right_constant_32(long value) {
    301     if (doThrow) {
    302       throw new Error();
    303     }
    304     return (value >>> 32) | (value << -32);
    305   }
    306 
    307   public static long $noinline$rotate_long_right_constant_48(long value) {
    308     if (doThrow) {
    309       throw new Error();
    310     }
    311     return (value >>> 48) | (value << -48);
    312   }
    313 
    314   public static long $noinline$rotate_long_right_constant_64(long value) {
    315     if (doThrow) {
    316       throw new Error();
    317     }
    318     return (value >>> 64) | (value << -64);
    319   }
    320 
    321   public static void test_Long_right_constant_v() throws Exception {
    322     assertLongEquals($noinline$rotate_long_right_constant_0(0x11), 0x11);
    323     assertLongEquals($noinline$rotate_long_right_constant_1(0x11), 0x8000000000000008L);
    324     assertLongEquals($noinline$rotate_long_right_constant_m1(0x11), 0x22);
    325     assertLongEquals($noinline$rotate_long_right_constant_16(0x11), 0x11000000000000L);
    326     assertLongEquals($noinline$rotate_long_right_constant_32(0x11), 0x1100000000L);
    327     assertLongEquals($noinline$rotate_long_right_constant_48(0x11), 0x110000L);
    328   }
    329 
    330   public static int $noinline$rotate_int_left_constant_0(int value) {
    331     if (doThrow) {
    332       throw new Error();
    333     }
    334     return (value << 0) | (value >>> 0);
    335   }
    336 
    337   public static int $noinline$rotate_int_left_constant_1(int value) {
    338     if (doThrow) {
    339       throw new Error();
    340     }
    341     return (value << 1) | (value >>> -1);
    342   }
    343 
    344   public static int $noinline$rotate_int_left_constant_m1(int value) {
    345     if (doThrow) {
    346       throw new Error();
    347     }
    348     return (value << -1) | (value >>> 1);
    349   }
    350 
    351   public static int $noinline$rotate_int_left_constant_16(int value) {
    352     if (doThrow) {
    353       throw new Error();
    354     }
    355     return (value << 16) | (value >>> -16);
    356   }
    357 
    358   public static void test_Integer_left_constant_v() throws Exception {
    359     assertIntEquals($noinline$rotate_int_left_constant_0(0x11), 0x11);
    360     assertIntEquals($noinline$rotate_int_left_constant_1(0x11), 0x22);
    361     assertIntEquals($noinline$rotate_int_left_constant_m1(0x11), 0x80000008);
    362     assertIntEquals($noinline$rotate_int_left_constant_16(0x11), 0x110000);
    363   }
    364 
    365   public static long $noinline$rotate_long_left_constant_0(long value) {
    366     if (doThrow) {
    367       throw new Error();
    368     }
    369     return (value << 0) | (value >>> 0);
    370   }
    371 
    372   public static long $noinline$rotate_long_left_constant_1(long value) {
    373     if (doThrow) {
    374       throw new Error();
    375     }
    376     return (value << 1) | (value >>> -1);
    377   }
    378 
    379   public static long $noinline$rotate_long_left_constant_m1(long value) {
    380     if (doThrow) {
    381       throw new Error();
    382     }
    383     return (value << -1) | (value >>> 1);
    384   }
    385 
    386   public static long $noinline$rotate_long_left_constant_16(long value) {
    387     if (doThrow) {
    388       throw new Error();
    389     }
    390     return (value << 16) | (value >>> -16);
    391   }
    392 
    393   public static long $noinline$rotate_long_left_constant_32(long value) {
    394     if (doThrow) {
    395       throw new Error();
    396     }
    397     return (value << 32) | (value >>> -32);
    398   }
    399 
    400   public static long $noinline$rotate_long_left_constant_48(long value) {
    401     if (doThrow) {
    402       throw new Error();
    403     }
    404     return (value << 48) | (value >>> -48);
    405   }
    406 
    407   public static long $noinline$rotate_long_left_constant_64(long value) {
    408     if (doThrow) {
    409       throw new Error();
    410     }
    411     return (value << 64) | (value >>> -64);
    412   }
    413 
    414   public static void test_Long_left_constant_v() throws Exception {
    415     assertLongEquals($noinline$rotate_long_left_constant_0(0x11), 0x11);
    416     assertLongEquals($noinline$rotate_long_left_constant_1(0x11), 0x22);
    417     assertLongEquals($noinline$rotate_long_left_constant_m1(0x11), 0x8000000000000008L);
    418     assertLongEquals($noinline$rotate_long_left_constant_16(0x11), 0x110000L);
    419     assertLongEquals($noinline$rotate_long_left_constant_32(0x11), 0x1100000000L);
    420     assertLongEquals($noinline$rotate_long_left_constant_48(0x11), 0x11000000000000L);
    421   }
    422 
    423 }
    424