SkSL::RP Namespace Reference

Classes
class	AutoContinueMask
class	AutoLoopTarget
class	AutoStack
class	Builder
class	Callbacks
class	DynamicIndexLValue
class	Generator
class	ImmutableLValue
struct	Instruction
class	LValue
class	LValueSlice
class	Program
class	ScratchLValue
class	SlotManager
struct	SlotRange
class	SwizzleLValue
class	UnownedLValueSlice
class	VariableLValue

Typedefs
using	Slot = int

Enumerations
enum class	ProgramOp { M }
enum class	BuilderOp {   M , push_clone , push_clone_from_stack , push_clone_indirect_from_stack ,   push_constant , push_immutable , push_immutable_indirect , push_slots ,   push_slots_indirect , push_uniform , push_uniform_indirect , copy_stack_to_slots ,   copy_stack_to_slots_unmasked , copy_stack_to_slots_indirect , copy_uniform_to_slots_unmasked , store_immutable_value ,   swizzle_copy_stack_to_slots , swizzle_copy_stack_to_slots_indirect , discard_stack , pad_stack ,   select , push_condition_mask , pop_condition_mask , push_loop_mask ,   pop_loop_mask , pop_and_reenable_loop_mask , push_return_mask , pop_return_mask ,   push_src_rgba , push_dst_rgba , push_device_xy01 , pop_src_rgba ,   pop_dst_rgba , trace_var_indirect , branch_if_no_active_lanes_on_stack_top_equal , unsupported }

Functions
static bool	is_immediate_op (BuilderOp op)
static bool	is_multi_slot_immediate_op (BuilderOp op)
static BuilderOp	convert_n_way_op_to_immediate (BuilderOp op, int slots, int32_t *constantValue)
static bool	slot_ranges_overlap (SlotRange x, SlotRange y)
static int	pack_nybbles (SkSpan< const int8_t > components)
template<typename T >
static void	unpack_nybbles_to_offsets (uint32_t components, SkSpan< T > offsets)
static int	max_packed_nybble (uint32_t components, size_t numComponents)
static int	stack_usage (const Instruction &inst)
static bool	immutable_data_is_splattable (int32_t *immutablePtr, int numSlots)
static void *	context_bit_pun (intptr_t val)
static bool	unsupported ()
static bool	is_sliceable_swizzle (SkSpan< const int8_t > components)

Variables
constexpr Slot	NA = -1

Typedef Documentation

Slot

using SkSL::RP::Slot = typedef int

Definition at line 36 of file SkSLRasterPipelineBuilder.h.

Enumeration Type Documentation

BuilderOp

enum class SkSL::RP::BuilderOp

strong

Enumerator
M
push_clone
push_clone_from_stack
push_clone_indirect_from_stack
push_constant
push_immutable
push_immutable_indirect
push_slots
push_slots_indirect
push_uniform
push_uniform_indirect
copy_stack_to_slots
copy_stack_to_slots_unmasked
copy_stack_to_slots_indirect
copy_uniform_to_slots_unmasked
store_immutable_value
swizzle_copy_stack_to_slots
swizzle_copy_stack_to_slots_indirect
discard_stack
pad_stack
select
push_condition_mask
pop_condition_mask
push_loop_mask
pop_loop_mask
pop_and_reenable_loop_mask
push_return_mask
pop_return_mask
push_src_rgba
push_dst_rgba
push_device_xy01
pop_src_rgba
pop_dst_rgba
trace_var_indirect
branch_if_no_active_lanes_on_stack_top_equal
unsupported

Definition at line 77 of file SkSLRasterPipelineBuilder.h.

                     {
    #define M(stage) stage,
        // An in-flight program can contain all the native Raster Pipeline ops...
        SK_RASTER_PIPELINE_OPS_ALL(M)
 
        // ... and our extended ops...
        SKRP_EXTENDED_OPS(M)
    #undef M
 
    // ... and also has Builder-specific ops. These ops generally interface with the stack, and are
    // converted into ProgramOps during `makeStages`.
    push_clone,
    push_clone_from_stack,
    push_clone_indirect_from_stack,
    push_constant,
    push_immutable,
    push_immutable_indirect,
    push_slots,
    push_slots_indirect,
    push_uniform,
    push_uniform_indirect,
    copy_stack_to_slots,
    copy_stack_to_slots_unmasked,
    copy_stack_to_slots_indirect,
    copy_uniform_to_slots_unmasked,
    store_immutable_value,
    swizzle_copy_stack_to_slots,
    swizzle_copy_stack_to_slots_indirect,
    discard_stack,
    pad_stack,
    select,
    push_condition_mask,
    pop_condition_mask,
    push_loop_mask,
    pop_loop_mask,
    pop_and_reenable_loop_mask,
    push_return_mask,
    pop_return_mask,
    push_src_rgba,
    push_dst_rgba,
    push_device_xy01,
    pop_src_rgba,
    pop_dst_rgba,
    trace_var_indirect,
    branch_if_no_active_lanes_on_stack_top_equal,
    unsupported
};

