/*
 * Copyright 2022 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

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

#ifdef SK_ENABLE_SKSL_IN_RASTER_PIPELINE

static sk_sp<SkData> get_program_dump(SkSL::RP::Program& program) {
    SkDynamicMemoryWStream stream;
    program.dump(&stream);
    return stream.detachAsData();
}

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

static void check(skiatest::Reporter* r, SkSL::RP::Program& program, std::string_view expected) {
    // 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()));
}

static SkSL::RP::SlotRange one_slot_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 1};
}

static SkSL::RP::SlotRange two_slots_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 2};
}

static SkSL::RP::SlotRange three_slots_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 3};
}

static SkSL::RP::SlotRange four_slots_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 4};
}

static SkSL::RP::SlotRange five_slots_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 5};
}

static SkSL::RP::SlotRange ten_slots_at(SkSL::RP::Slot index) {
    return SkSL::RP::SlotRange{index, 10};
}

DEF_TEST(RasterPipelineBuilder, r) {
    // 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);
    check(r, *program,
R"(store_src_rg                   v0..1 = src.rg
store_src                      v2..5 = src.rgba
store_dst                      v4..7 = dst.rgba
store_device_xy01              v6..9 = DeviceCoords.xy01
init_lane_masks                CondMask = LoopMask = RetMask = true
mask_off_return_mask           RetMask &= ~(CondMask & LoopMask & RetMask)
mask_off_loop_mask             LoopMask &= ~(CondMask & LoopMask & RetMask)
reenable_loop_mask             LoopMask |= v4
load_src                       src.rgba = v1..4
load_dst                       dst.rgba = v3..6
)");
}

DEF_TEST(RasterPipelineBuilderPushPopMaskRegisters, r) {
    // 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

    REPORTER_ASSERT(r, builder.executionMaskWritesAreEnabled());
    builder.disableExecutionMaskWrites();
    REPORTER_ASSERT(r, !builder.executionMaskWritesAreEnabled());

    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(store_condition_mask           $0 = CondMask
store_loop_mask                $1 = LoopMask
store_return_mask              $2 = RetMask
merge_condition_mask           CondMask = $1 & $2
merge_inv_condition_mask       CondMask = $1 & ~$2
load_condition_mask            CondMask = $2
merge_loop_mask                LoopMask &= $1
store_condition_mask           $2 = CondMask
load_condition_mask            CondMask = $2
load_loop_mask                 LoopMask = $1
load_return_mask               RetMask = $0
store_condition_mask           $0 = CondMask
reenable_loop_mask             LoopMask |= $0
)");
}


DEF_TEST(RasterPipelineBuilderCaseOp, r) {
    // 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);
    check(r, *program,
R"(copy_constant                  $0 = 0x0000007B (1.723597e-43)
copy_constant                  $1 = 0xFFFFFFFF
case_op                        if ($0 == 0x0000007B) { 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();
    builder.pop_src_rgba();
    builder.exchange_src();
    builder.exchange_src();
    builder.exchange_src();
    builder.pop_dst_rgba();

    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(store_src                      $0..3 = src.rgba
store_dst                      $4..7 = dst.rgba
load_src                       src.rgba = $4..7
exchange_src                   swap(src.rgba, $0..3)
load_dst                       dst.rgba = $0..3
)");
}

DEF_TEST(RasterPipelineBuilderInvokeChild, r) {
    // 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,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(invoke_shader                  invoke_shader 0x00000001
invoke_color_filter            invoke_color_filter 0x00000002
invoke_blender                 invoke_blender 0x00000003
)");
}

DEF_TEST(RasterPipelineBuilderPushPopTempImmediates, r) {
    // 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);
    builder.push_constant_f(1.2f);                                        // push into 2
    builder.pad_stack(3);                                                 // pad slots 3,4,5
    builder.push_constant_f(3.4f);                                        // push into 6
    builder.discard_stack(7);                                             // discard 0 through 6
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/1,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(copy_constant                  $2 = 0x000003E7 (1.399897e-42)
copy_constant                  $0 = 0x41580000 (13.5)
copy_constant                  $1 = 0x00000165 (5.002636e-43)
)");
}

DEF_TEST(RasterPipelineBuilderPushPopIndirect, r) {
    // 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));
    builder.swizzle_copy_stack_to_slots_indirect(three_slots_at(6), /*dynamicStackID=*/1,
                                                 ten_slots_at(0), {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);
    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)
