src/lib.rs

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 // See Notices.txt for copyright information
   3
   4 #![cfg_attr(feature = "native_instrs", feature(llvm_asm))]
   5
   6 #[cfg(all(feature = "native_instrs", not(target_arch = "powerpc64")))]
   7 compile_error!("native_instrs feature requires target_arch to be powerpc64");
   8
   9 pub mod instr_models;
  10 mod serde_hex;
  11
  12 use power_instruction_analyzer_proc_macro::instructions;
  13 use serde::{Deserialize, Serialize};
  14 use serde_plain::forward_display_to_serde;
  15 use std::{cmp::Ordering, fmt};
  16
  17 // powerpc bit numbers count from MSB to LSB
  18 const fn get_xer_bit_mask(powerpc_bit_num: usize) -> u64 {
  19     (1 << 63) >> powerpc_bit_num
  20 }
  21
  22 macro_rules! xer_subset {
  23     (
  24         $struct_vis:vis struct $struct_name:ident {
  25             $(
  26                 #[bit($powerpc_bit_num:expr, $mask_name:ident)]
  27                 $field_vis:vis $field_name:ident: bool,
  28             )+
  29         }
  30     ) => {
  31         #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
  32         $struct_vis struct $struct_name {
  33             $(
  34                 $field_vis $field_name: bool,
  35             )+
  36         }
  37
  38         impl $struct_name {
  39             $(
  40                 $field_vis const $mask_name: u64 = get_xer_bit_mask($powerpc_bit_num);
  41             )+
  42             $struct_vis const XER_MASK: u64 = $(Self::$mask_name)|+;
  43             pub const fn from_xer(xer: u64) -> Self {
  44                 Self {
  45                     $(
  46                         $field_name: (xer & Self::$mask_name) != 0,
  47                     )+
  48                 }
  49             }
  50             pub const fn to_xer(self) -> u64 {
  51                 let mut retval = 0u64;
  52                 $(
  53                     if self.$field_name {
  54                         retval |= Self::$mask_name;
  55                     }
  56                 )+
  57                 retval
  58             }
  59         }
  60     };
  61 }
  62
  63 xer_subset! {
  64     pub struct OverflowFlags {
  65         #[bit(32, XER_SO_MASK)]
  66         pub so: bool,
  67         #[bit(33, XER_OV_MASK)]
  68         pub ov: bool,
  69         #[bit(44, XER_OV32_MASK)]
  70         pub ov32: bool,
  71     }
  72 }
  73
  74 impl OverflowFlags {
  75     pub const fn from_overflow(overflow: bool) -> Self {
  76         Self {
  77             so: overflow,
  78             ov: overflow,
  79             ov32: overflow,
  80         }
  81     }
  82 }
  83
  84 xer_subset! {
  85     pub struct CarryFlags {
  86         #[bit(34, XER_CA_MASK)]
  87         pub ca: bool,
  88         #[bit(45, XER_CA32_MASK)]
  89         pub ca32: bool,
  90     }
  91 }
  92
  93 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
  94 pub struct ConditionRegister {
  95     pub lt: bool,
  96     pub gt: bool,
  97     pub eq: bool,
  98     pub so: bool,
  99 }
 100
 101 impl ConditionRegister {
 102     pub const fn from_4_bits(bits: u8) -> Self {
 103         // assert bits is 4-bits long
 104         // can switch to using assert! once rustc feature const_panic is stabilized
 105         [0; 0x10][bits as usize];
 106
 107         Self {
 108             lt: (bits & 8) != 0,
 109             gt: (bits & 4) != 0,
 110             eq: (bits & 2) != 0,
 111             so: (bits & 1) != 0,
 112         }
 113     }
 114     pub const CR_FIELD_COUNT: usize = 8;
 115     pub const fn from_cr_field(cr: u32, field_index: usize) -> Self {
 116         // assert field_index is less than CR_FIELD_COUNT
 117         // can switch to using assert! once rustc feature const_panic is stabilized
 118         [0; Self::CR_FIELD_COUNT][field_index];
 119
 120         let reversed_field_index = Self::CR_FIELD_COUNT - field_index - 1;
 121         let bits = (cr >> (4 * reversed_field_index)) & 0xF;
 122         Self::from_4_bits(bits as u8)
 123     }
 124     pub fn from_signed_int<T: Ord + Default>(value: T, so: bool) -> Self {
 125         let ordering = value.cmp(&T::default());
 126         Self {
 127             lt: ordering == Ordering::Less,
 128             gt: ordering == Ordering::Greater,
 129             eq: ordering == Ordering::Equal,
 130             so,
 131         }
 132     }
 133 }
 134
 135 #[derive(Copy, Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 136 pub struct InstructionOutput {
 137     #[serde(
 138         default,
 139         skip_serializing_if = "Option::is_none",
 140         with = "serde_hex::SerdeHex"
 141     )]
 142     pub rt: Option<u64>,
 143     #[serde(default, flatten, skip_serializing_if = "Option::is_none")]
 144     pub overflow: Option<OverflowFlags>,
 145     #[serde(default, flatten, skip_serializing_if = "Option::is_none")]
 146     pub carry: Option<CarryFlags>,
 147     #[serde(default, skip_serializing_if = "Option::is_none")]
 148     pub cr0: Option<ConditionRegister>,
 149     #[serde(default, skip_serializing_if = "Option::is_none")]
 150     pub cr1: Option<ConditionRegister>,
 151     #[serde(default, skip_serializing_if = "Option::is_none")]
 152     pub cr2: Option<ConditionRegister>,
 153     #[serde(default, skip_serializing_if = "Option::is_none")]
 154     pub cr3: Option<ConditionRegister>,
 155     #[serde(default, skip_serializing_if = "Option::is_none")]
 156     pub cr4: Option<ConditionRegister>,
 157     #[serde(default, skip_serializing_if = "Option::is_none")]
 158     pub cr5: Option<ConditionRegister>,
 159     #[serde(default, skip_serializing_if = "Option::is_none")]
 160     pub cr6: Option<ConditionRegister>,
 161     #[serde(default, skip_serializing_if = "Option::is_none")]
 162     pub cr7: Option<ConditionRegister>,
 163 }
 164
 165 #[derive(Debug)]
 166 pub struct MissingInstructionInput {
 167     pub input: InstructionInputRegister,
 168 }
 169
 170 impl fmt::Display for MissingInstructionInput {
 171     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 172         write!(f, "missing instruction input: {}", self.input)
 173     }
 174 }
 175
 176 impl std::error::Error for MissingInstructionInput {}
 177
 178 pub type InstructionResult = Result<InstructionOutput, MissingInstructionInput>;
 179
 180 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Serialize, Deserialize)]
 181 pub enum InstructionInputRegister {
 182     #[serde(rename = "ra")]
 183     Ra,
 184     #[serde(rename = "rb")]
 185     Rb,
 186     #[serde(rename = "rc")]
 187     Rc,
 188     #[serde(rename = "carry")]
 189     Carry,
 190     #[serde(rename = "overflow")]
 191     Overflow,
 192     #[serde(rename = "immediate_s16")]
 193     ImmediateS16,
 194     #[serde(rename = "immediate_u16")]
 195     ImmediateU16,
 196 }
 197
 198 forward_display_to_serde!(InstructionInputRegister);
 199
 200 #[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]
 201 pub struct InstructionInput {
 202     #[serde(
 203         default,
 204         skip_serializing_if = "Option::is_none",
 205         with = "serde_hex::SerdeHex"
 206     )]
 207     pub ra: Option<u64>,
 208     #[serde(
 209         default,
 210         skip_serializing_if = "Option::is_none",
 211         with = "serde_hex::SerdeHex"
 212     )]
 213     pub rb: Option<u64>,
 214     #[serde(
 215         default,
 216         skip_serializing_if = "Option::is_none",
 217         with = "serde_hex::SerdeHex"
 218     )]
 219     pub rc: Option<u64>,
 220     #[serde(
 221         default,
 222         skip_serializing_if = "Option::is_none",
 223         with = "serde_hex::SerdeHex"
 224     )]
 225     pub immediate: Option<u64>,
 226     #[serde(default, skip_serializing_if = "Option::is_none", flatten)]
 227     pub carry: Option<CarryFlags>,
 228     #[serde(default, skip_serializing_if = "Option::is_none", flatten)]
 229     pub overflow: Option<OverflowFlags>,
 230 }
 231
 232 macro_rules! impl_instr_try_get {
 233     (
 234         $(
 235             $vis:vis fn $fn:ident -> $return_type:ty { .$field:ident else $error_enum:ident }
 236         )+
 237     ) => {
 238         impl InstructionInput {
 239             $(
 240                 $vis fn $fn(self) -> Result<$return_type, MissingInstructionInput> {
 241                     self.$field.ok_or(MissingInstructionInput {
 242                         input: InstructionInputRegister::$error_enum,
 243                     })
 244                 }
 245             )+
 246         }
 247     };
 248 }
 249
 250 impl_instr_try_get! {
 251     pub fn try_get_ra -> u64 {
 252         .ra else Ra
 253     }
 254     pub fn try_get_rb -> u64 {
 255         .rb else Rb
 256     }
 257     pub fn try_get_rc -> u64 {
 258         .rc else Rc
 259     }
 260     pub fn try_get_carry -> CarryFlags {
 261         .carry else Carry
 262     }
 263     pub fn try_get_overflow -> OverflowFlags {
 264         .overflow else Overflow
 265     }
 266 }
 267
 268 impl InstructionInput {
 269     fn try_get_immediate(
 270         self,
 271         input: InstructionInputRegister,
 272     ) -> Result<u64, MissingInstructionInput> {
 273         self.immediate.ok_or(MissingInstructionInput { input })
 274     }
 275     pub fn try_get_immediate_u16(self) -> Result<u16, MissingInstructionInput> {
 276         Ok(self.try_get_immediate(InstructionInputRegister::ImmediateU16)? as u16)
 277     }
 278     pub fn try_get_immediate_s16(self) -> Result<i16, MissingInstructionInput> {
 279         Ok(self.try_get_immediate(InstructionInputRegister::ImmediateS16)? as i16)
 280     }
 281 }
 282
 283 fn is_false(v: &bool) -> bool {
 284     !v
 285 }
 286
 287 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 288 pub struct TestCase {
 289     pub instr: Instr,
 290     #[serde(flatten)]
 291     pub inputs: InstructionInput,
 292     #[serde(default, skip_serializing_if = "Option::is_none")]
 293     pub native_outputs: Option<InstructionOutput>,
 294     pub model_outputs: InstructionOutput,
 295     #[serde(default, skip_serializing_if = "is_false")]
 296     pub model_mismatch: bool,
 297 }
 298
 299 #[derive(Clone, Debug, Serialize, Deserialize)]
 300 pub struct WholeTest {
 301     #[serde(default, skip_serializing_if = "Vec::is_empty")]
 302     pub test_cases: Vec<TestCase>,
 303     pub any_model_mismatch: bool,
 304 }
 305
 306 instructions! {
 307     #[enumerant = AddI]
 308     fn addi(Ra, ImmediateS16) -> (Rt) {
 309         "addi"
 310     }
 311
 312     #[enumerant = AddIS]
 313     fn addis(Ra, ImmediateS16) -> (Rt) {
 314         "addis"
 315     }
 316
 317     // add
 318     #[enumerant = Add]
 319     fn add(Ra, Rb) -> (Rt) {
 320         "add"
 321     }
 322     #[enumerant = AddO]
 323     fn addo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 324         "addo"
 325     }
 326     #[enumerant = Add_]
 327     fn add_(Ra, Rb, Overflow) -> (Rt, CR0) {
 328         "add."
 329     }
 330     #[enumerant = AddO_]
 331     fn addo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 332         "addo."
 333     }
 334
 335     // addic
 336     #[enumerant = AddIC]
 337     fn addic(Ra, ImmediateS16) -> (Rt, Carry) {
 338         "addic"
 339     }
 340     #[enumerant = AddIC_]
 341     fn addic_(Ra, ImmediateS16, Overflow) -> (Rt, Carry, CR0) {
 342         "addic."
 343     }
 344
 345     // subf
 346     #[enumerant = SubF]
 347     fn subf(Ra, Rb) -> (Rt) {
 348         "subf"
 349     }
 350     #[enumerant = SubFO]
 351     fn subfo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 352         "subfo"
 353     }
 354     #[enumerant = SubF_]
 355     fn subf_(Ra, Rb, Overflow) -> (Rt, CR0) {
 356         "subf."
 357     }
 358     #[enumerant = SubFO_]
 359     fn subfo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 360         "subfo."
 361     }
 362
 363     #[enumerant = SubFIC]
 364     fn subfic(Ra, ImmediateS16) -> (Rt, Carry) {
 365         "subfic"
 366     }
 367
 368     // addc
 369     #[enumerant = AddC]
 370     fn addc(Ra, Rb) -> (Rt, Carry) {
 371         "addc"
 372     }
 373     #[enumerant = AddCO]
 374     fn addco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 375         "addco"
 376     }
 377     #[enumerant = AddC_]
 378     fn addc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 379         "addc."
 380     }
 381     #[enumerant = AddCO_]
 382     fn addco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 383         "addco."
 384     }
 385
 386     // subfc
 387     #[enumerant = SubFC]
 388     fn subfc(Ra, Rb) -> (Rt, Carry) {
 389         "subfc"
 390     }
 391     #[enumerant = SubFCO]
 392     fn subfco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 393         "subfco"
 394     }
 395     #[enumerant = SubFC_]
 396     fn subfc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 397         "subfc."
 398     }
 399     #[enumerant = SubFCO_]
 400     fn subfco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 401         "subfco."
 402     }
 403
 404     // adde
 405     #[enumerant = AddE]
 406     fn adde(Ra, Rb, Carry) -> (Rt, Carry) {
 407         "adde"
 408     }
 409     #[enumerant = AddEO]
 410     fn addeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 411         "addeo"
 412     }
 413     #[enumerant = AddE_]
 414     fn adde_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 415         "adde."
 416     }
 417     #[enumerant = AddEO_]
 418     fn addeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 419         "addeo."
 420     }
 421
 422     // subfe
 423     #[enumerant = SubFE]
 424     fn subfe(Ra, Rb, Carry) -> (Rt, Carry) {
 425         "subfe"
 426     }
 427     #[enumerant = SubFEO]
 428     fn subfeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 429         "subfeo"
 430     }
 431     #[enumerant = SubFE_]
 432     fn subfe_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 433         "subfe."
 434     }
 435     #[enumerant = SubFEO_]
 436     fn subfeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 437         "subfeo."
 438     }
 439
 440     // addme
 441     #[enumerant = AddME]
 442     fn addme(Ra, Carry) -> (Rt, Carry) {
 443         "addme"
 444     }
 445     #[enumerant = AddMEO]
 446     fn addmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 447         "addmeo"
 448     }
 449     #[enumerant = AddME_]
 450     fn addme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 451         "addme."
 452     }
 453     #[enumerant = AddMEO_]
 454     fn addmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 455         "addmeo."
 456     }
 457
 458     // subfme
 459     #[enumerant = SubFME]
 460     fn subfme(Ra, Carry) -> (Rt, Carry) {
 461         "subfme"
 462     }
 463     #[enumerant = SubFMEO]
 464     fn subfmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 465         "subfmeo"
 466     }
 467     #[enumerant = SubFME_]
 468     fn subfme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 469         "subfme."
 470     }
 471     #[enumerant = SubFMEO_]
 472     fn subfmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 473         "subfmeo."
 474     }
 475
 476     // addze
 477     #[enumerant = AddZE]
 478     fn addze(Ra, Carry) -> (Rt, Carry) {
 479         "addze"
 480     }
 481     #[enumerant = AddZEO]
 482     fn addzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 483         "addzeo"
 484     }
 485     #[enumerant = AddZE_]
 486     fn addze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 487         "addze."
 488     }
 489     #[enumerant = AddZEO_]
 490     fn addzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 491         "addzeo."
 492     }
 493
 494     // subfze
 495     #[enumerant = SubFZE]
 496     fn subfze(Ra, Carry) -> (Rt, Carry) {
 497         "subfze"
 498     }
 499     #[enumerant = SubFZEO]
 500     fn subfzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 501         "subfzeo"
 502     }
 503     #[enumerant = SubFZE_]
 504     fn subfze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 505         "subfze."
 506     }
 507     #[enumerant = SubFZEO_]
 508     fn subfzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 509         "subfzeo."
 510     }
 511
 512     #[enumerant = AddEX]
 513     fn addex(Ra("r3"), Rb("r4"), Overflow) -> (Rt("r5"), Overflow) {
 514         // work around LLVM not supporting addex instruction:
 515         "addex" : ".long 0x7CA32154 # addex r5, r3, r4, 0"
 516     }
 517
 518     // neg
 519     #[enumerant = Neg]
 520     fn neg(Ra) -> (Rt) {
 521         "neg"
 522     }
 523     #[enumerant = NegO]
 524     fn nego(Ra, Overflow) -> (Rt, Overflow) {
 525         "nego"
 526     }
 527     #[enumerant = Neg_]
 528     fn neg_(Ra, Overflow) -> (Rt, CR0) {
 529         "neg."
 530     }
 531     #[enumerant = NegO_]
 532     fn nego_(Ra, Overflow) -> (Rt, Overflow, CR0) {
 533         "nego."
 534     }
 535
 536     // divde
 537     #[enumerant = DivDE]
 538     fn divde(Ra, Rb) -> (Rt) {
 539         "divde"
 540     }
 541     #[enumerant = DivDEO]
 542     fn divdeo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 543         "divdeo"
 544     }
 545     #[enumerant = DivDE_]
 546     fn divde_(Ra, Rb, Overflow) -> (Rt, CR0) {
 547         "divde."
 548     }
 549     #[enumerant = DivDEO_]
 550     fn divdeo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 551         "divdeo."
 552     }
 553
 554     // divdeu
 555     #[enumerant = DivDEU]
 556     fn divdeu(Ra, Rb) -> (Rt) {
 557         "divdeu"
 558     }
 559     #[enumerant = DivDEUO]
 560     fn divdeuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 561         "divdeuo"
 562     }
 563     #[enumerant = DivDEU_]
 564     fn divdeu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 565         "divdeu."
 566     }
 567     #[enumerant = DivDEUO_]
 568     fn divdeuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 569         "divdeuo."
 570     }
 571
 572     // divd
 573     #[enumerant = DivD]
 574     fn divd(Ra, Rb) -> (Rt) {
 575         "divd"
 576     }
 577     #[enumerant = DivDO]
 578     fn divdo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 579         "divdo"
 580     }
 581     #[enumerant = DivD_]
 582     fn divd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 583         "divd."
 584     }
 585     #[enumerant = DivDO_]
 586     fn divdo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 587         "divdo."
 588     }
 589
 590     // divdu
 591     #[enumerant = DivDU]
 592     fn divdu(Ra, Rb) -> (Rt) {
 593         "divdu"
 594     }
 595     #[enumerant = DivDUO]
 596     fn divduo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 597         "divduo"
 598     }
 599     #[enumerant = DivDU_]
 600     fn divdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 601         "divdu."
 602     }
 603     #[enumerant = DivDUO_]
 604     fn divduo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 605         "divduo."
 606     }
 607
 608     // divwe
 609     #[enumerant = DivWE]
 610     fn divwe(Ra, Rb) -> (Rt) {
 611         "divwe"
 612     }
 613     #[enumerant = DivWEO]
 614     fn divweo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 615         "divweo"
 616     }
 617     #[enumerant = DivWE_]
 618     fn divwe_(Ra, Rb, Overflow) -> (Rt, CR0) {
 619         "divwe."
 620     }
 621     #[enumerant = DivWEO_]
 622     fn divweo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 623         "divweo."
 624     }
 625
 626     // divweu
 627     #[enumerant = DivWEU]
 628     fn divweu(Ra, Rb) -> (Rt) {
 629         "divweu"
 630     }
 631     #[enumerant = DivWEUO]
 632     fn divweuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 633         "divweuo"
 634     }
 635     #[enumerant = DivWEU_]
 636     fn divweu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 637         "divweu."
 638     }
 639     #[enumerant = DivWEUO_]
 640     fn divweuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 641         "divweuo."
 642     }
 643
 644     // divw
 645     #[enumerant = DivW]
 646     fn divw(Ra, Rb) -> (Rt) {
 647         "divw"
 648     }
 649     #[enumerant = DivWO]
 650     fn divwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 651         "divwo"
 652     }
 653     #[enumerant = DivW_]
 654     fn divw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 655         "divw."
 656     }
 657     #[enumerant = DivWO_]
 658     fn divwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 659         "divwo."
 660     }
 661
 662     // divwu
 663     #[enumerant = DivWU]
 664     fn divwu(Ra, Rb) -> (Rt) {
 665         "divwu"
 666     }
 667     #[enumerant = DivWUO]
 668     fn divwuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 669         "divwuo"
 670     }
 671     #[enumerant = DivWU_]
 672     fn divwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 673         "divwu."
 674     }
 675     #[enumerant = DivWUO_]
 676     fn divwuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 677         "divwuo."
 678     }
 679
 680     // mod*
 681     #[enumerant = ModSD]
 682     fn modsd(Ra, Rb) -> (Rt) {
 683         "modsd"
 684     }
 685     #[enumerant = ModUD]
 686     fn modud(Ra, Rb) -> (Rt) {
 687         "modud"
 688     }
 689     #[enumerant = ModSW]
 690     fn modsw(Ra, Rb) -> (Rt) {
 691         "modsw"
 692     }
 693     #[enumerant = ModUW]
 694     fn moduw(Ra, Rb) -> (Rt) {
 695         "moduw"
 696     }
 697
 698     // mullw
 699     #[enumerant = MulLW]
 700     fn mullw(Ra, Rb) -> (Rt) {
 701         "mullw"
 702     }
 703     #[enumerant = MulLWO]
 704     fn mullwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 705         "mullwo"
 706     }
 707     #[enumerant = MulLW_]
 708     fn mullw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 709         "mullw."
 710     }
 711     #[enumerant = MulLWO_]
 712     fn mullwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 713         "mullwo."
 714     }
 715
 716     // mulhw
 717     #[enumerant = MulHW]
 718     fn mulhw(Ra, Rb) -> (Rt) {
 719         "mulhw"
 720     }
 721     #[enumerant = MulHW_]
 722     fn mulhw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 723         "mulhw."
 724     }
 725
 726     // mulhwu
 727     #[enumerant = MulHWU]
 728     fn mulhwu(Ra, Rb) -> (Rt) {
 729         "mulhwu"
 730     }
 731     #[enumerant = MulHWU_]
 732     fn mulhwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 733         "mulhwu."
 734     }
 735
 736     // mulld
 737     #[enumerant = MulLD]
 738     fn mulld(Ra, Rb) -> (Rt) {
 739         "mulld"
 740     }
 741     #[enumerant = MulLDO]
 742     fn mulldo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 743         "mulldo"
 744     }
 745     #[enumerant = MulLD_]
 746     fn mulld_(Ra, Rb, Overflow) -> (Rt, CR0) {
 747         "mulld."
 748     }
 749     #[enumerant = MulLDO_]
 750     fn mulldo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 751         "mulldo."
 752     }
 753
 754     // mulhd
 755     #[enumerant = MulHD]
 756     fn mulhd(Ra, Rb) -> (Rt) {
 757         "mulhd"
 758     }
 759     #[enumerant = MulHD_]
 760     fn mulhd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 761         "mulhd."
 762     }
 763
 764     // mulhdu
 765     #[enumerant = MulHDU]
 766     fn mulhdu(Ra, Rb) -> (Rt) {
 767         "mulhdu"
 768     }
 769     #[enumerant = MulHDU_]
 770     fn mulhdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 771         "mulhdu."
 772     }
 773
 774     // madd*
 775     #[enumerant = MAddHD]
 776     fn maddhd(Ra, Rb, Rc) -> (Rt) {
 777         "maddhd"
 778     }
 779     #[enumerant = MAddHDU]
 780     fn maddhdu(Ra, Rb, Rc) -> (Rt) {
 781         "maddhdu"
 782     }
 783     #[enumerant = MAddLD]
 784     fn maddld(Ra, Rb, Rc) -> (Rt) {
 785         "maddld"
 786     }
 787 }
 788
 789 // must be after instrs macro call since it uses a macro definition
 790 mod python;