ProgramOp

enum class SkSL::RP::ProgramOp

strong

Enumerator
M

Definition at line 61 of file SkSLRasterPipelineBuilder.h.

                     {
    #define M(stage) stage,
        // A finished program can contain any native Raster Pipeline op...
        SK_RASTER_PIPELINE_OPS_ALL(M)
 
        // ... as well as our extended ops.
        SKRP_EXTENDED_OPS(M)
    #undef M
};

Function Documentation

context_bit_pun()

static void * SkSL::RP::context_bit_pun ( intptr_t  val )

static

Definition at line 1630 of file SkSLRasterPipelineBuilder.cpp.

                                           {
    return sk_bit_cast<void*>(val);
}

convert_n_way_op_to_immediate()

static BuilderOp SkSL::RP::convert_n_way_op_to_immediate ( BuilderOp  op, int  slots, int32_t *  constantValue  )

static

Definition at line 146 of file SkSLRasterPipelineBuilder.cpp.

                                                                                                {
    // We rely on the exact ordering of SkRP ops here; the immediate-mode op must always come
    // directly before the n-way op. (If we have more than one, the increasing-slot variations
    // continue backwards from there.)
    BuilderOp immOp = (BuilderOp)((int)op - 1);
 
    // Some immediate ops support multiple slots.
    if (is_multi_slot_immediate_op(immOp)) {
        return immOp;
    }
 
    // Most immediate ops only directly support a single slot. However, it's still faster to execute
    // `add_imm_int, add_imm_int` instead of `splat_2_ints, add_2_ints`, so we allow those
    // conversions as well.
    if (slots <= 2) {
        if (is_immediate_op(immOp)) {
            return immOp;
        }
 
        // We also allow for immediate-mode subtraction, by adding a negative value.
        switch (op) {
            case BuilderOp::sub_n_ints:
                *constantValue *= -1;
                return BuilderOp::add_imm_int;
 
            case BuilderOp::sub_n_floats: {
                // This negates the floating-point value by inverting its sign bit.
                *constantValue ^= 0x80000000;
                return BuilderOp::add_imm_float;
            }
            default:
                break;
        }
    }
 
    // We don't have an immediate-mode version of this op.
    return op;
}

immutable_data_is_splattable()

static bool SkSL::RP::immutable_data_is_splattable ( int32_t *  immutablePtr, int  numSlots  )

static

Definition at line 1418 of file SkSLRasterPipelineBuilder.cpp.

                                                                              {
    // If every value between `immutablePtr[0]` and `immutablePtr[numSlots]` is bit-identical, we
    // can use a splat.
    for (int index = 1; index < numSlots; ++index) {
        if (immutablePtr[0] != immutablePtr[index]) {
            return false;
        }
    }
    return true;
}

is_immediate_op()

static bool SkSL::RP::is_immediate_op ( BuilderOp  op )

static

Definition at line 132 of file SkSLRasterPipelineBuilder.cpp.

                                          {
    switch (op) {
        case ALL_IMMEDIATE_BINARY_OP_CASES: return true;
        default:                            return false;
    }
}

is_multi_slot_immediate_op()

static bool SkSL::RP::is_multi_slot_immediate_op ( BuilderOp  op )

static

Definition at line 139 of file SkSLRasterPipelineBuilder.cpp.

                                                     {
    switch (op) {
        case ALL_IMMEDIATE_MULTI_SLOT_BINARY_OP_CASES: return true;
        default:                                       return false;
    }
}

is_sliceable_swizzle()

static bool SkSL::RP::is_sliceable_swizzle ( SkSpan< const int8_t >  components )

static

Definition at line 1233 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                  {
    // Determine if the swizzle rearranges its elements, or if it's a simple subset of its elements.
    // (A simple subset would be a sequential non-repeating range of components, like `.xyz` or
    // `.yzw` or `.z`, but not `.xx` or `.xz`, which can be accessed as a slice of the variable.)
    for (size_t index = 1; index < components.size(); ++index) {
        if (components[index] != int8_t(components[0] + index)) {
            return false;
        }
    }
    return true;
}

max_packed_nybble()

static int SkSL::RP::max_packed_nybble ( uint32_t  components, size_t  numComponents  )

static

Definition at line 1089 of file SkSLRasterPipelineBuilder.cpp.

                                                                        {
    int largest = 0;
    for (size_t index = 0; index < numComponents; ++index) {
        largest = std::max<int>(largest, components & 0xF);
        components >>= 4;
    }
    return largest;
}

pack_nybbles()

static int SkSL::RP::pack_nybbles ( SkSpan< const int8_t >  components )

static

Definition at line 1069 of file SkSLRasterPipelineBuilder.cpp.

                                                         {
    // Pack up to 8 elements into nybbles, in reverse order.
    int packed = 0;
    for (auto iter = components.rbegin(); iter != components.rend(); ++iter) {
        SkASSERT(*iter >= 0 && *iter <= 0xF);
        packed <<= 4;
        packed |= *iter;
    }
    return packed;
}