copy_to_indirect_masked        Indirect(v0..4 + $10) = Mask($5..9)
copy_to_indirect_masked        Indirect(v10..14 + $10) = Mask($0..4)
)");
}

DEF_TEST(RasterPipelineBuilderCopySlotsMasked, r) {
    // 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);
    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));
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/10,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(copy_3_slots_unmasked          v0..2 = v2..4
copy_4_slots_unmasked          v1..4 = v5..8
copy_slot_unmasked             v5 = v9
)");
}

DEF_TEST(RasterPipelineBuilderPushPopSlots, r) {
    // 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
    builder.push_slots(three_slots_at(30));          // push from 30~32 into $2~$4
    builder.pop_slots(five_slots_at(0));             // pop from $0~$4 into 0~4 (masked)
    builder.disableExecutionMaskWrites();

    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/50,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(copy_4_slots_unmasked          $0..3 = v10..13
copy_slot_unmasked             v5 = $1
copy_2_slots_unmasked          v20..21 = $2..3
copy_slot_unmasked             v4 = $0
copy_3_slots_unmasked          $2..4 = v30..32
copy_4_slots_masked            v0..3 = Mask($0..3)
copy_slot_masked               v4 = Mask($4)
)");
}

DEF_TEST(RasterPipelineBuilderDuplicateSelectAndSwizzleSlots, r) {
    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_constant_f(1.0f);          // push into 0
    builder.push_duplicates(1);             // duplicate into 1
    builder.push_duplicates(2);             // duplicate into 2~3
    builder.push_duplicates(3);             // duplicate into 4~6
    builder.push_duplicates(5);             // duplicate into 7~11
    builder.select(4);                      // select from 4~7 and 8~11 into 4~7
    builder.select(3);                      // select from 2~4 and 5~7 into 2~4
    builder.select(1);                      // select from 3 and 4 into 3
    builder.swizzle_copy_stack_to_slots(four_slots_at(1), {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);
    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)
copy_4_slots_masked            $4..7 = Mask($8..11)
copy_3_slots_masked            $2..4 = Mask($5..7)
copy_slot_masked               $3 = Mask($4)
swizzle_copy_4_slots_masked    (v1..4).wzyx = Mask($0..3)
swizzle_copy_3_slots_masked    (v0..3).xyw = Mask($1..3)
swizzle_4                      $0..3 = ($0..3).wzyx
swizzle_2                      $0..1 = ($0..2).yz
)");
}

DEF_TEST(RasterPipelineBuilderTransposeMatrix, r) {
    // 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);
    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);
    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);
    check(r, *program,
R"(copy_constant                  $0 = 0x3F800000 (1.0)
copy_constant                  $1 = 0x40000000 (2.0)
copy_constant                  $2 = 0x40400000 (3.0)
copy_constant                  $3 = 0x40800000 (4.0)
copy_constant                  $4 = 0
copy_constant                  $5 = 0x3F800000 (1.0)
shuffle                        $2..15 = ($2..15)[2 2 0 1 2 2 2 2 3 2 2 2 2 3]
shuffle                        $2..3 = ($2..3)[2 3]
copy_constant                  $4 = 0
shuffle                        $2..7 = ($2..7)[2 2 0 1 2 2]
copy_constant                  $8 = 0
shuffle                        $2..7 = ($2..7)[2 3 6 6 6 6]
copy_constant                  $8 = 0
copy_constant                  $9 = 0x3F800000 (1.0)
shuffle                        $2..8 = ($2..8)[6 0 1 6 2 3 7]
)");
}

