vectorscan/src/rose/rose_program.h

/*
 * Copyright (c) 2015-2020, Intel Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  * Neither the name of Intel Corporation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/** \file
 * \brief Rose data structures to do with role programs.
 */

#ifndef ROSE_ROSE_PROGRAM_H
#define ROSE_ROSE_PROGRAM_H

#include "som/som_operation.h"
#include "rose_internal.h"
#include "ue2common.h"
#include "util/simd_types.h"

/** \brief Minimum alignment for each instruction in memory. */
#define ROSE_INSTR_MIN_ALIGN 8U

/** \brief Role program instruction opcodes. */
enum RoseInstructionCode {
    ROSE_INSTR_END,               //!< End of program.
    ROSE_INSTR_ANCHORED_DELAY,    //!< Delay until after anchored matcher.
    ROSE_INSTR_CHECK_LIT_EARLY,   //!< Skip matches before floating min offset.
    ROSE_INSTR_CHECK_GROUPS,      //!< Check that literal groups are on.
    ROSE_INSTR_CHECK_ONLY_EOD,    //!< Role matches only at EOD.
    ROSE_INSTR_CHECK_BOUNDS,      //!< Bounds on distance from offset 0.
    ROSE_INSTR_CHECK_NOT_HANDLED, //!< Test & set role in "handled".
    ROSE_INSTR_CHECK_SINGLE_LOOKAROUND, //!< Single lookaround check.
    ROSE_INSTR_CHECK_LOOKAROUND,  //!< Lookaround check.
    ROSE_INSTR_CHECK_MASK,        //!< 8-bytes mask check.
    ROSE_INSTR_CHECK_MASK_32,     //!< 32-bytes and/cmp/neg mask check.
    ROSE_INSTR_CHECK_BYTE,        //!< Single Byte check.
    ROSE_INSTR_CHECK_SHUFTI_16x8, //!< Check 16-byte data by 8-bucket shufti.
    ROSE_INSTR_CHECK_SHUFTI_32x8, //!< Check 32-byte data by 8-bucket shufti.
    ROSE_INSTR_CHECK_SHUFTI_16x16, //!< Check 16-byte data by 16-bucket shufti.
    ROSE_INSTR_CHECK_SHUFTI_32x16, //!< Check 32-byte data by 16-bucket shufti.
    ROSE_INSTR_CHECK_INFIX,       //!< Infix engine must be in accept state.
    ROSE_INSTR_CHECK_PREFIX,      //!< Prefix engine must be in accept state.
    ROSE_INSTR_PUSH_DELAYED,      //!< Push delayed literal matches.
    ROSE_INSTR_DUMMY_NOP,         //!< NOP. Should not exist in build programs.
    ROSE_INSTR_CATCH_UP,          //!< Catch up engines, anchored matches.
    ROSE_INSTR_CATCH_UP_MPV,      //!< Catch up the MPV.
    ROSE_INSTR_SOM_ADJUST,        //!< Set SOM from a distance to EOM.
    ROSE_INSTR_SOM_LEFTFIX,       //!< Acquire SOM from a leftfix engine.
    ROSE_INSTR_SOM_FROM_REPORT,   //!< Acquire SOM from a som_operation.
    ROSE_INSTR_SOM_ZERO,          //!< Set SOM to zero.
    ROSE_INSTR_TRIGGER_INFIX,     //!< Trigger an infix engine.
    ROSE_INSTR_TRIGGER_SUFFIX,    //!< Trigger a suffix engine.
    ROSE_INSTR_DEDUPE,            //!< Run deduplication for report.
    ROSE_INSTR_DEDUPE_SOM,        //!< Run deduplication for SOM report.
    ROSE_INSTR_REPORT_CHAIN,      //!< Fire a chained report (MPV).
    ROSE_INSTR_REPORT_SOM_INT,    //!< Manipulate SOM only.
    ROSE_INSTR_REPORT_SOM_AWARE,  //!< Manipulate SOM from SOM-aware source.

    /** \brief Fire a report. */
    ROSE_INSTR_REPORT,

    /** \brief Fire an exhaustible report. */
    ROSE_INSTR_REPORT_EXHAUST,

    /** \brief Fire a SOM report. */
    ROSE_INSTR_REPORT_SOM,

