# Struct jit::Label [−] [src]

```pub struct Label<'a> {
// some fields omitted
}```

A label in the code that can be branched to in instructions

## Methods

### `impl<'a> Label<'a>`

#### `fn new(func: &UncompiledFunction<'a>) -> Label<'a>`

Create a new label

## Methods from Deref<Target=u64>

#### `fn count_ones(self) -> u32`

Returns the number of ones in the binary representation of `self`.

# Examples

```let n = 0b01001100u8;

assert_eq!(n.count_ones(), 3);
```

#### `fn count_zeros(self) -> u32`

Returns the number of zeros in the binary representation of `self`.

# Examples

```let n = 0b01001100u8;

assert_eq!(n.count_zeros(), 5);
```

#### `fn leading_zeros(self) -> u32`

Returns the number of leading zeros in the binary representation of `self`.

# Examples

```let n = 0b0101000u16;

assert_eq!(n.leading_zeros(), 10);
```

#### `fn trailing_zeros(self) -> u32`

Returns the number of trailing zeros in the binary representation of `self`.

# Examples

```let n = 0b0101000u16;

assert_eq!(n.trailing_zeros(), 3);
```

#### `fn rotate_left(self, n: u32) -> u64`

Shifts the bits to the left by a specified amount, `n`, wrapping the truncated bits to the end of the resulting integer.

# Examples

```let n = 0x0123456789ABCDEFu64;
let m = 0x3456789ABCDEF012u64;

assert_eq!(n.rotate_left(12), m);
```

#### `fn rotate_right(self, n: u32) -> u64`

Shifts the bits to the right by a specified amount, `n`, wrapping the truncated bits to the beginning of the resulting integer.

# Examples

```let n = 0x0123456789ABCDEFu64;
let m = 0xDEF0123456789ABCu64;

assert_eq!(n.rotate_right(12), m);
```

#### `fn swap_bytes(self) -> u64`

Reverses the byte order of the integer.

# Examples

```let n = 0x0123456789ABCDEFu64;
let m = 0xEFCDAB8967452301u64;

assert_eq!(n.swap_bytes(), m);
```

#### `fn to_be(self) -> u64`

Converts `self` to big endian from the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

# Examples

```let n = 0x0123456789ABCDEFu64;

if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}
```

#### `fn to_le(self) -> u64`

Converts `self` to little endian from the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

# Examples

```let n = 0x0123456789ABCDEFu64;

if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}
```

#### `fn checked_add(self, other: u64) -> Option<u64>`

Checked integer addition. Computes `self + other`, returning `None` if overflow occurred.

# Examples

```assert_eq!(5u16.checked_add(65530), Some(65535));
assert_eq!(6u16.checked_add(65530), None);
```

#### `fn checked_sub(self, other: u64) -> Option<u64>`

Checked integer subtraction. Computes `self - other`, returning `None` if underflow occurred.

# Examples

```assert_eq!((-127i8).checked_sub(1), Some(-128));
assert_eq!((-128i8).checked_sub(1), None);
```

#### `fn checked_mul(self, other: u64) -> Option<u64>`

Checked integer multiplication. Computes `self * other`, returning `None` if underflow or overflow occurred.

# Examples

```assert_eq!(5u8.checked_mul(51), Some(255));
assert_eq!(5u8.checked_mul(52), None);
```

#### `fn checked_div(self, v: u64) -> Option<u64>`

Checked integer division. Computes `self / other`, returning `None` if `other == 0` or the operation results in underflow or overflow.

# Examples

```assert_eq!((-127i8).checked_div(-1), Some(127));
assert_eq!((-128i8).checked_div(-1), None);
assert_eq!((1i8).checked_div(0), None);
```

#### `fn saturating_add(self, other: u64) -> u64`

Saturating integer addition. Computes `self + other`, saturating at the numeric bounds instead of overflowing.

#### `fn saturating_sub(self, other: u64) -> u64`

Saturating integer subtraction. Computes `self - other`, saturating at the numeric bounds instead of overflowing.

#### `fn wrapping_add(self, rhs: u64) -> u64`

Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of the type.

#### `fn wrapping_sub(self, rhs: u64) -> u64`

Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary of the type.

#### `fn wrapping_mul(self, rhs: u64) -> u64`

Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary of the type.

#### `fn wrapping_div(self, rhs: u64) -> u64`

Unstable

Wrapping (modular) division. Computes `floor(self / other)`, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where `MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value that is too large to represent in the type. In such a case, this function returns `MIN` itself..

#### `fn wrapping_rem(self, rhs: u64) -> u64`

Unstable

Wrapping (modular) remainder. Computes `self % other`, wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y` illegal for `MIN / -1` on a signed type illegal (where `MIN` is the negative minimal value). In such a case, this function returns `0`.

#### `fn wrapping_neg(self) -> u64`

Unstable

Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN` is the negative minimal value for the type); this is a positive value that is too large to represent in the type. In such a case, this function returns `MIN` itself.

#### `fn wrapping_shl(self, rhs: u32) -> u64`

Unstable

Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.

#### `fn wrapping_shr(self, rhs: u32) -> u64`

Unstable

Panic-free bitwise shift-left; yields `self >> mask(rhs)`, where `mask` removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.

#### `fn pow(self, exp: u32) -> u64`

Raises self to the power of `exp`, using exponentiation by squaring.

# Examples

```assert_eq!(2i32.pow(4), 16);
```

#### `fn is_power_of_two(self) -> bool`

Returns `true` iff `self == 2^k` for some `k`.

#### `fn next_power_of_two(self) -> u64`

Returns the smallest power of two greater than or equal to `self`. Unspecified behavior on overflow.

#### `fn checked_next_power_of_two(self) -> Option<u64>`

Returns the smallest power of two greater than or equal to `n`. If the next power of two is greater than the type's maximum value, `None` is returned, otherwise the power of two is wrapped in `Some`.