cores
/
a2o
mirror of https://github.com/OpenPOWERFoundation/a2o
3
1
Fork 1
Code Issues Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
pd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '200551679c'
${ noResults }
a2o/dev/verilog/work/lq_fgen.v

2059 lines
88 KiB
Verilog
Raw Normal View History Unescape Escape

add dev
2 years ago
// © IBM Corp. 2020
// Licensed under the Apache License, Version 2.0 (the "License"), as modified by
// the terms below; you may not use the files in this repository except in
// compliance with the License as modified.
// You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
//
// Modified Terms:
//
// 1) For the purpose of the patent license granted to you in Section 3 of the
// License, the "Work" hereby includes implementations of the work of authorship
// in physical form.
//
// 2) Notwithstanding any terms to the contrary in the License, any licenses
// necessary for implementation of the Work that are available from OpenPOWER
// via the Power ISA End User License Agreement (EULA) are explicitly excluded
// hereunder, and may be obtained from OpenPOWER under the terms and conditions
// of the EULA.
//
// Unless required by applicable law or agreed to in writing, the reference design
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
// for the specific language governing permissions and limitations under the License.
//
// Additional rights, including the ability to physically implement a softcore that
// is compliant with the required sections of the Power ISA Specification, are
// available at no cost under the terms of the OpenPOWER Power ISA EULA, which can be
// obtained (along with the Power ISA) here: https://openpowerfoundation.org.
`timescale 1 ns / 1 ns
//
// Description: XU LSU Flush Generation
//
//*****************************************************************************
// ##########################################################################################
// VHDL Contents
// 1) Reload Flush generation
// 2) Back-Invalidate Flush generation
// 4) Instruction Flush Handling
// ##########################################################################################
`include "tri_a2o.vh"
module lq_fgen(
ex0_i0_vld,
ex0_i0_ucode_preissue,
ex0_i0_2ucode,
ex0_i0_ucode_cnt,
ex0_i1_vld,
ex0_i1_ucode_preissue,
ex0_i1_2ucode,
ex0_i1_ucode_cnt,
dec_dcc_ex1_expt_det,
dec_dcc_ex1_priv_prog,
dec_dcc_ex1_hypv_prog,
dec_dcc_ex1_illeg_prog,
dec_dcc_ex1_dlock_excp,
dec_dcc_ex1_ilock_excp,
dec_dcc_ex1_ehpriv_excp,
byp_dcc_ex2_req_aborted,
ex3_stg_act,
ex4_stg_act,
ex1_thrd_id,
ex2_thrd_id,
ex3_thrd_id,
ex4_thrd_id,
ex5_thrd_id,
ex3_cache_acc,
ex3_ucode_val,
ex3_ucode_cnt,
ex4_ucode_op,
ex4_mem_attr,
ex4_blkable_touch,
ex3_ldst_fexcpt,
ex3_axu_op_val,
ex3_axu_instr_type,
ex3_optype16,
ex3_optype8,
ex3_optype4,
ex3_optype2,
ex3_eff_addr,
ex3_icswx_type,
ex3_dcbz_instr,
ex3_resv_instr,
ex3_mword_instr,
ex3_ldawx_instr,
ex3_illeg_lswx,
ex4_icswx_dsi,
ex4_wclr_all_val,
ex4_wNComp_rcvd,
ex4_dac_int_det,
ex4_strg_gate,
ex4_restart_val,
ex5_restart_val,
spr_ccr2_ucode_dis,
spr_ccr2_notlb,
spr_xucr0_mddp,
spr_xucr0_mdcp,
spr_xucr4_mmu_mchk,
spr_xucr4_mddmh,
derat_dcc_ex4_restart,
derat_dcc_ex4_wimge_w,
derat_dcc_ex4_wimge_i,
derat_dcc_ex4_miss,
derat_dcc_ex4_tlb_err,
derat_dcc_ex4_dsi,
derat_dcc_ex4_vf,
derat_dcc_ex4_multihit_err_det,
derat_dcc_ex4_multihit_err_flush,
derat_dcc_ex4_tlb_inelig,
derat_dcc_ex4_pt_fault,
derat_dcc_ex4_lrat_miss,
derat_dcc_ex4_tlb_multihit,
derat_dcc_ex4_tlb_par_err,
derat_dcc_ex4_lru_par_err,
derat_dcc_ex4_par_err_det,
derat_dcc_ex4_par_err_flush,
derat_fir_par_err,
derat_fir_multihit,
dir_dcc_ex5_dir_perr_det,
dir_dcc_ex5_dc_perr_det,
dir_dcc_ex5_dir_perr_flush,
dir_dcc_ex5_dc_perr_flush,
dir_dcc_ex5_multihit_det,
dir_dcc_ex5_multihit_flush,
dir_dcc_stq4_dir_perr_det,
dir_dcc_stq4_multihit_det,
dir_dcc_ex5_stp_flush,
spr_xucr0_aflsta,
spr_xucr0_flsta,
spr_ccr2_ap,
spr_msr_fp,
spr_msr_spv,
iu_lq_cp_flush,
ex4_ucode_restart,
ex4_sfx_excpt_det,
ex4_excp_det,
ex4_wNComp_excp,
ex4_wNComp_excp_restart,
ex5_flush_req,
ex5_blk_tlb_req,
ex5_flush_pfetch,
fgen_ex4_cp_flush,
fgen_ex5_cp_flush,
fgen_ex1_stg_flush,
fgen_ex2_stg_flush,
fgen_ex3_stg_flush,
fgen_ex4_stg_flush,
fgen_ex5_stg_flush,
ex5_flush2ucode,
ex5_n_flush,
ex5_np1_flush,
ex5_exception_val,
ex5_exception,
ex5_dear_val,
ex5_misalign_flush,
lq_pc_err_derat_parity,
lq_pc_err_dir_ldp_parity,
lq_pc_err_dir_stp_parity,
lq_pc_err_dcache_parity,
lq_pc_err_derat_multihit,
lq_pc_err_dir_ldp_multihit,
lq_pc_err_dir_stp_multihit,
vdd,
gnd,
nclk,
sg_0,
func_sl_thold_0_b,
func_sl_force,
d_mode_dc,
delay_lclkr_dc,
mpw1_dc_b,
mpw2_dc_b,
scan_in,
scan_out
);
//-------------------------------------------------------------------
// Generics
//-------------------------------------------------------------------
//parameter EXPAND_TYPE = 2;
//parameter THREADS = 2;
//parameter UCODE_ENTRIES_ENC = 3;
//parameter THREADS_POOL_ENC = 1;
//parameter ITAG_SIZE_ENC = 7;
// IU Dispatch to RV0
input [0:`THREADS-1] ex0_i0_vld;
input ex0_i0_ucode_preissue;
input ex0_i0_2ucode;
input [0:`UCODE_ENTRIES_ENC-1] ex0_i0_ucode_cnt;
input [0:`THREADS-1] ex0_i1_vld;
input ex0_i1_ucode_preissue;
input ex0_i1_2ucode;
input [0:`UCODE_ENTRIES_ENC-1] ex0_i1_ucode_cnt;
// Execution Pipe
input dec_dcc_ex1_expt_det;
input dec_dcc_ex1_priv_prog;
input dec_dcc_ex1_hypv_prog;
input dec_dcc_ex1_illeg_prog;
input dec_dcc_ex1_dlock_excp;
input dec_dcc_ex1_ilock_excp;
input dec_dcc_ex1_ehpriv_excp;
input byp_dcc_ex2_req_aborted;
// Control
input ex3_stg_act;
input ex4_stg_act;
input [0:`THREADS-1] ex1_thrd_id;
input [0:`THREADS-1] ex2_thrd_id;
input [0:`THREADS-1] ex3_thrd_id;
input [0:`THREADS-1] ex4_thrd_id;
input [0:`THREADS-1] ex5_thrd_id;
input ex3_cache_acc; // Cache Access is Valid in ex3
input ex3_ucode_val; // Ucode Preissue is Valid in ex3
input [0:`UCODE_ENTRIES_ENC-1] ex3_ucode_cnt; // Ucode Count in ex3
input ex4_ucode_op; // Op is from Ucode in ex4
input [0:8] ex4_mem_attr;
input ex4_blkable_touch;
input ex3_ldst_fexcpt; // Force Exception on misaligned AXU access
input ex3_axu_op_val; // ex3 AXU operation is valid
input [0:2] ex3_axu_instr_type;
input ex3_optype16; // Operation is 16 Byte Access
input ex3_optype8; // Operation is 8 Byte Access
input ex3_optype4; // Operation is 4 Byte Access
input ex3_optype2; // Operation is 2 Byte Access
input [57:63] ex3_eff_addr;
input ex3_icswx_type;
input ex3_dcbz_instr; // DCBZ instruction is valid in ex3
input ex3_resv_instr; // lwarx, ldarx, stwcx, and stdcx operations
input ex3_mword_instr; // Load/Store Multiple Word preissue
input ex3_ldawx_instr; // ldawx operation
input ex3_illeg_lswx; // STQ detected illegal form of LSWX
input ex4_icswx_dsi; // Unavailable Coprocessor DSI Interrupt
input ex4_wclr_all_val; // wclr All instruction is valid
input ex4_wNComp_rcvd; // Request is CP_NEXT with recirc valid
input ex4_dac_int_det; // Debug Address Compare Interrupt Detected
input ex4_strg_gate; // LSWX/STSWX NOOP indicator, gate mem attribute update
input ex4_restart_val; // Instruction is getting restarted in EX4
input ex5_restart_val; // Instruction is getting restarted in EX5
// SPR Bits
input spr_ccr2_ucode_dis; // CCR2[UCODE_DIS]
input spr_ccr2_notlb; // CCR2[NOTLB]
input spr_xucr0_mddp; // XUCR0[MDDP]
input spr_xucr0_mdcp; // XUCR0[MDCP]
input spr_xucr4_mmu_mchk; // XUCR4[MMU_MCHK]
input spr_xucr4_mddmh; // XUCR4[MDDMH]
// ERAT Interface
input derat_dcc_ex4_restart;
input derat_dcc_ex4_wimge_w;
input derat_dcc_ex4_wimge_i;
input derat_dcc_ex4_miss;
input derat_dcc_ex4_tlb_err;
input derat_dcc_ex4_dsi;
input derat_dcc_ex4_vf;
input derat_dcc_ex4_multihit_err_det;
input derat_dcc_ex4_multihit_err_flush;
input derat_dcc_ex4_tlb_inelig;
input derat_dcc_ex4_pt_fault;
input derat_dcc_ex4_lrat_miss;
input derat_dcc_ex4_tlb_multihit;
input derat_dcc_ex4_tlb_par_err;
input derat_dcc_ex4_lru_par_err;
input derat_dcc_ex4_par_err_det;
input derat_dcc_ex4_par_err_flush;
input derat_fir_par_err;
input derat_fir_multihit;
// D$ Parity Error Detected
input dir_dcc_ex5_dir_perr_det; // Data Directory Parity Error Detected
input dir_dcc_ex5_dc_perr_det; // Data Cache Parity Error Detected
input dir_dcc_ex5_dir_perr_flush; // Data Directory Parity Error Flush
input dir_dcc_ex5_dc_perr_flush; // Data Cache Parity Error Flush
input dir_dcc_ex5_multihit_det; // Directory Multihit Detected
input dir_dcc_ex5_multihit_flush; // Directory Multihit Flush
input dir_dcc_stq4_dir_perr_det; // Data Cache Parity Error Detected on the STQ Commit Pipeline
input dir_dcc_stq4_multihit_det; // Directory Multihit Detected on the STQ Commit Pipeline
input dir_dcc_ex5_stp_flush; // Directory Error detected on the STQ Commit Pipeline with EX5 LDP valid
// SPR's
input spr_xucr0_aflsta;
input spr_xucr0_flsta;
input spr_ccr2_ap;
input spr_msr_fp;
input spr_msr_spv;
// Instruction Flush
input [0:`THREADS-1] iu_lq_cp_flush;
// Flush Pipe Outputs
output ex4_ucode_restart; // Memory Attributes are not known, need to restart
output ex4_sfx_excpt_det; // Priveleged and illegal instructions
output ex4_excp_det; // Any Exception was detected
output ex4_wNComp_excp; // Exception with RECIRC_VAL detected
output ex4_wNComp_excp_restart; // CP_NEXT instruction got an exception, restart the 2 younger instructions
output ex5_flush_req; // Non-CP_NEXT Flush Request Detected
output ex5_blk_tlb_req; // Block ERAT Miss from going to the MMU
output ex5_flush_pfetch; // Flush Prefetch in ex5
output fgen_ex4_cp_flush; // Completion Flush Request in ex4
output fgen_ex5_cp_flush; // Completion Flush Request in ex5
output fgen_ex1_stg_flush; // Flush Instructions in ex1
output fgen_ex2_stg_flush; // Flush Instructions in ex2
output fgen_ex3_stg_flush; // Flush Instructions in ex3
output fgen_ex4_stg_flush; // Flush Instructions in ex4
output fgen_ex5_stg_flush; // Flush Instructions in ex5
// Completion Indicators
output ex5_flush2ucode; // EX5 Flush to Ucode indicator
output ex5_n_flush; // EX5 N Flush Indicator
output ex5_np1_flush; // EX5 NP1 Flush Indicator
output ex5_exception_val; // EX5 Exception Valid Indicator
output [0:5] ex5_exception; // EX5 Exception Encode
output [0:`THREADS-1] ex5_dear_val; // EX5 Dear Valid Indicator
// Performance Events
output ex5_misalign_flush;
// Error Reporting
output lq_pc_err_derat_parity;
output lq_pc_err_dir_ldp_parity;
output lq_pc_err_dir_stp_parity;
output lq_pc_err_dcache_parity;
output lq_pc_err_derat_multihit;
output lq_pc_err_dir_ldp_multihit;
output lq_pc_err_dir_stp_multihit;
//pervasive
inout vdd;
inout gnd;
(* pin_data="PIN_FUNCTION=/G_CLK/CAP_LIMIT=/99999/" *)
input [0:`NCLK_WIDTH-1] nclk;
input sg_0;
input func_sl_thold_0_b;
input func_sl_force;
input d_mode_dc;
input delay_lclkr_dc;
input mpw1_dc_b;
input mpw2_dc_b;
(* pin_data="PIN_FUNCTION=/SCAN_IN/" *)
input scan_in;
(* pin_data="PIN_FUNCTION=/SCAN_OUT/" *)
output scan_out;
//--------------------------
// components
//--------------------------
//--------------------------
// constants
//--------------------------
parameter UCODEDEPTH = (2**`UCODE_ENTRIES_ENC)*`THREADS;
//--------------------------
// signals
//--------------------------
wire ex3_16Bop16_unal;
wire ex3_16Bop8_unal;
wire ex3_16Bop4_unal;
wire ex3_16Bop2_unal;
wire ex3_16Bunal_op;
wire ex4_wt_ci_trans;
wire ex3_valid_resv;
wire ex1_cp_flush_val;
wire ex2_cp_flush_val;
wire ex3_cp_flush_val;
wire ex4_cp_flush_val;
wire ex5_cp_flush_val;
wire ex4_local_flush;
wire ex4_valid_resv_d;
wire ex4_valid_resv_q;
wire ex4_prealign_int_d;
wire ex4_prealign_int_q;
wire force_align_int_a;
wire force_align_int_x;
wire force_align_int;
wire ex3_flush_2ucode_chk;
wire ex3_flush_2ucode;
wire ex4_flush_2ucode_d;
wire ex4_flush_2ucode_q;
wire ex5_flush_2ucode_d;
wire ex5_flush_2ucode_q;
wire ex4_ucode_dis_prog_d;
wire ex4_ucode_dis_prog_q;
wire ex3_op16_unal;
wire ex3_op8_unal;
wire ex3_op4_unal;
wire ex3_op2_unal;
wire ex3_unal_op;
wire ex5_misalign_flush_d;
wire ex5_misalign_flush_q;
wire ex4_n_flush_req;
wire ex4_tlb_flush_req;
wire ex5_tlb_flush_req_d;
wire ex5_tlb_flush_req_q;
wire ex5_tlb_mchk_req_d;
wire ex5_tlb_mchk_req_q;
wire ex5_flush_req_mchk;
wire ex5_flush_req_int;
wire ex3_icswx_unal;
wire ex4_is_dcbz_d;
wire ex4_is_dcbz_q;
wire ex4_dsi_int;
wire ex4_align_int;
wire ex4_dcbz_err;
wire ex4_axu_ap_unavail_d;
wire ex4_axu_ap_unavail_q;
wire ex4_axu_fp_unavail_d;
wire ex4_axu_fp_unavail_q;
wire ex4_axu_spv_unavail_d;
wire ex4_axu_spv_unavail_q;
wire ex5_local_flush;
wire ex5_local_flush_d;
wire ex5_local_flush_q;
wire [0:25] ex4_excp_pri;
wire [7:11] ex5_excp_pri;
wire ex4_tlb_perr_mchk;
wire ex4_tlb_lru_perr_mchk;
wire ex4_tlb_multihit_mchk;
wire ex5_derat_perr_mchk;
wire ex5_dir_perr_mchk;
wire ex5_dc_perr_mchk;
wire ex5_derat_multihit_mchk;
wire ex5_dir_multihit_mchk;
wire ex4_tlb_perr_flush;
wire ex4_tlb_lru_perr_flush;
wire ex4_tlb_multihit_flush;
wire ex5_derat_perr_flush;
wire ex5_dir_perr_flush;
wire ex5_dc_perr_flush;
wire ex5_derat_multihit_flush;
wire ex5_dir_multihit_flush;
wire ex4_non_cp_next_excp;
wire ex5_high_pri_excp_d;
wire ex5_high_pri_excp_q;
wire ex4_cp_next_excp;
wire ex4_cp_next_excp_det;
wire ex4_cp_next_excp_rpt;
wire ex5_low_pri_excp_d;
wire ex5_low_pri_excp_q;
wire [0:5] ex4_exception;
wire ex5_sel_mid_pri_excp;
wire [0:5] ex5_mid_pri_excp;
wire [0:5] ex5_exception_d;
wire [0:5] ex5_exception_q;
wire [0:5] ex5_exception_int;
wire [0:`THREADS-1] ex5_dear_val_d;
wire [0:`THREADS-1] ex5_dear_val_q;
wire ex5_derat_multihit_flush_d;
wire ex5_derat_multihit_flush_q;
wire ex5_derat_multihit_det_d;
wire ex5_derat_multihit_det_q;
wire ex5_derat_perr_flush_d;
wire ex5_derat_perr_flush_q;
wire ex5_derat_perr_det_d;
wire ex5_derat_perr_det_q;
wire ex2_sfx_excpt_det_d;
wire ex2_sfx_excpt_det_q;
wire ex3_sfx_excpt_det_d;
wire ex3_sfx_excpt_det_q;
wire ex4_sfx_excpt_det_d;
wire ex4_sfx_excpt_det_q;
wire ex2_priv_prog_d;
wire ex2_priv_prog_q;
wire ex3_priv_prog_d;
wire ex3_priv_prog_q;
wire ex4_priv_prog_d;
wire ex4_priv_prog_q;
wire ex2_hypv_prog_d;
wire ex2_hypv_prog_q;
wire ex3_hypv_prog_d;
wire ex3_hypv_prog_q;
wire ex4_hypv_prog_d;
wire ex4_hypv_prog_q;
wire ex2_illeg_prog_d;
wire ex2_illeg_prog_q;
wire ex3_illeg_prog_d;
wire ex3_illeg_prog_q;
wire ex4_illeg_prog_d;
wire ex4_illeg_prog_q;
wire ex2_dlock_excp_d;
wire ex2_dlock_excp_q;
wire ex3_dlock_excp_d;
wire ex3_dlock_excp_q;
wire ex4_dlock_excp_d;
wire ex4_dlock_excp_q;
wire ex2_ilock_excp_d;
wire ex2_ilock_excp_q;
wire ex3_ilock_excp_d;
wire ex3_ilock_excp_q;
wire ex4_ilock_excp_d;
wire ex4_ilock_excp_q;
wire ex2_ehpriv_excp_d;
wire ex2_ehpriv_excp_q;
wire ex3_ehpriv_excp_d;
wire ex3_ehpriv_excp_q;
wire ex4_ucode_val_d;
wire ex4_ucode_val_q;
wire [0:`UCODE_ENTRIES_ENC-1] ex4_ucode_cnt_d;
wire [0:`UCODE_ENTRIES_ENC-1] ex4_ucode_cnt_q;
wire [0:`UCODE_ENTRIES_ENC+`THREADS_POOL_ENC-1] ex0_i0_tid_ucode_cnt;
wire [0:`UCODE_ENTRIES_ENC+`THREADS_POOL_ENC-1] ex0_i1_tid_ucode_cnt;
wire [0:`UCODE_ENTRIES_ENC+`THREADS_POOL_ENC-1] ex3_tid_ucode_cnt;
wire [0:`UCODE_ENTRIES_ENC+`THREADS_POOL_ENC-1] ex4_tid_ucode_cnt;
wire [0:UCODEDEPTH-1] ex0_i0_ucode_cnt_entry;
wire [0:UCODEDEPTH-1] ex0_i0_ucode_cnt_start;
wire [0:UCODEDEPTH-1] ex0_i1_ucode_cnt_entry;
wire [0:UCODEDEPTH-1] ex0_i1_ucode_cnt_start;
wire [0:UCODEDEPTH-1] ex0_ucode_cnt_rst;
wire [0:UCODEDEPTH-1] ex3_ucode_cnt_entry;
wire [0:UCODEDEPTH-1] ex4_ucode_cnt_entry;
wire [0:UCODEDEPTH-1] ex4_ucode_cnt_set;
wire [0:1] ucode_cnt_ctrl[0:UCODEDEPTH-1];
wire [0:1] ucode_cnt_2ucode_ctrl[0:UCODEDEPTH-1];
wire [0:UCODEDEPTH-1] ucode_cnt_val_d;
wire [0:UCODEDEPTH-1] ucode_cnt_val_q;
wire [0:UCODEDEPTH-1] ucode_cnt_2ucode_d;
wire [0:UCODEDEPTH-1] ucode_cnt_2ucode_q;
wire [0:8] ucode_cnt_memAttr_d[0:UCODEDEPTH-1];
wire [0:8] ucode_cnt_memAttr_q[0:UCODEDEPTH-1];
wire ex4_cache_acc_d;
wire ex4_cache_acc_q;
wire [0:UCODEDEPTH-1] ex3_2ucode_cnt_set;
wire ex3_2ucode_set;
wire [0:UCODEDEPTH-1] ex4_ucode_align_int;
wire ex4_ucode_align_val;
wire [0:UCODEDEPTH-1] ex4_ucode_cnt_restart;
wire ex4_derat_vf_int;
wire ex5_wNComp_rcvd_d;
wire ex5_wNComp_rcvd_q;
wire ex5_wNComp_excp;
wire ex6_wNComp_excp_d;
wire ex6_wNComp_excp_q;
wire ex5_dac_int_det_d;
wire ex5_dac_int_det_q;
wire [0:6] perv_fir_rpt;
wire [0:6] perv_fir_rpt_d;
wire [0:6] perv_fir_rpt_q;
parameter ex4_valid_resv_offset = 0;
parameter ex4_prealign_int_offset = ex4_valid_resv_offset + 1;
parameter ex4_flush_2ucode_offset = ex4_prealign_int_offset + 1;
parameter ex5_flush_2ucode_offset = ex4_flush_2ucode_offset + 1;
parameter ex4_ucode_dis_prog_offset = ex5_flush_2ucode_offset + 1;
parameter ex4_is_dcbz_offset = ex4_ucode_dis_prog_offset + 1;
parameter ex5_misalign_flush_offset = ex4_is_dcbz_offset + 1;
parameter ex4_axu_ap_unavail_offset = ex5_misalign_flush_offset + 1;
parameter ex4_axu_fp_unavail_offset = ex4_axu_ap_unavail_offset + 1;
parameter ex4_axu_spv_unavail_offset = ex4_axu_fp_unavail_offset + 1;
parameter ex5_local_flush_offset = ex4_axu_spv_unavail_offset + 1;
parameter ex5_tlb_flush_req_offset = ex5_local_flush_offset + 1;
parameter ex5_tlb_mchk_req_offset = ex5_tlb_flush_req_offset + 1;
parameter ex5_low_pri_excp_offset = ex5_tlb_mchk_req_offset + 1;
parameter ex5_high_pri_excp_offset = ex5_low_pri_excp_offset + 1;
parameter ex5_exception_offset = ex5_high_pri_excp_offset + 1;
parameter ex5_dear_val_offset = ex5_exception_offset + 6;
parameter ex5_derat_multihit_flush_offset = ex5_dear_val_offset + `THREADS;
parameter ex5_derat_multihit_det_offset = ex5_derat_multihit_flush_offset + 1;
parameter ex5_derat_perr_flush_offset = ex5_derat_multihit_det_offset + 1;
parameter ex5_derat_perr_det_offset = ex5_derat_perr_flush_offset + 1;
parameter ex2_sfx_excpt_det_offset = ex5_derat_perr_det_offset + 1;
parameter ex3_sfx_excpt_det_offset = ex2_sfx_excpt_det_offset + 1;
parameter ex4_sfx_excpt_det_offset = ex3_sfx_excpt_det_offset + 1;
parameter ex2_priv_prog_offset = ex4_sfx_excpt_det_offset + 1;
parameter ex3_priv_prog_offset = ex2_priv_prog_offset + 1;
parameter ex4_priv_prog_offset = ex3_priv_prog_offset + 1;
parameter ex2_hypv_prog_offset = ex4_priv_prog_offset + 1;
parameter ex3_hypv_prog_offset = ex2_hypv_prog_offset + 1;
parameter ex4_hypv_prog_offset = ex3_hypv_prog_offset + 1;
parameter ex2_illeg_prog_offset = ex4_hypv_prog_offset + 1;
parameter ex3_illeg_prog_offset = ex2_illeg_prog_offset + 1;
parameter ex4_illeg_prog_offset = ex3_illeg_prog_offset + 1;
parameter ex2_dlock_excp_offset = ex4_illeg_prog_offset + 1;
parameter ex3_dlock_excp_offset = ex2_dlock_excp_offset + 1;
parameter ex4_dlock_excp_offset = ex3_dlock_excp_offset + 1;
parameter ex2_ilock_excp_offset = ex4_dlock_excp_offset + 1;
parameter ex3_ilock_excp_offset = ex2_ilock_excp_offset + 1;
parameter ex4_ilock_excp_offset = ex3_ilock_excp_offset + 1;
parameter ex2_ehpriv_excp_offset = ex4_ilock_excp_offset + 1;
parameter ex3_ehpriv_excp_offset = ex2_ehpriv_excp_offset + 1;
parameter ex4_cache_acc_offset = ex3_ehpriv_excp_offset + 1;
parameter ex4_ucode_val_offset = ex4_cache_acc_offset + 1;
parameter ex4_ucode_cnt_offset = ex4_ucode_val_offset + 1;
parameter ex5_wNComp_rcvd_offset = ex4_ucode_cnt_offset + `UCODE_ENTRIES_ENC;
parameter ex6_wNComp_excp_offset = ex5_wNComp_rcvd_offset + 1;
parameter ex5_dac_int_det_offset = ex6_wNComp_excp_offset + 1;
parameter perv_fir_rpt_offset = ex5_dac_int_det_offset + 1;
parameter ucode_cnt_val_offset = perv_fir_rpt_offset + 7;
parameter ucode_cnt_2ucode_offset = ucode_cnt_val_offset + UCODEDEPTH;
parameter ucode_cnt_memAttr_offset = ucode_cnt_2ucode_offset + UCODEDEPTH;
parameter scan_right = ucode_cnt_memAttr_offset + 9*UCODEDEPTH - 1;
wire tiup;
wire tidn;
wire [0:scan_right] siv;
wire [0:scan_right] sov;
(* analysis_not_referenced="true" *)
wire unused;
//--!! Bugspray Include: lq_fgen
// #############################################
// Inputs
// #############################################
assign tiup = 1'b1;
assign tidn = 1'b0;
assign ex4_derat_vf_int = ((ex4_cache_acc_q | ex4_ucode_val_q) & derat_dcc_ex4_vf) & ~(ex4_blkable_touch | ex4_strg_gate | ex4_wclr_all_val);
assign ex5_derat_multihit_flush_d = derat_dcc_ex4_multihit_err_flush & ~ex4_cp_flush_val;
assign ex5_derat_multihit_det_d = derat_dcc_ex4_multihit_err_det;
assign ex5_derat_perr_flush_d = derat_dcc_ex4_par_err_flush & ~ex4_cp_flush_val;
assign ex5_derat_perr_det_d = derat_dcc_ex4_par_err_det;
assign ex2_sfx_excpt_det_d = dec_dcc_ex1_expt_det & ~ex1_cp_flush_val;
assign ex3_sfx_excpt_det_d = ex2_sfx_excpt_det_q & ~ex2_cp_flush_val;
assign ex4_sfx_excpt_det_d = ex3_sfx_excpt_det_q & ~ex3_cp_flush_val;
assign ex2_priv_prog_d = dec_dcc_ex1_priv_prog;
assign ex3_priv_prog_d = ex2_priv_prog_q;
assign ex4_priv_prog_d = ex3_priv_prog_q & ex3_sfx_excpt_det_q & ~ex3_cp_flush_val;
assign ex2_hypv_prog_d = dec_dcc_ex1_hypv_prog;
assign ex3_hypv_prog_d = ex2_hypv_prog_q;
assign ex4_hypv_prog_d = (ex3_hypv_prog_q | ex3_ehpriv_excp_q) & ex3_sfx_excpt_det_q & ~ex3_cp_flush_val;
assign ex2_illeg_prog_d = dec_dcc_ex1_illeg_prog;
assign ex3_illeg_prog_d = ex2_illeg_prog_q;
assign ex4_illeg_prog_d = ((ex3_illeg_prog_q & ex3_sfx_excpt_det_q) | ex3_illeg_lswx) & ~ex3_cp_flush_val;
assign ex2_dlock_excp_d = dec_dcc_ex1_dlock_excp;
assign ex3_dlock_excp_d = ex2_dlock_excp_q;
assign ex4_dlock_excp_d = ex3_dlock_excp_q & ex3_sfx_excpt_det_q & ~ex3_cp_flush_val;
assign ex2_ilock_excp_d = dec_dcc_ex1_ilock_excp;
assign ex3_ilock_excp_d = ex2_ilock_excp_q;
assign ex4_ilock_excp_d = ex3_ilock_excp_q & ex3_sfx_excpt_det_q & ~ex3_cp_flush_val;
assign ex2_ehpriv_excp_d = dec_dcc_ex1_ehpriv_excp;
assign ex3_ehpriv_excp_d = ex2_ehpriv_excp_q;
assign ex4_ucode_val_d = ex3_ucode_val & ~ex3_cp_flush_val;
assign ex4_ucode_cnt_d = ex3_ucode_cnt;
assign ex4_is_dcbz_d = ex3_dcbz_instr & ex3_cache_acc & ~ex3_cp_flush_val;
assign ex4_cache_acc_d = ex3_cache_acc & ~ex3_cp_flush_val;
// XUCR[FLSTA] = '0' => Flush to ucode
// XUCR[FLSTA] = '1' => Flush to Alignment Interrupt
// XUCR[AFLSTA] = '0' => Flush to ucode (AXUop)
// XUCR[AFLSTA] = '1' => Flush to Alignment Interrupt (AXUop)
assign force_align_int_a = ex3_axu_op_val & (spr_xucr0_aflsta | ex3_ldst_fexcpt);
assign force_align_int_x = ~ex3_axu_op_val & spr_xucr0_flsta;
assign force_align_int = force_align_int_x | force_align_int_a | ex3_resv_instr | ex3_ldawx_instr | ex3_mword_instr;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// UCODE Memory Attributes Array
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
generate
if (`THREADS_POOL_ENC == 0) begin : tid1
wire [0:`THREADS_POOL_ENC] ex0_i0_enc_tid;
wire [0:`THREADS_POOL_ENC] ex0_i1_enc_tid;
wire [0:`THREADS_POOL_ENC] ex3_enc_tid;
wire [0:`THREADS_POOL_ENC] ex4_enc_tid;
assign ex0_i0_tid_ucode_cnt = ex0_i0_ucode_cnt;
assign ex0_i1_tid_ucode_cnt = ex0_i1_ucode_cnt;
assign ex3_tid_ucode_cnt = ex3_ucode_cnt;
assign ex4_tid_ucode_cnt = ex4_ucode_cnt_q;
assign ex0_i0_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] = tidn;
assign ex0_i1_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] = tidn;
assign ex3_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] = tidn;
assign ex4_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] = tidn;
assign unused = ex0_i0_enc_tid[`THREADS_POOL_ENC] | ex0_i1_enc_tid[`THREADS_POOL_ENC] | ex3_enc_tid[`THREADS_POOL_ENC] | ex4_enc_tid[`THREADS_POOL_ENC];
end
endgenerate
generate
if (`THREADS_POOL_ENC > 0) begin : tidMulti
reg [0:`THREADS_POOL_ENC] ex0_i0_enc_tid;
reg [0:`THREADS_POOL_ENC] ex0_i1_enc_tid;
reg [0:`THREADS_POOL_ENC] ex3_enc_tid;
reg [0:`THREADS_POOL_ENC] ex4_enc_tid;
always @(*) begin: tidEnc
reg [0:`THREADS_POOL_ENC-1] i0Tid;
reg [0:`THREADS_POOL_ENC-1] i1Tid;
reg [0:`THREADS_POOL_ENC-1] ex3Tid;
reg [0:`THREADS_POOL_ENC-1] ex4Tid;
//(* analysis_not_referenced="true" *)
reg [0:31] tid;
i0Tid = {`THREADS_POOL_ENC{1'b0}};
i1Tid = {`THREADS_POOL_ENC{1'b0}};
ex3Tid = {`THREADS_POOL_ENC{1'b0}};
ex4Tid = {`THREADS_POOL_ENC{1'b0}};
ex0_i0_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] <= tidn;
ex0_i1_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] <= tidn;
ex3_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] <= tidn;
ex4_enc_tid[`THREADS_POOL_ENC:`THREADS_POOL_ENC] <= tidn;
for (tid=0; tid<`THREADS; tid=tid+1) begin
i0Tid = (tid[32-`THREADS_POOL_ENC:31] & {`THREADS_POOL_ENC{ex0_i0_vld[tid]}}) | i0Tid;
i1Tid = (tid[32-`THREADS_POOL_ENC:31] & {`THREADS_POOL_ENC{ex0_i1_vld[tid]}}) | i1Tid;
ex3Tid = (tid[32-`THREADS_POOL_ENC:31] & {`THREADS_POOL_ENC{ex3_thrd_id[tid]}}) | ex3Tid;
ex4Tid = (tid[32-`THREADS_POOL_ENC:31] & {`THREADS_POOL_ENC{ex4_thrd_id[tid]}}) | ex4Tid;
end
ex0_i0_enc_tid[0:`THREADS_POOL_ENC-1] <= i0Tid;
ex0_i1_enc_tid[0:`THREADS_POOL_ENC-1] <= i1Tid;
ex3_enc_tid[0:`THREADS_POOL_ENC-1] <= ex3Tid;
ex4_enc_tid[0:`THREADS_POOL_ENC-1] <= ex4Tid;
end
assign ex0_i0_tid_ucode_cnt = {ex0_i0_enc_tid[0:`THREADS_POOL_ENC-1], ex0_i0_ucode_cnt};
assign ex0_i1_tid_ucode_cnt = {ex0_i1_enc_tid[0:`THREADS_POOL_ENC-1], ex0_i1_ucode_cnt};
assign ex3_tid_ucode_cnt = {ex3_enc_tid[0:`THREADS_POOL_ENC-1], ex3_ucode_cnt};
assign ex4_tid_ucode_cnt = {ex4_enc_tid[0:`THREADS_POOL_ENC-1], ex4_ucode_cnt_q};
assign unused = ex0_i0_enc_tid[`THREADS_POOL_ENC] | ex0_i1_enc_tid[`THREADS_POOL_ENC] | ex3_enc_tid[`THREADS_POOL_ENC] | ex4_enc_tid[`THREADS_POOL_ENC];
end
endgenerate
generate begin : memAttrQ
genvar ucodeEntry;
for (ucodeEntry=0; ucodeEntry<UCODEDEPTH; ucodeEntry=ucodeEntry+1) begin : memAttrQ
wire [0:`UCODE_ENTRIES_ENC+`THREADS_POOL_ENC-1] ucodeEntryDummy = ucodeEntry;
// Detect PreIssue of ucode for a given ucode engine entry
assign ex0_i0_ucode_cnt_entry[ucodeEntry] = (ucodeEntryDummy == ex0_i0_tid_ucode_cnt);
assign ex0_i0_ucode_cnt_start[ucodeEntry] = ex0_i0_ucode_cnt_entry[ucodeEntry] & |(ex0_i0_vld) & ex0_i0_ucode_preissue;
assign ex0_i1_ucode_cnt_entry[ucodeEntry] = (ucodeEntryDummy == ex0_i1_tid_ucode_cnt);
assign ex0_i1_ucode_cnt_start[ucodeEntry] = ex0_i1_ucode_cnt_entry[ucodeEntry] & |(ex0_i1_vld) & ex0_i1_ucode_preissue;
// Want to reset the ucode engine entry Valid on a PreIssue from Dispatch
assign ex0_ucode_cnt_rst[ucodeEntry] = ex0_i0_ucode_cnt_start[ucodeEntry] | ex0_i1_ucode_cnt_start[ucodeEntry];
// Want to Set the ucode engine entry Valid on either the PreIssue or the first ucode instruction from Issue
// Dont want to set valid if we got an ERAT Miss or a Restart from the ERAT
assign ex3_ucode_cnt_entry[ucodeEntry] = (ucodeEntryDummy == ex3_tid_ucode_cnt);
assign ex4_ucode_cnt_entry[ucodeEntry] = (ucodeEntryDummy == ex4_tid_ucode_cnt);
assign ex4_ucode_cnt_set[ucodeEntry] = ex4_ucode_cnt_entry[ucodeEntry] & ex4_ucode_val_q & ~(ucode_cnt_val_q[ucodeEntry] | derat_dcc_ex4_restart | derat_dcc_ex4_miss | ex4_strg_gate);
// Control for ucode engine entry Valid
// We should never see cnt_rst and cnt_set at the same time
assign ucode_cnt_ctrl[ucodeEntry] = {ex0_ucode_cnt_rst[ucodeEntry], ex4_ucode_cnt_set[ucodeEntry]};
assign ucode_cnt_val_d[ucodeEntry] = (ucode_cnt_ctrl[ucodeEntry] == 2'b00) ? ucode_cnt_val_q[ucodeEntry] :
(ucode_cnt_ctrl[ucodeEntry] == 2'b01) ? 1'b1 :
1'b0;
// Control for 2ucode, should only be set on the PreIssue of the ucode instruction
// We should never set i0_cnt_start and i1_cnt_start for the same ucodeEntry
assign ucode_cnt_2ucode_ctrl[ucodeEntry] = {ex0_i0_ucode_cnt_start[ucodeEntry], ex0_i1_ucode_cnt_start[ucodeEntry]};
assign ucode_cnt_2ucode_d[ucodeEntry] = (ucode_cnt_2ucode_ctrl[ucodeEntry] == 2'b10) ? ex0_i0_2ucode :
(ucode_cnt_2ucode_ctrl[ucodeEntry] == 2'b01) ? ex0_i1_2ucode :
ucode_cnt_2ucode_q[ucodeEntry];
// 2ucode Mux Select, want to gate misalignment flush2ucode check on a ucode preIssue
// that was already flushed2ucode due to misalignment
assign ex3_2ucode_cnt_set[ucodeEntry] = ucode_cnt_2ucode_q[ucodeEntry] & ex3_ucode_cnt_entry[ucodeEntry];
// Want to update the memory attribute bits when the Valid is set
assign ucode_cnt_memAttr_d[ucodeEntry] = ex4_mem_attr;
// ucode Alignment Interrupt detect
assign ex4_ucode_align_int[ucodeEntry] = (ucode_cnt_memAttr_q[ucodeEntry] != ex4_mem_attr) & ucode_cnt_val_q[ucodeEntry] & ex4_ucode_cnt_entry[ucodeEntry] & ex4_ucode_op & ex4_cache_acc_q;
// ucode Restart detected
// need to wait for preIssue to update the memory attribute bits
// was hitting a case where
// 1) second page loads updated memory attribute bits
// 2) first page and second page memory attributes bits differ
// 3) second page should be causing a DSI and test expects a DSI
// 4) first page access was causing an alignment interrupt because memory attributes differed,
// should have caused a DSI instead
assign ex4_ucode_cnt_restart[ucodeEntry] = ex4_ucode_cnt_entry[ucodeEntry] & ex4_ucode_op & ex4_cache_acc_q & ~ucode_cnt_val_q[ucodeEntry];
end
end
endgenerate
assign ex4_ucode_align_val = |(ex4_ucode_align_int);
assign ex4_ucode_restart = |(ex4_ucode_cnt_restart);
assign ex3_2ucode_set = |(ex3_2ucode_cnt_set);
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Exception Calculations
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// FP, VEC, AP not available
assign ex4_axu_ap_unavail_d = (ex3_cache_acc | ex3_ucode_val) & ex3_axu_op_val & ex3_axu_instr_type[0] & ~(spr_ccr2_ap | ex3_cp_flush_val);
assign ex4_axu_spv_unavail_d = (ex3_cache_acc | ex3_ucode_val) & ex3_axu_op_val & ex3_axu_instr_type[1] & ~(spr_msr_spv | ex3_cp_flush_val);
assign ex4_axu_fp_unavail_d = (ex3_cache_acc | ex3_ucode_val) & ex3_axu_op_val & ex3_axu_instr_type[2] & ~(spr_msr_fp | ex3_cp_flush_val);
// Operation translated to either Write-Through or Cache-Inhibited
assign ex4_wt_ci_trans = derat_dcc_ex4_wimge_w | derat_dcc_ex4_wimge_i;
// ################################################################################################################
// Alignment Interrupt
// 1) Load/Store is not aligned and FLSTA/AFLSTA bit is set
// 2) Unaligned lwarx,ldarx,stwcx, or stdcx
// 3) Unaligned ldawx
// 4) Unaligned AXU operation and fexcpt is set
// 5) dcbz translates to write through required or cache-inhibit
// ################################################################################################################
// ########################
// Unaligned Operation crossing the operand's size
// ########################
// Crossing the Operand Size boundary, only used to determine alignment interrupt if FLSTA = 1 or is_lock_instruction
assign ex3_op16_unal = ex3_optype16 & (ex3_eff_addr[60] | ex3_eff_addr[61] | ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_op8_unal = ex3_optype8 & (ex3_eff_addr[61] | ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_op4_unal = ex3_optype4 & (ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_op2_unal = ex3_optype2 & ex3_eff_addr[63];
assign ex3_unal_op = ex3_op16_unal | ex3_op8_unal | ex3_op4_unal | ex3_op2_unal;
// ########################
// ########################
// Unaligned ICSWX crossing the 64Byte boundary
// ########################
// icswx crossing the 128 byte boundary
assign ex3_icswx_unal = ex3_icswx_type & |(ex3_eff_addr);
// ########################
// Unaligned Operation crossing a 16 Byte boundary
// ########################
assign ex3_16Bop16_unal = ex3_optype16 & (ex3_eff_addr[60] | ex3_eff_addr[61] | ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_16Bop8_unal = ex3_optype8 & ex3_eff_addr[60] & (ex3_eff_addr[61] | ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_16Bop4_unal = ex3_optype4 & ex3_eff_addr[60] & ex3_eff_addr[61] & (ex3_eff_addr[62] | ex3_eff_addr[63]);
assign ex3_16Bop2_unal = ex3_optype2 & ex3_eff_addr[60] & ex3_eff_addr[61] & ex3_eff_addr[62] & ex3_eff_addr[63];
assign ex3_16Bunal_op = ex3_16Bop16_unal | ex3_16Bop8_unal | ex3_16Bop4_unal | ex3_16Bop2_unal;
// Flush to uCode if ucode supports unalignment
assign ex3_flush_2ucode_chk = ex3_cache_acc | (ex3_ucode_val & ~ex3_2ucode_set);
assign ex3_flush_2ucode = (~(ex3_resv_instr | ex3_ldawx_instr | ex3_mword_instr | ex3_icswx_type)) & ex3_16Bunal_op & ex3_flush_2ucode_chk & ~ex3_cp_flush_val;
assign ex4_flush_2ucode_d = ex3_flush_2ucode & ~spr_ccr2_ucode_dis;
assign ex4_ucode_dis_prog_d = ex3_flush_2ucode & spr_ccr2_ucode_dis & ~ex3_cp_flush_val;
assign ex5_flush_2ucode_d = ex4_flush_2ucode_q & ~(ex4_cp_flush_val | ex4_cp_next_excp_rpt | ex4_non_cp_next_excp | ex4_restart_val);
// Alignment Interrupt Collected
assign ex4_prealign_int_d = (ex3_icswx_unal | (force_align_int & (ex3_unal_op | ex3_16Bunal_op))) & (ex3_cache_acc | ex3_ucode_val) & ~ex3_cp_flush_val;
// DCBZ translated to Write-Through or Cache-Inhibited.
assign ex4_dcbz_err = ex4_is_dcbz_q & ex4_wt_ci_trans;
assign ex4_align_int = ex4_prealign_int_q | ((ex4_dcbz_err | ex4_ucode_align_val) & ~derat_dcc_ex4_miss);
// ########################
assign ex5_misalign_flush_d = (ex4_flush_2ucode_q & ~ex4_restart_val) | ex4_prealign_int_q;
// ################################################################################################################
// ################################################################################################################
// Data Storage Interrupt
// 1) lwarx,ldarx,stwcx, or stdcx translate to write through required or cache-inhibit
// ################################################################################################################
// lwarx,ldarx,stwcx,stdcx translate to write-through or cache-inhibit
assign ex3_valid_resv = ex3_resv_instr & ex3_cache_acc & ~ex3_cp_flush_val;
assign ex4_valid_resv_d = ex3_valid_resv;
assign ex4_dsi_int = ex4_valid_resv_q & ex4_wt_ci_trans & ~derat_dcc_ex4_miss;
// ################################################################################################################
// #############################################
// FLUSH CONDITIONS
// #############################################
// ex1 Instruction Flush
assign ex1_cp_flush_val = |(ex1_thrd_id & iu_lq_cp_flush);
// ex2 Instruction Flush and ex2 Speculative Flush
assign ex2_cp_flush_val = |(ex2_thrd_id & iu_lq_cp_flush) | byp_dcc_ex2_req_aborted;
// ex3 Instruction Flush
assign ex3_cp_flush_val = |(ex3_thrd_id & iu_lq_cp_flush);
// ex4 Instruction Flush
// CP_FLUSH should be the only thing coming into this
// this is getting used by the slowspr partition
// If something else needs to go in here, need to create
// a special one for the slowspr partition
assign ex4_cp_flush_val = |(ex4_thrd_id & iu_lq_cp_flush);
// ex5 Instruction Flush
assign ex5_cp_flush_val = |(ex5_thrd_id & iu_lq_cp_flush);
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// ex1 Flush Stage
// 1) Instruction Flush from Completion
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
assign fgen_ex1_stg_flush = ex1_cp_flush_val;
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// ex2 Flush Stage
// 1) Instruction Flush from Completion
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
assign fgen_ex2_stg_flush = ex2_cp_flush_val;
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// ex3 Flush Stage
// 1) Instruction Flush from Completion
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
assign fgen_ex3_stg_flush = ex3_cp_flush_val;
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// ex4 Flush Stage takes into account the following
// 1) Directory Parity Error
// 2) Cache Parity Error
// 3) Directory Multiple ways hit
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
assign ex4_tlb_flush_req = ex4_tlb_perr_flush | ex4_tlb_lru_perr_flush | ex4_tlb_multihit_flush;
assign ex5_tlb_flush_req_d = ex4_tlb_flush_req;
assign ex5_tlb_mchk_req_d = |(ex4_excp_pri[12:14]);
assign ex4_n_flush_req = (ex4_flush_2ucode_q | ex4_dac_int_det | ex4_tlb_flush_req) & ~ex4_restart_val;
assign ex5_flush_req_mchk = |(ex5_excp_pri);
assign ex5_flush_req_int = ex5_derat_perr_flush | ex5_dir_perr_flush | ex5_dc_perr_flush | ex5_derat_multihit_flush | ex5_dir_multihit_flush | dir_dcc_ex5_stp_flush;
assign ex4_local_flush = (ex4_n_flush_req & ~ex4_cp_next_excp_det) | ex4_cp_next_excp_rpt | ex4_non_cp_next_excp;
// Currently a placeholder in case the STQ ever needs to report an exception
assign ex4_excp_det = ex4_local_flush;
assign ex5_local_flush_d = ex4_local_flush;
assign ex5_local_flush = ex5_local_flush_q | ex5_flush_req_int;
assign ex5_dac_int_det_d = ex4_dac_int_det;
// Exception Priority
// POWERPC ARCHITECTURE EXCEPTION PRIORITY
//ex4_excp_pri <=
//ex4_illeg_prog_q & -- 0 illegal instr type Non CP_NEXT
//ex4_priv_prog_q & -- 1 Privilege Non CP_NEXT
//ex4_axu_fp_unavail_q & -- 2 FP Unavailable Non CP_NEXT
//ex4_axu_ap_unavail_q & -- 3 AP Unavailable Non CP_NEXT
//ex4_axu_spv_unavail_q & -- 4 Vector Unavailable Non CP_NEXT
//ex4_ucode_dis_prog_q & -- 5 Ucode Disabled Program Interrupt Non CP_NEXT
//ex4_hypv_prog_q & -- 6 Hypervisor Privilege Non CP_NEXT
//'0' & -- 7 DERAT Parity Non CP_NEXT
//'0' & -- 8 Data Dir Parity Error Non CP_NEXT
//'0' & -- 9 Data Cache Parity Error Non CP_NEXT
//'0' & -- 10 DERAT Multihit Non CP_NEXT
//'0' & -- 11 Data Dir Multihit Non CP_NEXT
//derat_dcc_ex4_tlb_par_err & -- 12 TLB Parity Error CP_NEXT
//derat_dcc_ex4_lru_par_err & -- 13 TLB LRU Parity Error CP_NEXT
//derat_dcc_ex4_tlb_multihit & -- 14 TLB Multihit Error CP_NEXT
//derat_dcc_ex4_tlb_err & -- 15 TLB/DERAT Miss CP_NEXT
//ex4_dlock_excp_q & -- 16 DSI DLOCK Instruction CP_NEXT
//ex4_ilock_excp_q & -- 17 DSI ILOCK Instruction CP_NEXT
//derat_dcc_ex4_pt_fault & -- 18 DSI Page Table Fault CP_NEXT
//ex4_derat_vf_int & -- 19 DSI Virtualization Fault CP_NEXT
//derat_dcc_ex4_tlb_inelig & -- 20 TLB Ineligible CP_NEXT
//derat_dcc_ex4_dsi & -- 21 DSI R/W Access Violation CP_NEXT
//ex4_dsi_int & -- 22 LARX/STCX DSI CP_NEXT
//ex4_icswx_dsi & -- 23 Unavailable Coprocessor CP_NEXT
//ex4_align_int & -- 24 load/store Alignment CP_NEXT
//derat_dcc_ex4_lrat_miss; -- 25 Data Side LRAT Miss CP_NEXT
// A2I/A2O ARCHITECTURE EXCEPTION PRIORITY
assign ex4_excp_pri = {ex4_illeg_prog_q, // 0 illegal instr type Non CP_NEXT
ex4_priv_prog_q, // 1 Privilege Non CP_NEXT
ex4_axu_fp_unavail_q, // 2 FP Unavailable Non CP_NEXT
ex4_axu_ap_unavail_q, // 3 AP Unavailable Non CP_NEXT
ex4_axu_spv_unavail_q, // 4 Vector Unavailable Non CP_NEXT
ex4_ucode_dis_prog_q, // 5 Ucode Disabled Program Interrupt Non CP_NEXT
ex4_hypv_prog_q, // 6 Hypervisor Privilege Non CP_NEXT
1'b0, // 7 DERAT Parity Non CP_NEXT
1'b0, // 8 Data Dir Parity Error Non CP_NEXT
1'b0, // 9 Data Cache Parity Error Non CP_NEXT
1'b0, // 10 DERAT Multihit Non CP_NEXT
1'b0, // 11 Data Dir Multihit Non CP_NEXT
ex4_tlb_perr_mchk, // 12 TLB Parity Error CP_NEXT
ex4_tlb_lru_perr_mchk, // 13 TLB LRU Parity Error CP_NEXT
ex4_tlb_multihit_mchk, // 14 TLB Multihit Error CP_NEXT
derat_dcc_ex4_tlb_err, // 15 TLB/DERAT Miss CP_NEXT
derat_dcc_ex4_pt_fault, // 16 DSI Page Table Fault CP_NEXT
derat_dcc_ex4_tlb_inelig, // 17 TLB Ineligible CP_NEXT
ex4_dlock_excp_q, // 18 DSI DLOCK Instruction CP_NEXT
ex4_ilock_excp_q, // 19 DSI ILOCK Instruction CP_NEXT
ex4_derat_vf_int, // 20 DSI Virtualization Fault CP_NEXT
derat_dcc_ex4_dsi, // 21 DSI R/W Access Violation CP_NEXT
ex4_dsi_int, // 22 LARX/STCX DSI CP_NEXT
ex4_icswx_dsi, // 23 Unavailable Coprocessor CP_NEXT
ex4_align_int, // 24 load/store Alignment CP_NEXT
derat_dcc_ex4_lrat_miss}; // 25 Data Side LRAT Miss CP_NEXT
// 26 L2 Reload ECC_UE Machine Check Non CP_NEXT Detected by Loadmiss Queue on reload
// Machine Check Enabled Interrupts
assign ex4_tlb_perr_mchk = derat_dcc_ex4_tlb_par_err & spr_xucr4_mmu_mchk;
assign ex4_tlb_lru_perr_mchk = derat_dcc_ex4_lru_par_err & spr_xucr4_mmu_mchk;
assign ex4_tlb_multihit_mchk = derat_dcc_ex4_tlb_multihit & spr_xucr4_mmu_mchk;
assign ex5_derat_perr_mchk = ex5_derat_perr_flush_q & (spr_xucr4_mmu_mchk | spr_ccr2_notlb);
assign ex5_dir_perr_mchk = dir_dcc_ex5_dir_perr_flush & spr_xucr0_mddp;
assign ex5_dc_perr_mchk = dir_dcc_ex5_dc_perr_flush & spr_xucr0_mdcp;
assign ex5_derat_multihit_mchk = ex5_derat_multihit_flush_q & (spr_xucr4_mmu_mchk | spr_ccr2_notlb);
assign ex5_dir_multihit_mchk = dir_dcc_ex5_multihit_flush & spr_xucr4_mddmh;
// N-Flush Generated Scenarios
assign ex4_tlb_perr_flush = derat_dcc_ex4_tlb_par_err;
assign ex4_tlb_lru_perr_flush = derat_dcc_ex4_lru_par_err;
assign ex4_tlb_multihit_flush = derat_dcc_ex4_tlb_multihit;
assign ex5_derat_perr_flush = ex5_derat_perr_flush_q;
assign ex5_dir_perr_flush = dir_dcc_ex5_dir_perr_flush;
assign ex5_dc_perr_flush = dir_dcc_ex5_dc_perr_flush;
assign ex5_derat_multihit_flush = ex5_derat_multihit_flush_q;
assign ex5_dir_multihit_flush = dir_dcc_ex5_multihit_flush;
assign ex4_exception = (ex4_excp_pri[0] == 1'b1) ? 6'b000000 :
(ex4_excp_pri[1] == 1'b1) ? 6'b000001 :
(ex4_excp_pri[2] == 1'b1) ? 6'b000010 :
(ex4_excp_pri[3] == 1'b1) ? 6'b000011 :
(ex4_excp_pri[4] == 1'b1) ? 6'b000100 :
(ex4_excp_pri[5] == 1'b1) ? 6'b000101 :
(ex4_excp_pri[6] == 1'b1) ? 6'b000110 :
(ex4_excp_pri[7] == 1'b1) ? 6'b000111 :
(ex4_excp_pri[8] == 1'b1) ? 6'b001000 :
(ex4_excp_pri[9] == 1'b1) ? 6'b001001 :
(ex4_excp_pri[10] == 1'b1) ? 6'b001010 :
(ex4_excp_pri[11] == 1'b1) ? 6'b001011 :
(ex4_excp_pri[12] == 1'b1) ? 6'b001100 :
(ex4_excp_pri[13] == 1'b1) ? 6'b001101 :
(ex4_excp_pri[14] == 1'b1) ? 6'b001110 :
(ex4_excp_pri[15] == 1'b1) ? 6'b001111 :
(ex4_excp_pri[16] == 1'b1) ? 6'b010000 :
(ex4_excp_pri[17] == 1'b1) ? 6'b010001 :
(ex4_excp_pri[18] == 1'b1) ? 6'b010010 :
(ex4_excp_pri[19] == 1'b1) ? 6'b010011 :
(ex4_excp_pri[20] == 1'b1) ? 6'b010100 :
(ex4_excp_pri[21] == 1'b1) ? 6'b010101 :
(ex4_excp_pri[22] == 1'b1) ? 6'b010110 :
(ex4_excp_pri[23] == 1'b1) ? 6'b010111 :
(ex4_excp_pri[24] == 1'b1) ? 6'b011000 :
6'b011001;
assign ex5_excp_pri = {ex5_derat_perr_mchk, // 7 DERAT Parity
ex5_dir_perr_mchk, // 8 Data Dir Parity Error
ex5_dc_perr_mchk, // 9 Data Cache Parity Error
ex5_derat_multihit_mchk, // 10 DERAT Multihit
ex5_dir_multihit_mchk}; // 11 Data Dir Multihit
assign ex5_mid_pri_excp = (ex5_excp_pri[7] == 1'b1) ? 6'b000111 :
(ex5_excp_pri[8] == 1'b1) ? 6'b001000 :
(ex5_excp_pri[9] == 1'b1) ? 6'b001001 :
(ex5_excp_pri[10] == 1'b1) ? 6'b001010 :
6'b001011;
assign ex5_sel_mid_pri_excp = ex5_flush_req_int & ~ex5_high_pri_excp_q;
assign ex4_non_cp_next_excp = |(ex4_excp_pri[0:11]);
assign ex5_high_pri_excp_d = ex4_non_cp_next_excp & ~ex4_cp_flush_val;
assign ex5_low_pri_excp_d = ex4_cp_next_excp & ~ex4_cp_flush_val;
assign ex4_cp_next_excp = |(ex4_excp_pri[12:25]) & ex4_wNComp_rcvd & ~ex4_restart_val;
assign ex4_cp_next_excp_det = |(ex4_excp_pri[12:25]) & ~ex4_restart_val;
assign ex4_cp_next_excp_rpt = ex4_cp_next_excp;
assign ex4_wNComp_excp = ex4_cp_next_excp_det & ~(ex4_cp_flush_val | ex4_non_cp_next_excp);
assign ex4_sfx_excpt_det = ex4_sfx_excpt_det_q;
// Want to blow away everything when there is a Non-CP_NEXT exception detected
assign ex5_flush_req = ex5_flush_req_int | ex5_high_pri_excp_q;
assign ex5_exception_d = ex4_exception;
// CP_NEXT instruction got a Flush
// need to restart instructions behind it so that the directory
// does not get corrupted, this handles the case where a dcbtls
// got an exception and a lq pipeline instruction behind it bypassed
// the wrong directory results, also needed in case there is a parity
// error in either directory, dataCache, or erats
assign ex5_wNComp_rcvd_d = ex4_wNComp_rcvd;
assign ex5_wNComp_excp = (ex5_wNComp_rcvd_q & ex5_local_flush) | dir_dcc_ex5_dir_perr_det | dir_dcc_ex5_dc_perr_det |
dir_dcc_ex5_multihit_det | ex5_derat_multihit_det_q | ex5_derat_perr_det_q |
dir_dcc_stq4_dir_perr_det | dir_dcc_stq4_multihit_det;
assign ex6_wNComp_excp_d = ex5_wNComp_excp;
assign ex4_wNComp_excp_restart = ex5_wNComp_excp | ex6_wNComp_excp_q;
// Select between EX4 and EX5 Exceptions
assign ex5_exception_int = ~ex5_sel_mid_pri_excp ? ex5_exception_q : ex5_mid_pri_excp;
assign ex5_dear_val_d = ex4_thrd_id & {`THREADS{ex4_cp_next_excp_rpt}};
assign ex5_flush2ucode = ex5_flush_2ucode_q & ~(ex5_flush_req_int | ex5_high_pri_excp_q);
assign ex5_n_flush = ex5_local_flush_q | ex5_flush_req_int;
assign ex5_np1_flush = 1'b0; //'
// Want to take an interrupt if
// 1) high priority interrupt ex4_excp_pri(0:6) => program interrupts, these interrupts ignore any bad machine path errors detected by
// data cache, directory, and erat
// 2) mid priority interrupt ex4_excp_pri(7:11) => machine check enabled and bad machine path error detected by
// data cache, directory, or erat
// 3) mid priority interrupt ex4_excp_pri(12:14) => machine check enabled and bad machine path error detected by the MMU, these exceptions
// are gated if error detected by data cache, directory, or erat and machine check disabled for error
// 4) low priority interrupt ex4_excp_pri(15:25) => translation type interrupts, these exceptions are gated if error detected by
// data cache, directory, mmu, or erat and machine check disabled for error
assign ex5_exception_val = ex5_high_pri_excp_q | ex5_flush_req_mchk | (ex5_tlb_mchk_req_q & ~ex5_flush_req_int) | (ex5_low_pri_excp_q & ~(ex5_flush_req_int | ex5_tlb_flush_req_q));
assign ex5_exception = ex5_exception_int;
assign ex5_dear_val = ex5_dear_val_q;
assign ex5_blk_tlb_req = ex5_high_pri_excp_q | ex5_flush_req_int;
assign fgen_ex4_stg_flush = ex4_cp_flush_val | ex4_n_flush_req | ex4_non_cp_next_excp | ex4_cp_next_excp_det;
assign fgen_ex5_stg_flush = ex5_cp_flush_val | ex5_local_flush | ex5_restart_val | ex5_dac_int_det_q;
assign ex5_flush_pfetch = dir_dcc_ex5_dir_perr_det | dir_dcc_ex5_dc_perr_det | dir_dcc_ex5_multihit_det |
ex5_derat_multihit_det_q | ex5_derat_perr_det_q | dir_dcc_stq4_dir_perr_det |
dir_dcc_stq4_multihit_det;
assign fgen_ex4_cp_flush = ex4_cp_flush_val;
assign fgen_ex5_cp_flush = ex5_cp_flush_val;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// FIR Error Reporting
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
assign perv_fir_rpt_d = {derat_fir_par_err, dir_dcc_ex5_dir_perr_det, dir_dcc_ex5_dc_perr_det, derat_fir_multihit, dir_dcc_ex5_multihit_det, dir_dcc_stq4_dir_perr_det, dir_dcc_stq4_multihit_det};
tri_direct_err_rpt #(.WIDTH(7)) pervFir(
.vd(vdd),
.gd(gnd),
.err_in(perv_fir_rpt_q),
.err_out(perv_fir_rpt)
);
assign lq_pc_err_derat_parity = perv_fir_rpt[0];
assign lq_pc_err_dir_ldp_parity = perv_fir_rpt[1];
assign lq_pc_err_dcache_parity = perv_fir_rpt[2];
assign lq_pc_err_derat_multihit = perv_fir_rpt[3];
assign lq_pc_err_dir_ldp_multihit = perv_fir_rpt[4];
assign lq_pc_err_dir_stp_parity = perv_fir_rpt[5];
assign lq_pc_err_dir_stp_multihit = perv_fir_rpt[6];
// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// Performance Events
// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
assign ex5_misalign_flush = ex5_misalign_flush_q;
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// Registers
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_valid_resv_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_valid_resv_offset]),
.scout(sov[ex4_valid_resv_offset]),
.din(ex4_valid_resv_d),
.dout(ex4_valid_resv_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_prealign_int_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_prealign_int_offset]),
.scout(sov[ex4_prealign_int_offset]),
.din(ex4_prealign_int_d),
.dout(ex4_prealign_int_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_flush_2ucode_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_flush_2ucode_offset]),
.scout(sov[ex4_flush_2ucode_offset]),
.din(ex4_flush_2ucode_d),
.dout(ex4_flush_2ucode_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_flush_2ucode_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_flush_2ucode_offset]),
.scout(sov[ex5_flush_2ucode_offset]),
.din(ex5_flush_2ucode_d),
.dout(ex5_flush_2ucode_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_ucode_dis_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_ucode_dis_prog_offset]),
.scout(sov[ex4_ucode_dis_prog_offset]),
.din(ex4_ucode_dis_prog_d),
.dout(ex4_ucode_dis_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_is_dcbz_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_is_dcbz_offset]),
.scout(sov[ex4_is_dcbz_offset]),
.din(ex4_is_dcbz_d),
.dout(ex4_is_dcbz_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_misalign_flush_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_misalign_flush_offset]),
.scout(sov[ex5_misalign_flush_offset]),
.din(ex5_misalign_flush_d),
.dout(ex5_misalign_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_axu_ap_unavail_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_axu_ap_unavail_offset]),
.scout(sov[ex4_axu_ap_unavail_offset]),
.din(ex4_axu_ap_unavail_d),
.dout(ex4_axu_ap_unavail_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_axu_fp_unavail_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_axu_fp_unavail_offset]),
.scout(sov[ex4_axu_fp_unavail_offset]),
.din(ex4_axu_fp_unavail_d),
.dout(ex4_axu_fp_unavail_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_axu_spv_unavail_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_axu_spv_unavail_offset]),
.scout(sov[ex4_axu_spv_unavail_offset]),
.din(ex4_axu_spv_unavail_d),
.dout(ex4_axu_spv_unavail_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_local_flush_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_local_flush_offset]),
.scout(sov[ex5_local_flush_offset]),
.din(ex5_local_flush_d),
.dout(ex5_local_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_tlb_flush_req_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_tlb_flush_req_offset]),
.scout(sov[ex5_tlb_flush_req_offset]),
.din(ex5_tlb_flush_req_d),
.dout(ex5_tlb_flush_req_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_tlb_mchk_req_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_tlb_mchk_req_offset]),
.scout(sov[ex5_tlb_mchk_req_offset]),
.din(ex5_tlb_mchk_req_d),
.dout(ex5_tlb_mchk_req_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_low_pri_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_low_pri_excp_offset]),
.scout(sov[ex5_low_pri_excp_offset]),
.din(ex5_low_pri_excp_d),
.dout(ex5_low_pri_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_high_pri_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_high_pri_excp_offset]),
.scout(sov[ex5_high_pri_excp_offset]),
.din(ex5_high_pri_excp_d),
.dout(ex5_high_pri_excp_q)
);
tri_rlmreg_p #(.WIDTH(6), .INIT(0), .NEEDS_SRESET(1)) ex5_exception_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(ex4_stg_act),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_exception_offset:ex5_exception_offset + 6 - 1]),
.scout(sov[ex5_exception_offset:ex5_exception_offset + 6 - 1]),
.din(ex5_exception_d),
.dout(ex5_exception_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ex5_dear_val_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_dear_val_offset:ex5_dear_val_offset + `THREADS - 1]),
.scout(sov[ex5_dear_val_offset:ex5_dear_val_offset + `THREADS - 1]),
.din(ex5_dear_val_d),
.dout(ex5_dear_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_derat_multihit_flush_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_derat_multihit_flush_offset]),
.scout(sov[ex5_derat_multihit_flush_offset]),
.din(ex5_derat_multihit_flush_d),
.dout(ex5_derat_multihit_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_derat_multihit_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_derat_multihit_det_offset]),
.scout(sov[ex5_derat_multihit_det_offset]),
.din(ex5_derat_multihit_det_d),
.dout(ex5_derat_multihit_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_derat_perr_flush_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_derat_perr_flush_offset]),
.scout(sov[ex5_derat_perr_flush_offset]),
.din(ex5_derat_perr_flush_d),
.dout(ex5_derat_perr_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_derat_perr_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_derat_perr_det_offset]),
.scout(sov[ex5_derat_perr_det_offset]),
.din(ex5_derat_perr_det_d),
.dout(ex5_derat_perr_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_sfx_excpt_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_sfx_excpt_det_offset]),
.scout(sov[ex2_sfx_excpt_det_offset]),
.din(ex2_sfx_excpt_det_d),
.dout(ex2_sfx_excpt_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_sfx_excpt_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_sfx_excpt_det_offset]),
.scout(sov[ex3_sfx_excpt_det_offset]),
.din(ex3_sfx_excpt_det_d),
.dout(ex3_sfx_excpt_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_sfx_excpt_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_sfx_excpt_det_offset]),
.scout(sov[ex4_sfx_excpt_det_offset]),
.din(ex4_sfx_excpt_det_d),
.dout(ex4_sfx_excpt_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_priv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_priv_prog_offset]),
.scout(sov[ex2_priv_prog_offset]),
.din(ex2_priv_prog_d),
.dout(ex2_priv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_priv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_priv_prog_offset]),
.scout(sov[ex3_priv_prog_offset]),
.din(ex3_priv_prog_d),
.dout(ex3_priv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_priv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_priv_prog_offset]),
.scout(sov[ex4_priv_prog_offset]),
.din(ex4_priv_prog_d),
.dout(ex4_priv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_hypv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_hypv_prog_offset]),
.scout(sov[ex2_hypv_prog_offset]),
.din(ex2_hypv_prog_d),
.dout(ex2_hypv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_hypv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_hypv_prog_offset]),
.scout(sov[ex3_hypv_prog_offset]),
.din(ex3_hypv_prog_d),
.dout(ex3_hypv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_hypv_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_hypv_prog_offset]),
.scout(sov[ex4_hypv_prog_offset]),
.din(ex4_hypv_prog_d),
.dout(ex4_hypv_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_illeg_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_illeg_prog_offset]),
.scout(sov[ex2_illeg_prog_offset]),
.din(ex2_illeg_prog_d),
.dout(ex2_illeg_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_illeg_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_illeg_prog_offset]),
.scout(sov[ex3_illeg_prog_offset]),
.din(ex3_illeg_prog_d),
.dout(ex3_illeg_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_illeg_prog_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_illeg_prog_offset]),
.scout(sov[ex4_illeg_prog_offset]),
.din(ex4_illeg_prog_d),
.dout(ex4_illeg_prog_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_dlock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_dlock_excp_offset]),
.scout(sov[ex2_dlock_excp_offset]),
.din(ex2_dlock_excp_d),
.dout(ex2_dlock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_dlock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_dlock_excp_offset]),
.scout(sov[ex3_dlock_excp_offset]),
.din(ex3_dlock_excp_d),
.dout(ex3_dlock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_dlock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_dlock_excp_offset]),
.scout(sov[ex4_dlock_excp_offset]),
.din(ex4_dlock_excp_d),
.dout(ex4_dlock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_ilock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_ilock_excp_offset]),
.scout(sov[ex2_ilock_excp_offset]),
.din(ex2_ilock_excp_d),
.dout(ex2_ilock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_ilock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_ilock_excp_offset]),
.scout(sov[ex3_ilock_excp_offset]),
.din(ex3_ilock_excp_d),
.dout(ex3_ilock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_ilock_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_ilock_excp_offset]),
.scout(sov[ex4_ilock_excp_offset]),
.din(ex4_ilock_excp_d),
.dout(ex4_ilock_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex2_ehpriv_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex2_ehpriv_excp_offset]),
.scout(sov[ex2_ehpriv_excp_offset]),
.din(ex2_ehpriv_excp_d),
.dout(ex2_ehpriv_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex3_ehpriv_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex3_ehpriv_excp_offset]),
.scout(sov[ex3_ehpriv_excp_offset]),
.din(ex3_ehpriv_excp_d),
.dout(ex3_ehpriv_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_cache_acc_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_cache_acc_offset]),
.scout(sov[ex4_cache_acc_offset]),
.din(ex4_cache_acc_d),
.dout(ex4_cache_acc_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_ucode_val_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_ucode_val_offset]),
.scout(sov[ex4_ucode_val_offset]),
.din(ex4_ucode_val_d),
.dout(ex4_ucode_val_q)
);
tri_rlmreg_p #(.WIDTH(`UCODE_ENTRIES_ENC), .INIT(0), .NEEDS_SRESET(1)) ex4_ucode_cnt_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(ex3_stg_act),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex4_ucode_cnt_offset:ex4_ucode_cnt_offset + `UCODE_ENTRIES_ENC - 1]),
.scout(sov[ex4_ucode_cnt_offset:ex4_ucode_cnt_offset + `UCODE_ENTRIES_ENC - 1]),
.din(ex4_ucode_cnt_d),
.dout(ex4_ucode_cnt_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_wNComp_rcvd_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_wNComp_rcvd_offset]),
.scout(sov[ex5_wNComp_rcvd_offset]),
.din(ex5_wNComp_rcvd_d),
.dout(ex5_wNComp_rcvd_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex6_wNComp_excp_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex6_wNComp_excp_offset]),
.scout(sov[ex6_wNComp_excp_offset]),
.din(ex6_wNComp_excp_d),
.dout(ex6_wNComp_excp_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_dac_int_det_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ex5_dac_int_det_offset]),
.scout(sov[ex5_dac_int_det_offset]),
.din(ex5_dac_int_det_d),
.dout(ex5_dac_int_det_q)
);
tri_rlmreg_p #(.WIDTH(7), .INIT(0), .NEEDS_SRESET(1)) perv_fir_rpt_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[perv_fir_rpt_offset:perv_fir_rpt_offset + 7 - 1]),
.scout(sov[perv_fir_rpt_offset:perv_fir_rpt_offset + 7 - 1]),
.din(perv_fir_rpt_d),
.dout(perv_fir_rpt_q)
);
tri_rlmreg_p #(.WIDTH(UCODEDEPTH), .INIT(0), .NEEDS_SRESET(1)) ucode_cnt_val_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ucode_cnt_val_offset:ucode_cnt_val_offset + UCODEDEPTH - 1]),
.scout(sov[ucode_cnt_val_offset:ucode_cnt_val_offset + UCODEDEPTH - 1]),
.din(ucode_cnt_val_d),
.dout(ucode_cnt_val_q)
);
tri_rlmreg_p #(.WIDTH(UCODEDEPTH), .INIT(0), .NEEDS_SRESET(1)) ucode_cnt_2ucode_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(tiup),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ucode_cnt_2ucode_offset:ucode_cnt_2ucode_offset + UCODEDEPTH - 1]),
.scout(sov[ucode_cnt_2ucode_offset:ucode_cnt_2ucode_offset + UCODEDEPTH - 1]),
.din(ucode_cnt_2ucode_d),
.dout(ucode_cnt_2ucode_q)
);
generate begin : ucode_cnt_memAttr
genvar ucodeEntry;
for (ucodeEntry=0; ucodeEntry<UCODEDEPTH; ucodeEntry=ucodeEntry+1) begin : ucode_cnt_memAttr
tri_rlmreg_p #(.WIDTH(9), .INIT(1), .NEEDS_SRESET(1)) ucode_cnt_memAttr_reg(
.vd(vdd),
.gd(gnd),
.nclk(nclk),
.act(ex4_ucode_cnt_set[ucodeEntry]),
.force_t(func_sl_force),
.d_mode(d_mode_dc),
.delay_lclkr(delay_lclkr_dc),
.mpw1_b(mpw1_dc_b),
.mpw2_b(mpw2_dc_b),
.thold_b(func_sl_thold_0_b),
.sg(sg_0),
.scin(siv[ucode_cnt_memAttr_offset + 9*ucodeEntry:ucode_cnt_memAttr_offset + 9*(ucodeEntry+1)-1]),
.scout(sov[ucode_cnt_memAttr_offset + 9*ucodeEntry:ucode_cnt_memAttr_offset + 9*(ucodeEntry+1)-1]),
.din(ucode_cnt_memAttr_d[ucodeEntry]),
.dout(ucode_cnt_memAttr_q[ucodeEntry])
);
end
end
endgenerate
assign siv[0:scan_right] = {sov[1:scan_right], scan_in};
assign scan_out = sov[0];
endmodule