src/instr_models.rs

   1 use crate::{OverflowFlags, TestDivInput, TestDivResult};
   2
   3 pub fn divdeo(inputs: TestDivInput) -> TestDivResult {
   4     let dividend = i128::from(inputs.dividend as i64) << 64;
   5     let divisor = i128::from(inputs.divisor as i64);
   6     let overflow;
   7     let result;
   8     if divisor == 0 || (divisor == -1 && dividend == i128::min_value()) {
   9         result = 0;
  10         overflow = true;
  11     } else {
  12         let result128 = dividend / divisor;
  13         result = result128 as u64;
  14         overflow = result128 as i64 as i128 != result128;
  15     }
  16     TestDivResult {
  17         result,
  18         overflow: Some(OverflowFlags {
  19             overflow,
  20             overflow32: overflow,
  21         }),
  22     }
  23 }
  24
  25 pub fn divdeuo(inputs: TestDivInput) -> TestDivResult {
  26     let dividend = u128::from(inputs.dividend) << 64;
  27     let divisor = u128::from(inputs.divisor);
  28     let overflow;
  29     let result;
  30     if divisor == 0 {
  31         result = 0;
  32         overflow = true;
  33     } else {
  34         let resultu128 = dividend / divisor;
  35         result = resultu128 as u64;
  36         overflow = resultu128 > u128::from(u64::max_value());
  37     }
  38     TestDivResult {
  39         result,
  40         overflow: Some(OverflowFlags {
  41             overflow,
  42             overflow32: overflow,
  43         }),
  44     }
  45 }
  46
  47 pub fn divdo(inputs: TestDivInput) -> TestDivResult {
  48     let dividend = inputs.dividend as i64;
  49     let divisor = inputs.divisor as i64;
  50     let overflow;
  51     let result;
  52     if divisor == 0 || (divisor == -1 && dividend == i64::min_value()) {
  53         result = 0;
  54         overflow = true;
  55     } else {
  56         result = (dividend / divisor) as u64;
  57         overflow = false;
  58     }
  59     TestDivResult {
  60         result,
  61         overflow: Some(OverflowFlags {
  62             overflow,
  63             overflow32: overflow,
  64         }),
  65     }
  66 }
  67
  68 pub fn divduo(inputs: TestDivInput) -> TestDivResult {
  69     let dividend: u64 = inputs.dividend;
  70     let divisor: u64 = inputs.divisor;
  71     let overflow;
  72     let result;
  73     if divisor == 0 {
  74         result = 0;
  75         overflow = true;
  76     } else {
  77         result = dividend / divisor;
  78         overflow = false;
  79     }
  80     TestDivResult {
  81         result,
  82         overflow: Some(OverflowFlags {
  83             overflow,
  84             overflow32: overflow,
  85         }),
  86     }
  87 }
  88
  89 pub fn divweo(inputs: TestDivInput) -> TestDivResult {
  90     let dividend = i64::from(inputs.dividend as i32) << 32;
  91     let divisor = i64::from(inputs.divisor as i32);
  92     let overflow;
  93     let result;
  94     if divisor == 0 || (divisor == -1 && dividend == i64::min_value()) {
  95         result = 0;
  96         overflow = true;
  97     } else {
  98         let result64 = dividend / divisor;
  99         result = result64 as u32 as u64;
 100         overflow = result64 as i32 as i64 != result64;
 101     }
 102     TestDivResult {
 103         result,
 104         overflow: Some(OverflowFlags {
 105             overflow,
 106             overflow32: overflow,
 107         }),
 108     }
 109 }
 110
 111 pub fn divweuo(inputs: TestDivInput) -> TestDivResult {
 112     let dividend = u64::from(inputs.dividend) << 32;
 113     let divisor = u64::from(inputs.divisor);
 114     let overflow;
 115     let result;
 116     if divisor == 0 {
 117         result = 0;
 118         overflow = true;
 119     } else {
 120         let resultu64 = dividend / divisor;
 121         result = resultu64 as u32 as u64;
 122         overflow = resultu64 > u64::from(u32::max_value());
 123     }
 124     TestDivResult {
 125         result,
 126         overflow: Some(OverflowFlags {
 127             overflow,
 128             overflow32: overflow,
 129         }),
 130     }
 131 }
 132
 133 pub fn divwo(inputs: TestDivInput) -> TestDivResult {
 134     let dividend = inputs.dividend as i32;
 135     let divisor = inputs.divisor as i32;
 136     let overflow;
 137     let result;
 138     if divisor == 0 || (divisor == -1 && dividend == i32::min_value()) {
 139         result = 0;
 140         overflow = true;
 141     } else {
 142         result = (dividend / divisor) as u32 as u64;
 143         overflow = false;
 144     }
 145     TestDivResult {
 146         result,
 147         overflow: Some(OverflowFlags {
 148             overflow,
 149             overflow32: overflow,
 150         }),
 151     }
 152 }
 153
 154 pub fn divwuo(inputs: TestDivInput) -> TestDivResult {
 155     let dividend = inputs.dividend as u32;
 156     let divisor = inputs.divisor as u32;
 157     let overflow;
 158     let result;
 159     if divisor == 0 {
 160         result = 0;
 161         overflow = true;
 162     } else {
 163         result = (dividend / divisor) as u64;
 164         overflow = false;
 165     }
 166     TestDivResult {
 167         result,
 168         overflow: Some(OverflowFlags {
 169             overflow,
 170             overflow32: overflow,
 171         }),
 172     }
 173 }
 174
 175 pub fn modsd(inputs: TestDivInput) -> TestDivResult {
 176     let dividend = inputs.dividend as i64;
 177     let divisor = inputs.divisor as i64;
 178     let result;
 179     if divisor == 0 || (divisor == -1 && dividend == i64::min_value()) {
 180         result = 0;
 181     } else {
 182         result = (dividend % divisor) as u64;
 183     }
 184     TestDivResult {
 185         result,
 186         overflow: None,
 187     }
 188 }
 189
 190 pub fn modud(inputs: TestDivInput) -> TestDivResult {
 191     let dividend: u64 = inputs.dividend;
 192     let divisor: u64 = inputs.divisor;
 193     let result;
 194     if divisor == 0 {
 195         result = 0;
 196     } else {
 197         result = dividend % divisor;
 198     }
 199     TestDivResult {
 200         result,
 201         overflow: None,
 202     }
 203 }
 204
 205 pub fn modsw(inputs: TestDivInput) -> TestDivResult {
 206     let dividend = inputs.dividend as i32;
 207     let divisor = inputs.divisor as i32;
 208     let result;
 209     if divisor == 0 || (divisor == -1 && dividend == i32::min_value()) {
 210         result = 0;
 211     } else {
 212         result = (dividend % divisor) as u32 as u64;
 213     }
 214     TestDivResult {
 215         result,
 216         overflow: None,
 217     }
 218 }
 219
 220 pub fn moduw(inputs: TestDivInput) -> TestDivResult {
 221     let dividend = inputs.dividend as u32;
 222     let divisor = inputs.divisor as u32;
 223     let result;
 224     if divisor == 0 {
 225         result = 0;
 226     } else {
 227         result = (dividend % divisor) as u64;
 228     }
 229     TestDivResult {
 230         result,
 231         overflow: None,
 232     }
 233 }