    /** \brief Fire an exhaustible SOM report. */
    ROSE_INSTR_REPORT_SOM_EXHAUST,

    /** \brief Super-instruction combining DEDUPE and REPORT. */
    ROSE_INSTR_DEDUPE_AND_REPORT,

    /**
     * \brief Fire a report and stop program execution. This is a
     * specialisation intended for short, frequently-executed programs.
     */
    ROSE_INSTR_FINAL_REPORT,

    ROSE_INSTR_CHECK_EXHAUSTED,   //!< Check if an ekey has already been set.
    ROSE_INSTR_CHECK_MIN_LENGTH,  //!< Check (EOM - SOM) against min length.
    ROSE_INSTR_SET_STATE,         //!< Switch a state index on.
    ROSE_INSTR_SET_GROUPS,        //!< Set some literal group bits.
    ROSE_INSTR_SQUASH_GROUPS,     //!< Conditionally turn off some groups.
    ROSE_INSTR_CHECK_STATE,       //!< Test a single bit in the state multibit.
    ROSE_INSTR_SPARSE_ITER_BEGIN, //!< Begin running a sparse iter over states.
    ROSE_INSTR_SPARSE_ITER_NEXT,  //!< Continue running sparse iter over states.
    ROSE_INSTR_SPARSE_ITER_ANY,   //!< Test for any bit in the sparse iterator.

    /** \brief Check outfixes and suffixes for EOD and fire reports if so. */
    ROSE_INSTR_ENGINES_EOD,

    /** \brief Catch up and check active suffixes for EOD and fire reports if
     * so. */
    ROSE_INSTR_SUFFIXES_EOD,

    /** \brief Run the EOD-anchored HWLM literal matcher. */
    ROSE_INSTR_MATCHER_EOD,

    /**
     * \brief Confirm a case-sensitive literal at the current offset. In
     * streaming mode, this makes use of the long literal table.
     */
    ROSE_INSTR_CHECK_LONG_LIT,

    /**
     * \brief Confirm a case-insensitive literal at the current offset. In
     * streaming mode, this makes use of the long literal table.
     */
    ROSE_INSTR_CHECK_LONG_LIT_NOCASE,

    /**
     * \brief Confirm a case-sensitive "medium length" literal at the current
     * offset. In streaming mode, this will check history if needed.
     */
    ROSE_INSTR_CHECK_MED_LIT,

    /**
     * \brief Confirm a case-insensitive "medium length" literal at the current
     * offset. In streaming mode, this will check history if needed.
     */
    ROSE_INSTR_CHECK_MED_LIT_NOCASE,

    /**
     * \brief Clear the "work done" flag used by the SQUASH_GROUPS instruction.
     */
    ROSE_INSTR_CLEAR_WORK_DONE,

    /** \brief Check lookaround if it has multiple paths. */
    ROSE_INSTR_MULTIPATH_LOOKAROUND,

    /**
     * \brief Use shufti to check lookaround with multiple paths. The total
     * length of the paths is 16 bytes at most and shufti has 8 buckets.
     * All paths can be at most 16 bytes long.
     */
    ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_16x8,

    /**
     * \brief Use shufti to check lookaround with multiple paths. The total
     * length of the paths is 32 bytes at most and shufti has 8 buckets.
     * All paths can be at most 16 bytes long.
     */
    ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_32x8,

    /**
     * \brief Use shufti to check lookaround with multiple paths. The total
     * length of the paths is 32 bytes at most and shufti has 16 buckets.
     * All paths can be at most 16 bytes long.
     */
    ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_32x16,

    /**
     * \brief Use shufti to check multiple paths lookaround. The total
     * length of the paths is 64 bytes at most and shufti has 8 buckets.
     * All paths can be at most 16 bytes long.
     */
    ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_64,

    /**
     * \brief Jump to the program of included literal.
     */
    ROSE_INSTR_INCLUDED_JUMP,

    /**
     * \brief Set matching status of a sub-expression.
     */
    ROSE_INSTR_SET_LOGICAL,

    /**
     * \brief Set combination status pending checking.
     */
    ROSE_INSTR_SET_COMBINATION,

    /**
     * \brief Check if compliant with any logical constraints.
     */
    ROSE_INSTR_FLUSH_COMBINATION,

    /** \brief Mark as exhausted instead of report while quiet. */
    ROSE_INSTR_SET_EXHAUST,