DEF_TEST(RasterPipelineBuilderBranches, r) {
#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)
label                          label 0
copy_constant                  v0 = 0
label                          label 0x00000001
copy_constant                  v1 = 0
jump                           jump -4 (label 0 at #2)
label                          label 0x00000002
copy_constant                  v2 = 0
jump                           jump -7 (label 0 at #2)
label                          label 0x00000003
branch_if_no_active_lanes_eq   branch -4 (label 2 at #7) if no lanes of v2 == 0
branch_if_no_active_lanes_eq   branch -10 (label 0 at #2) if no lanes of v2 == 0x00000001 (1.401298e-45)
)";
    static constexpr char kExpectationWithExecutionMaskWrites[] =
R"(jump                           jump +10 (label 3 at #11)
label                          label 0
copy_constant                  v0 = 0
label                          label 0x00000001
copy_constant                  v1 = 0
branch_if_no_lanes_active      branch_if_no_lanes_active -2 (label 1 at #4)
branch_if_all_lanes_active     branch_if_all_lanes_active -5 (label 0 at #2)
label                          label 0x00000002
copy_constant                  v2 = 0
branch_if_any_lanes_active     branch_if_any_lanes_active -8 (label 0 at #2)
label                          label 0x00000003
branch_if_no_active_lanes_eq   branch -4 (label 2 at #8) if no lanes of v2 == 0
branch_if_no_active_lanes_eq   branch -11 (label 0 at #2) if no lanes of v2 == 0x00000001 (1.401298e-45)
)";
#else
    // We don't have guaranteed tail-calling, so we rewind the stack immediately before any backward
    // branches.
    static constexpr char kExpectationWithKnownExecutionMask[] =
R"(jump                           jump +11 (label 3 at #12)
label                          label 0
copy_constant                  v0 = 0
label                          label 0x00000001
copy_constant                  v1 = 0
stack_rewind
jump                           jump -5 (label 0 at #2)
label                          label 0x00000002
copy_constant                  v2 = 0
stack_rewind
jump                           jump -9 (label 0 at #2)
label                          label 0x00000003
stack_rewind
branch_if_no_active_lanes_eq   branch -6 (label 2 at #8) if no lanes of v2 == 0
stack_rewind
branch_if_no_active_lanes_eq   branch -14 (label 0 at #2) if no lanes of v2 == 0x00000001 (1.401298e-45)
)";
    static constexpr char kExpectationWithExecutionMaskWrites[] =
R"(jump                           jump +13 (label 3 at #14)
label                          label 0
copy_constant                  v0 = 0
label                          label 0x00000001
copy_constant                  v1 = 0
stack_rewind
branch_if_no_lanes_active      branch_if_no_lanes_active -3 (label 1 at #4)
stack_rewind
branch_if_all_lanes_active     branch_if_all_lanes_active -7 (label 0 at #2)
label                          label 0x00000002
copy_constant                  v2 = 0
stack_rewind
branch_if_any_lanes_active     branch_if_any_lanes_active -11 (label 0 at #2)
label                          label 0x00000003
stack_rewind
branch_if_no_active_lanes_eq   branch -6 (label 2 at #10) if no lanes of v2 == 0
stack_rewind
branch_if_no_active_lanes_eq   branch -16 (label 0 at #2) if no lanes of v2 == 0x00000001 (1.401298e-45)
)";
#endif

    for (bool enableExecutionMaskWrites : {false, true}) {
        // Create a very simple nonsense program.
        SkSL::RP::Builder builder;
        int label1 = builder.nextLabelID();
        int label2 = builder.nextLabelID();
        int label3 = builder.nextLabelID();
        int label4 = builder.nextLabelID();

        if (enableExecutionMaskWrites) {
            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);
        builder.label(label3);
        builder.zero_slots_unmasked(one_slot_at(2));
        builder.branch_if_any_lanes_active(label1);
        builder.branch_if_any_lanes_active(label1);
        builder.label(label4);
        builder.branch_if_no_active_lanes_on_stack_top_equal(0, label3);
        builder.branch_if_no_active_lanes_on_stack_top_equal(0, label2);
        builder.branch_if_no_active_lanes_on_stack_top_equal(1, label1);
        builder.branch_if_no_active_lanes_on_stack_top_equal(1, label4);

        if (enableExecutionMaskWrites) {
            builder.disableExecutionMaskWrites();
        }

        std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/3,
                                                                    /*numUniformSlots=*/0);

        check(r, *program, enableExecutionMaskWrites ? kExpectationWithExecutionMaskWrites
                                                     : kExpectationWithKnownExecutionMask);
    }
}

DEF_TEST(RasterPipelineBuilderBinaryFloatOps, r) {
    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);
    builder.binary_op(BuilderOp::min_n_floats, 2);
    builder.binary_op(BuilderOp::cmplt_n_floats, 5);
    builder.binary_op(BuilderOp::cmple_n_floats, 4);
    builder.binary_op(BuilderOp::cmpeq_n_floats, 3);
    builder.binary_op(BuilderOp::cmpne_n_floats, 2);
    builder.discard_stack(2);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x41200000 (10.0)
splat_4_constants              $4..7 = 0x41200000 (10.0)
splat_4_constants              $8..11 = 0x41200000 (10.0)
splat_4_constants              $12..15 = 0x41200000 (10.0)
splat_4_constants              $16..19 = 0x41200000 (10.0)
splat_4_constants              $20..23 = 0x41200000 (10.0)
splat_4_constants              $24..27 = 0x41200000 (10.0)
splat_2_constants              $28..29 = 0x41200000 (10.0)
add_imm_float                  $29 += 0x41200000 (10.0)
sub_2_floats                   $26..27 -= $28..29
mul_3_floats                   $22..24 *= $25..27
div_4_floats                   $17..20 /= $21..24
max_3_floats                   $15..17 = max($15..17, $18..20)
min_2_floats                   $14..15 = min($14..15, $16..17)
cmplt_n_floats                 $6..10 = lessThan($6..10, $11..15)
cmple_4_floats                 $3..6 = lessThanEqual($3..6, $7..10)
cmpeq_3_floats                 $1..3 = equal($1..3, $4..6)
cmpne_2_floats                 $0..1 = notEqual($0..1, $2..3)
)");
}

DEF_TEST(RasterPipelineBuilderBinaryIntOps, r) {
    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);
    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)
min_3_ints                     $11..13 = min($11..13, $14..16)
cmplt_int                      $12 = lessThan($12, $13)
cmple_2_ints                   $9..10 = lessThanEqual($9..10, $11..12)
cmpeq_3_ints                   $5..7 = equal($5..7, $8..10)
cmpne_4_ints                   $0..3 = notEqual($0..3, $4..7)
)");
}

DEF_TEST(RasterPipelineBuilderBinaryUIntOps, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    SkSL::RP::Builder builder;
    builder.push_constant_u(456);
    builder.push_duplicates(21);
    builder.binary_op(BuilderOp::div_n_uints, 6);
    builder.binary_op(BuilderOp::cmplt_n_uints, 5);
    builder.binary_op(BuilderOp::cmple_n_uints, 4);
    builder.binary_op(BuilderOp::max_n_uints, 3);
    builder.binary_op(BuilderOp::min_n_uints, 2);
    builder.discard_stack(2);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x000001C8 (6.389921e-43)
splat_4_constants              $4..7 = 0x000001C8 (6.389921e-43)
splat_4_constants              $8..11 = 0x000001C8 (6.389921e-43)
splat_4_constants              $12..15 = 0x000001C8 (6.389921e-43)
splat_4_constants              $16..19 = 0x000001C8 (6.389921e-43)
splat_2_constants              $20..21 = 0x000001C8 (6.389921e-43)
div_n_uints                    $10..15 /= $16..21
cmplt_n_uints                  $6..10 = lessThan($6..10, $11..15)
cmple_4_uints                  $3..6 = lessThanEqual($3..6, $7..10)
max_3_uints                    $1..3 = max($1..3, $4..6)
min_2_uints                    $0..1 = min($0..1, $2..3)
)");
}

DEF_TEST(RasterPipelineBuilderUnaryOps, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    SkSL::RP::Builder builder;
    builder.push_constant_i(456);
    builder.push_duplicates(4);
    builder.unary_op(BuilderOp::cast_to_float_from_int, 1);
    builder.unary_op(BuilderOp::cast_to_float_from_uint, 2);
    builder.unary_op(BuilderOp::cast_to_int_from_float, 3);
    builder.unary_op(BuilderOp::cast_to_uint_from_float, 4);
    builder.unary_op(BuilderOp::cos_float, 4);
    builder.unary_op(BuilderOp::tan_float, 3);
    builder.unary_op(BuilderOp::sin_float, 2);
    builder.unary_op(BuilderOp::sqrt_float, 1);
    builder.unary_op(BuilderOp::abs_int, 2);
    builder.unary_op(BuilderOp::floor_float, 3);
    builder.unary_op(BuilderOp::ceil_float, 4);
    builder.discard_stack(5);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x000001C8 (6.389921e-43)
copy_constant                  $4 = 0x000001C8 (6.389921e-43)
cast_to_float_from_int         $4 = IntToFloat($4)
cast_to_float_from_2_uints     $3..4 = UintToFloat($3..4)
cast_to_int_from_3_floats      $2..4 = FloatToInt($2..4)
cast_to_uint_from_4_floats     $1..4 = FloatToUint($1..4)
cos_float                      $1 = cos($1)
cos_float                      $2 = cos($2)
cos_float                      $3 = cos($3)
cos_float                      $4 = cos($4)
tan_float                      $2 = tan($2)
tan_float                      $3 = tan($3)
tan_float                      $4 = tan($4)
sin_float                      $3 = sin($3)
sin_float                      $4 = sin($4)
sqrt_float                     $4 = sqrt($4)
abs_2_ints                     $3..4 = abs($3..4)
floor_3_floats                 $2..4 = floor($2..4)
ceil_4_floats                  $1..4 = ceil($1..4)
)");
}

DEF_TEST(RasterPipelineBuilderUniforms, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_uniform(one_slot_at(0));        // push into 0
    builder.push_uniform(two_slots_at(1));       // push into 1~2
    builder.push_uniform(three_slots_at(3));     // push into 3~5
    builder.push_uniform(four_slots_at(6));      // push into 6~9
    builder.push_uniform(five_slots_at(0));      // push into 10~14
    builder.unary_op(BuilderOp::abs_int, 1);     // perform work so the program isn't eliminated
    builder.discard_stack(15);                   // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/10);
    check(r, *program,
R"(copy_4_uniforms                $0..3 = u0..3
copy_4_uniforms                $4..7 = u4..7
copy_2_uniforms                $8..9 = u8..9
copy_4_uniforms                $10..13 = u0..3
copy_uniform                   $14 = u4
abs_int                        $14 = abs($14)
)");
}

DEF_TEST(RasterPipelineBuilderPushZeros, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    // Create a very simple nonsense program.
    SkSL::RP::Builder builder;
    builder.push_zeros(1);                    // push into 0
    builder.push_zeros(2);                    // push into 1~2
    builder.push_zeros(3);                    // push into 3~5
    builder.push_zeros(4);                    // push into 6~9
    builder.push_zeros(5);                    // push into 10~14
    builder.unary_op(BuilderOp::abs_int, 1);  // perform work so the program isn't eliminated
    builder.discard_stack(15);                // balance stack
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/10);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0
splat_4_constants              $4..7 = 0
splat_4_constants              $8..11 = 0
splat_3_constants              $12..14 = 0
abs_int                        $14 = abs($14)
)");
}

DEF_TEST(RasterPipelineBuilderTernaryFloatOps, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    SkSL::RP::Builder builder;
    builder.push_constant_f(0.75f);
    builder.push_duplicates(8);
    builder.ternary_op(BuilderOp::mix_n_floats, 3);
    builder.discard_stack(3);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    check(r, *program,
R"(splat_4_constants              $0..3 = 0x3F400000 (0.75)
splat_4_constants              $4..7 = 0x3F400000 (0.75)
copy_constant                  $8 = 0x3F400000 (0.75)
mix_3_floats                   $0..2 = mix($3..5, $6..8, $0..2)
)");
}

DEF_TEST(RasterPipelineBuilderAutomaticStackRewinding, r) {
    using BuilderOp = SkSL::RP::BuilderOp;

    SkSL::RP::Builder builder;
    builder.push_constant_i(1);
    builder.push_duplicates(2000);
    builder.unary_op(BuilderOp::abs_int, 1);  // perform work so the program isn't eliminated
    builder.discard_stack(2001);
    std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/0,
                                                                /*numUniformSlots=*/0);
    sk_sp<SkData> dump = get_program_dump(*program);

#if SK_HAS_MUSTTAIL
    // We have guaranteed tail-calling, so we never use `stack_rewind`.
    REPORTER_ASSERT(r, !skstd::contains(as_string_view(dump), "stack_rewind"));
#else
    // We can't guarantee tail-calling, so we should automatically insert `stack_rewind` stages into
    // long programs.
    REPORTER_ASSERT(r, skstd::contains(as_string_view(dump), "stack_rewind"));
#endif
}

DEF_TEST(RasterPipelineBuilderTraceOps, r) {
    for (bool provideDebugTrace : {false, true}) {
        SkSL::RP::Builder builder;
        // Create a trace mask stack on stack-ID 123.
        builder.set_current_stack(123);
        builder.push_constant_i(~0);
        // Emit trace ops.
        builder.trace_enter(123, 2);
        builder.trace_scope(123, +1);
        builder.trace_line(123, 456);
        builder.trace_var(123, two_slots_at(3));
        builder.trace_scope(123, -1);
        builder.trace_exit(123, 2);
        // Discard the trace mask.
        builder.discard_stack(1);

        if (!provideDebugTrace) {
            // Test the output when no DebugTrace info is provided.
            std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/20,
                                                                        /*numUniformSlots=*/0);
            check(r, *program,
R"(copy_constant                  $0 = 0xFFFFFFFF
trace_enter                    TraceEnter(???) when $0 is true
trace_scope                    TraceScope(+1) when $0 is true
trace_line                     TraceLine(456) when $0 is true
trace_var                      TraceVar(v3..4) when $0 is true
trace_scope                    TraceScope(-1) when $0 is true
trace_exit                     TraceExit(???) when $0 is true
)");
        } else {
            // Test the output when we supply a populated DebugTrace.
            SkSL::DebugTracePriv trace;
            trace.fFuncInfo = {{"FunctionA"}, {"FunctionB"}, {"FunctionC"}, {"FunctionD"}};

            SkSL::SlotDebugInfo slot;
            slot.name = "Var0";
            trace.fSlotInfo.push_back(slot);
            slot.name = "Var1";
            trace.fSlotInfo.push_back(slot);
            slot.name = "Var2";
            trace.fSlotInfo.push_back(slot);
            slot.name = "Var3";
            trace.fSlotInfo.push_back(slot);
            slot.name = "Var4";
            trace.fSlotInfo.push_back(slot);

            std::unique_ptr<SkSL::RP::Program> program = builder.finish(/*numValueSlots=*/20,
                                                                        /*numUniformSlots=*/0,
                                                                        &trace);
            check(r, *program,
R"(copy_constant                  $0 = 0xFFFFFFFF
trace_enter                    TraceEnter(FunctionC) when $0 is true
trace_scope                    TraceScope(+1) when $0 is true
trace_line                     TraceLine(456) when $0 is true
trace_var                      TraceVar(Var3, Var4) when $0 is true
trace_scope                    TraceScope(-1) when $0 is true
trace_exit                     TraceExit(FunctionC) when $0 is true
)");
        }
    }
}

#endif  // SK_ENABLE_SKSL_IN_RASTER_PIPELINE