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     // add
 313     #[enumerant = Add]
 314     fn add(Ra, Rb) -> (Rt) {
 315         "add"
 316     }
 317     #[enumerant = AddO]
 318     fn addo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 319         "addo"
 320     }
 321     #[enumerant = Add_]
 322     fn add_(Ra, Rb, Overflow) -> (Rt, CR0) {
 323         "add."
 324     }
 325     #[enumerant = AddO_]
 326     fn addo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 327         "addo."
 328     }
 329
 330     // subf
 331     #[enumerant = SubF]
 332     fn subf(Ra, Rb) -> (Rt) {
 333         "subf"
 334     }
 335     #[enumerant = SubFO]
 336     fn subfo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 337         "subfo"
 338     }
 339     #[enumerant = SubF_]
 340     fn subf_(Ra, Rb, Overflow) -> (Rt, CR0) {
 341         "subf."
 342     }
 343     #[enumerant = SubFO_]
 344     fn subfo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 345         "subfo."
 346     }
 347
 348     // addc
 349     #[enumerant = AddC]
 350     fn addc(Ra, Rb) -> (Rt, Carry) {
 351         "addc"
 352     }
 353     #[enumerant = AddCO]
 354     fn addco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 355         "addco"
 356     }
 357     #[enumerant = AddC_]
 358     fn addc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 359         "addc."
 360     }
 361     #[enumerant = AddCO_]
 362     fn addco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 363         "addco."
 364     }
 365
 366     // subfc
 367     #[enumerant = SubFC]
 368     fn subfc(Ra, Rb) -> (Rt, Carry) {
 369         "subfc"
 370     }
 371     #[enumerant = SubFCO]
 372     fn subfco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 373         "subfco"
 374     }
 375     #[enumerant = SubFC_]
 376     fn subfc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 377         "subfc."
 378     }
 379     #[enumerant = SubFCO_]
 380     fn subfco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 381         "subfco."
 382     }
 383
 384     // adde
 385     #[enumerant = AddE]
 386     fn adde(Ra, Rb, Carry) -> (Rt, Carry) {
 387         "adde"
 388     }
 389     #[enumerant = AddEO]
 390     fn addeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 391         "addeo"
 392     }
 393     #[enumerant = AddE_]
 394     fn adde_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 395         "adde."
 396     }
 397     #[enumerant = AddEO_]
 398     fn addeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 399         "addeo."
 400     }
 401
 402     // subfe
 403     #[enumerant = SubFE]
 404     fn subfe(Ra, Rb, Carry) -> (Rt, Carry) {
 405         "subfe"
 406     }
 407     #[enumerant = SubFEO]
 408     fn subfeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 409         "subfeo"
 410     }
 411     #[enumerant = SubFE_]
 412     fn subfe_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 413         "subfe."
 414     }
 415     #[enumerant = SubFEO_]
 416     fn subfeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 417         "subfeo."
 418     }
 419
 420     // addme
 421     #[enumerant = AddME]
 422     fn addme(Ra, Carry) -> (Rt, Carry) {
 423         "addme"
 424     }
 425     #[enumerant = AddMEO]
 426     fn addmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 427         "addmeo"
 428     }
 429     #[enumerant = AddME_]
 430     fn addme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 431         "addme."
 432     }
 433     #[enumerant = AddMEO_]
 434     fn addmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 435         "addmeo."
 436     }
 437
 438     // subfme
 439     #[enumerant = SubFME]
 440     fn subfme(Ra, Carry) -> (Rt, Carry) {
 441         "subfme"
 442     }
 443     #[enumerant = SubFMEO]
 444     fn subfmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 445         "subfmeo"
 446     }
 447     #[enumerant = SubFME_]
 448     fn subfme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 449         "subfme."
 450     }
 451     #[enumerant = SubFMEO_]
 452     fn subfmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 453         "subfmeo."
 454     }
 455
 456     // addze
 457     #[enumerant = AddZE]
 458     fn addze(Ra, Carry) -> (Rt, Carry) {
 459         "addze"
 460     }
 461     #[enumerant = AddZEO]
 462     fn addzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 463         "addzeo"
 464     }
 465     #[enumerant = AddZE_]
 466     fn addze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 467         "addze."
 468     }
 469     #[enumerant = AddZEO_]
 470     fn addzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 471         "addzeo."
 472     }
 473
 474     // subfze
 475     #[enumerant = SubFZE]
 476     fn subfze(Ra, Carry) -> (Rt, Carry) {
 477         "subfze"
 478     }
 479     #[enumerant = SubFZEO]
 480     fn subfzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 481         "subfzeo"
 482     }
 483     #[enumerant = SubFZE_]
 484     fn subfze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 485         "subfze."
 486     }
 487     #[enumerant = SubFZEO_]
 488     fn subfzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 489         "subfzeo."
 490     }
 491
 492     #[enumerant = AddEX]
 493     fn addex(Ra("r3"), Rb("r4"), Overflow) -> (Rt("r5"), Overflow) {
 494         // work around LLVM not supporting addex instruction:
 495         "addex" : ".long 0x7CA32154 # addex r5, r3, r4, 0"
 496     }
 497
 498     // neg
 499     #[enumerant = Neg]
 500     fn neg(Ra) -> (Rt) {
 501         "neg"
 502     }
 503     #[enumerant = NegO]
 504     fn nego(Ra, Overflow) -> (Rt, Overflow) {
 505         "nego"
 506     }
 507     #[enumerant = Neg_]
 508     fn neg_(Ra, Overflow) -> (Rt, CR0) {
 509         "neg."
 510     }
 511     #[enumerant = NegO_]
 512     fn nego_(Ra, Overflow) -> (Rt, Overflow, CR0) {
 513         "nego."
 514     }
 515
 516     // divde
 517     #[enumerant = DivDE]
 518     fn divde(Ra, Rb) -> (Rt) {
 519         "divde"
 520     }
 521     #[enumerant = DivDEO]
 522     fn divdeo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 523         "divdeo"
 524     }
 525     #[enumerant = DivDE_]
 526     fn divde_(Ra, Rb, Overflow) -> (Rt, CR0) {
 527         "divde."
 528     }
 529     #[enumerant = DivDEO_]
 530     fn divdeo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 531         "divdeo."
 532     }
 533
 534     // divdeu
 535     #[enumerant = DivDEU]
 536     fn divdeu(Ra, Rb) -> (Rt) {
 537         "divdeu"
 538     }
 539     #[enumerant = DivDEUO]
 540     fn divdeuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 541         "divdeuo"
 542     }
 543     #[enumerant = DivDEU_]
 544     fn divdeu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 545         "divdeu."
 546     }
 547     #[enumerant = DivDEUO_]
 548     fn divdeuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 549         "divdeuo."
 550     }
 551
 552     // divd
 553     #[enumerant = DivD]
 554     fn divd(Ra, Rb) -> (Rt) {
 555         "divd"
 556     }
 557     #[enumerant = DivDO]
 558     fn divdo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 559         "divdo"
 560     }
 561     #[enumerant = DivD_]
 562     fn divd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 563         "divd."
 564     }
 565     #[enumerant = DivDO_]
 566     fn divdo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 567         "divdo."
 568     }
 569
 570     // divdu
 571     #[enumerant = DivDU]
 572     fn divdu(Ra, Rb) -> (Rt) {
 573         "divdu"
 574     }
 575     #[enumerant = DivDUO]
 576     fn divduo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 577         "divduo"
 578     }
 579     #[enumerant = DivDU_]
 580     fn divdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 581         "divdu."
 582     }
 583     #[enumerant = DivDUO_]
 584     fn divduo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 585         "divduo."
 586     }
 587
 588     // divwe
 589     #[enumerant = DivWE]
 590     fn divwe(Ra, Rb) -> (Rt) {
 591         "divwe"
 592     }
 593     #[enumerant = DivWEO]
 594     fn divweo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 595         "divweo"
 596     }
 597     #[enumerant = DivWE_]
 598     fn divwe_(Ra, Rb, Overflow) -> (Rt, CR0) {
 599         "divwe."
 600     }
 601     #[enumerant = DivWEO_]
 602     fn divweo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 603         "divweo."
 604     }
 605
 606     // divweu
 607     #[enumerant = DivWEU]
 608     fn divweu(Ra, Rb) -> (Rt) {
 609         "divweu"
 610     }
 611     #[enumerant = DivWEUO]
 612     fn divweuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 613         "divweuo"
 614     }
 615     #[enumerant = DivWEU_]
 616     fn divweu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 617         "divweu."
 618     }
 619     #[enumerant = DivWEUO_]
 620     fn divweuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 621         "divweuo."
 622     }
 623
 624     // divw
 625     #[enumerant = DivW]
 626     fn divw(Ra, Rb) -> (Rt) {
 627         "divw"
 628     }
 629     #[enumerant = DivWO]
 630     fn divwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 631         "divwo"
 632     }
 633     #[enumerant = DivW_]
 634     fn divw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 635         "divw."
 636     }
 637     #[enumerant = DivWO_]
 638     fn divwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 639         "divwo."
 640     }
 641
 642     // divwu
 643     #[enumerant = DivWU]
 644     fn divwu(Ra, Rb) -> (Rt) {
 645         "divwu"
 646     }
 647     #[enumerant = DivWUO]
 648     fn divwuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 649         "divwuo"
 650     }
 651     #[enumerant = DivWU_]
 652     fn divwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 653         "divwu."
 654     }
 655     #[enumerant = DivWUO_]
 656     fn divwuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 657         "divwuo."
 658     }
 659
 660     // mod*
 661     #[enumerant = ModSD]
 662     fn modsd(Ra, Rb) -> (Rt) {
 663         "modsd"
 664     }
 665     #[enumerant = ModUD]
 666     fn modud(Ra, Rb) -> (Rt) {
 667         "modud"
 668     }
 669     #[enumerant = ModSW]
 670     fn modsw(Ra, Rb) -> (Rt) {
 671         "modsw"
 672     }
 673     #[enumerant = ModUW]
 674     fn moduw(Ra, Rb) -> (Rt) {
 675         "moduw"
 676     }
 677
 678     // mullw
 679     #[enumerant = MulLW]
 680     fn mullw(Ra, Rb) -> (Rt) {
 681         "mullw"
 682     }
 683     #[enumerant = MulLWO]
 684     fn mullwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 685         "mullwo"
 686     }
 687     #[enumerant = MulLW_]
 688     fn mullw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 689         "mullw."
 690     }
 691     #[enumerant = MulLWO_]
 692     fn mullwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 693         "mullwo."
 694     }
 695
 696     // mulhw
 697     #[enumerant = MulHW]
 698     fn mulhw(Ra, Rb) -> (Rt) {
 699         "mulhw"
 700     }
 701     #[enumerant = MulHW_]
 702     fn mulhw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 703         "mulhw."
 704     }
 705
 706     // mulhwu
 707     #[enumerant = MulHWU]
 708     fn mulhwu(Ra, Rb) -> (Rt) {
 709         "mulhwu"
 710     }
 711     #[enumerant = MulHWU_]
 712     fn mulhwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 713         "mulhwu."
 714     }
 715
 716     // mulld
 717     #[enumerant = MulLD]
 718     fn mulld(Ra, Rb) -> (Rt) {
 719         "mulld"
 720     }
 721     #[enumerant = MulLDO]
 722     fn mulldo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 723         "mulldo"
 724     }
 725     #[enumerant = MulLD_]
 726     fn mulld_(Ra, Rb, Overflow) -> (Rt, CR0) {
 727         "mulld."
 728     }
 729     #[enumerant = MulLDO_]
 730     fn mulldo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 731         "mulldo."
 732     }
 733
 734     // mulhd
 735     #[enumerant = MulHD]
 736     fn mulhd(Ra, Rb) -> (Rt) {
 737         "mulhd"
 738     }
 739     #[enumerant = MulHD_]
 740     fn mulhd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 741         "mulhd."
 742     }
 743
 744     // mulhdu
 745     #[enumerant = MulHDU]
 746     fn mulhdu(Ra, Rb) -> (Rt) {
 747         "mulhdu"
 748     }
 749     #[enumerant = MulHDU_]
 750     fn mulhdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 751         "mulhdu."
 752     }
 753
 754     // madd*
 755     #[enumerant = MAddHD]
 756     fn maddhd(Ra, Rb, Rc) -> (Rt) {
 757         "maddhd"
 758     }
 759     #[enumerant = MAddHDU]
 760     fn maddhdu(Ra, Rb, Rc) -> (Rt) {
 761         "maddhdu"
 762     }
 763     #[enumerant = MAddLD]
 764     fn maddld(Ra, Rb, Rc) -> (Rt) {
 765         "maddld"
 766     }
 767 }
 768
 769 // must be after instrs macro call since it uses a macro definition
 770 mod python;