slot_ranges_overlap()

static bool SkSL::RP::slot_ranges_overlap ( SlotRange  x, SlotRange  y  )

static

Definition at line 899 of file SkSLRasterPipelineBuilder.cpp.

                                                          {
    return x.index < y.index + y.count &&
           y.index < x.index + x.count;
}

stack_usage()

static int SkSL::RP::stack_usage ( const Instruction &  inst )

static

Definition at line 1278 of file SkSLRasterPipelineBuilder.cpp.

                                                {
    switch (inst.fOp) {
        case BuilderOp::push_condition_mask:
        case BuilderOp::push_loop_mask:
        case BuilderOp::push_return_mask:
            return 1;
 
        case BuilderOp::push_src_rgba:
        case BuilderOp::push_dst_rgba:
        case BuilderOp::push_device_xy01:
            return 4;
 
        case BuilderOp::push_immutable:
        case BuilderOp::push_immutable_indirect:
        case BuilderOp::push_constant:
        case BuilderOp::push_slots:
        case BuilderOp::push_slots_indirect:
        case BuilderOp::push_uniform:
        case BuilderOp::push_uniform_indirect:
        case BuilderOp::push_clone:
        case BuilderOp::push_clone_from_stack:
        case BuilderOp::push_clone_indirect_from_stack:
        case BuilderOp::pad_stack:
            return inst.fImmA;
 
        case BuilderOp::pop_condition_mask:
        case BuilderOp::pop_loop_mask:
        case BuilderOp::pop_and_reenable_loop_mask:
        case BuilderOp::pop_return_mask:
            return -1;
 
        case BuilderOp::pop_src_rgba:
        case BuilderOp::pop_dst_rgba:
            return -4;
 
        case ALL_N_WAY_BINARY_OP_CASES:
        case ALL_MULTI_SLOT_BINARY_OP_CASES:
        case BuilderOp::discard_stack:
        case BuilderOp::select:
            return -inst.fImmA;
 
        case ALL_N_WAY_TERNARY_OP_CASES:
        case ALL_MULTI_SLOT_TERNARY_OP_CASES:
            return 2 * -inst.fImmA;
 
        case BuilderOp::swizzle_1:
            return 1 - inst.fImmA;  // consumes immA slots and emits a scalar
        case BuilderOp::swizzle_2:
            return 2 - inst.fImmA;  // consumes immA slots and emits a 2-slot vector
        case BuilderOp::swizzle_3:
            return 3 - inst.fImmA;  // consumes immA slots and emits a 3-slot vector
        case BuilderOp::swizzle_4:
            return 4 - inst.fImmA;  // consumes immA slots and emits a 4-slot vector
 
        case BuilderOp::dot_2_floats:
            return -3;  // consumes two 2-slot vectors and emits one scalar
        case BuilderOp::dot_3_floats:
            return -5;  // consumes two 3-slot vectors and emits one scalar
        case BuilderOp::dot_4_floats:
            return -7;  // consumes two 4-slot vectors and emits one scalar
 
        case BuilderOp::refract_4_floats:
            return -5;  // consumes nine slots (N + I + eta) and emits a 4-slot vector (R)
 
        case BuilderOp::matrix_multiply_2:
        case BuilderOp::matrix_multiply_3:
        case BuilderOp::matrix_multiply_4:
            // consumes the left- and right-matrices; emits result over existing padding slots
            return -(inst.fImmA * inst.fImmB + inst.fImmC * inst.fImmD);
 
        case BuilderOp::shuffle: {
            int consumed = inst.fImmA;
            int generated = inst.fImmB;
            return generated - consumed;
        }
        case ALL_SINGLE_SLOT_UNARY_OP_CASES:
        case ALL_MULTI_SLOT_UNARY_OP_CASES:
        case ALL_IMMEDIATE_BINARY_OP_CASES:
        default:
            return 0;
    }
}

unpack_nybbles_to_offsets()

template<typename T >

static void SkSL::RP::unpack_nybbles_to_offsets ( uint32_t  components, SkSpan< T >  offsets  )

static

Definition at line 1081 of file SkSLRasterPipelineBuilder.cpp.

                                                                              {
    // Unpack component nybbles into byte-offsets pointing at stack slots.
    for (size_t index = 0; index < offsets.size(); ++index) {
        offsets[index] = (components & 0xF) * SkOpts::raster_pipeline_highp_stride * sizeof(float);
        components >>= 4;
    }
}

unsupported()

static bool SkSL::RP::unsupported ( )

static

Definition at line 86 of file SkSLRasterPipelineCodeGenerator.cpp.

                          {
    // If MakeRasterPipelineProgram returns false, set a breakpoint here for more information.
    return false;
}

Variable Documentation

NA

constexpr Slot SkSL::RP::NA = -1

constexpr

Definition at line 37 of file SkSLRasterPipelineBuilder.h.