src/tools/miri/tests/pass/intrinsics-integer.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![feature(core_intrinsics)]
  12 use std::intrinsics::*;
  13
  14 pub fn main() {
  15     unsafe {
  16         [assert_eq!(ctpop(0u8), 0), assert_eq!(ctpop(0i8), 0)];
  17         [assert_eq!(ctpop(0u16), 0), assert_eq!(ctpop(0i16), 0)];
  18         [assert_eq!(ctpop(0u32), 0), assert_eq!(ctpop(0i32), 0)];
  19         [assert_eq!(ctpop(0u64), 0), assert_eq!(ctpop(0i64), 0)];
  20
  21         [assert_eq!(ctpop(1u8), 1), assert_eq!(ctpop(1i8), 1)];
  22         [assert_eq!(ctpop(1u16), 1), assert_eq!(ctpop(1i16), 1)];
  23         [assert_eq!(ctpop(1u32), 1), assert_eq!(ctpop(1i32), 1)];
  24         [assert_eq!(ctpop(1u64), 1), assert_eq!(ctpop(1i64), 1)];
  25
  26         [assert_eq!(ctpop(10u8), 2), assert_eq!(ctpop(10i8), 2)];
  27         [assert_eq!(ctpop(10u16), 2), assert_eq!(ctpop(10i16), 2)];
  28         [assert_eq!(ctpop(10u32), 2), assert_eq!(ctpop(10i32), 2)];
  29         [assert_eq!(ctpop(10u64), 2), assert_eq!(ctpop(10i64), 2)];
  30
  31         [assert_eq!(ctpop(100u8), 3), assert_eq!(ctpop(100i8), 3)];
  32         [assert_eq!(ctpop(100u16), 3), assert_eq!(ctpop(100i16), 3)];
  33         [assert_eq!(ctpop(100u32), 3), assert_eq!(ctpop(100i32), 3)];
  34         [assert_eq!(ctpop(100u64), 3), assert_eq!(ctpop(100i64), 3)];
  35
  36         [assert_eq!(ctpop(-1i8 as u8), 8), assert_eq!(ctpop(-1i8), 8)];
  37         [assert_eq!(ctpop(-1i16 as u16), 16), assert_eq!(ctpop(-1i16), 16)];
  38         [assert_eq!(ctpop(-1i32 as u32), 32), assert_eq!(ctpop(-1i32), 32)];
  39         [assert_eq!(ctpop(-1i64 as u64), 64), assert_eq!(ctpop(-1i64), 64)];
  40
  41         [assert_eq!(ctlz(0u8), 8), assert_eq!(ctlz(0i8), 8)];
  42         [assert_eq!(ctlz(0u16), 16), assert_eq!(ctlz(0i16), 16)];
  43         [assert_eq!(ctlz(0u32), 32), assert_eq!(ctlz(0i32), 32)];
  44         [assert_eq!(ctlz(0u64), 64), assert_eq!(ctlz(0i64), 64)];
  45
  46         [assert_eq!(ctlz(1u8), 7), assert_eq!(ctlz(1i8), 7)];
  47         [assert_eq!(ctlz(1u16), 15), assert_eq!(ctlz(1i16), 15)];
  48         [assert_eq!(ctlz(1u32), 31), assert_eq!(ctlz(1i32), 31)];
  49         [assert_eq!(ctlz(1u64), 63), assert_eq!(ctlz(1i64), 63)];
  50
  51         [assert_eq!(ctlz(10u8), 4), assert_eq!(ctlz(10i8), 4)];
  52         [assert_eq!(ctlz(10u16), 12), assert_eq!(ctlz(10i16), 12)];
  53         [assert_eq!(ctlz(10u32), 28), assert_eq!(ctlz(10i32), 28)];
  54         [assert_eq!(ctlz(10u64), 60), assert_eq!(ctlz(10i64), 60)];
  55
  56         [assert_eq!(ctlz(100u8), 1), assert_eq!(ctlz(100i8), 1)];
  57         [assert_eq!(ctlz(100u16), 9), assert_eq!(ctlz(100i16), 9)];
  58         [assert_eq!(ctlz(100u32), 25), assert_eq!(ctlz(100i32), 25)];
  59         [assert_eq!(ctlz(100u64), 57), assert_eq!(ctlz(100i64), 57)];
  60
  61         [assert_eq!(ctlz_nonzero(1u8), 7), assert_eq!(ctlz_nonzero(1i8), 7)];
  62         [assert_eq!(ctlz_nonzero(1u16), 15), assert_eq!(ctlz_nonzero(1i16), 15)];
  63         [assert_eq!(ctlz_nonzero(1u32), 31), assert_eq!(ctlz_nonzero(1i32), 31)];
  64         [assert_eq!(ctlz_nonzero(1u64), 63), assert_eq!(ctlz_nonzero(1i64), 63)];
  65
  66         [assert_eq!(ctlz_nonzero(10u8), 4), assert_eq!(ctlz_nonzero(10i8), 4)];
  67         [assert_eq!(ctlz_nonzero(10u16), 12), assert_eq!(ctlz_nonzero(10i16), 12)];
  68         [assert_eq!(ctlz_nonzero(10u32), 28), assert_eq!(ctlz_nonzero(10i32), 28)];
  69         [assert_eq!(ctlz_nonzero(10u64), 60), assert_eq!(ctlz_nonzero(10i64), 60)];
  70
  71         [assert_eq!(ctlz_nonzero(100u8), 1), assert_eq!(ctlz_nonzero(100i8), 1)];
  72         [assert_eq!(ctlz_nonzero(100u16), 9), assert_eq!(ctlz_nonzero(100i16), 9)];
  73         [assert_eq!(ctlz_nonzero(100u32), 25), assert_eq!(ctlz_nonzero(100i32), 25)];
  74         [assert_eq!(ctlz_nonzero(100u64), 57), assert_eq!(ctlz_nonzero(100i64), 57)];
  75
  76         [assert_eq!(cttz(-1i8 as u8), 0), assert_eq!(cttz(-1i8), 0)];
  77         [assert_eq!(cttz(-1i16 as u16), 0), assert_eq!(cttz(-1i16), 0)];
  78         [assert_eq!(cttz(-1i32 as u32), 0), assert_eq!(cttz(-1i32), 0)];
  79         [assert_eq!(cttz(-1i64 as u64), 0), assert_eq!(cttz(-1i64), 0)];
  80
  81         [assert_eq!(cttz(0u8), 8), assert_eq!(cttz(0i8), 8)];
  82         [assert_eq!(cttz(0u16), 16), assert_eq!(cttz(0i16), 16)];
  83         [assert_eq!(cttz(0u32), 32), assert_eq!(cttz(0i32), 32)];
  84         [assert_eq!(cttz(0u64), 64), assert_eq!(cttz(0i64), 64)];
  85
  86         [assert_eq!(cttz(1u8), 0), assert_eq!(cttz(1i8), 0)];
  87         [assert_eq!(cttz(1u16), 0), assert_eq!(cttz(1i16), 0)];
  88         [assert_eq!(cttz(1u32), 0), assert_eq!(cttz(1i32), 0)];
  89         [assert_eq!(cttz(1u64), 0), assert_eq!(cttz(1i64), 0)];
  90
  91         [assert_eq!(cttz(10u8), 1), assert_eq!(cttz(10i8), 1)];
  92         [assert_eq!(cttz(10u16), 1), assert_eq!(cttz(10i16), 1)];
  93         [assert_eq!(cttz(10u32), 1), assert_eq!(cttz(10i32), 1)];
  94         [assert_eq!(cttz(10u64), 1), assert_eq!(cttz(10i64), 1)];
  95
  96         [assert_eq!(cttz(100u8), 2), assert_eq!(cttz(100i8), 2)];
  97         [assert_eq!(cttz(100u16), 2), assert_eq!(cttz(100i16), 2)];
  98         [assert_eq!(cttz(100u32), 2), assert_eq!(cttz(100i32), 2)];
  99         [assert_eq!(cttz(100u64), 2), assert_eq!(cttz(100i64), 2)];
 100
 101         [assert_eq!(cttz_nonzero(-1i8 as u8), 0), assert_eq!(cttz_nonzero(-1i8), 0)];
 102         [assert_eq!(cttz_nonzero(-1i16 as u16), 0), assert_eq!(cttz_nonzero(-1i16), 0)];
 103         [assert_eq!(cttz_nonzero(-1i32 as u32), 0), assert_eq!(cttz_nonzero(-1i32), 0)];
 104         [assert_eq!(cttz_nonzero(-1i64 as u64), 0), assert_eq!(cttz_nonzero(-1i64), 0)];
 105
 106         [assert_eq!(cttz_nonzero(1u8), 0), assert_eq!(cttz_nonzero(1i8), 0)];
 107         [assert_eq!(cttz_nonzero(1u16), 0), assert_eq!(cttz_nonzero(1i16), 0)];
 108         [assert_eq!(cttz_nonzero(1u32), 0), assert_eq!(cttz_nonzero(1i32), 0)];
 109         [assert_eq!(cttz_nonzero(1u64), 0), assert_eq!(cttz_nonzero(1i64), 0)];
 110
 111         [assert_eq!(cttz_nonzero(10u8), 1), assert_eq!(cttz_nonzero(10i8), 1)];
 112         [assert_eq!(cttz_nonzero(10u16), 1), assert_eq!(cttz_nonzero(10i16), 1)];
 113         [assert_eq!(cttz_nonzero(10u32), 1), assert_eq!(cttz_nonzero(10i32), 1)];
 114         [assert_eq!(cttz_nonzero(10u64), 1), assert_eq!(cttz_nonzero(10i64), 1)];
 115
 116         [assert_eq!(cttz_nonzero(100u8), 2), assert_eq!(cttz_nonzero(100i8), 2)];
 117         [assert_eq!(cttz_nonzero(100u16), 2), assert_eq!(cttz_nonzero(100i16), 2)];
 118         [assert_eq!(cttz_nonzero(100u32), 2), assert_eq!(cttz_nonzero(100i32), 2)];
 119         [assert_eq!(cttz_nonzero(100u64), 2), assert_eq!(cttz_nonzero(100i64), 2)];
 120
 121         assert_eq!(bswap(0x0Au8), 0x0A); // no-op
 122         assert_eq!(bswap(0x0Ai8), 0x0A); // no-op
 123         assert_eq!(bswap(0x0A0Bu16), 0x0B0A);
 124         assert_eq!(bswap(0x0A0Bi16), 0x0B0A);
 125         assert_eq!(bswap(0x0ABBCC0Du32), 0x0DCCBB0A);
 126         assert_eq!(bswap(0x0ABBCC0Di32), 0x0DCCBB0A);
 127         assert_eq!(bswap(0x0122334455667708u64), 0x0877665544332201);
 128         assert_eq!(bswap(0x0122334455667708i64), 0x0877665544332201);
 129
 130         assert_eq!(exact_div(9 * 9u32, 3), 27);
 131         assert_eq!(exact_div(-9 * 9i32, 3), -27);
 132         assert_eq!(exact_div(9 * 9i8, -3), -27);
 133         assert_eq!(exact_div(-9 * 9i64, -3), 27);
 134
 135         assert_eq!(unchecked_div(9 * 9u32, 2), 40);
 136         assert_eq!(unchecked_div(-9 * 9i32, 2), -40);
 137         assert_eq!(unchecked_div(9 * 9i8, -2), -40);
 138         assert_eq!(unchecked_div(-9 * 9i64, -2), 40);
 139
 140         assert_eq!(unchecked_rem(9 * 9u32, 2), 1);
 141         assert_eq!(unchecked_rem(-9 * 9i32, 2), -1);
 142         assert_eq!(unchecked_rem(9 * 9i8, -2), 1);
 143         assert_eq!(unchecked_rem(-9 * 9i64, -2), -1);
 144
 145         assert_eq!(unchecked_add(23u8, 19), 42);
 146         assert_eq!(unchecked_add(5, -10), -5);
 147
 148         assert_eq!(unchecked_sub(23u8, 19), 4);
 149         assert_eq!(unchecked_sub(-17, -27), 10);
 150
 151         assert_eq!(unchecked_mul(6u8, 7), 42);
 152         assert_eq!(unchecked_mul(13, -5), -65);
 153     }
 154 }