RasterPipelineBuilderTest.cpp File Reference

#include "include/core/SkStream.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkStringView.h"
#include "src/core/SkRasterPipeline.h"
#include "src/sksl/codegen/SkSLRasterPipelineBuilder.h"
#include "src/sksl/tracing/SkSLDebugTracePriv.h"
#include "tests/Test.h"

Go to the source code of this file.

Functions
static sk_sp< SkData >	get_program_dump (SkSL::RP::Program &program)
static std::string_view	as_string_view (const sk_sp< SkData > &dump)
static void	check (skiatest::Reporter *r, SkSL::RP::Program &program, std::string_view expected)
static SkSL::RP::SlotRange	one_slot_at (SkSL::RP::Slot index)
static SkSL::RP::SlotRange	two_slots_at (SkSL::RP::Slot index)
static SkSL::RP::SlotRange	three_slots_at (SkSL::RP::Slot index)
static SkSL::RP::SlotRange	four_slots_at (SkSL::RP::Slot index)
static SkSL::RP::SlotRange	five_slots_at (SkSL::RP::Slot index)
static SkSL::RP::SlotRange	ten_slots_at (SkSL::RP::Slot index)
	DEF_TEST (RasterPipelineBuilder, r)
	DEF_TEST (RasterPipelineBuilderPushPopMaskRegisters, r)
	DEF_TEST (RasterPipelineBuilderCaseOp, r)
	DEF_TEST (RasterPipelineBuilderPushPopSrcDst, r)
	DEF_TEST (RasterPipelineBuilderInvokeChild, r)
	DEF_TEST (RasterPipelineBuilderPushPopTempImmediates, r)
	DEF_TEST (RasterPipelineBuilderPushPopIndirect, r)
	DEF_TEST (RasterPipelineBuilderCopySlotsMasked, r)
	DEF_TEST (RasterPipelineBuilderCopySlotsUnmasked, r)
	DEF_TEST (RasterPipelineBuilderPushPopSlots, r)
	DEF_TEST (RasterPipelineBuilderDuplicateSelectAndSwizzleSlots, r)
	DEF_TEST (RasterPipelineBuilderTransposeMatrix, r)
	DEF_TEST (RasterPipelineBuilderDiagonalMatrix, r)
	DEF_TEST (RasterPipelineBuilderMatrixResize, r)
	DEF_TEST (RasterPipelineBuilderBranches, r)
	DEF_TEST (RasterPipelineBuilderBinaryFloatOps, r)
	DEF_TEST (RasterPipelineBuilderBinaryIntOps, r)
	DEF_TEST (RasterPipelineBuilderBinaryUIntOps, r)
	DEF_TEST (RasterPipelineBuilderUnaryOps, r)
	DEF_TEST (RasterPipelineBuilderUniforms, r)
	DEF_TEST (RasterPipelineBuilderPushZeros, r)
	DEF_TEST (RasterPipelineBuilderTernaryFloatOps, r)
	DEF_TEST (RasterPipelineBuilderAutomaticStackRewinding, r)
	DEF_TEST (RasterPipelineBuilderTraceOps, r)

Function Documentation

as_string_view()

static std::string_view as_string_view ( const sk_sp< SkData > &  dump )

static

Definition at line 22 of file RasterPipelineBuilderTest.cpp.

                                                                {
    return std::string_view(static_cast<const char*>(dump->data()), dump->size());
}

check()

static void check ( skiatest::Reporter *  r, SkSL::RP::Program &  program, std::string_view  expected  )

static

Definition at line 26 of file RasterPipelineBuilderTest.cpp.

                                                                                        {
    // Verify that the program matches expectations.
    sk_sp<SkData> dump = get_program_dump(program);
    REPORTER_ASSERT(r, as_string_view(dump) == expected,
                    "Output did not match expectation:\n%.*s",
                    (int)dump->size(), static_cast<const char*>(dump->data()));
}

DEF_TEST() [1/24]

DEF_TEST	(	RasterPipelineBuilder	,
		r
	)