    /**
     * \brief Calculate any combination's logical value if none of its
     * sub-expression matches until EOD, then check if compliant with any
     * logical constraints.
     */
    ROSE_INSTR_LAST_FLUSH_COMBINATION,

    ROSE_INSTR_CHECK_SHUFTI_64x8, //!< Check 64-byte data by 8-bucket shufti.
    ROSE_INSTR_CHECK_SHUFTI_64x16, //!< Check 64-byte data by 16-bucket shufti.
    ROSE_INSTR_CHECK_MASK_64,     //!< 64-bytes and/cmp/neg mask check.

    LAST_ROSE_INSTRUCTION = ROSE_INSTR_CHECK_MASK_64 //!< Sentinel.
};

struct ROSE_STRUCT_END {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_ANCHORED_DELAY {
    u8 code; //!< From enum RoseInstructionCode.
    rose_group groups; //!< Bitmask.
    u32 anch_id; //!< Program to restart after the delay.
    u32 done_jump; //!< Jump forward this many bytes if we have to delay.
};

struct ROSE_STRUCT_CHECK_LIT_EARLY {
    u8 code; //!< From enum RoseInstructionCode.
    u32 min_offset; //!< Minimum offset for this literal.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

/** Note: check failure will halt program. */
struct ROSE_STRUCT_CHECK_GROUPS {
    u8 code; //!< From enum RoseInstructionCode.
    rose_group groups; //!< Bitmask.
};

struct ROSE_STRUCT_CHECK_ONLY_EOD {
    u8 code; //!< From enum RoseInstructionCode.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_BOUNDS {
    u8 code; //!< From enum RoseInstructionCode.
    u64a min_bound; //!< Min distance from zero.
    u64a max_bound; //!< Max distance from zero.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_NOT_HANDLED {
    u8 code; //!< From enum RoseInstructionCode.
    u32 key; //!< Key in the "handled_roles" fatbit in scratch.
    u32 fail_jump; //!< Jump forward this many bytes if we have seen key before.
};

struct ROSE_STRUCT_CHECK_SINGLE_LOOKAROUND {
    u8 code; //!< From enum RoseInstructionCode.
    s8 offset; //!< The offset of the byte to examine.
    u32 reach_index; //!< Index for lookaround reach bitvectors.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_LOOKAROUND {
    u8 code; //!< From enum RoseInstructionCode.
    u32 look_index; //!< Offset in bytecode of lookaround offset list.
    u32 reach_index; //!< Offset in bytecode of lookaround reach bitvectors.
    u32 count; //!< The count of lookaround entries in one instruction.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MASK {
    u8 code; //!< From enum roseInstructionCode.
    u64a and_mask; //!< 8-byte and mask.
    u64a cmp_mask; //!< 8-byte cmp mask.
    u64a neg_mask; //!< 8-byte negation mask.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MASK_32 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 and_mask[32]; //!< 32-byte and mask.
    u8 cmp_mask[32]; //!< 32-byte cmp mask.
    u32 neg_mask; //!< negation mask with 32 bits.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MASK_64 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 and_mask[64]; //!< 64-byte and mask.
    u8 cmp_mask[64]; //!< 64-byte cmp mask.
    u64a neg_mask; //!< negation mask with 32 bits.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_BYTE {
    u8 code; //!< From enum RoseInstructionCode.
    u8 and_mask; //!< 8-bits and mask.
    u8 cmp_mask; //!< 8-bits cmp mask.
    u8 negation; //!< Flag about negation.
    s32 offset; //!< The relative offset.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

// Since m128 and m256 could be missaligned in the bytecode,
// we'll use u8[16] and u8[32] instead in all rose_check_shufti structures.
struct ROSE_STRUCT_CHECK_SHUFTI_16x8 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 nib_mask[32]; //!< High 16 and low 16 bits nibble mask in shufti.
    u8 bucket_select_mask[16]; //!< Mask for bucket assigning.
    u32 neg_mask; //!< Negation mask in low 16 bits.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_SHUFTI_32x8 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[16]; //!< High nibble mask in shufti.
    u8 lo_mask[16]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask[32]; //!< Mask for bucket assigning.
    u32 neg_mask; //!< 32 bits negation mask.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_SHUFTI_16x16 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[32]; //!< High nibble mask in shufti.
    u8 lo_mask[32]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask[32]; //!< Mask for bucket assigning.
    u32 neg_mask; //!< Negation mask in low 16 bits.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_SHUFTI_32x16 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[32]; //!< High nibble mask in shufti.
    u8 lo_mask[32]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask_hi[32]; //!< Bucket mask for high 8 buckets.
    u8 bucket_select_mask_lo[32]; //!< Bucket mask for low 8 buckets.
    u32 neg_mask; //!< 32 bits negation mask.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_SHUFTI_64x8 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[64]; //!< High nibble mask in shufti.
    u8 lo_mask[64]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask[64]; //!< Mask for bucket assigning.
    u64a neg_mask; //!< 64 bits negation mask.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_SHUFTI_64x16 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask_1[64]; //!< 4 copies of 0-15 High nibble mask.
    u8 hi_mask_2[64]; //!< 4 copies of 16-32 High nibble mask.
    u8 lo_mask_1[64]; //!< 4 copies of 0-15 Low nibble mask.
    u8 lo_mask_2[64]; //!< 4 copies of 16-32 Low nibble mask.
    u8 bucket_select_mask_hi[64]; //!< Bucket mask for high 8 buckets.
    u8 bucket_select_mask_lo[64]; //!< Bucket mask for low 8 buckets.
    u64a neg_mask; //!< 64 bits negation mask.
    s32 offset; //!< Relative offset of the first byte.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_INFIX {
    u8 code; //!< From enum RoseInstructionCode.
    u32 queue; //!< Queue of leftfix to check.
    u32 lag; //!< Lag of leftfix for this case.
    ReportID report; //!< ReportID of leftfix to check.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_PREFIX {
    u8 code; //!< From enum RoseInstructionCode.
    u32 queue; //!< Queue of leftfix to check.
    u32 lag; //!< Lag of leftfix for this case.
    ReportID report; //!< ReportID of leftfix to check.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_PUSH_DELAYED {
    u8 code; //!< From enum RoseInstructionCode.
    u8 delay; // Number of bytes to delay.
    u32 index; // Delay literal index (relative to first delay lit).
};

struct ROSE_STRUCT_DUMMY_NOP {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_CATCH_UP {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_CATCH_UP_MPV {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_SOM_ADJUST {
    u8 code; //!< From enum RoseInstructionCode.
    u32 distance; //!< Distance to EOM.
};

struct ROSE_STRUCT_SOM_LEFTFIX {
    u8 code; //!< From enum RoseInstructionCode.
    u32 queue; //!< Queue index of leftfix providing SOM.
    u32 lag; //!< Lag of leftfix for this case.
};

struct ROSE_STRUCT_SOM_FROM_REPORT {
    u8 code; //!< From enum RoseInstructionCode.
    struct som_operation som;
};

struct ROSE_STRUCT_SOM_ZERO {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_TRIGGER_INFIX {
    u8 code; //!< From enum RoseInstructionCode.
    u8 cancel; //!< Cancels previous top event.
    u32 queue; //!< Queue index of infix.
    u32 event; //!< Queue event, from MQE_*.
};

struct ROSE_STRUCT_TRIGGER_SUFFIX {
    u8 code; //!< From enum RoseInstructionCode.
    u32 queue; //!< Queue index of suffix.
    u32 event; //!< Queue event, from MQE_*.
};

struct ROSE_STRUCT_DEDUPE {
    u8 code; //!< From enum RoseInstructionCode.
    u8 quash_som; //!< Force SOM to zero for this report.
    u32 dkey; //!< Dedupe key.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_DEDUPE_SOM {
    u8 code; //!< From enum RoseInstructionCode.
    u8 quash_som; //!< Force SOM to zero for this report.
    u32 dkey; //!< Dedupe key.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_REPORT_CHAIN {
    u8 code; //!< From enum RoseInstructionCode.
    u32 event; //!< Queue event, from MQE_*. Must be a top.

