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 }
 193
 194 forward_display_to_serde!(InstructionInputRegister);
 195
 196 #[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]
 197 pub struct InstructionInput {
 198     #[serde(
 199         default,
 200         skip_serializing_if = "Option::is_none",
 201         with = "serde_hex::SerdeHex"
 202     )]
 203     pub ra: Option<u64>,
 204     #[serde(
 205         default,
 206         skip_serializing_if = "Option::is_none",
 207         with = "serde_hex::SerdeHex"
 208     )]
 209     pub rb: Option<u64>,
 210     #[serde(
 211         default,
 212         skip_serializing_if = "Option::is_none",
 213         with = "serde_hex::SerdeHex"
 214     )]
 215     pub rc: Option<u64>,
 216     #[serde(default, skip_serializing_if = "Option::is_none", flatten)]
 217     pub carry: Option<CarryFlags>,
 218     #[serde(default, skip_serializing_if = "Option::is_none", flatten)]
 219     pub overflow: Option<OverflowFlags>,
 220 }
 221
 222 macro_rules! impl_instr_try_get {
 223     (
 224         $(
 225             $vis:vis fn $fn:ident -> $return_type:ty { .$field:ident else $error_enum:ident }
 226         )+
 227     ) => {
 228         impl InstructionInput {
 229             $(
 230                 $vis fn $fn(self) -> Result<$return_type, MissingInstructionInput> {
 231                     self.$field.ok_or(MissingInstructionInput {
 232                         input: InstructionInputRegister::$error_enum,
 233                     })
 234                 }
 235             )+
 236         }
 237     };
 238 }
 239
 240 impl_instr_try_get! {
 241     pub fn try_get_ra -> u64 {
 242         .ra else Ra
 243     }
 244     pub fn try_get_rb -> u64 {
 245         .rb else Rb
 246     }
 247     pub fn try_get_rc -> u64 {
 248         .rc else Rc
 249     }
 250     pub fn try_get_carry -> CarryFlags {
 251         .carry else Carry
 252     }
 253     pub fn try_get_overflow -> OverflowFlags {
 254         .overflow else Overflow
 255     }
 256 }
 257
 258 fn is_false(v: &bool) -> bool {
 259     !v
 260 }
 261
 262 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 263 pub struct TestCase {
 264     pub instr: Instr,
 265     #[serde(flatten)]
 266     pub inputs: InstructionInput,
 267     #[serde(default, skip_serializing_if = "Option::is_none")]
 268     pub native_outputs: Option<InstructionOutput>,
 269     pub model_outputs: InstructionOutput,
 270     #[serde(default, skip_serializing_if = "is_false")]
 271     pub model_mismatch: bool,
 272 }
 273
 274 #[derive(Clone, Debug, Serialize, Deserialize)]
 275 pub struct WholeTest {
 276     #[serde(default, skip_serializing_if = "Vec::is_empty")]
 277     pub test_cases: Vec<TestCase>,
 278     pub any_model_mismatch: bool,
 279 }
 280
 281 instructions! {
 282     // add
 283     #[enumerant = Add]
 284     fn add(Ra, Rb) -> (Rt) {
 285         "add"
 286     }
 287     #[enumerant = AddO]
 288     fn addo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 289         "addo"
 290     }
 291     #[enumerant = Add_]
 292     fn add_(Ra, Rb, Overflow) -> (Rt, CR0) {
 293         "add."
 294     }
 295     #[enumerant = AddO_]
 296     fn addo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 297         "addo."
 298     }
 299
 300     // subf
 301     #[enumerant = SubF]
 302     fn subf(Ra, Rb) -> (Rt) {
 303         "subf"
 304     }
 305     #[enumerant = SubFO]
 306     fn subfo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 307         "subfo"
 308     }
 309     #[enumerant = SubF_]
 310     fn subf_(Ra, Rb, Overflow) -> (Rt, CR0) {
 311         "subf."
 312     }
 313     #[enumerant = SubFO_]
 314     fn subfo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 315         "subfo."
 316     }
 317
 318     // addc
 319     #[enumerant = AddC]
 320     fn addc(Ra, Rb) -> (Rt, Carry) {
 321         "addc"
 322     }
 323     #[enumerant = AddCO]
 324     fn addco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 325         "addco"
 326     }
 327     #[enumerant = AddC_]
 328     fn addc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 329         "addc."
 330     }
 331     #[enumerant = AddCO_]
 332     fn addco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 333         "addco."
 334     }
 335
 336     // subfc
 337     #[enumerant = SubFC]
 338     fn subfc(Ra, Rb) -> (Rt, Carry) {
 339         "subfc"
 340     }
 341     #[enumerant = SubFCO]
 342     fn subfco(Ra, Rb, Overflow) -> (Rt, Carry, Overflow) {
 343         "subfco"
 344     }
 345     #[enumerant = SubFC_]
 346     fn subfc_(Ra, Rb, Overflow) -> (Rt, Carry, CR0) {
 347         "subfc."
 348     }
 349     #[enumerant = SubFCO_]
 350     fn subfco_(Ra, Rb, Overflow) -> (Rt, Carry, Overflow, CR0) {
 351         "subfco."
 352     }
 353
 354     // adde
 355     #[enumerant = AddE]
 356     fn adde(Ra, Rb, Carry) -> (Rt, Carry) {
 357         "adde"
 358     }
 359     #[enumerant = AddEO]
 360     fn addeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 361         "addeo"
 362     }
 363     #[enumerant = AddE_]
 364     fn adde_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 365         "adde."
 366     }
 367     #[enumerant = AddEO_]
 368     fn addeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 369         "addeo."
 370     }
 371
 372     // subfe
 373     #[enumerant = SubFE]
 374     fn subfe(Ra, Rb, Carry) -> (Rt, Carry) {
 375         "subfe"
 376     }
 377     #[enumerant = SubFEO]
 378     fn subfeo(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow) {
 379         "subfeo"
 380     }
 381     #[enumerant = SubFE_]
 382     fn subfe_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, CR0) {
 383         "subfe."
 384     }
 385     #[enumerant = SubFEO_]
 386     fn subfeo_(Ra, Rb, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 387         "subfeo."
 388     }
 389
 390     // addme
 391     #[enumerant = AddME]
 392     fn addme(Ra, Carry) -> (Rt, Carry) {
 393         "addme"
 394     }
 395     #[enumerant = AddMEO]
 396     fn addmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 397         "addmeo"
 398     }
 399     #[enumerant = AddME_]
 400     fn addme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 401         "addme."
 402     }
 403     #[enumerant = AddMEO_]
 404     fn addmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 405         "addmeo."
 406     }
 407
 408     // subfme
 409     #[enumerant = SubFME]
 410     fn subfme(Ra, Carry) -> (Rt, Carry) {
 411         "subfme"
 412     }
 413     #[enumerant = SubFMEO]
 414     fn subfmeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 415         "subfmeo"
 416     }
 417     #[enumerant = SubFME_]
 418     fn subfme_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 419         "subfme."
 420     }
 421     #[enumerant = SubFMEO_]
 422     fn subfmeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 423         "subfmeo."
 424     }
 425
 426     // addze
 427     #[enumerant = AddZE]
 428     fn addze(Ra, Carry) -> (Rt, Carry) {
 429         "addze"
 430     }
 431     #[enumerant = AddZEO]
 432     fn addzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 433         "addzeo"
 434     }
 435     #[enumerant = AddZE_]
 436     fn addze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 437         "addze."
 438     }
 439     #[enumerant = AddZEO_]
 440     fn addzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 441         "addzeo."
 442     }
 443
 444     // subfze
 445     #[enumerant = SubFZE]
 446     fn subfze(Ra, Carry) -> (Rt, Carry) {
 447         "subfze"
 448     }
 449     #[enumerant = SubFZEO]
 450     fn subfzeo(Ra, Overflow, Carry) -> (Rt, Carry, Overflow) {
 451         "subfzeo"
 452     }
 453     #[enumerant = SubFZE_]
 454     fn subfze_(Ra, Overflow, Carry) -> (Rt, Carry, CR0) {
 455         "subfze."
 456     }
 457     #[enumerant = SubFZEO_]
 458     fn subfzeo_(Ra, Overflow, Carry) -> (Rt, Carry, Overflow, CR0) {
 459         "subfzeo."
 460     }
 461
 462     // divde
 463     #[enumerant = DivDE]
 464     fn divde(Ra, Rb) -> (Rt) {
 465         "divde"
 466     }
 467     #[enumerant = DivDEO]
 468     fn divdeo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 469         "divdeo"
 470     }
 471     #[enumerant = DivDE_]
 472     fn divde_(Ra, Rb, Overflow) -> (Rt, CR0) {
 473         "divde."
 474     }
 475     #[enumerant = DivDEO_]
 476     fn divdeo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 477         "divdeo."
 478     }
 479
 480     // divdeu
 481     #[enumerant = DivDEU]
 482     fn divdeu(Ra, Rb) -> (Rt) {
 483         "divdeu"
 484     }
 485     #[enumerant = DivDEUO]
 486     fn divdeuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 487         "divdeuo"
 488     }
 489     #[enumerant = DivDEU_]
 490     fn divdeu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 491         "divdeu."
 492     }
 493     #[enumerant = DivDEUO_]
 494     fn divdeuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 495         "divdeuo."
 496     }
 497
 498     // divd
 499     #[enumerant = DivD]
 500     fn divd(Ra, Rb) -> (Rt) {
 501         "divd"
 502     }
 503     #[enumerant = DivDO]
 504     fn divdo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 505         "divdo"
 506     }
 507     #[enumerant = DivD_]
 508     fn divd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 509         "divd."
 510     }
 511     #[enumerant = DivDO_]
 512     fn divdo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 513         "divdo."
 514     }
 515
 516     // divdu
 517     #[enumerant = DivDU]
 518     fn divdu(Ra, Rb) -> (Rt) {
 519         "divdu"
 520     }
 521     #[enumerant = DivDUO]
 522     fn divduo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 523         "divduo"
 524     }
 525     #[enumerant = DivDU_]
 526     fn divdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 527         "divdu."
 528     }
 529     #[enumerant = DivDUO_]
 530     fn divduo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 531         "divduo."
 532     }
 533
 534     // divwe
 535     #[enumerant = DivWE]
 536     fn divwe(Ra, Rb) -> (Rt) {
 537         "divwe"
 538     }
 539     #[enumerant = DivWEO]
 540     fn divweo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 541         "divweo"
 542     }
 543     #[enumerant = DivWE_]
 544     fn divwe_(Ra, Rb, Overflow) -> (Rt, CR0) {
 545         "divwe."
 546     }
 547     #[enumerant = DivWEO_]
 548     fn divweo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 549         "divweo."
 550     }
 551
 552     // divweu
 553     #[enumerant = DivWEU]
 554     fn divweu(Ra, Rb) -> (Rt) {
 555         "divweu"
 556     }
 557     #[enumerant = DivWEUO]
 558     fn divweuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 559         "divweuo"
 560     }
 561     #[enumerant = DivWEU_]
 562     fn divweu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 563         "divweu."
 564     }
 565     #[enumerant = DivWEUO_]
 566     fn divweuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 567         "divweuo."
 568     }
 569
 570     // divw
 571     #[enumerant = DivW]
 572     fn divw(Ra, Rb) -> (Rt) {
 573         "divw"
 574     }
 575     #[enumerant = DivWO]
 576     fn divwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 577         "divwo"
 578     }
 579     #[enumerant = DivW_]
 580     fn divw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 581         "divw."
 582     }
 583     #[enumerant = DivWO_]
 584     fn divwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 585         "divwo."
 586     }
 587
 588     // divwu
 589     #[enumerant = DivWU]
 590     fn divwu(Ra, Rb) -> (Rt) {
 591         "divwu"
 592     }
 593     #[enumerant = DivWUO]
 594     fn divwuo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 595         "divwuo"
 596     }
 597     #[enumerant = DivWU_]
 598     fn divwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 599         "divwu."
 600     }
 601     #[enumerant = DivWUO_]
 602     fn divwuo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 603         "divwuo."
 604     }
 605
 606     // mod*
 607     #[enumerant = ModSD]
 608     fn modsd(Ra, Rb) -> (Rt) {
 609         "modsd"
 610     }
 611     #[enumerant = ModUD]
 612     fn modud(Ra, Rb) -> (Rt) {
 613         "modud"
 614     }
 615     #[enumerant = ModSW]
 616     fn modsw(Ra, Rb) -> (Rt) {
 617         "modsw"
 618     }
 619     #[enumerant = ModUW]
 620     fn moduw(Ra, Rb) -> (Rt) {
 621         "moduw"
 622     }
 623
 624     // mullw
 625     #[enumerant = MulLW]
 626     fn mullw(Ra, Rb) -> (Rt) {
 627         "mullw"
 628     }
 629     #[enumerant = MulLWO]
 630     fn mullwo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 631         "mullwo"
 632     }
 633     #[enumerant = MulLW_]
 634     fn mullw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 635         "mullw."
 636     }
 637     #[enumerant = MulLWO_]
 638     fn mullwo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 639         "mullwo."
 640     }
 641
 642     // mulhw
 643     #[enumerant = MulHW]
 644     fn mulhw(Ra, Rb) -> (Rt) {
 645         "mulhw"
 646     }
 647     #[enumerant = MulHW_]
 648     fn mulhw_(Ra, Rb, Overflow) -> (Rt, CR0) {
 649         "mulhw."
 650     }
 651
 652     // mulhwu
 653     #[enumerant = MulHWU]
 654     fn mulhwu(Ra, Rb) -> (Rt) {
 655         "mulhwu"
 656     }
 657     #[enumerant = MulHWU_]
 658     fn mulhwu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 659         "mulhwu."
 660     }
 661
 662     // mulld
 663     #[enumerant = MulLD]
 664     fn mulld(Ra, Rb) -> (Rt) {
 665         "mulld"
 666     }
 667     #[enumerant = MulLDO]
 668     fn mulldo(Ra, Rb, Overflow) -> (Rt, Overflow) {
 669         "mulldo"
 670     }
 671     #[enumerant = MulLD_]
 672     fn mulld_(Ra, Rb, Overflow) -> (Rt, CR0) {
 673         "mulld."
 674     }
 675     #[enumerant = MulLDO_]
 676     fn mulldo_(Ra, Rb, Overflow) -> (Rt, Overflow, CR0) {
 677         "mulldo."
 678     }
 679
 680     // mulhd
 681     #[enumerant = MulHD]
 682     fn mulhd(Ra, Rb) -> (Rt) {
 683         "mulhd"
 684     }
 685     #[enumerant = MulHD_]
 686     fn mulhd_(Ra, Rb, Overflow) -> (Rt, CR0) {
 687         "mulhd."
 688     }
 689
 690     // mulhdu
 691     #[enumerant = MulHDU]
 692     fn mulhdu(Ra, Rb) -> (Rt) {
 693         "mulhdu"
 694     }
 695     #[enumerant = MulHDU_]
 696     fn mulhdu_(Ra, Rb, Overflow) -> (Rt, CR0) {
 697         "mulhdu."
 698     }
 699
 700     // madd*
 701     #[enumerant = MAddHD]
 702     fn maddhd(Ra, Rb, Rc) -> (Rt) {
 703         "maddhd"
 704     }
 705     #[enumerant = MAddHDU]
 706     fn maddhdu(Ra, Rb, Rc) -> (Rt) {
 707         "maddhdu"
 708     }
 709     #[enumerant = MAddLD]
 710     fn maddld(Ra, Rb, Rc) -> (Rt) {
 711         "maddld"
 712     }
 713 }
 714
 715 // must be after instrs macro call since it uses a macro definition
 716 mod python;