macros.rs.html -- source
Description: Source to the Rust file `src/libcore/../stdarch/crates/core_arch/src/x86/macros.rs`.
Keywords: rust, rustlang, rust-lang

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109

    //! Utility macros.

    macro_rules! constify_imm6 {
        ($imm8:expr, $expand:ident) => {
            #[allow(overflowing_literals)]
            match ($imm8) & 0b1_1111 {
                0 => $expand!(0),
                1 => $expand!(1),
                2 => $expand!(2),
                3 => $expand!(3),
                4 => $expand!(4),
                5 => $expand!(5),
                6 => $expand!(6),
                7 => $expand!(7),
                8 => $expand!(8),
                9 => $expand!(9),
                10 => $expand!(10),
                11 => $expand!(11),
                12 => $expand!(12),
                13 => $expand!(13),
                14 => $expand!(14),
                15 => $expand!(15),
                16 => $expand!(16),
                17 => $expand!(17),
                18 => $expand!(18),
                19 => $expand!(19),
                20 => $expand!(20),
                21 => $expand!(21),
                22 => $expand!(22),
                23 => $expand!(23),
                24 => $expand!(24),
                25 => $expand!(25),
                26 => $expand!(26),
                27 => $expand!(27),
                28 => $expand!(28),
                29 => $expand!(29),
                30 => $expand!(30),
                _ => $expand!(31),
            }
        };
    }

    macro_rules! constify_imm4 {
        ($imm8:expr, $expand:ident) => {
            #[allow(overflowing_literals)]
            match ($imm8) & 0b1111 {
                0 => $expand!(0),
                1 => $expand!(1),
                2 => $expand!(2),
                3 => $expand!(3),
                4 => $expand!(4),
                5 => $expand!(5),
                6 => $expand!(6),
                7 => $expand!(7),
                8 => $expand!(8),
                9 => $expand!(9),
                10 => $expand!(10),
                11 => $expand!(11),
                12 => $expand!(12),
                13 => $expand!(13),
                14 => $expand!(14),
                _ => $expand!(15),
            }
        };
    }

    macro_rules! constify_imm3 {
        ($imm8:expr, $expand:ident) => {
            #[allow(overflowing_literals)]
            match ($imm8) & 0b111 {
                0 => $expand!(0),
                1 => $expand!(1),
                2 => $expand!(2),
                3 => $expand!(3),
                4 => $expand!(4),
                5 => $expand!(5),
                6 => $expand!(6),
                _ => $expand!(7),
            }
        };
    }

    macro_rules! constify_imm2 {
        ($imm8:expr, $expand:ident) => {
            #[allow(overflowing_literals)]
            match ($imm8) & 0b11 {
                0 => $expand!(0),
                1 => $expand!(1),
                2 => $expand!(2),
                _ => $expand!(3),
            }
        };
    }

    #[cfg(test)]
    macro_rules! assert_approx_eq {
        ($a:expr, $b:expr, $eps:expr) => {{
            let (a, b) = (&$a, &$b);
            assert!(
                (*a - *b).abs() < $eps,
                "assertion failed: `(left !== right)` \
                 (left: `{:?}`, right: `{:?}`, expect diff: `{:?}`, real diff: `{:?}`)",
                *a,
                *b,
                $eps,
                (*a - *b).abs()
            );
        }};
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)