Module std::intrinsics

Functions implemented directly in the compiler.

Functions in this module are not intended for general use, and are usually called by wrapper functions in the standard library (e.g. size_of and unreachable).

Intrinsic functions are not first-class citizens. You cannot take a reference to one, or pass it as an argument to another function. The intrinsic call signature is not strictly enforced (pass as many arguments as you want, they will be ignored, the intrinsic may return a value of different type, etc.). Needless to say, intrinsics do not participate in type inference.

Functions

• extern "intrinsic" fn compile_fail(reason: &[u8]) -> !

  source

  Marker return type for intrinsics where the return type is not expressible or depends on the arguments (gasp!) Fail the compilation process with a human-readable message.

  Use compile_fail instead.

• extern "intrinsic" fn compile_warn(reason: &[u8])

  source

  Emit a warning message during compilation.

• extern "intrinsic" fn compile_note(reason: &[u8])

  source

  Emit a note during compilation.

• extern "intrinsic" fn unreachable() -> !

  source

  Unreachable code

  Use unreachable instead.

• extern "intrinsic" fn trap() -> !

  source

  Trigger a trap (e.g. through an invalid instruction).

• extern "intrinsic" fn size_of<T>() -> usize

  source

  Size of type in bytes

  Use size_of instead.

• extern "intrinsic" fn length_of<T>() -> usize

  T: Array | Tuple

  source

  Length of a fixed-size array or tuple

  Use len or len instead.

• extern "intrinsic" fn type_id<T>() -> usize

  source

  Unique type identifier

  Use type_id instead.

• extern "intrinsic" fn type_name<T>() -> &[u8]

  source

  Name of a type

  Use type_name instead.

• extern "intrinsic" fn named_type_name<T>() -> &[u8]

  source

  Name of the named type

  Use name instead.

• extern "intrinsic" fn align_of<T>() -> usize

  source

  Minimum alignment of a type in bytes.

  Use align_of instead.

• extern "intrinsic" fn vtable<Proto, T>() -> /* computed */

  source

  Generate a virtual method table for the given protocol and type.

  Do not use directly, use coercion to &dyn Protocol instead. Meant to be called from a const initializer.

• extern "intrinsic" fn enum_variants<T>() -> /* computed */

  T: Enum

  source

  Enum variants

  Do not use directly, use Type instead. Meant to be called from a const initializer (see ENUM_VARIANTS).

• extern "intrinsic" fn fields<T>() -> /* computed */

  T: Struct | Union

  source

  Field descriptors for a struct

  Do not use directly, use Type instead. Meant to be called from a const initializer (see FIELDS).

• extern "intrinsic" fn attributed<Args>(name: &[u8]) -> /* computed */

  Args: Tuple

  source

  Find items by attribute name

  It returns a tuple of Types for each item found. Generic arguments can be provided to monomorphize all items with specific type parameters.

  There is no stable equivalent in the standard library as the return type is dependent on the input (deep magic lol).

• extern "intrinsic" fn value_of<T>() -> T

  T: Const | Static

  source

  Value of a constant or static referenced by a type

  Use value instead.

  This intrinsic emits a lvalue.

• extern "intrinsic" fn asm(assembly: &[u8])

  source

  Inline assembly

• extern "intrinsic" fn uninitialized<T>() -> T

  source

  Uninitialized value of type T

  Use uninitialized instead.

• extern "intrinsic" fn zeroed<T>() -> T

  source

  Zero-initialized value of type T

  Use zeroed instead.

• extern "intrinsic" fn dangling<Ptr>() -> Ptr

  Ptr: Pointer

  source

  Appropriately aligned non-null pointer

  Use dangling instead.

• extern "intrinsic" fn transmute<T1, T2>(val: T1) -> T2

  source

  Transmute a value from one type to another.

  Use transmute instead.

• extern "intrinsic" fn volatile<Ptr>(ptr: Ptr) -> Ptr

  Ptr: Pointer

  source

  Cast a pointer into a pointer-to-volatile.

  Use read_volatile and write_volatile instead.

• extern "intrinsic" fn in_const_context() -> bool

  source

  Whether we are in constant evaluation context

  Use in_const_context instead.

• extern "intrinsic" fn is_const_evaluable<T>(expr: T) -> bool

  source

  Returns true if the expression is evaluable at compile-time.

  Use is_const_evaluable instead.

• extern "intrinsic" fn const_eval<T>(expr: T) -> T

  source

  Forces the argument to be evaluated at compile-time.

  Use const_eval instead.

• extern "intrinsic" fn const_panic(msg: &[u8]) -> !

  source

  Panics during constant evaluation (aborts compilation).

  Invoking this during normal runtime is undefined behavior.

  Use panic instead.

• extern "intrinsic" fn const_note(msg: &[u8])

  source

  Writes a note during constant evaluation.

  Invoking this during normal runtime is undefined behavior.

  Use println instead.

• extern "intrinsic" fn const_warning(msg: &[u8])

  source

  Writes a warning during constant evaluation.

  Invoking this during normal runtime is undefined behavior.

  Use eprintln instead.

• extern "intrinsic" fn const_alloc<T>(size: usize) -> &mut T

  source

  Allocates memory during constant evaluation.

  Use alloc in const context instead.

• extern "intrinsic" fn const_free<T>(ptr: &mut T)

  source

  Frees memory allocated during constant evaluation.

  Use free in const context instead.

• extern "intrinsic" fn tag<T>(tag: &[u8], val: T) -> T

  source

  Identity function.

  Adds a tag to the IR subtree. This has no effect on the generated code, but is generally preserved accross passes until codegen. Tags control certain aspects of const evaluation and compiler diagnostics. They are not meant to be used by user code.

  Tags are currently added when desugaring certain language constructs, such as for loops and defer expressions.

  The type, constness and value-kind of the tagged expression are preserved.

  let x = 0;
  std::intrinsics::tag("foo", x) += 1; // this is valid
  
  assert_eq!(x, 1);
  Run this example

  No user-facing equivalent.

• extern "intrinsic" fn tuple_invoke<Fun, Args, Ret>(f: Fun, args: Args) -> Ret

  Fun: Fn(Args, Ret)

  source

  Invoke a function with arguments passed as a tuple.

  Use invoke instead.

• extern "intrinsic" fn stop_iteration() -> !

  source

  Stop iteration in a for const loop.

  No user-facing equivalent.

• extern "intrinsic" fn module_path<T>() -> &[u8]

  source

  Get the source path of a named item.

  Use module_path instead.

• extern "intrinsic" fn has_attribute<T>(name: &[u8]) -> bool

  source

  Returns true if the named item has the specified attribute.

• extern "intrinsic" fn expect(value: bool, to_be: bool) -> bool

  source

  Hint that the value is expected to be to_be.

  Use likely and unlikely instead.

• extern "intrinsic" fn with_span_of<T, E>(expr: E) -> E

  source

  Lowers the inner expression using the definition span of the provided generic argument.

  This intrinsic may return a lvalue.

  No stable equivalent.

• extern "intrinsic" fn codegen_const<T>(name: &[u8]) -> T

  source

  Return the value of a C builtin constant

• extern "intrinsic" fn codegen_func<T>(name: &[u8], ...) -> T

  source

  Call a builtin C function

• extern "intrinsic" fn codegen_type_func<T, Ret>(name: &[u8]) -> T

  source

  Call a builtin C "type function" (e.g. sizeof)