Struct `Sym64`

struct Sym64<E: Endian> { ... }

Symbol table entry.

Fields

st_name: crate::endian::U32<E>

Symbol name.

This is an offset into the symbol string table.

st_info: u8

Symbol type and binding.

Use the st_bind and st_type methods to access this value.

st_other: u8

Symbol visibility.

Use the st_visibility method to access this value.

st_shndx: crate::endian::U16<E>

Section index or one of the SHN_* values.

st_value: crate::endian::U64<E>

Symbol value.

st_size: crate::endian::U64<E>

Symbol size.

Implementations

`impl<E: Endian> Sym64<E>`

fn st_bind(self: &Self) -> u8: Get the st_bind component of the st_info field.
fn st_type(self: &Self) -> u8: Get the st_type component of the st_info field.
fn set_st_info(self: &mut Self, st_bind: u8, st_type: u8): Set the st_info field given the st_bind and st_type components.
fn st_visibility(self: &Self) -> u8: Get the st_visibility component of the st_info field.

`impl<E> Freeze for Sym64<E>`

`impl<E> RefUnwindSafe for Sym64<E>`

`impl<E> Send for Sym64<E>`

`impl<E> Sync for Sym64<E>`

`impl<E> Unpin for Sym64<E>`

`impl<E> UnwindSafe for Sym64<E>`

`impl<E: $crate::clone::Clone + Endian> Clone for Sym64<E>`

fn clone(self: &Self) -> Sym64<E>

`impl<E: $crate::default::Default + Endian> Default for Sym64<E>`

fn default() -> Sym64<E>

`impl<E: $crate::fmt::Debug + Endian> Debug for Sym64<E>`

fn fmt(self: &Self, f: &mut $crate::fmt::Formatter<'_>) -> $crate::fmt::Result

`impl<E: $crate::marker::Copy + Endian> Copy for Sym64<E>`

`impl<E: Endian> Pod for Sym64<E>`

`impl<Endian: endian::Endian> Sym for elf::Sym64<Endian>`

fn st_name(self: &Self, endian: <Self as >::Endian) -> u32
fn st_info(self: &Self) -> u8
fn st_bind(self: &Self) -> u8
fn st_type(self: &Self) -> u8
fn st_other(self: &Self) -> u8
fn st_visibility(self: &Self) -> u8
fn st_shndx(self: &Self, endian: <Self as >::Endian) -> u16
fn st_value(self: &Self, endian: <Self as >::Endian) -> <Self as >::Word
fn st_size(self: &Self, endian: <Self as >::Endian) -> <Self as >::Word

`impl<T> Any for Sym64<E>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Sym64<E>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Sym64<E>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Sym64<E>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Sym64<E>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Sym64<E>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Sym64<E>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Sym64<E>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Sym64<E>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>