Struct naga::proc::index::BoundsCheckPolicies

pub struct BoundsCheckPolicies {
    pub index: BoundsCheckPolicy,
    pub buffer: BoundsCheckPolicy,
    pub image_load: BoundsCheckPolicy,
    pub binding_array: BoundsCheckPolicy,
}

Policies for injecting bounds checks during code generation.

Fields

index: BoundsCheckPolicy

How should the generated code handle array, vector, or matrix indices that are out of range?

buffer: BoundsCheckPolicy

How should the generated code handle array, vector, or matrix indices that are out of range, when those values live in a GlobalVariable in the Storage or Uniform address spaces?

Some graphics hardware provides “robust buffer access”, a feature that ensures that using a pointer cannot access memory outside the ‘buffer’ that it was derived from. In Naga terms, this means that the hardware ensures that pointers computed by applying Access and AccessIndex expressions to a GlobalVariable whose space is Storage or Uniform will never read or write memory outside that global variable.

When hardware offers such a feature, it is probably undesirable to have Naga inject bounds checking code for such accesses, since the hardware can probably provide the same protection more efficiently. However, bounds checks are still needed on accesses to indexable values that do not live in buffers, like local variables.

So, this option provides a separate policy that applies only to accesses to storage and uniform globals. When depending on hardware bounds checking, this policy can be Unchecked to avoid unnecessary overhead.

When special hardware support is not available, this should probably be the same as index_bounds_check_policy.

image_load: BoundsCheckPolicy

How should the generated code handle image texel loads that are out of range?

This controls the behavior of ImageLoad expressions when a coordinate, texture array index, level of detail, or multisampled sample number is out of range.

There is no corresponding policy for ImageStore statements. All the platforms we support already discard out-of-bounds image stores, effectively implementing the “skip write” part of ReadZeroSkipWrite.

binding_array: BoundsCheckPolicy

How should the generated code handle binding array indexes that are out of bounds.

Implementations

impl BoundsCheckPolicies

pub fn choose_policy( &self, base: Handle<Expression>, types: &UniqueArena<Type>, info: &FunctionInfo, ) -> BoundsCheckPolicy

Determine which policy applies to base.

base is the “base” expression (the expression being indexed) of a Access and AccessIndex expression. This is either a pointer, a value, being directly indexed, or a binding array.

See the documentation for BoundsCheckPolicy for details about when each policy applies.

pub fn contains(&self, policy: BoundsCheckPolicy) -> bool

Return true if any of self’s policies are policy.

Trait Implementations

impl Clone for BoundsCheckPolicies

fn clone(&self) -> BoundsCheckPolicies

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BoundsCheckPolicies

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

Formats the value using the given formatter.

impl Default for BoundsCheckPolicies

fn default() -> BoundsCheckPolicies

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BoundsCheckPolicies

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for BoundsCheckPolicies

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BoundsCheckPolicies

fn eq(&self, other: &BoundsCheckPolicies) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BoundsCheckPolicies

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BoundsCheckPolicies

impl Eq for BoundsCheckPolicies

impl StructuralPartialEq for BoundsCheckPolicies