Definition at line 58 of file RasterPipelineBuilderTest.cpp.

                                   {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.store_src_rg(two_slots_at(0));
    builder.store_src(four_slots_at(2));
    builder.store_dst(four_slots_at(4));
    builder.store_device_xy01(four_slots_at(6));
    builder.init_lane_masks();
    builder.enableExecutionMaskWrites();
    builder.mask_off_return_mask();
    builder.mask_off_loop_mask();
    builder.reenable_loop_mask(one_slot_at(4));
    builder.disableExecutionMaskWrites();
    builder.load_src(four_slots_at(1));
    builder.load_dst(four_slots_at(3));
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/10,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(store_src_rg                   v0..1 = src.rg
store_src                      v2..5 = src.rgba

DEF_TEST() [2/24]

DEF_TEST	(	RasterPipelineBuilderAutomaticStackRewinding	,
		r
	)

Definition at line 576 of file RasterPipelineBuilderTest.cpp.

DEF_TEST() [3/24]

DEF_TEST	(	RasterPipelineBuilderBinaryFloatOps	,
		r
	)

Definition at line 428 of file RasterPipelineBuilderTest.cpp.

                                           {
#if SK_HAS_MUSTTAIL
    // We have guaranteed tail-calling, and don't need to rewind the stack.
    static constexpr char kExpectationWithKnownExecutionMask[] =
R"(jump                           jump +9 (label 3 at #10)

DEF_TEST() [4/24]

DEF_TEST	(	RasterPipelineBuilderBinaryIntOps	,
		r
	)

Definition at line 452 of file RasterPipelineBuilderTest.cpp.

DEF_TEST() [5/24]

DEF_TEST	(	RasterPipelineBuilderBinaryUIntOps	,
		r
	)

Definition at line 479 of file RasterPipelineBuilderTest.cpp.

DEF_TEST() [6/24]

DEF_TEST	(	RasterPipelineBuilderBranches	,
		r
	)

Definition at line 344 of file RasterPipelineBuilderTest.cpp.

                                                  {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_constant_f(1.0f);          // push into 0
    builder.push_duplicates(15);            // duplicate into 1~15
    builder.transpose(2, 2);                // transpose a 2x2 matrix
    builder.transpose(3, 3);                // transpose a 3x3 matrix
    builder.transpose(4, 4);                // transpose a 4x4 matrix
    builder.transpose(2, 4);                // transpose a 2x4 matrix
    builder.transpose(4, 3);                // transpose a 4x3 matrix
    builder.discard_stack(16);              // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x3F800000 (1.0)
splat_4_constants              $4..7 = 0x3F800000 (1.0)
splat_4_constants              $8..11 = 0x3F800000 (1.0)
splat_4_constants              $12..15 = 0x3F800000 (1.0)
swizzle_3                      $13..15 = ($13..15).yxz
shuffle                        $8..15 = ($8..15)[2 5 0 3 6 1 4 7]
shuffle                        $1..15 = ($1..15)[3 7 11 0 4 8 12 1 5 9 13 2 6 10 14]
shuffle                        $9..15 = ($9..15)[3 0 4 1 5 2 6]
shuffle                        $5..15 = ($5..15)[2 5 8 0 3 6 9 1 4 7 10]
)");
}
 
DEF_TEST(RasterPipelineBuilderDiagonalMatrix, r) {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_constant_f(0.0f);          // push into 0
    builder.push_constant_f(1.0f);          // push into 1
    builder.diagonal_matrix(2, 2);          // generate a 2x2 diagonal matrix
    builder.discard_stack(4);               // balance stack
    builder.push_constant_f(0.0f);          // push into 0
    builder.push_constant_f(2.0f);          // push into 1
    builder.diagonal_matrix(4, 4);          // generate a 4x4 diagonal matrix
    builder.discard_stack(16);              // balance stack
    builder.push_constant_f(0.0f);          // push into 0
    builder.push_constant_f(3.0f);          // push into 1
    builder.diagonal_matrix(2, 3);          // generate a 2x3 diagonal matrix
    builder.discard_stack(6);               // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(copy_constant                  $0 = 0
copy_constant                  $1 = 0x3F800000 (1.0)
swizzle_4                      $0..3 = ($0..3).yxxy
copy_constant                  $0 = 0
copy_constant                  $1 = 0x40000000 (2.0)
shuffle                        $0..15 = ($0..15)[1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1]
copy_constant                  $0 = 0
copy_constant                  $1 = 0x40400000 (3.0)
shuffle                        $0..5 = ($0..5)[1 0 0 0 1 0]
)");
}
 
DEF_TEST(RasterPipelineBuilderMatrixResize, r) {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_constant_f(1.0f);          // synthesize a 2x2 matrix
    builder.push_constant_f(2.0f);
    builder.push_constant_f(3.0f);
    builder.push_constant_f(4.0f);
    builder.matrix_resize(2, 2, 4, 4);      // resize 2x2 matrix into 4x4
    builder.matrix_resize(4, 4, 2, 2);      // resize 4x4 matrix back into 2x2
    builder.matrix_resize(2, 2, 2, 4);      // resize 2x2 matrix into 2x4
    builder.matrix_resize(2, 4, 4, 2);      // resize 2x4 matrix into 4x2
    builder.matrix_resize(4, 2, 3, 3);      // resize 4x2 matrix into 3x3
    builder.discard_stack(9);               // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);

DEF_TEST() [7/24]

DEF_TEST	(	RasterPipelineBuilderCaseOp	,
		r
	)

Definition at line 114 of file RasterPipelineBuilderTest.cpp.

DEF_TEST() [8/24]

DEF_TEST	(	RasterPipelineBuilderCopySlotsMasked	,
		r
	)

Definition at line 217 of file RasterPipelineBuilderTest.cpp.

DEF_TEST() [9/24]

DEF_TEST	(	RasterPipelineBuilderCopySlotsUnmasked	,
		r
	)

Definition at line 229 of file RasterPipelineBuilderTest.cpp.

                                                  {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.set_current_stack(1);
    builder.push_constant_i(3);
    builder.set_current_stack(0);
    builder.push_slots_indirect(two_slots_at(0), /*dynamicStack=*/1, ten_slots_at(0));
    builder.push_slots_indirect(four_slots_at(10), /*dynamicStack=*/1, ten_slots_at(10));
    builder.push_uniform_indirect(one_slot_at(0), /*dynamicStack=*/1, five_slots_at(0));
    builder.push_uniform_indirect(three_slots_at(5), /*dynamicStack=*/1, five_slots_at(5));

DEF_TEST() [10/24]

DEF_TEST	(	RasterPipelineBuilderDiagonalMatrix	,
		r
	)

Definition at line 302 of file RasterPipelineBuilderTest.cpp.

                                                                 {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_constant_f(1.0f);          // push into 0

DEF_TEST() [11/24]

DEF_TEST	(	RasterPipelineBuilderDuplicateSelectAndSwizzleSlots	,
		r
	)

Definition at line 260 of file RasterPipelineBuilderTest.cpp.

                                                  {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.copy_slots_masked(two_slots_at(0),  two_slots_at(2));
    builder.copy_slots_masked(four_slots_at(1), four_slots_at(5));
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/9,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(copy_2_slots_masked            v0..1 = Mask(v2..3)
copy_4_slots_masked            v1..4 = Mask(v5..8)
)");
}
 
DEF_TEST(RasterPipelineBuilderCopySlotsUnmasked, r) {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.copy_slots_unmasked(three_slots_at(0), three_slots_at(2));
    builder.copy_slots_unmasked(five_slots_at(1),  five_slots_at(5));

DEF_TEST() [12/24]

DEF_TEST	(	RasterPipelineBuilderInvokeChild	,
		r
	)

Definition at line 150 of file RasterPipelineBuilderTest.cpp.

                                                     { LoopMask = true; $1 = false; }
case_op                        if ($0 == 0x0000007C) { LoopMask = true; $1 = false; }
)");
}
 
DEF_TEST(RasterPipelineBuilderPushPopSrcDst, r) {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
 
    builder.push_src_rgba();
    builder.push_dst_rgba();

DEF_TEST() [13/24]

DEF_TEST	(	RasterPipelineBuilderMatrixResize	,
		r
	)

Definition at line 324 of file RasterPipelineBuilderTest.cpp.

                                                          {3, 2, 1, 0}, 4);
    builder.swizzle_copy_stack_to_slots(four_slots_at(0), {0, 1, 3}, 3);
    builder.swizzle(4, {3, 2, 1, 0});       // reverse the order of 0~3 (value.wzyx)
    builder.swizzle(4, {1, 2});             // eliminate elements 0 and 3 (value.yz)
    builder.swizzle(2, {0});                // eliminate element 1 (value.x)
    builder.discard_stack(1);               // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/6,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x3F800000 (1.0)
splat_4_constants              $4..7 = 0x3F800000 (1.0)
splat_4_constants              $8..11 = 0x3F800000 (1.0)

DEF_TEST() [14/24]

DEF_TEST	(	RasterPipelineBuilderPushPopIndirect	,
		r
	)

Definition at line 192 of file RasterPipelineBuilderTest.cpp.

                                                        {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.set_current_stack(1);
    builder.push_constant_i(999);                                         // push into 2
    builder.set_current_stack(0);
    builder.push_constant_f(13.5f);                                       // push into 0
    builder.push_clone_from_stack(one_slot_at(0), /*otherStackID=*/1, /*offsetFromStackTop=*/1);
                                                                          // push into 1 from 2
    builder.discard_stack(1);                                             // discard 2
    builder.push_constant_u(357);                                         // push into 2
    builder.set_current_stack(1);
    builder.push_clone_from_stack(one_slot_at(0), /*otherStackID=*/0, /*offsetFromStackTop=*/1);
                                                                          // push into 3 from 0
    builder.discard_stack(2);                                             // discard 2 and 3
    builder.set_current_stack(0);

DEF_TEST() [15/24]

DEF_TEST	(	RasterPipelineBuilderPushPopMaskRegisters	,
		r
	)

Definition at line 80 of file RasterPipelineBuilderTest.cpp.

                                                       {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
 
    REPORTER_ASSERT(r, !builder.executionMaskWritesAreEnabled());
    builder.enableExecutionMaskWrites();
    REPORTER_ASSERT(r, builder.executionMaskWritesAreEnabled());
 
    builder.push_condition_mask();         // push into 0
    builder.push_loop_mask();              // push into 1
    builder.push_return_mask();            // push into 2
    builder.merge_condition_mask();        // set the condition-mask to 1 & 2
    builder.merge_inv_condition_mask();    // set the condition-mask to 1 & ~2
    builder.pop_condition_mask();          // pop from 2
    builder.merge_loop_mask();             // mask off the loop-mask against 1
    builder.push_condition_mask();         // push into 2
    builder.pop_condition_mask();          // pop from 2
    builder.pop_loop_mask();               // pop from 1
    builder.pop_return_mask();             // pop from 0
    builder.push_condition_mask();         // push into 0
    builder.pop_and_reenable_loop_mask();  // pop from 0
 

DEF_TEST() [16/24]

DEF_TEST	(	RasterPipelineBuilderPushPopSlots	,
		r
	)

Definition at line 241 of file RasterPipelineBuilderTest.cpp.

                                                                  {2, 1, 0},
                                                 /*offsetFromStackTop=*/3);
    builder.copy_stack_to_slots_indirect(three_slots_at(4), /*dynamicStackID=*/1, ten_slots_at(0));
    builder.pop_slots_indirect(five_slots_at(0), /*dynamicStackID=*/1, ten_slots_at(0));
    builder.pop_slots_indirect(five_slots_at(10), /*dynamicStackID=*/1, ten_slots_at(10));
    builder.set_current_stack(1);
    builder.discard_stack(1);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/20,
                                                                /*numUniformSlots=*/10,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(copy_constant                  $10 = 0x00000003 (4.203895e-45)
copy_from_indirect_unmasked    $0..1 = Indirect(v0..1 + $10)
copy_from_indirect_unmasked    $2..5 = Indirect(v10..13 + $10)
copy_from_indirect_uniform_unm $6 = Indirect(u0 + $10)
copy_from_indirect_uniform_unm $7..9 = Indirect(u5..7 + $10)
swizzle_copy_to_indirect_maske Indirect(v6..8 + $10).zyx = Mask($7..9)
copy_to_indirect_masked        Indirect(v4..6 + $10) = Mask($7..9)

DEF_TEST() [17/24]

DEF_TEST	(	RasterPipelineBuilderPushPopSrcDst	,
		r
	)

Definition at line 131 of file RasterPipelineBuilderTest.cpp.

                                         {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
 
    builder.push_constant_i(123);  // push a test value
    builder.push_constant_i(~0);   // push an all-on default mask
    builder.case_op(123);          // do `case 123:`
    builder.case_op(124);          // do `case 124:`
    builder.discard_stack(2);
 
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0,

DEF_TEST() [18/24]

DEF_TEST	(	RasterPipelineBuilderPushPopTempImmediates	,
		r
	)

Definition at line 165 of file RasterPipelineBuilderTest.cpp.

                                              {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
 
    builder.invoke_shader(1);
    builder.invoke_color_filter(2);
    builder.invoke_blender(3);
 
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,

DEF_TEST() [19/24]

DEF_TEST	(	RasterPipelineBuilderPushZeros	,
		r
	)

Definition at line 542 of file RasterPipelineBuilderTest.cpp.

                                       {
            builder.disableExecutionMaskWrites();
        }
 
        std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/3,
                                                                    /*numUniformSlots=*/0,
                                                                    /*numImmutableSlots=*/0);
 
        check(r, *program, enableExecutionMaskWrites ? kExpectationWithExecutionMaskWrites

DEF_TEST() [20/24]

DEF_TEST	(	RasterPipelineBuilderTernaryFloatOps	,
		r
	)

Definition at line 561 of file RasterPipelineBuilderTest.cpp.

                                                 {
    using BuilderOp = SkSL::RP::BuilderOp;
 
    SkSL::RP::Builder builder;
    builder.push_constant_f(10.0f);
    builder.push_duplicates(30);
    builder.binary_op(BuilderOp::add_n_floats, 1);
    builder.binary_op(BuilderOp::sub_n_floats, 2);
    builder.binary_op(BuilderOp::mul_n_floats, 3);
    builder.binary_op(BuilderOp::div_n_floats, 4);
    builder.binary_op(BuilderOp::max_n_floats, 3);

DEF_TEST() [21/24]

DEF_TEST	(	RasterPipelineBuilderTraceOps	,
		r
	)

Definition at line 599 of file RasterPipelineBuilderTest.cpp.

                                               {
    using BuilderOp = SkSL::RP::BuilderOp;
 
    SkSL::RP::Builder builder;
    builder.push_constant_i(123);
    builder.push_duplicates(40);
    builder.binary_op(BuilderOp::bitwise_and_n_ints, 1);
    builder.binary_op(BuilderOp::bitwise_xor_n_ints, 2);
    builder.binary_op(BuilderOp::bitwise_or_n_ints, 3);
    builder.binary_op(BuilderOp::add_n_ints, 2);
    builder.binary_op(BuilderOp::sub_n_ints, 3);
    builder.binary_op(BuilderOp::mul_n_ints, 4);
    builder.binary_op(BuilderOp::div_n_ints, 5);
    builder.binary_op(BuilderOp::max_n_ints, 4);
    builder.binary_op(BuilderOp::min_n_ints, 3);
    builder.binary_op(BuilderOp::cmplt_n_ints, 1);
    builder.binary_op(BuilderOp::cmple_n_ints, 2);
    builder.binary_op(BuilderOp::cmpeq_n_ints, 3);
    builder.binary_op(BuilderOp::cmpne_n_ints, 4);
    builder.discard_stack(4);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0,
                                                                /*numImmutableSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x0000007B (1.723597e-43)
splat_4_constants              $4..7 = 0x0000007B (1.723597e-43)
splat_4_constants              $8..11 = 0x0000007B (1.723597e-43)
splat_4_constants              $12..15 = 0x0000007B (1.723597e-43)
splat_4_constants              $16..19 = 0x0000007B (1.723597e-43)
splat_4_constants              $20..23 = 0x0000007B (1.723597e-43)
splat_4_constants              $24..27 = 0x0000007B (1.723597e-43)
splat_4_constants              $28..31 = 0x0000007B (1.723597e-43)
splat_4_constants              $32..35 = 0x0000007B (1.723597e-43)
splat_4_constants              $36..39 = 0x0000007B (1.723597e-43)
bitwise_and_imm_int            $39 &= 0x0000007B
bitwise_xor_2_ints             $36..37 ^= $38..39
bitwise_or_3_ints              $32..34 |= $35..37
add_2_ints                     $31..32 += $33..34
sub_3_ints                     $27..29 -= $30..32
mul_4_ints                     $22..25 *= $26..29
div_n_ints                     $16..20 /= $21..25
max_4_ints                     $13..16 = max($13..16, $17..20)

DEF_TEST() [22/24]

DEF_TEST	(	RasterPipelineBuilderTransposeMatrix	,
		r
	)

Definition at line 284 of file RasterPipelineBuilderTest.cpp.

                                               {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_slots(four_slots_at(10));           // push from 10~13 into $0~$3
    builder.copy_stack_to_slots(one_slot_at(5), 3);  // copy from $1 into 5
    builder.pop_slots_unmasked(two_slots_at(20));    // pop from $2~$3 into 20~21 (unmasked)
    builder.enableExecutionMaskWrites();
    builder.copy_stack_to_slots_unmasked(one_slot_at(4), 2);  // copy from $0 into 4

DEF_TEST() [23/24]

DEF_TEST	(	RasterPipelineBuilderUnaryOps	,
		r
	)

Definition at line 498 of file RasterPipelineBuilderTest.cpp.

                                        : {false, true}) {

DEF_TEST() [24/24]

DEF_TEST	(	RasterPipelineBuilderUniforms	,
		r
	)

Definition at line 523 of file RasterPipelineBuilderTest.cpp.

                                       {
            builder.enableExecutionMaskWrites();
        }
 
        builder.jump(label4);
        builder.label(label1);
        builder.zero_slots_unmasked(one_slot_at(0));
        builder.label(label2);
        builder.zero_slots_unmasked(one_slot_at(1));
        builder.branch_if_no_lanes_active(label2);
        builder.branch_if_no_lanes_active(label3);
        builder.branch_if_all_lanes_active(label1);

five_slots_at()

static SkSL::RP::SlotRange five_slots_at ( SkSL::RP::Slot  index )

static

Definition at line 50 of file RasterPipelineBuilderTest.cpp.

                                                       {
    return SkSL::RP::SlotRange{index, 5};
}

four_slots_at()

static SkSL::RP::SlotRange four_slots_at ( SkSL::RP::Slot  index )

static

Definition at line 46 of file RasterPipelineBuilderTest.cpp.

                                                       {
    return SkSL::RP::SlotRange{index, 4};
}

get_program_dump()

static sk_sp< SkData > get_program_dump ( SkSL::RP::Program &  program )

static

Definition at line 16 of file RasterPipelineBuilderTest.cpp.

                                                              {
    SkDynamicMemoryWStream stream;
    program.dump(&stream);
    return stream.detachAsData();
}

one_slot_at()

static SkSL::RP::SlotRange one_slot_at ( SkSL::RP::Slot  index )

static

Definition at line 34 of file RasterPipelineBuilderTest.cpp.

                                                     {
    return SkSL::RP::SlotRange{index, 1};
}

ten_slots_at()

static SkSL::RP::SlotRange ten_slots_at ( SkSL::RP::Slot  index )

static

Definition at line 54 of file RasterPipelineBuilderTest.cpp.

                                                      {
    return SkSL::RP::SlotRange{index, 10};
}

three_slots_at()

static SkSL::RP::SlotRange three_slots_at ( SkSL::RP::Slot  index )

static

Definition at line 42 of file RasterPipelineBuilderTest.cpp.

                                                        {
    return SkSL::RP::SlotRange{index, 3};
}

two_slots_at()

static SkSL::RP::SlotRange two_slots_at ( SkSL::RP::Slot  index )

static

Definition at line 38 of file RasterPipelineBuilderTest.cpp.

                                                      {
    return SkSL::RP::SlotRange{index, 2};
}