    /**
     * \brief Number of bytes behind us that we are allowed to squash
     * identical top events on the queue.
     */
    u64a top_squash_distance;
};

struct ROSE_STRUCT_REPORT_SOM_INT {
    u8 code; //!< From enum RoseInstructionCode.
    struct som_operation som;
};

struct ROSE_STRUCT_REPORT_SOM_AWARE {
    u8 code; //!< From enum RoseInstructionCode.
    struct som_operation som;
};

struct ROSE_STRUCT_REPORT {
    u8 code; //!< From enum RoseInstructionCode.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
};

struct ROSE_STRUCT_REPORT_EXHAUST {
    u8 code; //!< From enum RoseInstructionCode.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
    u32 ekey; //!< Exhaustion key.
};

struct ROSE_STRUCT_REPORT_SOM {
    u8 code; //!< From enum RoseInstructionCode.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
};

struct ROSE_STRUCT_REPORT_SOM_EXHAUST {
    u8 code; //!< From enum RoseInstructionCode.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
    u32 ekey; //!< Exhaustion key.
};

struct ROSE_STRUCT_DEDUPE_AND_REPORT {
    u8 code; //!< From enum RoseInstructionCode.
    u8 quash_som; //!< Force SOM to zero for this report.
    u32 dkey; //!< Dedupe key.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_FINAL_REPORT {
    u8 code; //!< From enum RoseInstructionCode.
    ReportID onmatch; //!< Report ID to deliver to user.
    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
};

struct ROSE_STRUCT_CHECK_EXHAUSTED {
    u8 code; //!< From enum RoseInstructionCode.
    u32 ekey; //!< Exhaustion key to check.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MIN_LENGTH {
    u8 code; //!< From enum RoseInstructionCode.
    s32 end_adj; //!< Offset adjustment to add to EOM first.
    u64a min_length; //!< Minimum distance from SOM to EOM.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_SET_STATE {
    u8 code; //!< From enum RoseInstructionCode.
    u32 index; //!< State index in multibit.
};

struct ROSE_STRUCT_SET_GROUPS {
    u8 code; //!< From enum RoseInstructionCode.
    rose_group groups; //!< Bitmask to OR into groups.
};

struct ROSE_STRUCT_SQUASH_GROUPS {
    u8 code; //!< From enum RoseInstructionCode.
    rose_group groups; //!< Bitmask to AND into groups.
};

struct ROSE_STRUCT_CHECK_STATE {
    u8 code; //!< From enum RoseInstructionCode.
    u32 index; //!< State index in the role multibit.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

/**
 * Note that the offsets in the jump table are always relative to the start of
 * the program, not the current instruction.
 */
struct ROSE_STRUCT_SPARSE_ITER_BEGIN {
    u8 code; //!< From enum RoseInstructionCode.
    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
    u32 jump_table; //!< Offset of jump table indexed by sparse iterator.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

/**
 * Note that the offsets in the jump table are always relative to the start of
 * the program, not the current instruction.
 */
struct ROSE_STRUCT_SPARSE_ITER_NEXT {
    u8 code; //!< From enum RoseInstructionCode.
    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
    u32 jump_table; //!< Offset of jump table indexed by sparse iterator.
    u32 state; // Current state index.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_SPARSE_ITER_ANY {
    u8 code; //!< From enum RoseInstructionCode.
    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_ENGINES_EOD {
    u8 code; //!< From enum RoseInstructionCode.
    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
};

struct ROSE_STRUCT_SUFFIXES_EOD {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_MATCHER_EOD {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_CHECK_LONG_LIT {
    u8 code; //!< From enum RoseInstructionCode.
    u32 lit_offset; //!< Offset of literal string.
    u32 lit_length; //!< Length of literal string.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_LONG_LIT_NOCASE {
    u8 code; //!< From enum RoseInstructionCode.
    u32 lit_offset; //!< Offset of literal string.
    u32 lit_length; //!< Length of literal string.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MED_LIT {
    u8 code; //!< From enum RoseInstructionCode.
    u32 lit_offset; //!< Offset of literal string.
    u32 lit_length; //!< Length of literal string.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MED_LIT_NOCASE {
    u8 code; //!< From enum RoseInstructionCode.
    u32 lit_offset; //!< Offset of literal string.
    u32 lit_length; //!< Length of literal string.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CLEAR_WORK_DONE {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_MULTIPATH_LOOKAROUND {
    u8 code; //!< From enum RoseInstructionCode.
    u32 look_index; //!< Offset in bytecode of lookaround offset list.
    u32 reach_index; //!< Offset in bytecode of lookaround reach bitvectors.
    u32 count; //!< The lookaround byte numbers for each path.
    s32 last_start; //!< The latest start offset among 8 paths.
    u8 start_mask[MULTIPATH_MAX_LEN]; /*!< Used to initialize path if left-most
                                       * data is missed. */
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_16x8 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 nib_mask[2 * sizeof(m128)]; //!< High and low nibble mask in shufti.
    u8 bucket_select_mask[sizeof(m128)]; //!< Mask for bucket assigning.
    u8 data_select_mask[sizeof(m128)]; //!< Shuffle mask for data ordering.
    u32 hi_bits_mask; //!< High-bits used in multi-path validation.
    u32 lo_bits_mask; //!< Low-bits used in multi-path validation.
    u32 neg_mask; //!< 64 bits negation mask.
    s32 base_offset; //!< Relative offset of the first byte.
    s32 last_start; //!< The latest start offset among 8 paths.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_32x8 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[sizeof(m128)]; //!< High nibble mask in shufti.
    u8 lo_mask[sizeof(m128)]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask[sizeof(m256)]; //!< Mask for bucket assigning.
    u8 data_select_mask[sizeof(m256)]; //!< Shuffle mask for data ordering.
    u32 hi_bits_mask; //!< High-bits used in multi-path validation.
    u32 lo_bits_mask; //!< Low-bits used in multi-path validation.
    u32 neg_mask; //!< 64 bits negation mask.
    s32 base_offset; //!< Relative offset of the first byte.
    s32 last_start; //!< The latest start offset among 8 paths.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_32x16 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[sizeof(m256)]; //!< High nibble mask in shufti.
    u8 lo_mask[sizeof(m256)]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask_hi[sizeof(m256)]; //!< Mask for bucket assigning.
    u8 bucket_select_mask_lo[sizeof(m256)]; //!< Mask for bucket assigning.
    u8 data_select_mask[sizeof(m256)]; //!< Shuffle mask for data ordering.
    u32 hi_bits_mask; //!< High-bits used in multi-path validation.
    u32 lo_bits_mask; //!< Low-bits used in multi-path validation.
    u32 neg_mask; //!< 64 bits negation mask.
    s32 base_offset; //!< Relative offset of the first byte.
    s32 last_start; //!< The latest start offset among 8 paths.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_64 {
    u8 code; //!< From enum RoseInstructionCode.
    u8 hi_mask[sizeof(m128)]; //!< High nibble mask in shufti.
    u8 lo_mask[sizeof(m128)]; //!< Low nibble mask in shufti.
    u8 bucket_select_mask[2 * sizeof(m256)]; //!< Mask for bucket assigning.
    u8 data_select_mask[2 * sizeof(m256)]; //!< Shuffle mask for data ordering.
    u64a hi_bits_mask; //!< High-bits used in multi-path validation.
    u64a lo_bits_mask; //!< Low-bits used in multi-path validation.
    u64a neg_mask; //!< 64 bits negation mask.
    s32 base_offset; //!< Relative offset of the first byte.
    s32 last_start; //!< The latest start offset among 8 paths.
    u32 fail_jump; //!< Jump forward this many bytes on failure.
};

struct ROSE_STRUCT_INCLUDED_JUMP {
    u8 code; //!< From enum RoseInstructionCode.
    u8 squash; //!< FDR confirm squash mask for included literal.
    u32 child_offset; //!< Program offset of included literal.
};

struct ROSE_STRUCT_SET_LOGICAL {
    u8 code; //!< From enum RoseInstructionCode.
    u32 lkey; //!< Logical key to set.
    s32 offset_adjust; //!< offsetAdjust from struct Report triggers the flush.
};

struct ROSE_STRUCT_SET_COMBINATION {
    u8 code; //!< From enum RoseInstructionCode.
    u32 ckey; //!< Combination key to set.
};

struct ROSE_STRUCT_FLUSH_COMBINATION {
    u8 code; //!< From enum RoseInstructionCode.
};

struct ROSE_STRUCT_SET_EXHAUST {
    u8 code; //!< From enum RoseInstructionCode.
    u32 ekey; //!< Exhaustion key.
};

struct ROSE_STRUCT_LAST_FLUSH_COMBINATION {
    u8 code; //!< From enum RoseInstructionCode.
};
#endif // ROSE_ROSE_PROGRAM_H