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 'f89d2a0f0c'
${ noResults }
a2o/dev/verilog/work/lq_ldq.v

8404 lines
365 KiB
Verilog
Raw Blame History

// © 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 Store Data Rotator Wrapper
//
//*****************************************************************************
// ##########################################################################################
// Contents
// 1) Load Queue
// 2) Store Queue
// 3) Load/Store Queue Control
// ##########################################################################################
`include "tri_a2o.vh"
module lq_ldq(
rv_lq_vld,
rv_lq_isLoad,
rv_lq_rvs_empty,
ctl_lsq_rv1_dir_rd_val,
l2_back_inv_val,
l2_back_inv_addr,
ctl_lsq_ex3_ldreq_val,
ctl_lsq_ex3_pfetch_val,
ctl_lsq_ex4_ldreq_val,
ctl_lsq_ex4_streq_val,
ctl_lsq_ex4_othreq_val,
ctl_lsq_ex4_p_addr,
ctl_lsq_ex4_itag,
ctl_lsq_ex4_dReq_val,
ctl_lsq_ex4_gath_load,
ctl_lsq_ex4_wimge,
ctl_lsq_ex4_is_sync,
ctl_lsq_ex4_all_thrd_chk,
ctl_lsq_ex4_byte_swap,
ctl_lsq_ex4_is_resv,
ctl_lsq_ex4_thrd_id,
ctl_lsq_ex5_lock_set,
ctl_lsq_ex5_watch_set,
ctl_lsq_ex5_thrd_id,
ctl_lsq_ex5_load_hit,
ctl_lsq_ex5_opsize,
ctl_lsq_ex5_tgpr,
ctl_lsq_ex5_axu_val,
ctl_lsq_ex5_usr_def,
ctl_lsq_ex5_drop_rel,
ctl_lsq_ex5_flush_req,
ctl_lsq_ex5_flush_pfetch,
ctl_lsq_ex5_cmmt_events,
ctl_lsq_ex5_perf_val0,
ctl_lsq_ex5_perf_sel0,
ctl_lsq_ex5_perf_val1,
ctl_lsq_ex5_perf_sel1,
ctl_lsq_ex5_perf_val2,
ctl_lsq_ex5_perf_sel2,
ctl_lsq_ex5_perf_val3,
ctl_lsq_ex5_perf_sel3,
ctl_lsq_ex5_not_touch,
ctl_lsq_ex5_algebraic,
ctl_lsq_ex5_class_id,
ctl_lsq_ex5_dvc,
ctl_lsq_ex5_ttype,
ctl_lsq_ex5_dacrw,
lsq_ctl_ex6_ldq_events,
lsq_perv_ex7_events,
lsq_perv_ldq_events,
ctl_lsq_ex7_thrd_id,
ctl_lsq_pf_empty,
ctl_lsq_spr_dvc1_dbg,
ctl_lsq_spr_dvc2_dbg,
ctl_lsq_spr_dbcr2_dvc1m,
ctl_lsq_spr_dbcr2_dvc1be,
ctl_lsq_spr_dbcr2_dvc2m,
ctl_lsq_spr_dbcr2_dvc2be,
ctl_lsq_dbg_int_en,
ctl_lsq_ldp_idle,
stq_ldq_ex5_stq_restart,
stq_ldq_ex5_stq_restart_miss,
stq_ldq_ex5_fwd_val,
odq_ldq_resolved,
odq_ldq_report_needed,
odq_ldq_report_itag,
odq_ldq_n_flush,
odq_ldq_np1_flush,
odq_ldq_report_tid,
odq_ldq_report_dacrw,
odq_ldq_report_eccue,
odq_ldq_report_pEvents,
odq_ldq_oldest_ld_tid,
odq_ldq_oldest_ld_itag,
odq_ldq_ex7_pfetch_blk,
stq_ldq_empty,
iu_lq_cp_flush,
iu_lq_cp_next_itag,
arb_ldq_ldq_unit_sel,
l2_lsq_resp_isComing,
l2_lsq_resp_val,
l2_lsq_resp_cTag,
l2_lsq_resp_qw,
l2_lsq_resp_crit_qw,
l2_lsq_resp_l1_dump,
l2_lsq_resp_data,
l2_lsq_resp_ecc_err,
l2_lsq_resp_ecc_err_ue,
xu_lq_spr_xucr0_cls,
ctl_lsq_spr_lsucr0_lge,
ctl_lsq_spr_lsucr0_lca,
pc_lq_inj_relq_parity,
ldq_stq_rel1_blk_store,
ldq_stq_ex5_ldm_hit,
ldq_stq_ex5_ldm_entry,
ldq_stq_ldm_cpl,
ldq_stq_stq4_dir_upd,
ldq_stq_stq4_cclass,
lq_rv_itag2_vld,
lq_rv_itag2,
ldq_rel2_byte_swap,
ldq_rel2_data,
ldq_odq_vld,
ldq_odq_pfetch_vld,
ldq_odq_wimge_i,
ldq_odq_ex6_pEvents,
ldq_odq_upd_val,
ldq_odq_upd_itag,
ldq_odq_upd_nFlush,
ldq_odq_upd_np1Flush,
ldq_odq_upd_tid,
ldq_odq_upd_dacrw,
ldq_odq_upd_eccue,
ldq_odq_upd_pEvents,
lq1_iu_execute_vld,
lq1_iu_itag,
lq1_iu_exception_val,
lq1_iu_exception,
lq1_iu_n_flush,
lq1_iu_np1_flush,
lq1_iu_dacr_type,
lq1_iu_dacrw,
lq1_iu_perf_events,
ldq_hold_all_req,
ldq_rv_set_hold,
ldq_rv_clr_hold,
lsq_ctl_ex5_ldq_restart,
ldq_arb_ld_req_pwrToken,
ldq_arb_ld_req_avail,
ldq_arb_tid,
ldq_arb_usr_def,
ldq_arb_wimge,
ldq_arb_p_addr,
ldq_arb_ttype,
ldq_arb_opsize,
ldq_arb_cTag,
ldq_dat_stq1_stg_act,
lsq_dat_rel1_data_val,
lsq_dat_rel1_qw,
ldq_ctl_stq1_stg_act,
lsq_ctl_rel1_clr_val,
lsq_ctl_rel1_set_val,
lsq_ctl_rel1_data_val,
lsq_ctl_rel1_thrd_id,
lsq_ctl_rel1_back_inv,
lsq_ctl_rel1_tag,
lsq_ctl_rel1_classid,
lsq_ctl_rel1_lock_set,
lsq_ctl_rel1_watch_set,
lsq_ctl_rel2_blk_req,
lsq_ctl_rel2_upd_val,
lsq_ctl_rel3_l1dump_val,
lsq_ctl_rel3_clr_relq,
ldq_arb_rel1_data_sel,
ldq_arb_rel1_axu_val,
ldq_arb_rel1_op_size,
ldq_arb_rel1_addr,
ldq_arb_rel1_ci,
ldq_arb_rel1_byte_swap,
ldq_arb_rel1_thrd_id,
ldq_arb_rel1_data,
ldq_arb_rel2_rdat_sel,
ldq_arb_rel2_rd_data,
arb_ldq_rel2_wrt_data,
lsq_ctl_rel1_gpr_val,
lsq_ctl_rel1_ta_gpr,
lsq_ctl_rel1_upd_gpr,
lq_pc_err_invld_reld,
lq_pc_err_l2intrf_ecc,
lq_pc_err_l2intrf_ue,
lq_pc_err_relq_parity,
lq_mm_lmq_stq_empty,
lq_xu_quiesce,
lq_pc_ldq_quiesce,
lq_pc_stq_quiesce,
lq_pc_pfetch_quiesce,
bo_enable_2,
clkoff_dc_b,
g8t_clkoff_dc_b,
g8t_d_mode_dc,
g8t_delay_lclkr_dc,
g8t_mpw1_dc_b,
g8t_mpw2_dc_b,
pc_lq_ccflush_dc,
an_ac_scan_dis_dc_b,
an_ac_scan_diag_dc,
an_ac_lbist_ary_wrt_thru_dc,
pc_lq_abist_ena_dc,
pc_lq_abist_raw_dc_b,
pc_lq_abist_wl64_comp_ena,
pc_lq_abist_raddr_0,
pc_lq_abist_g8t_wenb,
pc_lq_abist_g8t1p_renb_0,
pc_lq_abist_g8t_dcomp,
pc_lq_abist_g8t_bw_1,
pc_lq_abist_g8t_bw_0,
pc_lq_abist_di_0,
pc_lq_abist_waddr_0,
pc_lq_bo_unload,
pc_lq_bo_repair,
pc_lq_bo_reset,
pc_lq_bo_shdata,
pc_lq_bo_select,
lq_pc_bo_fail,
lq_pc_bo_diagout,
vcs,
vdd,
gnd,
clk,
rst,
sg_0,
func_sl_thold_0_b,
func_sl_force,
func_nsl_thold_0_b,
func_nsl_force,
abst_sl_thold_0,
ary_nsl_thold_0,
time_sl_thold_0,
repr_sl_thold_0,
bolt_sl_thold_0,
d_mode_dc,
delay_lclkr_dc,
mpw1_dc_b,
mpw2_dc_b,
scan_in,
abst_scan_in,
time_scan_in,
repr_scan_in,
scan_out,
abst_scan_out,
time_scan_out,
repr_scan_out
);
// RV1 RV Issue Valid
input [0:`THREADS-1] rv_lq_vld;
input rv_lq_isLoad;
// RV is empty indicator
input [0:`THREADS-1] rv_lq_rvs_empty;
// SPR Directory Read Valid
input ctl_lsq_rv1_dir_rd_val;
// Back-Invalidate Valid
input l2_back_inv_val;
input [64-`REAL_IFAR_WIDTH:63-`CL_SIZE] l2_back_inv_addr;
// Load Request Interface
input ctl_lsq_ex3_ldreq_val;
input ctl_lsq_ex3_pfetch_val;
input ctl_lsq_ex4_ldreq_val;
input ctl_lsq_ex4_streq_val;
input ctl_lsq_ex4_othreq_val;
input [64-`REAL_IFAR_WIDTH:63] ctl_lsq_ex4_p_addr;
input [0:`ITAG_SIZE_ENC-1] ctl_lsq_ex4_itag;
input ctl_lsq_ex4_dReq_val;
input ctl_lsq_ex4_gath_load;
input [0:4] ctl_lsq_ex4_wimge;
input ctl_lsq_ex4_is_sync;
input ctl_lsq_ex4_all_thrd_chk;
input ctl_lsq_ex4_byte_swap;
input ctl_lsq_ex4_is_resv;
input [0:`THREADS-1] ctl_lsq_ex4_thrd_id;
input ctl_lsq_ex5_lock_set;
input ctl_lsq_ex5_watch_set;
input [0:`THREADS-1] ctl_lsq_ex5_thrd_id;
input ctl_lsq_ex5_load_hit;
input [0:2] ctl_lsq_ex5_opsize;
input [0:`AXU_SPARE_ENC+`GPR_POOL_ENC+`THREADS_POOL_ENC-1] ctl_lsq_ex5_tgpr;
input ctl_lsq_ex5_axu_val; // XU,AXU type operation
input [0:3] ctl_lsq_ex5_usr_def;
input ctl_lsq_ex5_drop_rel; // L2 only instructions
input ctl_lsq_ex5_flush_req; // Flush request from LDQ/STQ
input ctl_lsq_ex5_flush_pfetch; // Flush Prefetch in EX5
input [0:10] ctl_lsq_ex5_cmmt_events;
input ctl_lsq_ex5_perf_val0;
input [0:3] ctl_lsq_ex5_perf_sel0;
input ctl_lsq_ex5_perf_val1;
input [0:3] ctl_lsq_ex5_perf_sel1;
input ctl_lsq_ex5_perf_val2;
input [0:3] ctl_lsq_ex5_perf_sel2;
input ctl_lsq_ex5_perf_val3;
input [0:3] ctl_lsq_ex5_perf_sel3;
input ctl_lsq_ex5_not_touch;
input ctl_lsq_ex5_algebraic;
input [0:1] ctl_lsq_ex5_class_id;
input [0:1] ctl_lsq_ex5_dvc;
input [0:5] ctl_lsq_ex5_ttype;
input [0:3] ctl_lsq_ex5_dacrw;
output [0:3] lsq_ctl_ex6_ldq_events; // LDQ Pipeline Performance Events
output [0:`THREADS-1] lsq_perv_ex7_events; // LDQ Pipeline Performance Events
output [0:(2*`THREADS)+3] lsq_perv_ldq_events; // REL Pipeline Performance Events
input [0:`THREADS-1] ctl_lsq_ex7_thrd_id;
input [0:`THREADS-1] ctl_lsq_pf_empty;
// Interface with Local SPR's
input [64-(2**`GPR_WIDTH_ENC):63] ctl_lsq_spr_dvc1_dbg;
input [64-(2**`GPR_WIDTH_ENC):63] ctl_lsq_spr_dvc2_dbg;
input [0:2*`THREADS-1] ctl_lsq_spr_dbcr2_dvc1m;
input [0:8*`THREADS-1] ctl_lsq_spr_dbcr2_dvc1be;
input [0:2*`THREADS-1] ctl_lsq_spr_dbcr2_dvc2m;
input [0:8*`THREADS-1] ctl_lsq_spr_dbcr2_dvc2be;
input [0:`THREADS-1] ctl_lsq_dbg_int_en;
input [0:`THREADS-1] ctl_lsq_ldp_idle;
input stq_ldq_ex5_stq_restart;
input stq_ldq_ex5_stq_restart_miss;
input stq_ldq_ex5_fwd_val;
// OrderQ Inputs
input odq_ldq_resolved;
input odq_ldq_report_needed;
input [0:`ITAG_SIZE_ENC-1] odq_ldq_report_itag;
input odq_ldq_n_flush;
input odq_ldq_np1_flush;
input [0:`THREADS-1] odq_ldq_report_tid;
input [0:3] odq_ldq_report_dacrw;
input odq_ldq_report_eccue;
input [0:3] odq_ldq_report_pEvents;
input [0:`THREADS-1] odq_ldq_oldest_ld_tid;
input [0:`ITAG_SIZE_ENC-1] odq_ldq_oldest_ld_itag;
input odq_ldq_ex7_pfetch_blk;
// Store Queue is Empty
input [0:`THREADS-1] stq_ldq_empty;
// Completion Inputs
input [0:`THREADS-1] iu_lq_cp_flush;
input [0:`ITAG_SIZE_ENC*`THREADS-1] iu_lq_cp_next_itag;
// L2 Request Sent
input arb_ldq_ldq_unit_sel;
// L2 Reload
input l2_lsq_resp_isComing;
input l2_lsq_resp_val;
input [0:4] l2_lsq_resp_cTag;
input [57:59] l2_lsq_resp_qw;
input l2_lsq_resp_crit_qw;
input l2_lsq_resp_l1_dump;
input [0:127] l2_lsq_resp_data;
input l2_lsq_resp_ecc_err;
input l2_lsq_resp_ecc_err_ue;
// Data Cache Config
input xu_lq_spr_xucr0_cls; // Data Cache Line Size Mode
// Load Gather Enable Config
input ctl_lsq_spr_lsucr0_lge;
input [0:2] ctl_lsq_spr_lsucr0_lca;
// Inject Reload Data Array Parity Error
input pc_lq_inj_relq_parity;
// Interface to Store Queue
output ldq_stq_rel1_blk_store;
// Store Hit LoadMiss Queue Entries
output [0:`LMQ_ENTRIES-1] ldq_stq_ex5_ldm_hit;
output [0:`LMQ_ENTRIES-1] ldq_stq_ex5_ldm_entry;
output [0:`LMQ_ENTRIES-1] ldq_stq_ldm_cpl;
// Directory Congruence Class Updated
output ldq_stq_stq4_dir_upd;
output [64-(`DC_SIZE-3):57] ldq_stq_stq4_cclass;
// RV Reload Release Dependent ITAGs
output [0:`THREADS-1] lq_rv_itag2_vld;
output [0:`ITAG_SIZE_ENC-1] lq_rv_itag2;
// Physical Register File update data for Reloads
output ldq_rel2_byte_swap;
output [0:127] ldq_rel2_data;
// Load/Store Request was not restarted
output ldq_odq_vld;
output ldq_odq_pfetch_vld;
output ldq_odq_wimge_i;
output [0:3] ldq_odq_ex6_pEvents;
// Update Order Queue Entry when reload is complete and itag is not resolved
output ldq_odq_upd_val;
output [0:`ITAG_SIZE_ENC-1] ldq_odq_upd_itag;
output ldq_odq_upd_nFlush;
output ldq_odq_upd_np1Flush;
output [0:`THREADS-1] ldq_odq_upd_tid;
output [0:3] ldq_odq_upd_dacrw;
output ldq_odq_upd_eccue;
output [0:3] ldq_odq_upd_pEvents;
// Interface to Completion
output [0:`THREADS-1] lq1_iu_execute_vld;
output [0:`ITAG_SIZE_ENC-1] lq1_iu_itag;
output lq1_iu_exception_val;
output [0:5] lq1_iu_exception;
output lq1_iu_n_flush;
output lq1_iu_np1_flush;
output lq1_iu_dacr_type;
output [0:3] lq1_iu_dacrw;
output [0:3] lq1_iu_perf_events;
// Reservation station hold indicator
output ldq_hold_all_req;
// Reservation station set barrier indicator
output ldq_rv_set_hold;
output [0:`THREADS-1] ldq_rv_clr_hold;
// LOADMISS Queue RESTART indicator
output lsq_ctl_ex5_ldq_restart;
// LDQ Request to the L2
output ldq_arb_ld_req_pwrToken;
output ldq_arb_ld_req_avail;
output [0:1] ldq_arb_tid;
output [0:3] ldq_arb_usr_def;
output [0:4] ldq_arb_wimge;
output [64-`REAL_IFAR_WIDTH:63] ldq_arb_p_addr;
output [0:5] ldq_arb_ttype;
output [0:2] ldq_arb_opsize;
output [0:4] ldq_arb_cTag;
// RELOAD Data Control
output ldq_dat_stq1_stg_act; // ACT Pin for DAT
output lsq_dat_rel1_data_val;
output [57:59] lsq_dat_rel1_qw; // RELOAD Data Quadword
// RELOAD Directory Control
output ldq_ctl_stq1_stg_act; // ACT Pin for CTL
output lsq_ctl_rel1_clr_val; // Reload Data is valid, need to Pick a Way to update
output lsq_ctl_rel1_set_val; // Reload Data is valid for last beat, update Directory Contents and set Valid
output lsq_ctl_rel1_data_val; // Reload Data is Valid, need to update Way in Data Cache
output [0:`THREADS-1] lsq_ctl_rel1_thrd_id; // Reload Thread ID for initial requester
output lsq_ctl_rel1_back_inv; // Reload was Back-Invalidated
output [0:3] lsq_ctl_rel1_tag; // Reload Tag
output [0:1] lsq_ctl_rel1_classid; // Used to index into xucr2 RMT table
output lsq_ctl_rel1_lock_set; // Reload is for a dcbt[st]ls instruction
output lsq_ctl_rel1_watch_set; // Reload is for a ldawx. instruction
output lsq_ctl_rel2_blk_req; // Block Reload due to RV issue or Back-Invalidate
output lsq_ctl_rel2_upd_val; // all 8 data beats have transferred without error, set valid in dir
output lsq_ctl_rel3_l1dump_val; // Reload Complete for an L1_DUMP reload
output lsq_ctl_rel3_clr_relq; // Reload Complete due to an ECC error
// Control Common to Reload and Commit Pipes
output ldq_arb_rel1_data_sel;
output ldq_arb_rel1_axu_val;
output [0:2] ldq_arb_rel1_op_size;
output [64-`REAL_IFAR_WIDTH:63] ldq_arb_rel1_addr;
output ldq_arb_rel1_ci;
output ldq_arb_rel1_byte_swap;
output [0:`THREADS-1] ldq_arb_rel1_thrd_id;
output [0:127] ldq_arb_rel1_data;
output ldq_arb_rel2_rdat_sel;
output [0:143] ldq_arb_rel2_rd_data;
input [0:143] arb_ldq_rel2_wrt_data;
// RELOAD Register Control
output lsq_ctl_rel1_gpr_val; // Critical Quadword requires an update of the Regfile
output [0:`AXU_SPARE_ENC+`GPR_POOL_ENC+`THREADS_POOL_ENC-1] lsq_ctl_rel1_ta_gpr; // Reload Target Register
output lsq_ctl_rel1_upd_gpr; // Critical Quadword did not get and ECC error in REL1
// Interface to Pervasive Unit
output lq_pc_err_invld_reld; // Reload detected without Loadmiss waiting for reload or got extra beats for cacheable request
output lq_pc_err_l2intrf_ecc; // Reload detected with an ECC error
output lq_pc_err_l2intrf_ue; // Reload detected with an uncorrectable ECC error
output lq_pc_err_relq_parity; // Reload Data Queue Parity Error Detected
// Thread Quiesced
output [0:`THREADS-1] lq_xu_quiesce; // Thread is Quiesced
output [0:`THREADS-1] lq_pc_ldq_quiesce;
output [0:`THREADS-1] lq_pc_stq_quiesce;
output [0:`THREADS-1] lq_pc_pfetch_quiesce;
// Interface to MMU
output lq_mm_lmq_stq_empty; // Load and Store Queue is empty
// Array Pervasive Controls
input bo_enable_2;
input clkoff_dc_b;
input g8t_clkoff_dc_b;
input g8t_d_mode_dc;
input [0:4] g8t_delay_lclkr_dc;
input [0:4] g8t_mpw1_dc_b;
input g8t_mpw2_dc_b;
input pc_lq_ccflush_dc;
input an_ac_scan_dis_dc_b;
input an_ac_scan_diag_dc;
input an_ac_lbist_ary_wrt_thru_dc;
input pc_lq_abist_ena_dc;
input pc_lq_abist_raw_dc_b;
input pc_lq_abist_wl64_comp_ena;
input [3:8] pc_lq_abist_raddr_0;
input pc_lq_abist_g8t_wenb;
input pc_lq_abist_g8t1p_renb_0;
input [0:3] pc_lq_abist_g8t_dcomp;
input pc_lq_abist_g8t_bw_1;
input pc_lq_abist_g8t_bw_0;
input [0:3] pc_lq_abist_di_0;
input [4:9] pc_lq_abist_waddr_0;
input pc_lq_bo_unload;
input pc_lq_bo_repair;
input pc_lq_bo_reset;
input pc_lq_bo_shdata;
input [8:9] pc_lq_bo_select;
output [8:9] lq_pc_bo_fail;
output [8:9] lq_pc_bo_diagout;
// Pervasive
inout vcs;
inout vdd;
inout gnd;
input clk;
input rst;
input sg_0;
input func_sl_thold_0_b;
input func_sl_force;
input func_nsl_thold_0_b;
input func_nsl_force;
input abst_sl_thold_0;
input ary_nsl_thold_0;
input time_sl_thold_0;
input repr_sl_thold_0;
input bolt_sl_thold_0;
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_IN/" *)
input abst_scan_in;
(* pin_data="PIN_FUNCTION=/SCAN_IN/" *)
input time_scan_in;
(* pin_data="PIN_FUNCTION=/SCAN_IN/" *)
input repr_scan_in;
(* pin_data="PIN_FUNCTION=/SCAN_OUT/" *)
output scan_out;
(* pin_data="PIN_FUNCTION=/SCAN_OUT/" *)
output abst_scan_out;
(* pin_data="PIN_FUNCTION=/SCAN_OUT/" *)
output time_scan_out;
(* pin_data="PIN_FUNCTION=/SCAN_OUT/" *)
output repr_scan_out;
//--------------------------
// components
//--------------------------
//--------------------------
// signals
//--------------------------
parameter numGrps = ((((`LMQ_ENTRIES-1)/4)+1)*4);
parameter AXU_TARGET_ENC = `AXU_SPARE_ENC + `GPR_POOL_ENC + `THREADS_POOL_ENC;
wire [0:`LMQ_ENTRIES-1] ldqe_dRel_d;
wire [0:`LMQ_ENTRIES-1] ldqe_dRel_q;
wire [0:1] ldqe_dGpr_cntrl[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_dGpr_d;
wire [0:`LMQ_ENTRIES-1] ldqe_dGpr_q;
wire [0:`THREADS-1] ldqe_thrd_id_d[0:`LMQ_ENTRIES-1];
wire [0:`THREADS-1] ldqe_thrd_id_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_wimge_i;
wire [0:`LMQ_ENTRIES-1] ldqe_wimge_g;
wire [0:4] ldqe_wimge_d[0:`LMQ_ENTRIES-1];
wire [0:4] ldqe_wimge_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_byte_swap_d;
wire [0:`LMQ_ENTRIES-1] ldqe_byte_swap_q;
wire [0:`LMQ_ENTRIES-1] ldqe_resv_d;
wire [0:`LMQ_ENTRIES-1] ldqe_resv_q;
wire [0:`LMQ_ENTRIES-1] ldqe_pfetch_d;
wire [0:`LMQ_ENTRIES-1] ldqe_pfetch_q;
wire [0:2] ldqe_op_size_d[0:`LMQ_ENTRIES-1];
wire [0:2] ldqe_op_size_q[0:`LMQ_ENTRIES-1];
wire [0:AXU_TARGET_ENC-1] ldqe_tgpr_d[0:`LMQ_ENTRIES-1];
wire [0:AXU_TARGET_ENC-1] ldqe_tgpr_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_axu_d;
wire [0:`LMQ_ENTRIES-1] ldqe_axu_q;
wire [0:3] ldqe_usr_def_d[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_usr_def_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_lock_set_d;
wire [0:`LMQ_ENTRIES-1] ldqe_lock_set_q;
wire [0:`LMQ_ENTRIES-1] ldqe_watch_set_d;
wire [0:`LMQ_ENTRIES-1] ldqe_watch_set_q;
wire [0:`LMQ_ENTRIES-1] ldqe_algebraic_d;
wire [0:`LMQ_ENTRIES-1] ldqe_algebraic_q;
wire [0:1] ldqe_class_id_d[0:`LMQ_ENTRIES-1];
wire [0:1] ldqe_class_id_q[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_perf_events_d[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_perf_events_q[0:`LMQ_ENTRIES-1];
wire [0:1] ldqe_set_gpr_done[0:`LMQ_ENTRIES-1];
wire [0:1] ldqe_dvc_d[0:`LMQ_ENTRIES-1];
wire [0:1] ldqe_dvc_q[0:`LMQ_ENTRIES-1];
wire [0:5] ldqe_ttype_d[0:`LMQ_ENTRIES-1];
wire [0:5] ldqe_ttype_q[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_dacrw_d[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_dacrw_q[0:`LMQ_ENTRIES-1];
wire [0:`ITAG_SIZE_ENC-1] ldqe_itag_d[0:`LMQ_ENTRIES-1];
wire [0:`ITAG_SIZE_ENC-1] ldqe_itag_q[0:`LMQ_ENTRIES-1];
wire [64-`REAL_IFAR_WIDTH:57] ldqe_p_addr_msk[0:`LMQ_ENTRIES-1];
wire [64-`REAL_IFAR_WIDTH:63] ldqe_p_addr_d[0:`LMQ_ENTRIES-1];
wire [64-`REAL_IFAR_WIDTH:63] ldqe_p_addr_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_cp_flush;
wire [0:`LMQ_ENTRIES-1] ldqe_odq_flush;
wire [0:`LMQ_ENTRIES-1] ldqe_pfetch_flush;
wire [0:`LMQ_ENTRIES-1] ldqe_flush;
wire [0:`LMQ_ENTRIES-1] ldqe_kill;
wire [0:`LMQ_ENTRIES-1] ldqe_mkill;
wire [0:`LMQ_ENTRIES-1] ldqe_mkill_d;
wire [0:`LMQ_ENTRIES-1] ldqe_mkill_q;
wire [0:`LMQ_ENTRIES-1] ldqe_resolved;
wire [0:`LMQ_ENTRIES-1] ldqe_resolved_d;
wire [0:`LMQ_ENTRIES-1] ldqe_resolved_q;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_d;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_q;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_nFlush_d;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_nFlush_q;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_np1Flush_d;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_np1Flush_q;
wire [0:`LMQ_ENTRIES-1] ex5_ldm_hit_d;
wire [0:`LMQ_ENTRIES-1] ex5_ldm_hit_q;
wire spr_xucr0_cls_d;
wire spr_xucr0_cls_q;
wire spr_lsucr0_lge_d;
wire spr_lsucr0_lge_q;
wire [0:2] spr_lsucr0_lca_d;
wire [0:2] spr_lsucr0_lca_q;
wire spr_lsucr0_lca_zero;
wire [0:2] spr_lsucr0_lca_ovrd;
wire [0:`THREADS-1] iu_lq_cp_flush_d;
wire [0:`THREADS-1] iu_lq_cp_flush_q;
wire [0:`ITAG_SIZE_ENC-1] iu_lq_cp_next_itag_q[0:`THREADS-1];
wire ex4_stg_flush;
wire ex5_stg_flush;
wire odq_ldq_n_flush_d;
wire odq_ldq_n_flush_q;
wire odq_ldq_resolved_d;
wire odq_ldq_resolved_q;
wire [0:`ITAG_SIZE_ENC-1] odq_ldq_report_itag_d;
wire [0:`ITAG_SIZE_ENC-1] odq_ldq_report_itag_q;
wire [0:`THREADS-1] odq_ldq_report_tid_d;
wire [0:`THREADS-1] odq_ldq_report_tid_q;
wire [0:`THREADS-1] rv_lq_rvs_empty_d;
wire [0:`THREADS-1] rv_lq_rvs_empty_q;
wire ldq_rel1_set_rviss_dir_coll;
wire ldq_rel1_set_binv_dir_coll;
wire ldq_rel1_set_rd_dir_coll;
wire rel2_blk_req_d;
wire rel2_blk_req_q;
wire rel2_rviss_blk_d;
wire rel2_rviss_blk_q;
wire [64-`REAL_IFAR_WIDTH:57] l2_back_inv_addr_msk;
wire [64-`REAL_IFAR_WIDTH:57] ex4_p_addr_msk;
wire ex4_ldreq_d;
wire ex4_ldreq_q;
wire ex5_ldreq_val;
wire ex5_ldreq_val_d;
wire ex5_ldreq_val_q;
wire ex5_ldreq_flushed;
wire ex4_pfetch_val_d;
wire ex4_pfetch_val_q;
wire ex5_pfetch_val;
wire ex5_pfetch_val_d;
wire ex5_pfetch_val_q;
wire ex5_pfetch_flushed;
wire ex5_odq_ldreq_val_d;
wire ex5_odq_ldreq_val_q;
wire ex5_streq_val_d;
wire ex5_streq_val_q;
wire ex5_othreq_val_d;
wire ex5_othreq_val_q;
wire [64-`REAL_IFAR_WIDTH:63] ex5_p_addr_d;
wire [64-`REAL_IFAR_WIDTH:63] ex5_p_addr_q;
wire [0:4] ex5_wimge_d;
wire [0:4] ex5_wimge_q;
wire [0:11] ex5_cmmt_events;
wire [0:3] ex5_cmmt_perf_events;
wire [0:3] ex6_cmmt_perf_events_d;
wire [0:3] ex6_cmmt_perf_events_q;
wire [0:`LMQ_ENTRIES-1] ex4_ldqe_set_val;
wire [0:`LMQ_ENTRIES-1] ex4_ldqe_set_all;
wire [0:`LMQ_ENTRIES-1] ex5_ldqe_set_all_d;
wire [0:`LMQ_ENTRIES-1] ex5_ldqe_set_all_q;
wire [0:`LMQ_ENTRIES-1] ex5_ldqe_set_val_d;
wire [0:`LMQ_ENTRIES-1] ex5_ldqe_set_val_q;
wire [0:`LMQ_ENTRIES-1] ex6_ldqe_pfetch_val_d;
wire [0:`LMQ_ENTRIES-1] ex6_ldqe_pfetch_val_q;
wire [0:`LMQ_ENTRIES-1] ex7_ldqe_pfetch_val_d;
wire [0:`LMQ_ENTRIES-1] ex7_ldqe_pfetch_val_q;
wire ex7_pfetch_blk_val;
wire [0:`THREADS-1] ex7_pfetch_blk_tid;
wire [0:`LMQ_ENTRIES-1] ex5_ldm_entry;
reg [0:`THREADS-1] ldq_all_req_home;
wire [0:`THREADS-1] lq_xu_quiesce_d;
wire [0:`THREADS-1] lq_xu_quiesce_q;
wire lq_mm_lmq_stq_empty_d;
wire lq_mm_lmq_stq_empty_q;
wire [0:`THREADS-1] lq_pc_ldq_quiesce_d;
wire [0:`THREADS-1] lq_pc_ldq_quiesce_q;
wire [0:`THREADS-1] lq_pc_stq_quiesce_d;
wire [0:`THREADS-1] lq_pc_stq_quiesce_q;
wire [0:`THREADS-1] lq_pc_pfetch_quiesce_d;
wire [0:`THREADS-1] lq_pc_pfetch_quiesce_q;
reg [0:3] ex5_cTag;
reg [0:1] ex5_tid_enc;
wire [0:3] ldqe_beat_init;
wire [0:`LMQ_ENTRIES-1] ldqe_wrt_ptr;
wire [0:`LMQ_ENTRIES-1] ldqe_opposite_ptr;
wire ex4_one_machine_avail;
wire ex4_oldest_load;
wire ex4_reserved_taken;
wire ex5_reserved_taken_d;
wire ex5_reserved_taken_q;
wire ex4_resv_taken_restart;
wire ex5_resv_taken_restart_d;
wire ex5_resv_taken_restart_q;
wire [0:`LMQ_ENTRIES+`LGQ_ENTRIES-1] ldqe_cpl_sel;
wire [0:`LMQ_ENTRIES+`LGQ_ENTRIES-1] ldqe_cpl_sent;
wire [0:`LMQ_ENTRIES-1] ex5_inv_ldqe;
wire ex4_ldq_full;
wire ex5_ldq_full_d;
wire ex5_ldq_full_q;
wire ex4_ldq_full_restart;
wire ex5_ldq_full_restart_d;
wire ex5_ldq_full_restart_q;
wire ex4_ldq_hit;
wire ex5_ldq_hit_d;
wire ex5_ldq_hit_q;
wire ldq_full_qHit_held_set;
wire ldq_full_qHit_held_clr;
wire [0:1] ldq_full_qHit_held_ctrl;
wire ldq_full_qHit_held_d;
wire ldq_full_qHit_held_q;
wire ldq_resv_qHit_held_set;
wire ldq_resv_qHit_held_clr;
wire [0:1] ldq_resv_qHit_held_ctrl;
wire ldq_resv_qHit_held_d;
wire ldq_resv_qHit_held_q;
wire ldq_oth_qHit_clr_d;
wire ldq_oth_qHit_clr_q;
wire ex5_ldq_set_hold_d;
wire ex5_ldq_set_hold_q;
wire ex5_ldq_full_set_hold;
wire ex5_setHold;
wire ldq_clrHold;
wire [0:`THREADS-1] ldq_clrHold_tid;
wire [0:`THREADS-1] ldq_setHold_tid;
wire [0:`THREADS-1] ldq_hold_tid;
wire [0:`THREADS-1] ldq_hold_tid_d;
wire [0:`THREADS-1] ldq_hold_tid_q;
wire ex5_ldq_restart;
wire ex5_ldq_restart_d;
wire ex5_ldq_restart_q;
wire ex6_ldq_full_d;
wire ex6_ldq_full_q;
wire ex6_ldq_hit_d;
wire ex6_ldq_hit_q;
wire ex5_lgq_full_d;
wire ex5_lgq_full_q;
wire ex6_lgq_full_d;
wire ex6_lgq_full_q;
wire ex5_lgq_qwhit_d;
wire ex5_lgq_qwhit_q;
wire ex6_lgq_qwhit_d;
wire ex6_lgq_qwhit_q;
wire ex5_restart_val;
wire ex5_drop_req_val;
wire ex5_drop_gath;
wire perf_ex6_ldq_full_restart;
wire perf_ex6_ldq_hit_restart;
wire perf_ex6_lgq_full_restart;
wire perf_ex6_lgq_qwhit_restart;
wire [0:`LMQ_ENTRIES-1] ldqe_inuse;
wire [0:`THREADS-1] ldqe_tid_inuse[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_req_outstanding;
wire [0:`THREADS-1] ldqe_tid_req_outstanding[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_req_able_to_hold;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_blk_qHit_held;
wire [0:`LMQ_ENTRIES-1] ex4_load_qHit_upd;
wire [0:`LMQ_ENTRIES-1] ex4_addr_m_queue;
wire [0:`LMQ_ENTRIES-1] ex4_qw_hit_queue;
reg [0:`LMQ_ENTRIES-1] ex4_lgq_qw_hit;
wire ex5_ld_gath_d;
wire ex5_ld_gath_q;
wire ex4_ld_gath;
wire [0:`LMQ_ENTRIES-1] ldqe_entry_gatherable;
wire [0:`LMQ_ENTRIES-1] ex4_entry_gatherable;
wire [0:`LMQ_ENTRIES-1] ex4_entry_gath_ld;
wire [0:`LMQ_ENTRIES-1] ex4_entry_gath_full;
wire [0:`LMQ_ENTRIES-1] ex4_entry_gath_qwhit;
wire [0:`LMQ_ENTRIES-1] ex4_thrd_id_m;
wire [0:`LMQ_ENTRIES-1] ex4_larx_hit;
wire [0:`LMQ_ENTRIES-1] ex4_guarded_hit;
wire [0:`LMQ_ENTRIES-1] ex4_req_hit_ldq;
wire [0:`LMQ_ENTRIES-1] ex4_entry_load_qHit;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv;
wire [0:`LMQ_ENTRIES-1] ldqe_back_inv_flush_upd;
wire [0:`THREADS-1] ldqe_cpNext_tid[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_cpNext_val;
wire [0:((((`LMQ_ENTRIES-1)/4)+1)*4)-1] ldqe_sent;
reg [0:`LMQ_ENTRIES-1] ldqe_req_cmpl_d;
wire [0:`LMQ_ENTRIES-1] ldqe_req_cmpl_q;
reg [0:`LMQ_ENTRIES-1] ldqe_val_d;
wire [0:`LMQ_ENTRIES-1] ldqe_val_q;
wire [0:`LMQ_ENTRIES-1] ldqe_ctrl_act;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_inprog;
wire [0:`LMQ_ENTRIES-1] ldqe_zap;
wire [0:`LMQ_ENTRIES-1] ldqe_need_l2send;
wire [0:1] ldqe_beat_ctrl[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_beat_incr[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_beat_cntr_d[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_beat_cntr_q[0:`LMQ_ENTRIES-1];
wire ex5_upd_fifo_val;
wire fifo_ldq_act;
wire fifo_ldq_req_compr_val;
wire fifo_ldq_req_sent;
wire fifo_ldq_req0_mkill;
wire fifo_ldq_req0_avail;
wire [0:1] fifo_ldq_wrt_ptr_cntrl;
wire fifo_ldq_reset_ptr;
wire [0:`LMQ_ENTRIES] fifo_ldq_req_nxt_ptr;
wire [0:`LMQ_ENTRIES] fifo_ldq_req_nxt_ptr_d;
wire [0:`LMQ_ENTRIES] fifo_ldq_req_nxt_ptr_q;
wire [0:`LMQ_ENTRIES] fifo_ldq_req_wrt_ptr;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_upd;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_empty_entry;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_push;
wire [0:1] fifo_ldq_req_cntrl[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_val;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_val_d;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_val_q;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_pfetch_match;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_pfetch_send;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_pfetch;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_pfetch_d;
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_pfetch_q;
wire [0:`THREADS-1] fifo_ldq_req_tid_d[0:`LMQ_ENTRIES-1];
wire [0:`THREADS-1] fifo_ldq_req_tid_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_d[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] fifo_ldq_req_q[0:`LMQ_ENTRIES-1];
reg [0:3] ldq_mux_usr_def;
reg [0:4] ldq_mux_wimge;
reg [64-`REAL_IFAR_WIDTH:63] ldq_mux_p_addr;
reg [0:5] ldq_mux_ttype;
reg [0:2] ldq_mux_opsize;
reg [0:`THREADS-1] ldq_mux_tid;
reg [0:1] ldq_mux_tid_enc;
reg [0:3] ldq_mux_cTag;
wire [0:`LMQ_ENTRIES-1] ldqe_relmin1_cTag;
wire [0:`LMQ_ENTRIES-1] ldqe_rel0_cTag;
wire [0:`LMQ_ENTRIES-1] ldqe_rel1_cTag;
wire [0:`LMQ_ENTRIES-1] ldq_relmin1_l2_val;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_l2_val_q;
wire [0:`LMQ_ENTRIES-1] ldq_relmin1_l2_inval;
wire [0:`LMQ_ENTRIES-1] ldq_rel_l2_l1dumpBlk;
wire [0:`LMQ_ENTRIES-1] ldq_relmin1_l2_qHitBlk;
wire [0:`LMQ_ENTRIES-1] ldqe_cpNext_ecc_err;
wire [0:`LMQ_ENTRIES-1] ldqe_nFlush_ecc_err;
reg [0:6] ldqe_nxt_state[0:`LMQ_ENTRIES-1];
wire [0:6] ldqe_state_d[0:`LMQ_ENTRIES-1];
wire [0:6] ldqe_state_q[0:`LMQ_ENTRIES-1];
wire [0:3] ldq_resp_cTag;
wire [57:59] ldq_resp_qw;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_beats_home;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_beats_home_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_beats_home_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_beats_home_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_beats_home_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_beats_home_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_beats_home_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_beats_home_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_beats_home_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_entrySent;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_entrySent_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_entrySent_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_entrySent_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_entrySent_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_entrySent_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_entrySent_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_sentL1_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_sentL1_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_sentL1_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_sentL1_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_req_noL1done;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_req_done;
wire [0:`LMQ_ENTRIES-1] ldq_rel6_req_done_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel6_req_done_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_ci_done;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_drel_done;
wire ldq_rel1_val_d;
wire ldq_rel1_val_q;
wire ldq_rel1_arb_val_d;
wire ldq_rel1_arb_val_q;
wire ldq_rel0_rdat_sel;
wire [0:2] ldq_rel0_rdat_qw;
wire ldq_rel1_l1_dump_d;
wire ldq_rel1_l1_dump_q;
wire ldq_rel2_l1_dump_d;
wire ldq_rel2_l1_dump_q;
wire ldq_rel3_l1_dump_d;
wire ldq_rel3_l1_dump_q;
wire ldq_rel3_l1_dump_val;
wire ldq_rel3_clr_relq_d;
wire ldq_rel3_clr_relq_q;
wire [0:2] ldq_rel1_resp_qw_d;
wire [0:2] ldq_rel1_resp_qw_q;
wire [0:3] ldq_rel1_cTag_d;
wire [0:3] ldq_rel1_cTag_q;
wire l2_rel1_resp_val_d;
wire l2_rel1_resp_val_q;
wire l2_rel2_resp_val_d;
wire l2_rel2_resp_val_q;
wire ldq_err_inval_rel_d;
wire ldq_err_inval_rel_q;
wire ldq_err_ecc_det_d;
wire ldq_err_ecc_det_q;
wire ldq_err_ue_det_d;
wire ldq_err_ue_det_q;
wire ldq_rel3_rdat_par_err;
reg [0:2] ldq_rel_mux_opsize;
reg ldq_rel_mux_wimge_i;
reg ldq_rel_mux_byte_swap;
reg [64-`REAL_IFAR_WIDTH:63] ldq_rel_mux_p_addr;
wire [64-(`DC_SIZE-3):57] ldq_rel_mux_p_addr_msk;
reg [0:1] ldq_rel_mux_dvcEn;
reg ldq_rel_mux_lockSet;
reg ldq_rel_mux_watchSet;
reg [0:AXU_TARGET_ENC-1] ldq_rel_mux_tGpr;
reg ldq_rel_mux_axu;
reg ldq_rel_mux_algEn;
reg [0:1] ldq_rel_mux_classID;
reg [0:`THREADS-1] ldq_rel_mux_tid;
reg ldq_rel1_mux_back_inv;
reg [0:2] lgq_rel_mux_opsize;
reg [59:63] lgq_rel_mux_p_addr;
reg lgq_rel_mux_byte_swap;
reg [0:1] lgq_rel_mux_dvcEn;
reg [0:AXU_TARGET_ENC-1] lgq_rel_mux_tGpr;
reg lgq_rel_mux_axu;
reg lgq_rel_mux_algEn;
reg [0:`THREADS-1] lgq_rel_mux_tid;
wire [0:2] ldq_rel1_opsize_d;
wire [0:2] ldq_rel1_opsize_q;
wire ldq_rel1_wimge_i_d;
wire ldq_rel1_wimge_i_q;
wire ldq_rel1_byte_swap_d;
wire ldq_rel1_byte_swap_q;
wire ldq_rel2_byte_swap_d;
wire ldq_rel2_byte_swap_q;
wire [64-`REAL_IFAR_WIDTH:63] ldq_rel1_p_addr_d;
wire [64-`REAL_IFAR_WIDTH:63] ldq_rel1_p_addr_q;
wire [0:1] ldq_rel1_dvcEn_d;
wire [0:1] ldq_rel1_dvcEn_q;
wire ldq_rel1_lockSet_d;
wire ldq_rel1_lockSet_q;
wire ldq_rel1_watchSet_d;
wire ldq_rel1_watchSet_q;
wire [0:AXU_TARGET_ENC-1] ldq_rel1_tGpr_d;
wire [0:AXU_TARGET_ENC-1] ldq_rel1_tGpr_q;
wire ldq_rel1_axu_d;
wire ldq_rel1_axu_q;
wire ldq_rel1_algEn_d;
wire ldq_rel1_algEn_q;
wire [0:1] ldq_rel1_classID_d;
wire [0:1] ldq_rel1_classID_q;
wire [0:`THREADS-1] ldq_rel1_tid_d;
wire [0:`THREADS-1] ldq_rel1_tid_q;
wire [0:`THREADS-1] ldq_rel2_tid_d;
wire [0:`THREADS-1] ldq_rel2_tid_q;
wire [0:`THREADS-1] ldq_rel1_dir_tid_d;
wire [0:`THREADS-1] ldq_rel1_dir_tid_q;
reg [0:`ITAG_SIZE_ENC-1] ldqe_relmin1_iTag;
reg [0:`THREADS-1] ldqe_relmin1_tid;
reg [0:`ITAG_SIZE_ENC-1] lgqe_relmin1_iTag;
reg [0:`THREADS-1] lgqe_relmin1_tid;
wire [0:`THREADS-1] ldq_relmin1_tid;
wire [0:`ITAG_SIZE_ENC-1] ldq_relmin1_iTag;
wire [0:7] ldq_rel0_beat_upd;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_sentL1;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_sentL1_blk;
wire [0:1] ldqe_sentRel_ctrl[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_sentRel_incr[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_sentRel_cntr_d[0:`LMQ_ENTRIES-1];
wire [0:3] ldqe_sentRel_cntr_q[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_sentL1;
wire [0:`LMQ_ENTRIES-1] ldqe_last_beat;
wire [0:`LMQ_ENTRIES-1] ldqe_rel2_l1upd_cmpl;
wire [0:1] ldqe_rel_start_ctrl[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_relDir_start;
wire [0:`LMQ_ENTRIES-1] ldqe_relDir_start_d;
wire [0:`LMQ_ENTRIES-1] ldqe_relDir_start_q;
wire ldq_rel0_arb_val;
wire [0:3] ldq_rel0_arb_cTag;
wire ldq_rel0_arb_thresh;
wire [0:2] ldq_rel0_arb_qw;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_arb_sent;
wire ldq_rel0_arr_wren;
wire ldq_rel1_clr_val;
wire ldq_l2_rel0_qHitBlk_d;
wire ldq_l2_rel0_qHitBlk_q;
wire ldq_l2_resp_hold_all;
wire ldq_rel_arb_hold_all;
wire [64-(`DC_SIZE-3):57] ldq_rel2_cclass_d;
wire [64-(`DC_SIZE-3):57] ldq_rel2_cclass_q;
wire [64-(`DC_SIZE-3):57] ldq_rel3_cclass_d;
wire [64-(`DC_SIZE-3):57] ldq_rel3_cclass_q;
wire [64-(`DC_SIZE-3):57] ldq_rel4_cclass_d;
wire [64-(`DC_SIZE-3):57] ldq_rel4_cclass_q;
wire ldq_rel1_set_val;
wire ldq_rel2_set_val_d;
wire ldq_rel2_set_val_q;
wire ldq_rel3_set_val_d;
wire ldq_rel3_set_val_q;
wire ldq_rel4_set_val_d;
wire ldq_rel4_set_val_q;
wire ldq_rel1_data_val;
wire ldq_rel1_data_sel_d;
wire ldq_rel1_data_sel_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_l2_val_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_l2_val_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_l2_val_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_l2_val_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_l2_val_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_l2_val_q;
reg [0:`LMQ_ENTRIES-1] ldqe_cntr_reset_d;
wire [0:`LMQ_ENTRIES-1] ldqe_cntr_reset_q;
reg [0:`LMQ_ENTRIES-1] ldqe_resent_ecc_err_d;
wire [0:`LMQ_ENTRIES-1] ldqe_resent_ecc_err_q;
reg [0:`LMQ_ENTRIES-1] ldqe_reset_cpl_rpt_d;
wire [0:`LMQ_ENTRIES-1] ldqe_reset_cpl_rpt_q;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_rdat_perr;
reg [0:`LMQ_ENTRIES-1] ldqe_ecc_err_dgpr;
reg [0:`LMQ_ENTRIES-1] ldqe_rst_eccdet;
wire [0:`LMQ_ENTRIES-1] ldqe_rst_eccdet_d;
wire [0:`LMQ_ENTRIES-1] ldqe_rst_eccdet_q;
wire [0:1] ldqe_rel_eccdet_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet_d;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet_q;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet_ue;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet_ue_d;
wire [0:`LMQ_ENTRIES-1] ldqe_rel_eccdet_ue_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_gpr_ecc_err;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_gpr_eccue_err;
wire [0:1] ldqe_upd_gpr_ecc_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_ecc;
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_ecc_d;
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_ecc_q;
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_eccue;
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_eccue_d;
wire [0:`LMQ_ENTRIES-1] ldqe_upd_gpr_eccue_q;
wire rel0_stg_act;
wire ldq_reload_val;
wire [0:1] ldqe_rel_l1_dump_ctrl[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_drop_reload_val;
wire [0:`LMQ_ENTRIES-1] ldq_rel_l1_dump;
wire [0:`LMQ_ENTRIES-1] ldqe_l1_dump_d;
wire [0:`LMQ_ENTRIES-1] ldqe_l1_dump_q;
wire [57:59] ldq_reload_qw;
wire [0:`LMQ_ENTRIES-1] ldqe_relmin1_upd_gpr;
wire ldq_itag2_rel_val;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_crit_qw;
wire ldq_rel1_gpr_val;
wire ldq_rel1_gpr_val_d;
wire ldq_rel1_gpr_val_q;
wire rel2_eccdet;
wire rel2_eccdet_ue;
wire rel2_eccdet_err;
wire ldq_rel2_rdat_perr;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_upd_gpr_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel0_upd_gpr_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_upd_gpr_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_upd_gpr_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_upd_gpr_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_upd_gpr_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_upd_gpr_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_upd_gpr_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_upd_gpr;
wire [0:`LMQ_ENTRIES-1] ldqe_rel2_drop_cpl_rpt;
wire [0:`LMQ_ENTRIES-1] ldqe_rel3_drop_cpl_rpt_d;
wire [0:`LMQ_ENTRIES-1] ldqe_rel3_drop_cpl_rpt_q;
wire [0:`LMQ_ENTRIES-1] ldqe_reld_cpl_rpt;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_send_cpl_ok;
wire [0:`LMQ_ENTRIES-1] ldq_rel6_send_cpl_ok;
wire [0:`LMQ_ENTRIES-1] ldq_rel_send_cpl_ok;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_odq_cpl;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_odq_cpl_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel4_odq_cpl_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_odq_cpl_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_odq_cpl_q;
wire ldq_l2_req_need_send;
wire ldq_rel0_updating_cache;
wire ldq_rel1_collide_binv_d;
wire ldq_rel1_collide_binv_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel1_dbeat_val;
wire ldq_stq_rel1_blk_store_d;
wire ldq_stq_rel1_blk_store_q;
wire [0:`LMQ_ENTRIES-1] ldq_rel2_qHit_clr;
wire [0:1] ldqe_qHit_clr_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldq_rel_qHit_clr_d;
wire [0:`LMQ_ENTRIES-1] ldq_rel_qHit_clr_q;
wire [0:1] ldqe_qHit_held_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_qHit_held_d;
wire [0:`LMQ_ENTRIES-1] ldqe_qHit_held_q;
wire ldq_rel2_rv_clr_hold;
wire [0:`LMQ_ENTRIES-1] ldqe_available;
wire [0:`LMQ_ENTRIES-1] ldqe_cpl_rpt_done;
wire [0:`LMQ_ENTRIES-1] ldqe_need_cpl_rst;
wire [0:1] ldqe_need_cpl_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_need_cpl_d;
wire [0:`LMQ_ENTRIES-1] ldqe_need_cpl_q;
wire [0:`LMQ_ENTRIES-1] ldqe_send_cpl;
wire [0:1] ldqe_sent_cpl_sel[0:`LMQ_ENTRIES-1];
wire [0:`LMQ_ENTRIES-1] ldqe_sent_cpl_d;
wire [0:`LMQ_ENTRIES-1] ldqe_sent_cpl_q;
wire [0:`LMQ_ENTRIES-1] ldqe_complete;
wire [0:`LMQ_ENTRIES+`LGQ_ENTRIES-1] ldqe_remove;
wire [0:3] cpl_grpEntry_val[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
wire [0:3] cpl_grpEntry_sel[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
wire [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_sent;
wire [0:3] cpl_grpEntry_last_sel_d[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
wire [0:3] cpl_grpEntry_last_sel_q[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:`ITAG_SIZE_ENC-1] cpl_grpEntry_iTag[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_ecc;
reg [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_eccue;
reg [0:1] cpl_grpEntry_dvc[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:3] cpl_grpEntry_dacrw[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:`THREADS-1] cpl_grpEntry_tid[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_nFlush;
reg [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_np1Flush;
reg [0:3] cpl_grpEntry_pEvents[0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4];
reg [0:(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4] cpl_grpEntry_larx;
wire [0:3] cpl_group_val;
wire [0:3] cpl_group_sel;
wire [0:3] cpl_group_last_sel_d;
wire [0:3] cpl_group_last_sel_q;
wire cpl_credit_sent;
reg [0:`ITAG_SIZE_ENC-1] cpl_send_itag;
reg cpl_ecc_dec;
reg cpl_eccue_dec;
reg [0:1] cpl_dvc;
reg [0:3] cpl_dacrw;
reg [0:`THREADS-1] cpl_tid;
reg cpl_nFlush;
reg cpl_np1Flush;
reg [0:3] cpl_pEvents;
reg cpl_larx;
wire ldq_cpl_odq_zap;
wire ldq_cpl_odq_val;
wire ldq_cpl_odq_dbg_int_en;
wire ldq_cpl_odq_n_flush;
wire [0:3] ldq_cpl_odq_dacrw;
wire ldq_cpl_odq_eccue;
wire ldq_cpl_pending;
wire [0:`THREADS-1] ldq_execute_vld;
wire [0:`THREADS-1] odq_execute_vld;
wire [0:`THREADS-1] lq1_iu_execute_vld_d;
wire [0:`THREADS-1] lq1_iu_execute_vld_q;
wire [0:`ITAG_SIZE_ENC-1] lq1_iu_itag_d;
wire [0:`ITAG_SIZE_ENC-1] lq1_iu_itag_q;
wire lq1_iu_n_flush_d;
wire lq1_iu_n_flush_q;
wire lq1_iu_np1_flush_d;
wire lq1_iu_np1_flush_q;
wire lq1_iu_exception_val_d;
wire lq1_iu_exception_val_q;
wire ldq_cpl_dbg_int_en;
wire ldq_cpl_oth_flush;
wire ldq_cpl_n_flush;
wire ldq_cpl_np1_flush;
wire [0:1] ldq_cpl_dvc;
wire [0:3] ldq_cpl_dacrw;
wire [0:3] lq1_iu_dacrw_d;
wire [0:3] lq1_iu_dacrw_q;
wire [0:3] lq1_iu_perf_events_d;
wire [0:3] lq1_iu_perf_events_q;
wire [0:`THREADS-1] ldq_cpl_larx_d;
wire [0:`THREADS-1] ldq_cpl_larx_q;
wire [0:`THREADS-1] ldq_cpl_binv_d;
wire [0:`THREADS-1] ldq_cpl_binv_q;
wire ldq_rel_cmmt_d;
wire ldq_rel_cmmt_q;
wire ldq_rel_need_hole_d;
wire ldq_rel_need_hole_q;
wire ldq_rel_latency_d;
wire ldq_rel_latency_q;
wire [0:`THREADS-1] perf_ldq_cpl_larx;
wire [0:`THREADS-1] perf_ldq_cpl_binv;
wire perf_ldq_rel_attmpt;
wire perf_ldq_rel_cmmt;
wire perf_ldq_rel_need_hole;
wire perf_ldq_rel_latency;
wire ex4_stg_act_d;
wire ex4_stg_act_q;
wire ex5_stg_act_d;
wire ex5_stg_act_q;
wire [0:`LMQ_ENTRIES-1] ex4_ldqe_act;
wire [0:`LMQ_ENTRIES-1] ex5_ldqe_act;
wire [0:`LMQ_ENTRIES-1] ex4_lgqe_act;
wire [0:`LMQ_ENTRIES-1] ex5_lgqe_act;
reg [0:3] ldq_gath_Tag;
wire [0:`LGQ_ENTRIES-1] lgqe_wrt_ptr;
wire ld_gath_not_full;
wire [0:`LGQ_ENTRIES-1] lgqe_available;
wire [0:`LGQ_ENTRIES-1] lgqe_cpl_sent;
wire [0:`LGQ_ENTRIES-1] lgq_reset_val;
wire [0:`LGQ_ENTRIES-1] lgqe_odq_flush;
wire [0:`LGQ_ENTRIES-1] lgqe_cp_flush;
wire [0:`LGQ_ENTRIES-1] lgqe_kill;
wire [0:`LGQ_ENTRIES-1] lgqe_valid_d;
wire [0:`LGQ_ENTRIES-1] lgqe_valid_q;
wire ex4_gath_val;
wire [0:`LGQ_ENTRIES-1] ex4_lgqe_set_val;
wire [0:`LGQ_ENTRIES-1] ex4_lgqe_set_all;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_set_all_d;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_set_all_q;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_set_val_d;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_set_val_q;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_restart;
wire [0:`LGQ_ENTRIES-1] ex5_lgqe_drop;
wire ex5_lgq_restart;
wire [0:`THREADS-1] lgqe_thrd_id_d[0:`LGQ_ENTRIES-1];
wire [0:`THREADS-1] lgqe_thrd_id_q[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_byte_swap_d;
wire [0:`LGQ_ENTRIES-1] lgqe_byte_swap_q;
wire [0:`LGQ_ENTRIES-1] lqg_qw_match;
wire [0:2] lgqe_set_op_size[0:`LGQ_ENTRIES-1];
wire [0:2] lgqe_op_size_d[0:`LGQ_ENTRIES-1];
wire [0:2] lgqe_op_size_q[0:`LGQ_ENTRIES-1];
wire [0:AXU_TARGET_ENC-1] lgqe_set_tgpr[0:`LGQ_ENTRIES-1];
wire [0:AXU_TARGET_ENC-1] lgqe_tgpr_d[0:`LGQ_ENTRIES-1];
wire [0:AXU_TARGET_ENC-1] lgqe_tgpr_q[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_set_axu;
wire [0:`LGQ_ENTRIES-1] lgqe_axu_d;
wire [0:`LGQ_ENTRIES-1] lgqe_axu_q;
wire [0:3] lgqe_perf_events_d[0:`LGQ_ENTRIES-1];
wire [0:3] lgqe_perf_events_q[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_set_algebraic;
wire [0:`LGQ_ENTRIES-1] lgqe_algebraic_d;
wire [0:`LGQ_ENTRIES-1] lgqe_algebraic_q;
wire [0:`LGQ_ENTRIES-1] lgqe_gpr_done_d;
wire [0:`LGQ_ENTRIES-1] lgqe_gpr_done_q;
wire [0:`LGQ_ENTRIES-1] lgqe_resolved;
wire [0:`LGQ_ENTRIES-1] lgqe_resolved_d;
wire [0:`LGQ_ENTRIES-1] lgqe_resolved_q;
wire [0:`LGQ_ENTRIES-1] lgqe_back_inv_nFlush_d;
wire [0:`LGQ_ENTRIES-1] lgqe_back_inv_nFlush_q;
wire [0:`LGQ_ENTRIES-1] lgqe_back_inv_np1Flush_d;
wire [0:`LGQ_ENTRIES-1] lgqe_back_inv_np1Flush_q;
wire [0:1] lgqe_set_gpr_done[0:`LGQ_ENTRIES-1];
wire [0:1] lgqe_set_dvc[0:`LGQ_ENTRIES-1];
wire [0:1] lgqe_dvc_d[0:`LGQ_ENTRIES-1];
wire [0:1] lgqe_dvc_q[0:`LGQ_ENTRIES-1];
wire [0:3] lgqe_dacrw_d[0:`LGQ_ENTRIES-1];
wire [0:3] lgqe_dacrw_q[0:`LGQ_ENTRIES-1];
wire [0:`ITAG_SIZE_ENC-1] lgqe_itag_d[0:`LGQ_ENTRIES-1];
wire [0:`ITAG_SIZE_ENC-1] lgqe_itag_q[0:`LGQ_ENTRIES-1];
wire [57:63] lgqe_p_addr_d[0:`LGQ_ENTRIES-1];
wire [57:63] lgqe_p_addr_q[0:`LGQ_ENTRIES-1];
wire [0:3] lgqe_ldTag_d[0:`LGQ_ENTRIES-1];
wire [0:3] lgqe_ldTag_q[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] ldq_gath_Tag_1hot[0:`LMQ_ENTRIES-1];
reg [0:`LMQ_ENTRIES-1] ldqe_gather_done;
wire [0:`LGQ_ENTRIES-1] lgqe_back_inv_flush_upd;
wire [0:`THREADS-1] lgqe_cpNext_tid[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_cpNext_val;
wire [0:1] lgqe_upd_gpr_ecc_sel[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_ecc;
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_ecc_d;
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_ecc_q;
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_eccue;
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_eccue_d;
wire [0:`LGQ_ENTRIES-1] lgqe_upd_gpr_eccue_q;
wire [0:`LGQ_ENTRIES-1] lgqe_cpl_rpt_done;
wire [0:`LGQ_ENTRIES-1] lgqe_need_cpl_rst;
wire [0:1] lgqe_need_cpl_sel[0:`LGQ_ENTRIES-1];
wire [0:`LGQ_ENTRIES-1] lgqe_need_cpl_d;
wire [0:`LGQ_ENTRIES-1] lgqe_need_cpl_q;
wire [0:`LGQ_ENTRIES-1] lgqe_send_cpl;
wire lgq_rel1_gpr_val_d;
wire lgq_rel1_gpr_val_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel0_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel0_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel1_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel1_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel2_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel2_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel3_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel3_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel4_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel4_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel5_upd_gpr_d;
wire [0:`LGQ_ENTRIES-1] lgq_rel5_upd_gpr_q;
wire [0:`LGQ_ENTRIES-1] lgq_rel1_upd_gpr;
wire [0:`LGQ_ENTRIES-1] lgq_rel2_upd_gpr;
wire [0:`LGQ_ENTRIES-1] lgqe_relmin1_match;
wire [0:`LGQ_ENTRIES-1] lgqe_relmin1_upd_gpr;
wire [0:`LGQ_ENTRIES-1] lgq_rel2_send_cpl_ok;
reg [0:`ITAG_SIZE_ENC-1] ldq_rel3_odq_itag;
reg ldq_rel3_odq_ecc;
reg ldq_rel3_odq_eccue;
reg [0:1] ldq_rel3_odq_dvc;
reg [0:3] ldq_rel3_odq_dacrw;
reg [0:`THREADS-1] ldq_rel3_odq_tid;
reg ldq_rel3_odq_nFlush;
reg ldq_rel3_odq_np1Flush;
reg [0:3] ldq_rel3_odq_pEvents;
wire ldq_rel3_odq_dbg_int_en;
wire ldq_rel3_odq_oth_flush;
wire [0:3] ldq_rel3_dacrw;
wire [0:`LMQ_ENTRIES-1] ldq_rel3_odq_val;
wire [0:`LGQ_ENTRIES-1] lgq_rel3_odq_val;
wire [0:`LMQ_ENTRIES-1] ldq_rel5_odq_cpl;
wire [0:`LGQ_ENTRIES-1] lgq_rel5_odq_cpl;
wire ldq_state_machines_idle;
wire ldq_relmin1_ldq_val;
wire [0:3] ldq_relmin1_cTag;
wire l2_rel0_resp_val_d;
wire l2_rel0_resp_val_q;
wire l2_rel0_resp_ldq_val_d;
wire l2_rel0_resp_ldq_val_q;
wire [0:3] l2_rel0_resp_cTag_d;
wire [0:3] l2_rel0_resp_cTag_q;
wire [57:59] l2_rel0_resp_qw_d;
wire [57:59] l2_rel0_resp_qw_q;
wire l2_rel0_resp_crit_qw_d;
wire l2_rel0_resp_crit_qw_q;
wire l2_rel0_resp_l1_dump_d;
wire l2_rel0_resp_l1_dump_q;
wire [0:2] ldq_rel0_opsize;
wire [59:63] ldq_rel0_p_addr;
wire [0:4] ldq_rel0_opsize_1hot;
wire [0:4] ldq_rel0_rot_size;
wire [0:4] ldq_rel0_rot_max_size_le;
wire [0:4] ldq_rel0_rot_sel_le;
wire [0:3] ldq_rel0_rot_sel;
wire ldq_rel0_byte_swap;
wire [0:3] ldq_rel1_algebraic_sel_d;
wire [0:3] ldq_rel1_algebraic_sel_q;
wire lvl1_sel;
wire [0:1] lvl2_sel;
wire [0:1] lvl3_sel;
wire [0:1] rotate_sel1;
wire [0:3] rotate_sel2;
wire [0:3] rotate_sel3;
wire [0:7] ldq_rel1_rot_sel1_d;
wire [0:7] ldq_rel1_rot_sel1_q;
wire [0:7] ldq_rel1_rot_sel2_d;
wire [0:7] ldq_rel1_rot_sel2_q;
wire [0:7] ldq_rel1_rot_sel3_d;
wire [0:7] ldq_rel1_rot_sel3_q;
wire [0:127] ldq_rel1_data;
wire [0:127] ldq_rel2_rot_data;
wire [0:1] ldq_rel2_dvc;
wire [0:`THREADS-1] dbg_int_en_d;
wire [0:`THREADS-1] dbg_int_en_q;
wire rdat_scan_in;
wire rdat_scan_out;
//--------------------------
// constants
//--------------------------
parameter spr_xucr0_cls_offset = 0;
parameter spr_lsucr0_lge_offset = spr_xucr0_cls_offset + 1;
parameter spr_lsucr0_lca_offset = spr_lsucr0_lge_offset + 1;
parameter l2_rel0_resp_val_offset = spr_lsucr0_lca_offset + 3;
parameter l2_rel0_resp_ldq_val_offset = l2_rel0_resp_val_offset + 1;
parameter l2_rel0_resp_cTag_offset = l2_rel0_resp_ldq_val_offset + 1;
parameter l2_rel0_resp_qw_offset = l2_rel0_resp_cTag_offset + 4;
parameter l2_rel0_resp_crit_qw_offset = l2_rel0_resp_qw_offset + 3;
parameter l2_rel0_resp_l1_dump_offset = l2_rel0_resp_crit_qw_offset + 1;
parameter ldq_rel1_algebraic_sel_offset = l2_rel0_resp_l1_dump_offset + 1;
parameter ldq_rel1_rot_sel1_offset = ldq_rel1_algebraic_sel_offset + 4;
parameter ldq_rel1_rot_sel2_offset = ldq_rel1_rot_sel1_offset + 8;
parameter ldq_rel1_rot_sel3_offset = ldq_rel1_rot_sel2_offset + 8;
parameter iu_lq_cp_flush_offset = ldq_rel1_rot_sel3_offset + 8;
parameter iu_lq_cp_next_itag_offset = iu_lq_cp_flush_offset + `THREADS;
parameter odq_ldq_n_flush_offset = iu_lq_cp_next_itag_offset + (`THREADS) * (`ITAG_SIZE_ENC);
parameter odq_ldq_resolved_offset = odq_ldq_n_flush_offset + 1;
parameter odq_ldq_report_itag_offset = odq_ldq_resolved_offset + 1;
parameter odq_ldq_report_tid_offset = odq_ldq_report_itag_offset + `ITAG_SIZE_ENC;
parameter rv_lq_rvs_empty_offset = odq_ldq_report_tid_offset + `THREADS;
parameter rel2_blk_req_offset = rv_lq_rvs_empty_offset + `THREADS;
parameter rel2_rviss_blk_offset = rel2_blk_req_offset + 1;
parameter ldq_rel1_collide_binv_offset = rel2_rviss_blk_offset + 1;
parameter ldq_stq_rel1_blk_store_offset = ldq_rel1_collide_binv_offset + 1;
parameter ex4_ldreq_offset = ldq_stq_rel1_blk_store_offset + 1;
parameter ex5_ldreq_val_offset = ex4_ldreq_offset + 1;
parameter ex4_pfetch_val_offset = ex5_ldreq_val_offset + 1;
parameter ex5_pfetch_val_offset = ex4_pfetch_val_offset + 1;
parameter ex5_odq_ldreq_val_offset = ex5_pfetch_val_offset + 1;
parameter ex5_streq_val_offset = ex5_odq_ldreq_val_offset + 1;
parameter ex5_othreq_val_offset = ex5_streq_val_offset + 1;
parameter ex5_reserved_taken_offset = ex5_othreq_val_offset + 1;
parameter ex5_resv_taken_restart_offset = ex5_reserved_taken_offset + 1;
parameter lq_xu_quiesce_offset = ex5_resv_taken_restart_offset + 1;
parameter lq_pc_ldq_quiesce_offset = lq_xu_quiesce_offset + `THREADS;
parameter lq_pc_stq_quiesce_offset = lq_pc_ldq_quiesce_offset + `THREADS;
parameter lq_pc_pfetch_quiesce_offset = lq_pc_stq_quiesce_offset + `THREADS;
parameter lq_mm_lmq_stq_empty_offset = lq_pc_pfetch_quiesce_offset + `THREADS;
parameter ex5_ldq_full_offset = lq_mm_lmq_stq_empty_offset + 1;
parameter ex5_ldq_full_restart_offset = ex5_ldq_full_offset + 1;
parameter ex5_ldq_hit_offset = ex5_ldq_full_restart_offset + 1;
parameter ex5_ld_gath_offset = ex5_ldq_hit_offset + 1;
parameter ldq_full_qHit_held_offset = ex5_ld_gath_offset + 1;
parameter ldq_resv_qHit_held_offset = ldq_full_qHit_held_offset + 1;
parameter ldq_oth_qHit_clr_offset = ldq_resv_qHit_held_offset + 1;
parameter ex5_ldq_set_hold_offset = ldq_oth_qHit_clr_offset + 1;
parameter ex5_ldq_restart_offset = ex5_ldq_set_hold_offset + 1;
parameter ex6_ldq_full_offset = ex5_ldq_restart_offset + 1;
parameter ex6_ldq_hit_offset = ex6_ldq_full_offset + 1;
parameter ex5_lgq_full_offset = ex6_ldq_hit_offset + 1;
parameter ex6_lgq_full_offset = ex5_lgq_full_offset + 1;
parameter ex5_lgq_qwhit_offset = ex6_lgq_full_offset + 1;
parameter ex6_lgq_qwhit_offset = ex5_lgq_qwhit_offset + 1;
parameter ex5_p_addr_offset = ex6_lgq_qwhit_offset + 1;
parameter ex5_wimge_offset = ex5_p_addr_offset + `REAL_IFAR_WIDTH;
parameter ex6_cmmt_perf_events_offset = ex5_wimge_offset + 5;
parameter ex5_ldqe_set_all_offset = ex6_cmmt_perf_events_offset + 4;
parameter ex5_ldqe_set_val_offset = ex5_ldqe_set_all_offset + `LMQ_ENTRIES;
parameter ex6_ldqe_pfetch_val_offset = ex5_ldqe_set_val_offset + `LMQ_ENTRIES;
parameter ex7_ldqe_pfetch_val_offset = ex6_ldqe_pfetch_val_offset + `LMQ_ENTRIES;
parameter ex5_ldm_hit_offset = ex7_ldqe_pfetch_val_offset + `LMQ_ENTRIES;
parameter ldq_hold_tid_offset = ex5_ldm_hit_offset + `LMQ_ENTRIES;
parameter fifo_ldq_req_nxt_ptr_offset = ldq_hold_tid_offset + `THREADS;
parameter fifo_ldq_req_val_offset = fifo_ldq_req_nxt_ptr_offset + `LMQ_ENTRIES + 1;
parameter fifo_ldq_req_pfetch_offset = fifo_ldq_req_val_offset + `LMQ_ENTRIES;
parameter fifo_ldq_req_tid_offset = fifo_ldq_req_pfetch_offset + `LMQ_ENTRIES;
parameter fifo_ldq_req_offset = fifo_ldq_req_tid_offset + (`THREADS) * `LMQ_ENTRIES;
parameter ldqe_val_offset = fifo_ldq_req_offset + (`LMQ_ENTRIES) * `LMQ_ENTRIES;
parameter ldqe_req_cmpl_offset = ldqe_val_offset + `LMQ_ENTRIES;
parameter ldqe_cntr_reset_offset = ldqe_req_cmpl_offset + `LMQ_ENTRIES;
parameter ldqe_resent_ecc_err_offset = ldqe_cntr_reset_offset + `LMQ_ENTRIES;
parameter ldqe_reset_cpl_rpt_offset = ldqe_resent_ecc_err_offset + `LMQ_ENTRIES;
parameter ldqe_itag_offset = ldqe_reset_cpl_rpt_offset + `LMQ_ENTRIES;
parameter ldqe_thrd_id_offset = ldqe_itag_offset + (`ITAG_SIZE_ENC) * `LMQ_ENTRIES;
parameter ldqe_wimge_offset = ldqe_thrd_id_offset + `THREADS * `LMQ_ENTRIES;
parameter ldqe_byte_swap_offset = ldqe_wimge_offset + 5 * `LMQ_ENTRIES;
parameter ldqe_resv_offset = ldqe_byte_swap_offset + `LMQ_ENTRIES;
parameter ldqe_pfetch_offset = ldqe_resv_offset + `LMQ_ENTRIES;
parameter ldqe_op_size_offset = ldqe_pfetch_offset + `LMQ_ENTRIES;
parameter ldqe_tgpr_offset = ldqe_op_size_offset + 3 * `LMQ_ENTRIES;
parameter ldqe_usr_def_offset = ldqe_tgpr_offset + (`LMQ_ENTRIES) * (AXU_TARGET_ENC);
parameter ldqe_class_id_offset = ldqe_usr_def_offset + 4 * `LMQ_ENTRIES;
parameter ldqe_perf_events_offset = ldqe_class_id_offset + 2 * `LMQ_ENTRIES;
parameter ldqe_dvc_offset = ldqe_perf_events_offset + 4 * `LMQ_ENTRIES;
parameter ldqe_ttype_offset = ldqe_dvc_offset + 2 * `LMQ_ENTRIES;
parameter ldqe_dacrw_offset = ldqe_ttype_offset + 6 * `LMQ_ENTRIES;
parameter ldqe_p_addr_offset = ldqe_dacrw_offset + 4 * `LMQ_ENTRIES;
parameter ldqe_mkill_offset = ldqe_p_addr_offset + `REAL_IFAR_WIDTH * `LMQ_ENTRIES;
parameter ldqe_resolved_offset = ldqe_mkill_offset + `LMQ_ENTRIES;
parameter ldqe_back_inv_offset = ldqe_resolved_offset + `LMQ_ENTRIES;
parameter ldqe_back_inv_nFlush_offset = ldqe_back_inv_offset + `LMQ_ENTRIES;
parameter ldqe_back_inv_np1Flush_offset = ldqe_back_inv_nFlush_offset + `LMQ_ENTRIES;
parameter ldqe_beat_cntr_offset = ldqe_back_inv_np1Flush_offset + `LMQ_ENTRIES;
parameter ldqe_dRel_offset = ldqe_beat_cntr_offset + 4 * `LMQ_ENTRIES;
parameter ldqe_l1_dump_offset = ldqe_dRel_offset + `LMQ_ENTRIES;
parameter ldqe_dGpr_offset = ldqe_l1_dump_offset + `LMQ_ENTRIES;
parameter ldqe_axu_offset = ldqe_dGpr_offset + `LMQ_ENTRIES;
parameter ldqe_lock_set_offset = ldqe_axu_offset + `LMQ_ENTRIES;
parameter ldqe_watch_set_offset = ldqe_lock_set_offset + `LMQ_ENTRIES;
parameter ldqe_algebraic_offset = ldqe_watch_set_offset + `LMQ_ENTRIES;
parameter ldqe_state_offset = ldqe_algebraic_offset + `LMQ_ENTRIES;
parameter ldqe_sentRel_cntr_offset = ldqe_state_offset + 7 * `LMQ_ENTRIES;
parameter ex5_lgqe_set_all_offset = ldqe_sentRel_cntr_offset + 4 * `LMQ_ENTRIES;
parameter ex5_lgqe_set_val_offset = ex5_lgqe_set_all_offset + `LGQ_ENTRIES;
parameter lgqe_valid_offset = ex5_lgqe_set_val_offset + `LGQ_ENTRIES;
parameter lgqe_iTag_offset = lgqe_valid_offset + `LGQ_ENTRIES;
parameter lgqe_ldTag_offset = lgqe_iTag_offset + (`ITAG_SIZE_ENC) * `LGQ_ENTRIES;
parameter lgqe_thrd_id_offset = lgqe_ldTag_offset + 4 * `LGQ_ENTRIES;
parameter lgqe_byte_swap_offset = lgqe_thrd_id_offset + `THREADS * `LGQ_ENTRIES;
parameter lgqe_op_size_offset = lgqe_byte_swap_offset + `LGQ_ENTRIES;
parameter lgqe_tgpr_offset = lgqe_op_size_offset + 3 * `LGQ_ENTRIES;
parameter lgqe_gpr_done_offset = lgqe_tgpr_offset + (`LGQ_ENTRIES) * (AXU_TARGET_ENC);
parameter lgqe_resolved_offset = lgqe_gpr_done_offset + `LGQ_ENTRIES;
parameter lgqe_back_inv_nFlush_offset = lgqe_resolved_offset + `LGQ_ENTRIES;
parameter lgqe_back_inv_np1Flush_offset = lgqe_back_inv_nFlush_offset + `LGQ_ENTRIES;
parameter lgqe_dacrw_offset = lgqe_back_inv_np1Flush_offset + `LGQ_ENTRIES;
parameter lgqe_dvc_offset = lgqe_dacrw_offset + 4 * `LGQ_ENTRIES;
parameter lgqe_p_addr_offset = lgqe_dvc_offset + 2 * `LGQ_ENTRIES;
parameter lgqe_axu_offset = lgqe_p_addr_offset + 7 * `LGQ_ENTRIES;
parameter lgqe_perf_events_offset = lgqe_axu_offset + `LGQ_ENTRIES;
parameter lgqe_upd_gpr_ecc_offset = lgqe_perf_events_offset + 4 * `LGQ_ENTRIES;
parameter lgqe_upd_gpr_eccue_offset = lgqe_upd_gpr_ecc_offset + `LGQ_ENTRIES;
parameter lgqe_need_cpl_offset = lgqe_upd_gpr_eccue_offset + `LGQ_ENTRIES;
parameter lgqe_algebraic_offset = lgqe_need_cpl_offset + `LGQ_ENTRIES;
parameter ldqe_rst_eccdet_offset = lgqe_algebraic_offset + `LMQ_ENTRIES;
parameter ldq_rel2_beats_home_offset = ldqe_rst_eccdet_offset + `LMQ_ENTRIES;
parameter ldq_rel3_beats_home_offset = ldq_rel2_beats_home_offset + `LMQ_ENTRIES;
parameter ldq_rel4_beats_home_offset = ldq_rel3_beats_home_offset + `LMQ_ENTRIES;
parameter ldq_rel5_beats_home_offset = ldq_rel4_beats_home_offset + `LMQ_ENTRIES;
parameter ldq_rel1_entrySent_offset = ldq_rel5_beats_home_offset + `LMQ_ENTRIES;
parameter ldq_rel2_entrySent_offset = ldq_rel1_entrySent_offset + `LMQ_ENTRIES;
parameter ldq_rel3_entrySent_offset = ldq_rel2_entrySent_offset + `LMQ_ENTRIES;
parameter ldq_rel4_sentL1_offset = ldq_rel3_entrySent_offset + `LMQ_ENTRIES;
parameter ldq_rel5_sentL1_offset = ldq_rel4_sentL1_offset + `LMQ_ENTRIES;
parameter ldq_rel6_req_done_offset = ldq_rel5_sentL1_offset + `LMQ_ENTRIES;
parameter l2_rel1_resp_val_offset = ldq_rel6_req_done_offset + `LMQ_ENTRIES;
parameter l2_rel2_resp_val_offset = l2_rel1_resp_val_offset + 1;
parameter ldq_err_inval_rel_offset = l2_rel2_resp_val_offset + 1;
parameter ldq_err_ecc_det_offset = ldq_err_inval_rel_offset + 1;
parameter ldq_err_ue_det_offset = ldq_err_ecc_det_offset + 1;
parameter ldq_rel1_val_offset = ldq_err_ue_det_offset + 1;
parameter ldq_rel1_arb_val_offset = ldq_rel1_val_offset + 1;
parameter ldq_rel1_l1_dump_offset = ldq_rel1_arb_val_offset + 1;
parameter ldq_rel2_l1_dump_offset = ldq_rel1_l1_dump_offset + 1;
parameter ldq_rel3_l1_dump_offset = ldq_rel2_l1_dump_offset + 1;
parameter ldq_rel3_clr_relq_offset = ldq_rel3_l1_dump_offset + 1;
parameter ldq_rel1_resp_qw_offset = ldq_rel3_clr_relq_offset + 1;
parameter ldq_rel1_cTag_offset = ldq_rel1_resp_qw_offset + 3;
parameter ldq_rel1_opsize_offset = ldq_rel1_cTag_offset + 4;
parameter ldq_rel1_wimge_i_offset = ldq_rel1_opsize_offset + 3;
parameter ldq_rel1_byte_swap_offset = ldq_rel1_wimge_i_offset + 1;
parameter ldq_rel2_byte_swap_offset = ldq_rel1_byte_swap_offset + 1;
parameter ldq_rel1_p_addr_offset = ldq_rel2_byte_swap_offset + 1;
parameter ldq_rel1_dvcEn_offset = ldq_rel1_p_addr_offset + `REAL_IFAR_WIDTH;
parameter ldq_rel1_lockSet_offset = ldq_rel1_dvcEn_offset + 2;
parameter ldq_rel1_watchSet_offset = ldq_rel1_lockSet_offset + 1;
parameter ldq_rel1_tGpr_offset = ldq_rel1_watchSet_offset + 1;
parameter ldq_rel1_axu_offset = ldq_rel1_tGpr_offset + AXU_TARGET_ENC;
parameter ldq_rel1_algEn_offset = ldq_rel1_axu_offset + 1;
parameter ldq_rel1_classID_offset = ldq_rel1_algEn_offset + 1;
parameter ldq_rel1_tid_offset = ldq_rel1_classID_offset + 2;
parameter ldq_rel2_tid_offset = ldq_rel1_tid_offset + `THREADS;
parameter ldq_rel1_dir_tid_offset = ldq_rel2_tid_offset + `THREADS;
parameter ldqe_relDir_start_offset = ldq_rel1_dir_tid_offset + `THREADS;
parameter ldq_rel2_set_val_offset = ldqe_relDir_start_offset + `LMQ_ENTRIES;
parameter ldq_rel3_set_val_offset = ldq_rel2_set_val_offset + 1;
parameter ldq_rel4_set_val_offset = ldq_rel3_set_val_offset + 1;
parameter ldq_rel2_cclass_offset = ldq_rel4_set_val_offset + 1;
parameter ldq_rel3_cclass_offset = ldq_rel2_cclass_offset + (57-(64-(`DC_SIZE-3))+1);
parameter ldq_rel4_cclass_offset = ldq_rel3_cclass_offset + (57-(64-(`DC_SIZE-3))+1);
parameter ldq_rel1_data_sel_offset = ldq_rel4_cclass_offset + (57-(64-(`DC_SIZE-3))+1);
parameter ldq_rel0_l2_val_offset = ldq_rel1_data_sel_offset + 1;
parameter ldq_rel1_l2_val_offset = ldq_rel0_l2_val_offset + `LMQ_ENTRIES;
parameter ldq_rel2_l2_val_offset = ldq_rel1_l2_val_offset + `LMQ_ENTRIES;
parameter ldq_rel3_l2_val_offset = ldq_rel2_l2_val_offset + `LMQ_ENTRIES;
parameter ldq_rel4_l2_val_offset = ldq_rel3_l2_val_offset + `LMQ_ENTRIES;
parameter ldq_rel5_l2_val_offset = ldq_rel4_l2_val_offset + `LMQ_ENTRIES;
parameter ldqe_rel_eccdet_offset = ldq_rel5_l2_val_offset + `LMQ_ENTRIES;
parameter ldqe_rel_eccdet_ue_offset = ldqe_rel_eccdet_offset + `LMQ_ENTRIES;
parameter ldqe_upd_gpr_ecc_offset = ldqe_rel_eccdet_ue_offset + `LMQ_ENTRIES;
parameter ldqe_upd_gpr_eccue_offset = ldqe_upd_gpr_ecc_offset + `LMQ_ENTRIES;
parameter ldqe_need_cpl_offset = ldqe_upd_gpr_eccue_offset + `LMQ_ENTRIES;
parameter ldqe_sent_cpl_offset = ldqe_need_cpl_offset + `LMQ_ENTRIES;
parameter ldq_rel1_gpr_val_offset = ldqe_sent_cpl_offset + `LMQ_ENTRIES;
parameter ldq_rel0_upd_gpr_offset = ldq_rel1_gpr_val_offset + 1;
parameter ldq_rel1_upd_gpr_offset = ldq_rel0_upd_gpr_offset + `LMQ_ENTRIES;
parameter ldq_rel2_upd_gpr_offset = ldq_rel1_upd_gpr_offset + `LMQ_ENTRIES;
parameter ldq_rel3_upd_gpr_offset = ldq_rel2_upd_gpr_offset + `LMQ_ENTRIES;
parameter ldqe_rel3_drop_cpl_rpt_offset = ldq_rel3_upd_gpr_offset + `LMQ_ENTRIES;
parameter ldq_l2_rel0_qHitBlk_offset = ldqe_rel3_drop_cpl_rpt_offset + `LMQ_ENTRIES;
parameter lgq_rel1_gpr_val_offset = ldq_l2_rel0_qHitBlk_offset + 1;
parameter lgq_rel0_upd_gpr_offset = lgq_rel1_gpr_val_offset + 1;
parameter lgq_rel1_upd_gpr_offset = lgq_rel0_upd_gpr_offset + `LGQ_ENTRIES;
parameter lgq_rel2_upd_gpr_offset = lgq_rel1_upd_gpr_offset + `LGQ_ENTRIES;
parameter lgq_rel3_upd_gpr_offset = lgq_rel2_upd_gpr_offset + `LGQ_ENTRIES;
parameter lgq_rel4_upd_gpr_offset = lgq_rel3_upd_gpr_offset + `LGQ_ENTRIES;
parameter lgq_rel5_upd_gpr_offset = lgq_rel4_upd_gpr_offset + `LGQ_ENTRIES;
parameter ldq_rel4_odq_cpl_offset = lgq_rel5_upd_gpr_offset + `LGQ_ENTRIES;
parameter ldq_rel5_odq_cpl_offset = ldq_rel4_odq_cpl_offset + `LMQ_ENTRIES;
parameter ldq_rel_qHit_clr_offset = ldq_rel5_odq_cpl_offset + `LMQ_ENTRIES;
parameter ldqe_qHit_held_offset = ldq_rel_qHit_clr_offset + `LMQ_ENTRIES;
parameter cpl_grpEntry_last_sel_offset = ldqe_qHit_held_offset + `LMQ_ENTRIES;
parameter cpl_group_last_sel_offset = cpl_grpEntry_last_sel_offset + 4 * (((`LMQ_ENTRIES + `LGQ_ENTRIES - 1)/4) + 1);
parameter lq1_iu_execute_vld_offset = cpl_group_last_sel_offset + 4;
parameter lq1_iu_itag_offset = lq1_iu_execute_vld_offset + `THREADS;
parameter lq1_iu_n_flush_offset = lq1_iu_itag_offset + `ITAG_SIZE_ENC;
parameter lq1_iu_np1_flush_offset = lq1_iu_n_flush_offset + 1;
parameter lq1_iu_exception_val_offset = lq1_iu_np1_flush_offset + 1;
parameter lq1_iu_dacrw_offset = lq1_iu_exception_val_offset + 1;
parameter lq1_iu_perf_events_offset = lq1_iu_dacrw_offset + 4;
parameter ldq_cpl_larx_offset = lq1_iu_perf_events_offset + 4;
parameter ldq_cpl_binv_offset = ldq_cpl_larx_offset + `THREADS;
parameter ldq_rel_cmmt_offset = ldq_cpl_binv_offset + `THREADS;
parameter ldq_rel_need_hole_offset = ldq_rel_cmmt_offset + 1;
parameter ldq_rel_latency_offset = ldq_rel_need_hole_offset + 1;
parameter dbg_int_en_offset = ldq_rel_latency_offset + 1;
parameter ex4_stg_act_offset = dbg_int_en_offset + `THREADS;
parameter ex5_stg_act_offset = ex4_stg_act_offset + 1;
parameter rrot_scan_offset = ex5_stg_act_offset + 1;
parameter scan_right = rrot_scan_offset + 1 - 1;
parameter [0:6] LDQ_IDLE = 7'b1000000; // Idle State, Wait for valid request
parameter [0:6] LDQ_VAL = 7'b0100000; // Valid Request, need to send request to L2
parameter [0:6] LDQ_RPEN = 7'b0010000; // Waiting for Reload
parameter [0:6] LDQ_BEATM = 7'b0001000; // Mulitple Beat Request and all have arrived
parameter [0:6] LDQ_ECC = 7'b0000100; // Check for ECC error
parameter [0:6] LDQ_DCACHE = 7'b0000010; // Reload updated L1D$ with all its beats
parameter [0:6] LDQ_CMPL = 7'b0000001; // Report ITAG completion
parameter [0:4] rot_max_size = 5'b10000;
wire tiup;
wire tidn;
wire [0:scan_right] siv;
wire [0:scan_right] sov;
(* analysis_not_referenced="true" *)
wire unused;
//!! Bugspray Include: lq_ldq
assign tiup = 1'b1;
assign tidn = 1'b0;
assign unused = l2_lsq_resp_isComing | tidn | ldq_rel0_rot_sel_le[0] | fifo_ldq_req_wrt_ptr[8] | ldq_state_machines_idle;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// ACT Generation
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
assign ex4_stg_act_d = ctl_lsq_ex3_ldreq_val | ctl_lsq_ex3_pfetch_val;
assign ex5_stg_act_d = ex4_stg_act_q;
// EX4 Loadmiss Queue Entry Update ACT
assign ex4_ldqe_act = ldqe_wrt_ptr & {`LMQ_ENTRIES{ex4_stg_act_q}};
assign ex5_ldqe_act = ex5_ldqe_set_all_q & {`LMQ_ENTRIES{ex5_stg_act_q}};
assign ex4_lgqe_act = lgqe_wrt_ptr & {`LMQ_ENTRIES{ex4_stg_act_q}};
assign ex5_lgqe_act = ex5_lgqe_set_all_q & {`LMQ_ENTRIES{ex5_stg_act_q}};
// Reload Pipeline ACT
assign rel0_stg_act = ldq_reload_val;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XU Config Bits
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XUCR0[CLS] 128 Byte Cacheline Enabled
// 1 => 128 Byte Cacheline
// 0 => 64 Byte Cacheline
assign spr_xucr0_cls_d = xu_lq_spr_xucr0_cls;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LSU Config Bits
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LSUCR0[LGE] Load gather Enable
// 1 => load gathering enabled
// 0 => load gathering disabled
assign spr_lsucr0_lge_d = ctl_lsq_spr_lsucr0_lge;
// LSUCR0[LCA] Loadmiss Reload Attempts Count
assign spr_lsucr0_lca_d = ctl_lsq_spr_lsucr0_lca;
assign spr_lsucr0_lca_zero = ~(|(spr_lsucr0_lca_q));
assign spr_lsucr0_lca_ovrd = spr_lsucr0_lca_zero ? 3'b001 : spr_lsucr0_lca_q;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Completion Interface
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
assign iu_lq_cp_flush_d = iu_lq_cp_flush;
assign ex4_stg_flush = |(ctl_lsq_ex4_thrd_id & iu_lq_cp_flush_q);
assign ex5_stg_flush = |(ctl_lsq_ex5_thrd_id & iu_lq_cp_flush_q) | ctl_lsq_ex5_flush_req;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// ODQ->LDQ Resolved Interface
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
assign odq_ldq_n_flush_d = odq_ldq_resolved & odq_ldq_n_flush & ~ldq_cpl_odq_zap;
//odq_ldq_np1_flush_d <= odq_ldq_resolved and not odq_ldq_report_needed and odq_ldq_np1_flush;
assign odq_ldq_resolved_d = odq_ldq_resolved & (~odq_ldq_report_needed) & ~ldq_cpl_odq_zap;
assign odq_ldq_report_itag_d = odq_ldq_report_itag;
assign odq_ldq_report_tid_d = odq_ldq_report_tid;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// L2 Reload Interface
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// cTag(1) = 1 => either an IU reload or MMU reload
assign l2_rel0_resp_val_d = l2_lsq_resp_val;
assign l2_rel0_resp_ldq_val_d = ldq_relmin1_ldq_val;
assign l2_rel0_resp_cTag_d = ldq_relmin1_cTag;
assign l2_rel0_resp_qw_d = l2_lsq_resp_qw;
assign l2_rel0_resp_crit_qw_d = l2_lsq_resp_crit_qw;
assign l2_rel0_resp_l1_dump_d = l2_lsq_resp_l1_dump;
assign ldq_relmin1_ldq_val = l2_lsq_resp_val & (~l2_lsq_resp_cTag[1]);
assign ldq_relmin1_cTag = {l2_lsq_resp_cTag[0], l2_lsq_resp_cTag[2:4]};
assign ldq_rel1_data = l2_lsq_resp_data;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LOAD QUEUE
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// RV is empty indicator
assign rv_lq_rvs_empty_d = rv_lq_rvs_empty;
// Need to block reloads
// 1) RV issued an instruction
// 2) Back-Invalidate Congruence Class collided with Valid Reload Set/Clear Congruence Class
// 3) SPR Directory Read Operation
// 4) REL1 attempt and ECC error detected for same core Tag
// Need to block reloads
// 1) RV issued an instruction with valid reload set congruence class
assign ldq_rel1_set_rviss_dir_coll = |(rv_lq_vld) & rv_lq_isLoad & ldq_rel1_set_val;
// 2) Back-Invalidate Congruence Class collided with Valid Reload Set/Clear Congruence Class
assign ldq_rel1_set_binv_dir_coll = ldq_rel1_collide_binv_q & ldq_rel1_set_val;
// 3) SPR Directory Read Operation and valid reload set congruence class
assign ldq_rel1_set_rd_dir_coll = ctl_lsq_rv1_dir_rd_val & ldq_rel1_set_val;
assign rel2_blk_req_d = ldq_rel1_set_rviss_dir_coll | ldq_rel1_set_binv_dir_coll | ldq_rel1_set_rd_dir_coll;
assign rel2_rviss_blk_d = ldq_rel1_set_rviss_dir_coll;
// EX4 Address that is used to compare against all loadmiss queue entries
assign ex4_ldreq_d = ctl_lsq_ex3_ldreq_val;
assign ex4_pfetch_val_d = ctl_lsq_ex3_pfetch_val;
assign ex4_p_addr_msk = {ctl_lsq_ex4_p_addr[64-`REAL_IFAR_WIDTH:56], (ctl_lsq_ex4_p_addr[57] | spr_xucr0_cls_q)};
assign ex5_ldreq_val_d = ctl_lsq_ex4_ldreq_val & (~(ex4_ldq_full | ctl_lsq_ex4_dReq_val | ex4_stg_flush));
assign ex5_ldreq_val = ex5_ldreq_val_q & ~ex5_stg_flush;
assign ex5_ldreq_flushed = ex5_ldreq_val_q & ex5_stg_flush;
assign ex5_pfetch_val_d = ex4_pfetch_val_q & (~(ex4_ldq_full | ctl_lsq_ex4_dReq_val));
assign ex5_pfetch_val = ex5_pfetch_val_q & ~ctl_lsq_ex5_flush_pfetch;
assign ex5_pfetch_flushed = ex5_pfetch_val_q & ctl_lsq_ex5_flush_pfetch;
assign ex5_odq_ldreq_val_d = ctl_lsq_ex4_ldreq_val & (~ex4_stg_flush);
assign ex5_streq_val_d = ctl_lsq_ex4_streq_val & (~ex4_stg_flush);
assign ex5_othreq_val_d = ctl_lsq_ex4_othreq_val & (~ex4_stg_flush);
assign ex5_p_addr_d = ctl_lsq_ex4_p_addr;
assign ex5_wimge_d = ctl_lsq_ex4_wimge;
// Performance Events that need to go to the Completion Unit
assign ex5_cmmt_events = {ctl_lsq_ex5_cmmt_events, ex5_ld_gath_q};
assign ex5_cmmt_perf_events[0] = ctl_lsq_ex5_perf_val0 & ((ctl_lsq_ex5_perf_sel0 == 4'b1111) ? ex5_cmmt_events[11] :
(ctl_lsq_ex5_perf_sel0 == 4'b1110) ? ex5_cmmt_events[10] :
(ctl_lsq_ex5_perf_sel0 == 4'b1101) ? ex5_cmmt_events[9] :
(ctl_lsq_ex5_perf_sel0 == 4'b1100) ? ex5_cmmt_events[8] :
(ctl_lsq_ex5_perf_sel0 == 4'b1011) ? ex5_cmmt_events[7] :
(ctl_lsq_ex5_perf_sel0 == 4'b1010) ? ex5_cmmt_events[6] :
(ctl_lsq_ex5_perf_sel0 == 4'b1001) ? ex5_cmmt_events[5] :
(ctl_lsq_ex5_perf_sel0 == 4'b1000) ? ex5_cmmt_events[4] :
(ctl_lsq_ex5_perf_sel0 == 4'b0111) ? ex5_cmmt_events[3] :
(ctl_lsq_ex5_perf_sel0 == 4'b0110) ? ex5_cmmt_events[2] :
(ctl_lsq_ex5_perf_sel0 == 4'b0101) ? ex5_cmmt_events[1] :
(ctl_lsq_ex5_perf_sel0 == 4'b0100) ? ex5_cmmt_events[0] :
1'b0);
assign ex5_cmmt_perf_events[1] = ctl_lsq_ex5_perf_val1 & ((ctl_lsq_ex5_perf_sel1 == 4'b1111) ? ex5_cmmt_events[11] :
(ctl_lsq_ex5_perf_sel1 == 4'b1110) ? ex5_cmmt_events[10] :
(ctl_lsq_ex5_perf_sel1 == 4'b1101) ? ex5_cmmt_events[9] :
(ctl_lsq_ex5_perf_sel1 == 4'b1100) ? ex5_cmmt_events[8] :
(ctl_lsq_ex5_perf_sel1 == 4'b1011) ? ex5_cmmt_events[7] :
(ctl_lsq_ex5_perf_sel1 == 4'b1010) ? ex5_cmmt_events[6] :
(ctl_lsq_ex5_perf_sel1 == 4'b1001) ? ex5_cmmt_events[5] :
(ctl_lsq_ex5_perf_sel1 == 4'b1000) ? ex5_cmmt_events[4] :
(ctl_lsq_ex5_perf_sel1 == 4'b0111) ? ex5_cmmt_events[3] :
(ctl_lsq_ex5_perf_sel1 == 4'b0110) ? ex5_cmmt_events[2] :
(ctl_lsq_ex5_perf_sel1 == 4'b0101) ? ex5_cmmt_events[1] :
(ctl_lsq_ex5_perf_sel1 == 4'b0100) ? ex5_cmmt_events[0] :
1'b0);
assign ex5_cmmt_perf_events[2] = ctl_lsq_ex5_perf_val2 & ((ctl_lsq_ex5_perf_sel2 == 4'b1111) ? ex5_cmmt_events[11] :
(ctl_lsq_ex5_perf_sel2 == 4'b1110) ? ex5_cmmt_events[10] :
(ctl_lsq_ex5_perf_sel2 == 4'b1101) ? ex5_cmmt_events[9] :
(ctl_lsq_ex5_perf_sel2 == 4'b1100) ? ex5_cmmt_events[8] :
(ctl_lsq_ex5_perf_sel2 == 4'b1011) ? ex5_cmmt_events[7] :
(ctl_lsq_ex5_perf_sel2 == 4'b1010) ? ex5_cmmt_events[6] :
(ctl_lsq_ex5_perf_sel2 == 4'b1001) ? ex5_cmmt_events[5] :
(ctl_lsq_ex5_perf_sel2 == 4'b1000) ? ex5_cmmt_events[4] :
(ctl_lsq_ex5_perf_sel2 == 4'b0111) ? ex5_cmmt_events[3] :
(ctl_lsq_ex5_perf_sel2 == 4'b0110) ? ex5_cmmt_events[2] :
(ctl_lsq_ex5_perf_sel2 == 4'b0101) ? ex5_cmmt_events[1] :
(ctl_lsq_ex5_perf_sel2 == 4'b0100) ? ex5_cmmt_events[0] :
1'b0);
assign ex5_cmmt_perf_events[3] = ctl_lsq_ex5_perf_val3 & ((ctl_lsq_ex5_perf_sel3 == 4'b1111) ? ex5_cmmt_events[11] :
(ctl_lsq_ex5_perf_sel3 == 4'b1110) ? ex5_cmmt_events[10] :
(ctl_lsq_ex5_perf_sel3 == 4'b1101) ? ex5_cmmt_events[9] :
(ctl_lsq_ex5_perf_sel3 == 4'b1100) ? ex5_cmmt_events[8] :
(ctl_lsq_ex5_perf_sel3 == 4'b1011) ? ex5_cmmt_events[7] :
(ctl_lsq_ex5_perf_sel3 == 4'b1010) ? ex5_cmmt_events[6] :
(ctl_lsq_ex5_perf_sel3 == 4'b1001) ? ex5_cmmt_events[5] :
(ctl_lsq_ex5_perf_sel3 == 4'b1000) ? ex5_cmmt_events[4] :
(ctl_lsq_ex5_perf_sel3 == 4'b0111) ? ex5_cmmt_events[3] :
(ctl_lsq_ex5_perf_sel3 == 4'b0110) ? ex5_cmmt_events[2] :
(ctl_lsq_ex5_perf_sel3 == 4'b0101) ? ex5_cmmt_events[1] :
(ctl_lsq_ex5_perf_sel3 == 4'b0100) ? ex5_cmmt_events[0] :
1'b0);
assign ex6_cmmt_perf_events_d = ex5_cmmt_perf_events;
// Need to Mask off bit 57 of Back-Invalidate Address depending on the Cacheline Size we are running with
assign l2_back_inv_addr_msk = l2_back_inv_addr[64 - `REAL_IFAR_WIDTH:57];
// Init Number of expected Beats
assign ldqe_beat_init = {1'b0, ((~spr_xucr0_cls_q)), 2'b00};
// LDQ Entry WRT Pointer Logic
// Look for first IDLE state machine from LOADMISSQ(0) -> LOADMISSQ(`LMQ_ENTRIES-1)
assign ldqe_wrt_ptr[0] = ldqe_available[0];
generate begin : LdPriWrt
genvar ldq;
for (ldq=1; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin : LdPriWrt
assign ldqe_wrt_ptr[ldq] = &((~ldqe_available[0:ldq - 1])) & ldqe_available[ldq];
end
end
endgenerate
// Check for only 1 entry available
// Look for first IDLE state machine from LOADMISSQ(`LMQ_ENTRIES-1) -> LOADMISSQ(0)
assign ldqe_opposite_ptr[`LMQ_ENTRIES - 1] = ldqe_available[`LMQ_ENTRIES - 1];
generate begin : lastMach
genvar ldq;
for (ldq = 0; ldq <= `LMQ_ENTRIES-2; ldq=ldq+1) begin : lastMach
assign ldqe_opposite_ptr[ldq] = &((~ldqe_available[ldq + 1:`LMQ_ENTRIES - 1])) & ldqe_available[ldq];
end
end
endgenerate
assign ex4_one_machine_avail = |(ldqe_wrt_ptr & ldqe_opposite_ptr);
// Oldest Load can use state machine
assign ex4_oldest_load = (odq_ldq_oldest_ld_itag == ctl_lsq_ex4_itag) & |(odq_ldq_oldest_ld_tid & ctl_lsq_ex4_thrd_id);
assign ex4_reserved_taken = (ctl_lsq_ex4_ldreq_val | ex4_pfetch_val_q) & ex4_one_machine_avail & (~ex4_oldest_load);
assign ex5_reserved_taken_d = ex4_reserved_taken;
assign ex4_resv_taken_restart = ctl_lsq_ex4_ldreq_val & ex4_one_machine_avail & (~(ex4_oldest_load | ex4_stg_flush));
assign ex5_resv_taken_restart_d = ex4_resv_taken_restart;
// Load Queue Entry Update Control
assign ex4_ldqe_set_val = ldqe_wrt_ptr & {`LMQ_ENTRIES{((ctl_lsq_ex4_ldreq_val & (~ex4_stg_flush)) | ex4_pfetch_val_q)}};
assign ex4_ldqe_set_all = ldqe_wrt_ptr & {`LMQ_ENTRIES{(ex4_ldreq_q | ex4_pfetch_val_q)}};
assign ex5_ldqe_set_all_d = ex4_ldqe_set_all;
assign ex5_ldqe_set_val_d = ex4_ldqe_set_val;
assign ex5_ldm_entry = ex5_ldqe_set_val_q & {`LMQ_ENTRIES{(ex5_ldreq_val_q | ex5_pfetch_val_q)}};
assign ex6_ldqe_pfetch_val_d = ex5_ldqe_set_all_q & {`LMQ_ENTRIES{(ex5_pfetch_val & ~ex5_drop_req_val)}};
assign ex7_ldqe_pfetch_val_d = ex6_ldqe_pfetch_val_q;
assign ex7_pfetch_blk_val = |(ex7_ldqe_pfetch_val_q) & odq_ldq_ex7_pfetch_blk;
assign ex7_pfetch_blk_tid = ctl_lsq_ex7_thrd_id & {`THREADS{ex7_pfetch_blk_val}};
// Thread Quiesced OR reduce
always @(*) begin: tidQuiesce
reg [0:`THREADS-1] tidQ;
//(* analysis_not_referenced="true" *)
integer ldq;
tidQ = {`THREADS{1'b0}};
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin
tidQ = (ldqe_tid_inuse[ldq]) | tidQ;
end
ldq_all_req_home = ~tidQ;
end
assign lq_xu_quiesce_d = ldq_all_req_home & stq_ldq_empty & rv_lq_rvs_empty_q & ctl_lsq_pf_empty & ctl_lsq_ldp_idle;
assign lq_mm_lmq_stq_empty_d = &(ldq_all_req_home & stq_ldq_empty & rv_lq_rvs_empty_q & ctl_lsq_pf_empty & ctl_lsq_ldp_idle);
assign lq_pc_ldq_quiesce_d = ldq_all_req_home & ctl_lsq_ldp_idle;
assign lq_pc_stq_quiesce_d = stq_ldq_empty;
assign lq_pc_pfetch_quiesce_d = ctl_lsq_pf_empty;
generate begin : loadQ
genvar ldq;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin : loadQ
wire [0:3] ldqDummy;
assign ldqDummy = ldq[3:0];
// ##############################################
// ##############################################
// LDQ ENTRY State Machine
// ##############################################
// ##############################################
assign ldqe_complete[ldq] = (ldqe_sent_cpl_q[ldq] | ldqe_kill[ldq]) & ldqe_gather_done[ldq];
always @(*) begin: ldqState
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_val_d[ldq] = ldqe_val_q[ldq];
ldqe_req_cmpl_d[ldq] = 1'b0;
ldqe_rst_eccdet[ldq] = 1'b0;
ldqe_cntr_reset_d[ldq] = 1'b0;
ldqe_resent_ecc_err_d[ldq] = ldqe_resent_ecc_err_q[ldq];
ldqe_ecc_err_dgpr[ldq] = 1'b0;
ldqe_reset_cpl_rpt_d[ldq] = 1'b0;
case (ldqe_state_q[ldq])
// IDLE State
LDQ_IDLE : // STATE(0)
if (ex4_ldqe_set_val[ldq] == 1'b1 & ctl_lsq_ex4_dReq_val == 1'b0) begin // Instructions going to L2
ldqe_nxt_state[ldq] = LDQ_VAL;
ldqe_val_d[ldq] = 1'b1;
ldqe_cntr_reset_d[ldq] = 1'b1;
ldqe_resent_ecc_err_d[ldq] = 1'b0;
ldqe_reset_cpl_rpt_d[ldq] = 1'b1;
end
else
begin
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_val_d[ldq] = 1'b0;
ldqe_cntr_reset_d[ldq] = 1'b0;
ldqe_resent_ecc_err_d[ldq] = 1'b0;
ldqe_reset_cpl_rpt_d[ldq] = 1'b1;
end
// VALID State
LDQ_VAL : // STATE(1)
if (ex4_ldqe_set_val[ldq] == 1'b1 & ctl_lsq_ex4_dReq_val == 1'b0) begin // Load Hit in the L1D$ and back-to-back load wants to use same entry
ldqe_nxt_state[ldq] = LDQ_VAL;
ldqe_val_d[ldq] = 1'b1;
end
else if (ldqe_zap[ldq] == 1'b1 & ldqe_sent[ldq] == 1'b0) begin // Entry Zap and havent Sent
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_req_cmpl_d[ldq] = 1'b1;
ldqe_val_d[ldq] = 1'b0;
end
else if (ldqe_sent[ldq] == 1'b1) begin // Request sent to L2
ldqe_nxt_state[ldq] = LDQ_RPEN;
ldqe_val_d[ldq] = 1'b0;
end
else
ldqe_nxt_state[ldq] = LDQ_VAL;
// RELOAD PENDING State
LDQ_RPEN : // STATE(2)
if (ldqe_wimge_q[ldq][1] == 1'b1 & ldq_relmin1_l2_val[ldq] == 1'b1) // Cache-Inhibited Reload
ldqe_nxt_state[ldq] = LDQ_ECC;
else if (ldqe_wimge_q[ldq][1] == 1'b0 & ldq_relmin1_l2_val[ldq] == 1'b1) // Cacheable Reload Beat0 Received
ldqe_nxt_state[ldq] = LDQ_BEATM;
else
ldqe_nxt_state[ldq] = LDQ_RPEN;
// RELOAD MULTIPLE BEATS State
LDQ_BEATM : // STATE(3)
if (ldq_rel1_beats_home[ldq] == 1'b1 & ldq_rel1_l2_val_q[ldq] == 1'b1)
ldqe_nxt_state[ldq] = LDQ_ECC;
else
ldqe_nxt_state[ldq] = LDQ_BEATM;
// RELOAD CHECK ECC State
LDQ_ECC : // STATE(4)
if (ldq_rel2_l2_val_q[ldq] == 1'b1 & ldqe_rel_eccdet[ldq] == 1'b1) begin // Correctable ECC Error detected on any Beats
ldqe_nxt_state[ldq] = LDQ_RPEN;
ldqe_rst_eccdet[ldq] = 1'b1;
ldqe_cntr_reset_d[ldq] = 1'b1;
ldqe_resent_ecc_err_d[ldq] = 1'b1;
ldqe_ecc_err_dgpr[ldq] = 1'b1;
end
else if (ldq_rel2_l2_val_q[ldq] == 1'b1) // Uncorrectable or Reload Complete
ldqe_nxt_state[ldq] = LDQ_DCACHE;
else
ldqe_nxt_state[ldq] = LDQ_ECC;
// RELOAD UPDATE CACHE State
LDQ_DCACHE : // STATE(5)
if (ldq_rel6_req_done_q[ldq] == 1'b1) begin // Data Cache and Directory has been updated
if (ldqe_complete[ldq] == 1'b1) begin // Entry was Machine Killed or Already sent completion report
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_reset_cpl_rpt_d[ldq] = 1'b1;
ldqe_resent_ecc_err_d[ldq] = 1'b0;
ldqe_req_cmpl_d[ldq] = 1'b1;
ldqe_rst_eccdet[ldq] = 1'b1; // Reset ECC Error Indicator
end
else
// Entry has not been Machine Killed
ldqe_nxt_state[ldq] = LDQ_CMPL;
end
else
ldqe_nxt_state[ldq] = LDQ_DCACHE;
// COMPLETION REPORT
LDQ_CMPL : // STATE(6)
if (ldqe_complete[ldq] == 1'b1) begin // Entry was Machine Killed or Completion report returned
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_reset_cpl_rpt_d[ldq] = 1'b1;
ldqe_resent_ecc_err_d[ldq] = 1'b0;
ldqe_req_cmpl_d[ldq] = 1'b1;
ldqe_rst_eccdet[ldq] = 1'b1; // Reset ECC Error Indicator
end
else
ldqe_nxt_state[ldq] = LDQ_CMPL;
default :
begin
ldqe_nxt_state[ldq] = LDQ_IDLE;
ldqe_val_d[ldq] = ldqe_val_q[ldq];
ldqe_req_cmpl_d[ldq] = 1'b0;
ldqe_rst_eccdet[ldq] = 1'b0;
ldqe_cntr_reset_d[ldq] = 1'b0;
ldqe_resent_ecc_err_d[ldq] = ldqe_resent_ecc_err_q[ldq];
ldqe_ecc_err_dgpr[ldq] = 1'b0;
ldqe_reset_cpl_rpt_d[ldq] = 1'b0;
end
endcase
end
assign ldqe_state_d[ldq] = ldqe_nxt_state[ldq];
assign ldqe_rst_eccdet_d[ldq] = ldqe_rst_eccdet[ldq];
// ##############################################
// Load Queue Contents
// Drop Reload
assign ldqe_dRel_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_drop_rel : ldqe_dRel_q[ldq];
// Instructions ITAG
assign ldqe_itag_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_itag : ldqe_itag_q[ldq];
// Request Physical Address Bits
assign ldqe_p_addr_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_p_addr : ldqe_p_addr_q[ldq];
// WIMGE Bits
assign ldqe_wimge_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_wimge : ldqe_wimge_q[ldq];
assign ldqe_wimge_i[ldq] = ldqe_wimge_q[ldq][1];
assign ldqe_wimge_g[ldq] = ldqe_wimge_q[ldq][3];
// Byte Swap Bits
assign ldqe_byte_swap_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_byte_swap : ldqe_byte_swap_q[ldq];
// LARX Bits
assign ldqe_resv_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_is_resv : ldqe_resv_q[ldq];
// PreFetch Valid Bits
assign ldqe_pfetch_d[ldq] = ex4_ldqe_set_all[ldq] ? ex4_pfetch_val_q : ldqe_pfetch_q[ldq];
// `THREADS Bits
assign ldqe_thrd_id_d[ldq] = ex4_ldqe_set_all[ldq] ? ctl_lsq_ex4_thrd_id : ldqe_thrd_id_q[ldq];
// lock_set Bits
assign ldqe_lock_set_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_lock_set : ldqe_lock_set_q[ldq];
// watch_set Bits
assign ldqe_watch_set_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_watch_set : ldqe_watch_set_q[ldq];
// op_size Bits
assign ldqe_op_size_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_opsize : ldqe_op_size_q[ldq];
// tgpr Bits
assign ldqe_tgpr_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_tgpr : ldqe_tgpr_q[ldq];
// axu Bits
assign ldqe_axu_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_axu_val : ldqe_axu_q[ldq];
// usr_def Bits
assign ldqe_usr_def_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_usr_def : ldqe_usr_def_q[ldq];
// algebraic Bits
assign ldqe_algebraic_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_algebraic : ldqe_algebraic_q[ldq];
// class_id Bits
assign ldqe_class_id_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_class_id : ldqe_class_id_q[ldq];
// performance events
assign ldqe_perf_events_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ex5_cmmt_perf_events : ldqe_perf_events_q[ldq];
// GPR Update is done
// ldqe_set_gpr_done = "11" => This should never occur, will need bugspray here
assign ldqe_set_gpr_done[ldq] = {ex5_ldqe_set_all_q[ldq], ldq_rel2_upd_gpr_q[ldq]};
// DVC Bits
assign ldqe_dvc_d[ldq] = (ldqe_set_gpr_done[ldq] == 2'b01) ? ldq_rel2_dvc :
(ldqe_set_gpr_done[ldq] == 2'b00) ? ldqe_dvc_q[ldq] :
ctl_lsq_ex5_dvc;
// ttype Bits
assign ldqe_ttype_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_ttype : ldqe_ttype_q[ldq];
// DAC Status Bits
assign ldqe_dacrw_d[ldq] = ex5_ldqe_set_all_q[ldq] ? ctl_lsq_ex5_dacrw : ldqe_dacrw_q[ldq];
// Load Request was restarted due to load-hit-load
assign ldqe_qHit_held_sel[ldq] = {ex4_load_qHit_upd[ldq], ldq_rel2_qHit_clr[ldq]};
assign ldqe_qHit_held_d[ldq] = (ldqe_qHit_held_sel[ldq] == 2'b00) ? ldqe_qHit_held_q[ldq] :
(ldqe_qHit_held_sel[ldq] == 2'b10) ? 1'b1 :
1'b0;
// ##############################################
// ##############################################
// ##############################################
// LDQ Control
// ##############################################
// ##############################################
// Request Hit Detect Logic
// Detecting QHits for loads hitting against other loadmisses, used for the entry snoop detection
assign ldqe_p_addr_msk[ldq] = {ldqe_p_addr_q[ldq][64 - `REAL_IFAR_WIDTH:56], (ldqe_p_addr_q[ldq][57] | spr_xucr0_cls_q)};
assign ex4_addr_m_queue[ldq] = (ldqe_p_addr_msk[ldq] == ex4_p_addr_msk);
assign ex4_qw_hit_queue[ldq] = ~spr_xucr0_cls_q ? (ldqe_p_addr_q[ldq][58:59] == ctl_lsq_ex4_p_addr[58:59]) :
(ldqe_p_addr_q[ldq][57:59] == ctl_lsq_ex4_p_addr[57:59]);
assign ex4_thrd_id_m[ldq] = |(ldqe_thrd_id_q[ldq] & ctl_lsq_ex4_thrd_id);
assign ex4_larx_hit[ldq] = ex4_thrd_id_m[ldq] & ldqe_resv_q[ldq];
assign ex4_guarded_hit[ldq] = ex4_thrd_id_m[ldq] & ldqe_wimge_g[ldq] & ctl_lsq_ex4_wimge[3];
assign ex4_req_hit_ldq[ldq] = ex4_larx_hit[ldq] | ex4_guarded_hit[ldq] | ex4_addr_m_queue[ldq];
// Want to only gather from request that hasnt been sent to the L2 only if the thread matches, if the thread doesnt match,
// the request in ldm queue may get flushed and the gathered request will still be valid which causes the gathered request
// to match on an invalid reload.
// It is not thread dependent if the request has already been sent to the L2, we are guaranteed to get data back if the request in ldm queue
// is flushed.
assign ldqe_entry_gatherable[ldq] = ((ldqe_state_q[ldq][1] & ex4_thrd_id_m[ldq] & (~ex5_inv_ldqe[ldq])) | ldqe_state_q[ldq][2]) &
(~(ldq_relmin1_l2_val[ldq] | ldqe_wimge_q[ldq][1] | ldqe_resv_q[ldq]));
assign ex4_entry_gatherable[ldq] = ex4_addr_m_queue[ldq] & ctl_lsq_ex4_gath_load & spr_lsucr0_lge_q & ~ex4_qw_hit_queue[ldq];
assign ex4_entry_gath_ld[ldq] = ex4_entry_gatherable[ldq] & ldqe_entry_gatherable[ldq] & ld_gath_not_full & ~ex4_lgq_qw_hit[ldq];
// Performance Events
assign ex4_entry_gath_full[ldq] = ex4_entry_gatherable[ldq] & ldqe_entry_gatherable[ldq] & ~ld_gath_not_full;
assign ex4_entry_gath_qwhit[ldq] = ex4_entry_gatherable[ldq] & ldqe_entry_gatherable[ldq] & ld_gath_not_full & ex4_lgq_qw_hit[ldq];
// THIS STATEMENT CHANGES WHEN THE LDQ DOESNT HOLD UNRESOLVED ITAGS WHEN THE RELOAD IS COMPLETE
// WILL HAVE TO CHANGE LDQE_STATE_Q(LDQ)(2 TO 6)
// ldqe_inuse(ldq) = (ldqe_state_q(ldq)(1) and not ex5_inv_ldqe(ldq)) or or_reduce(ldqe_state_q(ldq)(2 to 5));
assign ldqe_inuse[ldq] = (ldqe_state_q[ldq][1] & (~ex5_inv_ldqe[ldq])) | |(ldqe_state_q[ldq][2:6]);
assign ldqe_tid_inuse[ldq] = (ldqe_thrd_id_q[ldq] & {`THREADS{ldqe_inuse[ldq]}});
assign ldqe_req_outstanding[ldq] = (ldqe_state_q[ldq][1] & (~ex5_inv_ldqe[ldq])) | |(ldqe_state_q[ldq][2:5]);
assign ldqe_tid_req_outstanding[ldq] = ldqe_thrd_id_q[ldq] & {`THREADS{ldqe_req_outstanding[ldq]}};
assign ldqe_req_able_to_hold[ldq] = (ldqe_state_q[ldq][1] & ex4_thrd_id_m[ldq] & (~ex5_inv_ldqe[ldq])) | |(ldqe_state_q[ldq][2:5]);
assign ex4_entry_load_qHit[ldq] = ldqe_req_outstanding[ldq] & ex4_req_hit_ldq[ldq] & (ctl_lsq_ex4_ldreq_val | ex4_pfetch_val_q) & (~ctl_lsq_ex4_dReq_val);
// Detect when to update qHit_held and when to report SET_HOLD to RV for a particular itag
assign ldqe_rel_blk_qHit_held[ldq] = ldq_rel2_qHit_clr[ldq] | ldq_rel_qHit_clr_q[ldq] | ex4_entry_gath_ld[ldq];
assign ex4_load_qHit_upd[ldq] = ldqe_req_able_to_hold[ldq] & ex4_req_hit_ldq[ldq] & (~ldqe_rel_blk_qHit_held[ldq]) & ctl_lsq_ex4_ldreq_val & (~ctl_lsq_ex4_dReq_val);
// Store Request Hit against outstanding Loadmiss Request
// It shouldnt matter if the outstanding load was zapped, the sync still needs to wait for the reload to complete if the request was sent out
// this is the case where a load went out, took forever to come back, got zapped while waiting for reload, sync came down the pipe,
// sync cant go out until reload is back, dci needs to look at all threads with outstanding requests, dci needs to wait until they are all back
assign ex5_ldm_hit_d[ldq] = ctl_lsq_ex4_streq_val & ldqe_req_outstanding[ldq] & (ex4_req_hit_ldq[ldq] | (ex4_thrd_id_m[ldq] & ctl_lsq_ex4_is_sync) | ctl_lsq_ex4_all_thrd_chk);
// Entry Was Back-Invalidated
assign ldqe_back_inv[ldq] = (ldqe_p_addr_msk[ldq] == l2_back_inv_addr_msk) & ldqe_inuse[ldq] & l2_back_inv_val;
assign ldqe_back_inv_d[ldq] = ({ex4_ldqe_set_all[ldq], ldqe_back_inv[ldq]} == 2'b00) ? ldqe_back_inv_q[ldq] :
({ex4_ldqe_set_all[ldq], ldqe_back_inv[ldq]} == 2'b01) ? 1'b1 :
1'b0;
// Determine if this entry was for the CP_NEXT itag
begin : ldqeItagTid
genvar tid;
for (tid=0; tid<`THREADS; tid=tid+1) begin : ldqeItagTid
assign ldqe_cpNext_tid[ldq][tid] = ldqe_thrd_id_q[ldq][tid] & (ldqe_itag_q[ldq] == iu_lq_cp_next_itag_q[tid]);
end
end
assign ldqe_cpNext_val[ldq] = |(ldqe_cpNext_tid[ldq]);
// Want to Flush if the loadqueue was back-invalidated or the L1 Dump signal is on for the reload
assign ldqe_back_inv_flush_upd[ldq] = ldqe_back_inv[ldq] | ldq_rel_l1_dump[ldq];
// NEED TO REVISIT THIS STATEMENT, I BELIEVE THIS SCENARIO ONLY EXISTS IF THE LDQ HOLDS UNRESOLVED ITAGS WHEN THE RELOAD IS COMPLETE
// Want to only capture the first back-invalidate
// There is a hole where it was a cp_next itag when the back-invalidate hit
// then an older loadmiss went to the L2, got newer data
// another back-invalidate comes in and sets the cpnext_val indicator causing an NP1 flush
// when we really wanted an N flush
assign ldqe_back_inv_nFlush_d[ldq] = ({ex4_ldqe_set_all[ldq], ldqe_back_inv_flush_upd[ldq]} == 2'b00) ? ldqe_back_inv_nFlush_q[ldq] :
({ex4_ldqe_set_all[ldq], ldqe_back_inv_flush_upd[ldq]} == 2'b01) ? (ldqe_back_inv_nFlush_q[ldq] | ((~ldqe_cpNext_val[ldq]))) :
1'b0;
assign ldqe_back_inv_np1Flush_d[ldq] = ({ex4_ldqe_set_all[ldq], ldqe_back_inv_flush_upd[ldq]} == 2'b00) ? ldqe_back_inv_np1Flush_q[ldq] :
({ex4_ldqe_set_all[ldq], ldqe_back_inv_flush_upd[ldq]} == 2'b01) ? (ldqe_back_inv_np1Flush_q[ldq] | ldqe_cpNext_val[ldq]) :
1'b0;
// Load Request access to L2 Available
assign ldqe_need_l2send[ldq] = ldqe_val_q[ldq] & (~ex5_ldqe_set_all_q[ldq]);
// Load Entry Sent to L2
assign ldqe_sent[ldq] = ((fifo_ldq_req0_avail & fifo_ldq_req_q[0][ldq]) | // Sent from FIFO
((ex5_ldreq_val | ex5_pfetch_val) & ex5_ldqe_set_all_q[ldq] &
(~(ex5_drop_req_val | ldq_l2_req_need_send)))) & // Sent from Pipe
arb_ldq_ldq_unit_sel;
// entry needs to be invalidated
// 1) Load was a Load Hit in the L1D$
// 2) There was only 1 state machine and non oldest load took it
assign ex5_inv_ldqe[ldq] = ex5_ldqe_set_all_q[ldq] & (ex5_drop_req_val | ex5_ldreq_flushed | ex5_pfetch_flushed);
// Determine if Entry should be Flushed
// CP Flush
assign ldqe_cp_flush[ldq] = |(iu_lq_cp_flush_q & ldqe_thrd_id_q[ldq]) & ~ldqe_pfetch_q[ldq];
// OrderQ Flush
assign ldqe_odq_flush[ldq] = (odq_ldq_report_itag_q == ldqe_itag_q[ldq]) & |(odq_ldq_report_tid_q & ldqe_thrd_id_q[ldq]) & odq_ldq_n_flush_q;
// OrderQ Prefetch Block due to the prefetch would have caused an NFlush of user code
assign ldqe_pfetch_flush[ldq] = ex7_ldqe_pfetch_val_q[ldq] & odq_ldq_ex7_pfetch_blk;
assign ldqe_flush[ldq] = (ldqe_cp_flush[ldq] | ldqe_odq_flush[ldq] | ldqe_pfetch_flush[ldq]) & (~ldqe_state_q[ldq][0]);
// Entry is Deleted when the entry is flushed or when we determine the entry was a load hit
assign ldqe_mkill[ldq] = ldqe_flush[ldq];
assign ldqe_kill[ldq] = ldqe_mkill[ldq] | ldqe_mkill_q[ldq];
assign ldqe_zap[ldq] = ldqe_mkill[ldq] | ex5_inv_ldqe[ldq];
// Load Request got Machine Killed
assign ldqe_mkill_d[ldq] = ({ex4_ldqe_set_all[ldq], ldqe_mkill[ldq]} == 2'b00) ? ldqe_mkill_q[ldq] :
({ex4_ldqe_set_all[ldq], ldqe_mkill[ldq]} == 2'b01) ? 1'b1 :
1'b0;
// Load Entry Has Resolved In Order Queue
assign ldqe_resolved[ldq] = (ldqe_itag_q[ldq] == odq_ldq_report_itag_q) & |(odq_ldq_report_tid_q & ldqe_thrd_id_q[ldq]) & odq_ldq_resolved_q & (~ldqe_state_q[ldq][0]);
assign ldqe_resolved_d[ldq] = ({ex4_ldqe_set_all[ldq], ldqe_resolved[ldq]} == 2'b00) ? ldqe_resolved_q[ldq] :
({ex4_ldqe_set_all[ldq], ldqe_resolved[ldq]} == 2'b01) ? 1'b1 :
1'b0;
// ##############################################
// ##############################################
// LDQ Reload Control
// ##############################################
// ##############################################
// Reload for Entry is valid
assign ldqe_ctrl_act[ldq] = ~ldqe_state_q[ldq][0];
assign ldqe_rel_inprog[ldq] = |(ldqe_state_q[ldq][2:3]);
assign ldqe_rel0_cTag[ldq] = (ldqDummy == ldq_resp_cTag);
assign ldqe_rel1_cTag[ldq] = (ldqDummy == ldq_rel1_cTag_q);
assign ldqe_relmin1_cTag[ldq] = (ldqDummy == ldq_relmin1_cTag);
assign ldq_relmin1_l2_val[ldq] = ldq_relmin1_ldq_val & ldqe_relmin1_cTag[ldq] & ldqe_rel_inprog[ldq];
assign ldq_rel0_l2_val_d[ldq] = ldq_relmin1_l2_val[ldq];
assign ldq_relmin1_l2_inval[ldq] = ldq_relmin1_ldq_val & ldqe_relmin1_cTag[ldq] & (~ldqe_rel_inprog[ldq]);
assign ldq_rel_l1_dump[ldq] = ldq_rel0_l2_val_q[ldq] & l2_rel0_resp_l1_dump_q;
assign ldq_rel0_arb_sent[ldq] = ldq_rel0_arb_val & ldqe_rel0_cTag[ldq];
assign ldq_rel_l2_l1dumpBlk[ldq] = ldq_rel0_l2_val_q[ldq] & l2_rel0_resp_l1_dump_q & (ldqe_watch_set_q[ldq] | ldqe_lock_set_q[ldq]);
assign ldq_relmin1_l2_qHitBlk[ldq] = ldqe_relmin1_cTag[ldq] & ldqe_qHit_held_q[ldq];
// Reload Data Queue Parity Error should cause an NFlush only if the request was a DCBT[ST]LS or an LDAWX
assign ldqe_cpNext_ecc_err[ldq] = (ldqe_lock_set_q[ldq] | ldqe_watch_set_q[ldq]) & (ldqe_resent_ecc_err_q[ldq] | ldqe_rel_rdat_perr[ldq]);
// Either L2 Reload or Reload ARB is valid
assign ldq_rel0_entrySent[ldq] = ldq_reload_val & ldqe_rel0_cTag[ldq] & (~(ldqe_wimge_i[ldq] | ldqe_drop_reload_val[ldq] | ldq_rel_l1_dump[ldq]));
assign ldq_rel1_entrySent_d[ldq] = ldq_rel0_entrySent[ldq] & ~ldqe_rst_eccdet_q[ldq];
assign ldq_rel2_entrySent_d[ldq] = ldq_rel1_entrySent_q[ldq] & ~ldqe_rst_eccdet_q[ldq];
assign ldq_rel3_entrySent_d[ldq] = ldq_rel2_entrySent_q[ldq] & ~ldqe_rst_eccdet_q[ldq];
// L2 reload is valid
assign ldq_rel1_l2_val_d[ldq] = ldq_rel0_l2_val_q[ldq];
assign ldq_rel2_l2_val_d[ldq] = ldq_rel1_l2_val_q[ldq];
assign ldq_rel3_l2_val_d[ldq] = ldq_rel2_l2_val_q[ldq] & (~ldqe_rel_eccdet[ldq]);
assign ldq_rel4_l2_val_d[ldq] = ldq_rel3_l2_val_q[ldq];
assign ldq_rel5_l2_val_d[ldq] = ldq_rel4_l2_val_q[ldq];
// L1 Reload is complete, Data Cache has been updated
assign ldq_rel4_sentL1_d[ldq] = ldq_rel3_entrySent_q[ldq] & ldqe_sentL1[ldq];
assign ldq_rel5_sentL1_d[ldq] = ldq_rel4_sentL1_q[ldq];
// Request is complete for REL6 type requests
// I=1 load L2 only load
assign ldq_rel5_req_noL1done[ldq] = ldq_rel5_l2_val_q[ldq] & (ldqe_wimge_i[ldq] | (ldqe_drop_reload_val[ldq] & ldq_rel5_beats_home_q[ldq]));
// I=0 L1 Load
assign ldq_rel5_req_done[ldq] = ldq_rel5_sentL1_q[ldq] | ldq_rel5_req_noL1done[ldq];
assign ldq_rel6_req_done_d[ldq] = ldq_rel5_req_done[ldq];
// Cache-Inhibited Reload is complete
assign ldq_rel2_ci_done[ldq] = ldq_rel2_l2_val_q[ldq] & ldqe_wimge_i[ldq];
// Drop Cacheable Reload is complete
assign ldq_rel2_drel_done[ldq] = ldq_rel2_l2_val_q[ldq] & ldqe_drop_reload_val[ldq] & ldq_rel2_beats_home_q[ldq];
// Increment Beat Counter
assign ldqe_beat_ctrl[ldq] = {ldqe_cntr_reset_q[ldq], ldq_rel0_l2_val_q[ldq]};
assign ldqe_beat_incr[ldq] = ldqe_beat_cntr_q[ldq] + 4'b0001;
assign ldqe_beat_cntr_d[ldq] = (ldqe_beat_ctrl[ldq] == 2'b01) ? ldqe_beat_incr[ldq] :
(ldqe_beat_ctrl[ldq] == 2'b00) ? ldqe_beat_cntr_q[ldq] :
ldqe_beat_init;
// All Reload Data Beats Recieved
assign ldq_rel1_beats_home[ldq] = ldqe_beat_cntr_q[ldq][0];
assign ldq_rel2_beats_home_d[ldq] = ldq_rel1_beats_home[ldq];
assign ldq_rel3_beats_home_d[ldq] = ldq_rel2_beats_home_q[ldq];
assign ldq_rel4_beats_home_d[ldq] = ldq_rel3_beats_home_q[ldq];
assign ldq_rel5_beats_home_d[ldq] = ldq_rel4_beats_home_q[ldq];
// Reload Critical Quadword beat valid, update regfile
assign ldqe_relmin1_upd_gpr[ldq] = l2_lsq_resp_crit_qw & ldq_relmin1_l2_val[ldq] & (~ldqe_dGpr_q[ldq]);
assign ldq_rel0_upd_gpr_d[ldq] = ldqe_relmin1_upd_gpr[ldq];
assign ldq_rel0_crit_qw[ldq] = l2_rel0_resp_crit_qw_q & ldq_rel0_l2_val_q[ldq];
// Need to Drop Regfile update when the LDQ entry is zapped or if its a touch type operation or
// first reload got an ecc error
assign ldqe_dGpr_cntrl[ldq][0] = ldqe_zap[ldq] | ldqe_ecc_err_dgpr[ldq];
assign ldqe_dGpr_cntrl[ldq][1] = ex5_ldqe_set_all_q[ldq];
assign ldqe_dGpr_d[ldq] = (ldqe_dGpr_cntrl[ldq] == 2'b01) ? (~ctl_lsq_ex5_not_touch) :
(ldqe_dGpr_cntrl[ldq] == 2'b00) ? ldqe_dGpr_q[ldq] :
1'b1;
// ECC Error Detect Logic
assign ldqe_rel_eccdet_sel[ldq] = {ldq_rel2_l2_val_q[ldq], ldqe_rst_eccdet_q[ldq]};
assign ldqe_rel_eccdet[ldq] = (ldqe_rel_eccdet_sel[ldq] == 2'b10) ? (ldqe_rel_eccdet_q[ldq] | l2_lsq_resp_ecc_err) :
(ldqe_rel_eccdet_sel[ldq] == 2'b00) ? ldqe_rel_eccdet_q[ldq] :
1'b0;
assign ldqe_rel_eccdet_d[ldq] = ldqe_rel_eccdet[ldq];
assign ldqe_rel_eccdet_ue[ldq] = (ldqe_rel_eccdet_sel[ldq] == 2'b10) ? (ldqe_rel_eccdet_ue_q[ldq] | l2_lsq_resp_ecc_err_ue) :
(ldqe_rel_eccdet_sel[ldq] == 2'b00) ? ldqe_rel_eccdet_ue_q[ldq] :
1'b0;
assign ldqe_rel_eccdet_ue_d[ldq] = ldqe_rel_eccdet_ue[ldq];
// ECC Error was detected on the GPR update
assign ldqe_upd_gpr_ecc_sel[ldq] = {ldq_rel2_l2_val_q[ldq], ldqe_reset_cpl_rpt_q[ldq]};
assign ldqe_upd_gpr_ecc[ldq] = (ldqe_upd_gpr_ecc_sel[ldq] == 2'b10) ? (ldqe_upd_gpr_ecc_q[ldq] | ldq_rel2_gpr_ecc_err[ldq]) :
(ldqe_upd_gpr_ecc_sel[ldq] == 2'b00) ? ldqe_upd_gpr_ecc_q[ldq] :
1'b0;
assign ldqe_upd_gpr_ecc_d[ldq] = ldqe_upd_gpr_ecc[ldq];
assign ldqe_upd_gpr_eccue[ldq] = (ldqe_upd_gpr_ecc_sel[ldq] == 2'b10) ? (ldqe_upd_gpr_eccue_q[ldq] | ldq_rel2_gpr_eccue_err[ldq]) :
(ldqe_upd_gpr_ecc_sel[ldq] == 2'b00) ? ldqe_upd_gpr_eccue_q[ldq] :
1'b0;
assign ldqe_upd_gpr_eccue_d[ldq] = ldqe_upd_gpr_eccue[ldq];
// ECC error detected, need to create an NFlush
assign ldqe_nFlush_ecc_err[ldq] = ldqe_upd_gpr_ecc_q[ldq] | ldqe_cpNext_ecc_err[ldq];
// LoadQ Available, State Machine is IDLE
assign ldqe_available[ldq] = ldqe_state_q[ldq][0] | (ldqe_state_q[ldq][1] & ex5_inv_ldqe[ldq]);
// LoadQ Entry is complete, Waiting to send Completion Report
assign ldqe_cpl_rpt_done[ldq] = ldqe_cpl_sent[ldq] | ldq_rel5_odq_cpl[ldq];
assign ldqe_need_cpl_rst[ldq] = ldqe_cpl_rpt_done[ldq] | ldqe_kill[ldq];
assign ldqe_need_cpl_sel[ldq] = {ldqe_need_cpl_rst[ldq], ldq_rel_send_cpl_ok[ldq]};
assign ldqe_need_cpl_d[ldq] = (ldqe_need_cpl_sel[ldq] == 2'b00) ? ldqe_need_cpl_q[ldq] :
(ldqe_need_cpl_sel[ldq] == 2'b01) ? 1'b1 :
1'b0;
assign ldqe_send_cpl[ldq] = ldqe_need_cpl_q[ldq] & ldqe_resolved_q[ldq];
// LoadQ Entry Sent Completion Report Indicator
assign ldqe_sent_cpl_sel[ldq] = {ldqe_reset_cpl_rpt_q[ldq], ldqe_cpl_rpt_done[ldq]};
assign ldqe_sent_cpl_d[ldq] = (ldqe_sent_cpl_sel[ldq] == 2'b00) ? ldqe_sent_cpl_q[ldq] :
(ldqe_sent_cpl_sel[ldq] == 2'b01) ? 1'b1 :
1'b0;
// Block the setting of qHit_held if reload is completeing and is in rel2 until the state machine is freed up
assign ldqe_qHit_clr_sel[ldq] = {ldq_rel2_qHit_clr[ldq], ldqe_reset_cpl_rpt_q[ldq]};
assign ldq_rel_qHit_clr_d[ldq] = (ldqe_qHit_clr_sel[ldq] == 2'b00) ? ldq_rel_qHit_clr_q[ldq] :
(ldqe_qHit_clr_sel[ldq] == 2'b10) ? 1'b1 :
1'b0;
// Drop Reload due to L1 Dump
assign ldqe_rel_l1_dump_ctrl[ldq] = {ldq_rel_l1_dump[ldq], ldqe_cntr_reset_q[ldq]};
assign ldqe_l1_dump_d[ldq] = (ldqe_rel_l1_dump_ctrl[ldq] == 2'b10) ? ldq_rel_l1_dump[ldq] :
(ldqe_rel_l1_dump_ctrl[ldq] == 2'b00) ? ldqe_l1_dump_q[ldq] :
1'b0;
assign ldqe_drop_reload_val[ldq] = ldqe_l1_dump_q[ldq] | ldqe_dRel_q[ldq];
// Reload Data Beat is Valid
assign ldq_rel1_dbeat_val[ldq] = ldq_rel1_l2_val_q[ldq] & (~(ldqe_wimge_i[ldq] | ldqe_drop_reload_val[ldq]));
// Reload Queue Entry was not restarted
assign ldq_rel2_sentL1[ldq] = ldq_rel2_entrySent_q[ldq] & (~rel2_blk_req_q);
// Reload Queue Entry was restarted
assign ldq_rel2_sentL1_blk[ldq] = ldq_rel2_entrySent_q[ldq] & rel2_rviss_blk_q;
// Sent to L1 Beat Counter
// Should indicate when all data beats have been sent to the L1
// including beats coming from both L2 Reload and Reload Arbiters
assign ldqe_sentRel_ctrl[ldq] = {ldqe_cntr_reset_q[ldq], ldq_rel2_sentL1[ldq]};
assign ldqe_sentRel_incr[ldq] = ldqe_sentRel_cntr_q[ldq] + 4'b0001;
assign ldqe_sentRel_cntr_d[ldq] = (ldqe_sentRel_ctrl[ldq] == 2'b00) ? ldqe_sentRel_cntr_q[ldq] :
(ldqe_sentRel_ctrl[ldq] == 2'b01) ? ldqe_sentRel_incr[ldq] :
ldqe_beat_init;
// All Reload Data Beats Recieved
assign ldqe_sentL1[ldq] = ldqe_sentRel_cntr_q[ldq][0];
// L1 Data Cache has been updated, Send CLR_HOLD report to RV
assign ldqe_rel2_l1upd_cmpl[ldq] = ldq_rel2_sentL1[ldq] & &(ldqe_sentRel_cntr_q[ldq][1:3]);
// Need to Determine Last Data Beat to be sent to the L1
// The last beat missing is when the cntr=7
assign ldqe_last_beat[ldq] = &(ldqe_sentRel_cntr_d[ldq][1:3]);
// Reload has Determined a Way to update
assign ldqe_rel_start_ctrl[ldq][0] = ldqe_cntr_reset_q[ldq];
assign ldqe_rel_start_ctrl[ldq][1] = ldq_rel2_sentL1[ldq] & (~ldqe_relDir_start_q[ldq]);
assign ldqe_relDir_start[ldq] = (ldqe_rel_start_ctrl[ldq] == 2'b00) ? ldqe_relDir_start_q[ldq] :
(ldqe_rel_start_ctrl[ldq] == 2'b01) ? 1'b1 :
1'b0;
assign ldqe_relDir_start_d[ldq] = ldqe_relDir_start[ldq];
end
end
endgenerate
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LOAD GATHERING QUEUE
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// determine load tag for the ldq entry that will be gathered into
always @(*) begin: ldq_gath_Tag_P
reg [0:3] tag;
//(* analysis_not_referenced="true" *)
integer ldq;
tag = 4'b0000;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1)
tag = (ldq[3:0] & {4{ex4_entry_gath_ld[ldq]}}) | tag;
ldq_gath_Tag = tag;
end
// determine if the ex4 load hits against the load gather queue
always @(*) begin: lgq_qw_hit_P
reg [0:`LMQ_ENTRIES-1] hit;
//(* analysis_not_referenced="true" *)
integer lgq;
hit = {`LMQ_ENTRIES{1'b0}};
for (lgq=0; lgq<`LGQ_ENTRIES; lgq=lgq+1)
hit = (ldq_gath_Tag_1hot[lgq] & {`LMQ_ENTRIES{(lgqe_valid_q[lgq] & lqg_qw_match[lgq])}}) | hit;
ex4_lgq_qw_hit = hit;
end
// LGQ Entry WRT Pointer Logic
// Look for first available entry
assign lgqe_available = (~lgqe_valid_q);
assign lgqe_wrt_ptr[0] = lgqe_available[0];
generate begin : LgPriWrt
genvar lgq;
for (lgq=1; lgq<`LGQ_ENTRIES; lgq=lgq+1) begin : LgPriWrt
assign lgqe_wrt_ptr[lgq] = &((~lgqe_available[0:lgq - 1])) & lgqe_available[lgq];
end
end
endgenerate
assign ld_gath_not_full = |(lgqe_available);
// removed prefetcher from the equation
// should never gather a prefetch
assign ex4_gath_val = ctl_lsq_ex4_ldreq_val & ex4_ld_gath & (~ex4_stg_flush);
assign ex4_lgqe_set_val = lgqe_wrt_ptr & {`LGQ_ENTRIES{ex4_gath_val}};
assign ex4_lgqe_set_all = lgqe_wrt_ptr & {`LGQ_ENTRIES{ex4_ldreq_q}};
assign ex5_lgqe_set_all_d = ex4_lgqe_set_all;
assign ex5_lgqe_set_val_d = ex4_lgqe_set_val;
generate begin : load_gath_Q
genvar lgq;
for (lgq=0; lgq<`LGQ_ENTRIES; lgq=lgq+1) begin : load_gath_Q
// Gathered and Reload at same cycle, need to restart gathered entry
assign ex5_lgqe_restart[lgq] = ex5_lgqe_set_val_q[lgq] & ldq_relmin1_ldq_val & (lgqe_ldTag_q[lgq] == ldq_relmin1_cTag);
assign ex5_lgqe_drop[lgq] = ex5_lgqe_set_val_q[lgq] & ex5_drop_gath;
// Determine if Entry should be Flushed
// CP Flush
assign lgqe_cp_flush[lgq] = |(iu_lq_cp_flush_q & lgqe_thrd_id_q[lgq]) & lgqe_valid_q[lgq];
// OrderQ Flush
assign lgqe_odq_flush[lgq] = (odq_ldq_report_itag_q == lgqe_itag_q[lgq]) & |(odq_ldq_report_tid_q & lgqe_thrd_id_q[lgq]) & odq_ldq_n_flush_q;
assign lgqe_kill[lgq] = lgqe_cp_flush[lgq] | lgqe_odq_flush[lgq];
assign lgq_reset_val[lgq] = lgqe_cpl_rpt_done[lgq] | ex5_lgqe_drop[lgq] | lgqe_kill[lgq];
assign lgqe_valid_d[lgq] = ex4_lgqe_set_val[lgq] ? 1'b1 :
lgq_reset_val[lgq] ? 1'b0 : lgqe_valid_q[lgq];
// Instructions ITAG
assign lgqe_itag_d[lgq] = ex4_lgqe_set_all[lgq] ? ctl_lsq_ex4_itag : lgqe_itag_q[lgq];
// `THREADS Bits
assign lgqe_thrd_id_d[lgq] = ex4_lgqe_set_all[lgq] ? ctl_lsq_ex4_thrd_id : lgqe_thrd_id_q[lgq];
// Core TAG of load entry being gathered into
assign lgqe_ldTag_d[lgq] = ex4_lgqe_set_all[lgq] ? ldq_gath_Tag : lgqe_ldTag_q[lgq];
// create a 1-hot core tag for each gather queue entry
begin : ldq_gath_Tag_1hot_G
genvar ldq;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin : ldq_gath_Tag_1hot_G
wire [0:3] ldqDummy;
assign ldqDummy = ldq[3:0];
assign ldq_gath_Tag_1hot[lgq][ldq] = lgqe_ldTag_q[lgq] == ldqDummy;
end
end
// Request Physical Address QW select Bits
assign lgqe_p_addr_d[lgq] = ex4_lgqe_set_all[lgq] ? ctl_lsq_ex4_p_addr[57:63] : lgqe_p_addr_q[lgq];
assign lqg_qw_match[lgq] = ~spr_xucr0_cls_q ? (lgqe_p_addr_q[lgq][58:59] == ctl_lsq_ex4_p_addr[58:59]) :
(lgqe_p_addr_q[lgq][57:59] == ctl_lsq_ex4_p_addr[57:59]);
// Byte Swap Bits
assign lgqe_byte_swap_d[lgq] = ex4_lgqe_set_all[lgq] ? ctl_lsq_ex4_byte_swap : lgqe_byte_swap_q[lgq];
// GPR Update is done
// lgqe_set_gpr_done = "11" => This should never occur, will need bugspray here
assign lgqe_set_gpr_done[lgq] = {ex4_lgqe_set_all[lgq], lgq_rel2_upd_gpr_q[lgq]};
// GPR Update is Done Indicator
assign lgqe_gpr_done_d[lgq] = (lgqe_set_gpr_done[lgq] == 2'b00) ? lgqe_gpr_done_q[lgq] :
(lgqe_set_gpr_done[lgq] == 2'b01) ? 1'b1 :
1'b0;
// op_size Bits
assign lgqe_set_op_size[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_opsize : lgqe_op_size_q[lgq];
assign lgqe_op_size_d[lgq] = lgqe_set_op_size[lgq];
// tgpr Bits
assign lgqe_set_tgpr[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_tgpr : lgqe_tgpr_q[lgq];
assign lgqe_tgpr_d[lgq] = lgqe_set_tgpr[lgq];
// axu Bits
assign lgqe_set_axu[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_axu_val : lgqe_axu_q[lgq];
assign lgqe_axu_d[lgq] = lgqe_set_axu[lgq];
// performance events
assign lgqe_perf_events_d[lgq] = ex5_lgqe_set_all_q[lgq] ? ex5_cmmt_perf_events : lgqe_perf_events_q[lgq];
// algebraic Bits
assign lgqe_set_algebraic[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_algebraic : lgqe_algebraic_q[lgq];
assign lgqe_algebraic_d[lgq] = lgqe_set_algebraic[lgq];
// DAC Status Bits
assign lgqe_dacrw_d[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_dacrw : lgqe_dacrw_q[lgq];
// DVC Bits
// Need to split it out for timing since we can be setting in ex5 and
// the quadword reload is valid the same cycle
// Should never see ex5_lgqe_set_all_q = '1' and lgq_rel4_upd_gpr_q = '1' at the same time
assign lgqe_set_dvc[lgq] = ex5_lgqe_set_all_q[lgq] ? ctl_lsq_ex5_dvc : lgqe_dvc_q[lgq];
assign lgqe_dvc_d[lgq] = lgq_rel2_upd_gpr_q[lgq] ? ldq_rel2_dvc : lgqe_set_dvc[lgq];
// Want to Flush if the loadqueue was back-invalidated or the L1 Dump signal is on for the reload
// Use back inv bits from the corresponding lmq entry
assign lgqe_back_inv_flush_upd[lgq] = |((ldqe_back_inv_q | ldq_rel_l1_dump) & ldq_gath_Tag_1hot[lgq]);
// Determine if request is CP_NEXT itag
begin : lgqeItagTid
genvar tid;
for (tid=0; tid<`THREADS; tid=tid+1) begin : lgqeItagTid
assign lgqe_cpNext_tid[lgq][tid] = lgqe_thrd_id_q[lgq][tid] & (lgqe_itag_q[lgq] == iu_lq_cp_next_itag_q[tid]);
end
end
assign lgqe_cpNext_val[lgq] = |(lgqe_cpNext_tid[lgq]);
// NEED TO REVISIT THIS STATEMENT, I BELIEVE THIS SCENARIO ONLY EXISTS IF THE LDQ HOLDS UNRESOLVED ITAGS WHEN THE RELOAD IS COMPLETE
// Want to only capture the first back-invalidate
// There is a hole where it was a cp_next itag when the back-invalidate hit
// then an older loadmiss went to the L2, got newer data
// another back-invalidate comes in and sets the cpnext_val indicator causing an NP1 flush
// when we really wanted an N flush
// Take a snapshot of the CP_NEXT check whenever the loadmiss queue entry was back-invalidated
assign lgqe_back_inv_nFlush_d[lgq] = ({ex4_lgqe_set_all[lgq], lgqe_back_inv_flush_upd[lgq]} == 2'b00) ? lgqe_back_inv_nFlush_q[lgq] :
({ex4_lgqe_set_all[lgq], lgqe_back_inv_flush_upd[lgq]} == 2'b01) ? (lgqe_back_inv_nFlush_q[lgq] | ((~lgqe_cpNext_val[lgq]))) :
1'b0;
assign lgqe_back_inv_np1Flush_d[lgq] = ({ex4_lgqe_set_all[lgq], lgqe_back_inv_flush_upd[lgq]} == 2'b00) ? lgqe_back_inv_np1Flush_q[lgq] :
({ex4_lgqe_set_all[lgq], lgqe_back_inv_flush_upd[lgq]} == 2'b01) ? (lgqe_back_inv_np1Flush_q[lgq] | lgqe_cpNext_val[lgq]) :
1'b0;
// ##############################################
// LGQ Reload Control
// ##############################################
assign lgqe_relmin1_match[lgq] = (ldq_relmin1_cTag == lgqe_ldTag_q[lgq]) &
((l2_lsq_resp_qw[57] == lgqe_p_addr_q[lgq][57]) | (~spr_xucr0_cls_q)) &
(l2_lsq_resp_qw[58:59] == lgqe_p_addr_q[lgq][58:59]) & lgqe_valid_q[lgq];
assign lgqe_relmin1_upd_gpr[lgq] = lgqe_relmin1_match[lgq] & ldq_relmin1_ldq_val & (~(lgqe_gpr_done_q[lgq] | ex5_lgqe_set_val_q[lgq]));
assign lgq_rel0_upd_gpr_d[lgq] = lgqe_relmin1_upd_gpr[lgq] & (~lgqe_kill[lgq]);
// Load Gather Entry Has Resolved In Order Queue
assign lgqe_resolved[lgq] = (lgqe_itag_q[lgq] == odq_ldq_report_itag_q) & |(odq_ldq_report_tid_q & lgqe_thrd_id_q[lgq]) & odq_ldq_resolved_q & lgqe_valid_q[lgq];
assign lgqe_resolved_d[lgq] = ({ex4_lgqe_set_all[lgq], lgqe_resolved[lgq]} == 2'b00) ? lgqe_resolved_q[lgq] :
({ex4_lgqe_set_all[lgq], lgqe_resolved[lgq]} == 2'b01) ? 1'b1 :
1'b0;
// LoadQ Entry is complete, Waiting to send Completion Report
assign lgqe_cpl_rpt_done[lgq] = lgqe_cpl_sent[lgq] | (lgqe_need_cpl_q[lgq] & lgq_rel5_odq_cpl[lgq]);
assign lgqe_need_cpl_rst[lgq] = lgqe_cpl_rpt_done[lgq] | lgqe_kill[lgq];
// Need to delay the completion report to cover the window where i am trying to update an FPR register
// and the gather queue entry got flushed, need to gate the FPR update
assign lgqe_need_cpl_sel[lgq] = {lgqe_need_cpl_rst[lgq], lgq_rel2_send_cpl_ok[lgq]};
assign lgqe_need_cpl_d[lgq] = (lgqe_need_cpl_sel[lgq] == 2'b00) ? lgqe_need_cpl_q[lgq] :
(lgqe_need_cpl_sel[lgq] == 2'b01) ? 1'b1 :
1'b0;
// Dont really think we need to wait for the full reload to be done on the interface
// We were waiting for the case that the L2 is sending a reload with newer data and a
// back-invalidate is seen for the previous data at the same cycle that the reload is
// occuring, the L2 should never do this, we should always either see the back-invalidate first
// followed by the reload with newer data, or we should see a reload with older data and the back-invalidate
// at the same time. For the second case, we should be covered for the scenario that eventually we get an older
// loadmiss to the same line that would bring in newer data because the younger loadmiss is sitting in the order queue
// and would have been flushed due to the back-invalidate hitting against the order queue. The older instruction may not
// have been resolved yet, so the older instruction would not get flushed.
assign lgqe_send_cpl[lgq] = lgqe_need_cpl_q[lgq] & lgqe_resolved_q[lgq] & lgqe_valid_q[lgq];
// ECC Error was detected on the GPR update
assign lgqe_upd_gpr_ecc_sel[lgq] = {lgq_rel2_upd_gpr[lgq], lgqe_need_cpl_rst[lgq]};
assign lgqe_upd_gpr_ecc[lgq] = (lgqe_upd_gpr_ecc_sel[lgq] == 2'b10) ? (lgqe_upd_gpr_ecc_q[lgq] | l2_lsq_resp_ecc_err | l2_lsq_resp_ecc_err_ue) :
(lgqe_upd_gpr_ecc_sel[lgq] == 2'b00) ? lgqe_upd_gpr_ecc_q[lgq] :
1'b0;
assign lgqe_upd_gpr_ecc_d[lgq] = lgqe_upd_gpr_ecc[lgq];
assign lgqe_upd_gpr_eccue[lgq] = (lgqe_upd_gpr_ecc_sel[lgq] == 2'b10) ? (lgqe_upd_gpr_eccue_q[lgq] | l2_lsq_resp_ecc_err_ue) :
(lgqe_upd_gpr_ecc_sel[lgq] == 2'b00) ? lgqe_upd_gpr_eccue_q[lgq] :
1'b0;
assign lgqe_upd_gpr_eccue_d[lgq] = lgqe_upd_gpr_eccue[lgq];
end
end
endgenerate
// determine when lmq entries do not have any more active gathers
always @(*) begin: ldq_gath_done_P
reg [0:`LMQ_ENTRIES-1] active;
//(* analysis_not_referenced="true" *)
integer lgq;
active = {`LMQ_ENTRIES{1'b0}};
for (lgq=0; lgq<`LGQ_ENTRIES; lgq=lgq+1)
active = (ldq_gath_Tag_1hot[lgq] & {`LGQ_ENTRIES{lgqe_valid_q[lgq]}}) | active;
ldqe_gather_done = (~active);
end
assign lgq_rel1_gpr_val_d = |(lgq_rel0_upd_gpr_q & (~(ex5_lgqe_drop | lgqe_kill)));
assign lgq_rel1_upd_gpr_d = lgq_rel0_upd_gpr_q & (~(ex5_lgqe_drop | lgqe_kill));
assign lgq_rel2_upd_gpr_d = lgq_rel1_upd_gpr_q & (~lgqe_kill);
assign lgq_rel3_upd_gpr_d = lgq_rel2_upd_gpr_q & (~lgqe_kill);
assign lgq_rel1_upd_gpr = lgq_rel1_upd_gpr_q & lgqe_valid_q & (~lgqe_kill);
assign lgq_rel2_upd_gpr = lgq_rel2_upd_gpr_q & lgqe_valid_q;
// Need to Send Completion Report
assign lgq_rel2_send_cpl_ok = lgq_rel2_upd_gpr_q & lgqe_valid_q & (~lgqe_need_cpl_q);
// LDQ has a Loadmiss Request to send
assign ldq_l2_req_need_send = |(ldqe_need_l2send);
// Reload will try to update Cache contents
assign ldq_rel0_updating_cache = |(ldq_rel0_entrySent);
assign ldq_stq_rel1_blk_store_d = ldq_rel0_updating_cache | |(ldq_rel_l2_l1dumpBlk) | |(ldq_rel0_upd_gpr_q) | |(lgq_rel0_upd_gpr_q & (~ex5_lgqe_drop));
// Clear qHit indicator when reload is about to complete
assign ldq_rel2_qHit_clr = ldqe_rel2_l1upd_cmpl | ldq_rel2_ci_done | ldq_rel2_drel_done;
assign ldq_rel2_rv_clr_hold = |(ldq_rel2_qHit_clr & ldqe_qHit_held_q);
assign ldq_clrHold = ldq_rel2_rv_clr_hold | ldq_oth_qHit_clr_q;
assign ldq_clrHold_tid = ldq_hold_tid & {`THREADS{ldq_clrHold}};
// Load Queue Full
assign ex4_ldq_full = &(~ldqe_available);
assign ex5_ldq_full_d = ex4_ldq_full;
assign ex4_ldq_full_restart = ctl_lsq_ex4_ldreq_val & ex4_ldq_full & (~ex4_stg_flush);
assign ex5_ldq_full_restart_d = ex4_ldq_full_restart;
// Load Queue Full SET_HOLD and CLR_HOLD logic to the reservation station
// Want to clear when the load queue isnt full
assign ldq_full_qHit_held_set = ex5_ldq_full_restart_q & (~(ctl_lsq_ex5_load_hit | stq_ldq_ex5_fwd_val));
assign ldq_full_qHit_held_clr = ldq_full_qHit_held_q & (~ex4_ldq_full);
assign ldq_full_qHit_held_ctrl = {ldq_full_qHit_held_set, ldq_full_qHit_held_clr};
assign ldq_full_qHit_held_d = (ldq_full_qHit_held_ctrl == 2'b00) ? ldq_full_qHit_held_q :
(ldq_full_qHit_held_ctrl == 2'b10) ? 1'b1 :
1'b0;
// Load Queue Entry Reserved SET_HOLD and CLR_HOLD logic to the reservation station
// Want to clear when the load queue isnt full or there is one entry available
assign ldq_resv_qHit_held_set = ex5_resv_taken_restart_q & (~(ctl_lsq_ex5_load_hit | stq_ldq_ex5_fwd_val));
assign ldq_resv_qHit_held_clr = ldq_resv_qHit_held_q & (~(ex4_one_machine_avail | ex4_ldq_full));
assign ldq_resv_qHit_held_ctrl = {ldq_resv_qHit_held_set, ldq_resv_qHit_held_clr};
assign ldq_resv_qHit_held_d = (ldq_resv_qHit_held_ctrl == 2'b00) ? ldq_resv_qHit_held_q :
(ldq_resv_qHit_held_ctrl == 2'b10) ? 1'b1 :
1'b0;
// CLR_HOLD indicator for LDQ Full or LDQ Reserved
assign ldq_oth_qHit_clr_d = ldq_full_qHit_held_clr | ldq_resv_qHit_held_clr;
// SET_HOLD due to LDQ Full or 1 Entry left and is reserved
assign ex5_ldq_full_set_hold = (ex5_ldq_full_restart_q | ex5_resv_taken_restart_q) & (~(ctl_lsq_ex5_load_hit | stq_ldq_ex5_fwd_val));
// Queue Hit Indicators
assign ex4_ldq_hit = |(ex4_entry_load_qHit);
assign ex5_ldq_hit_d = ex4_ldq_hit;
// Load Gathered Indicators
assign ex4_ld_gath = |(ex4_entry_gath_ld);
assign ex5_ld_gath_d = ex4_ld_gath;
// Set Hold on a LDQ restart
assign ex5_ldq_set_hold_d = |(ex4_load_qHit_upd);
assign ex5_setHold = ex5_ldq_set_hold_q | ex5_ldq_full_set_hold;
// Set Thread Held Indicator
assign ldq_setHold_tid = ldq_hold_tid_q | {`THREADS{ex5_setHold}};
generate begin : holdTid
genvar tid;
for (tid=0; tid<`THREADS; tid=tid+1) begin : holdTid
assign ldq_hold_tid[tid] = ctl_lsq_ex5_thrd_id[tid] ? ldq_setHold_tid[tid] : ldq_hold_tid_q[tid];
end
end
endgenerate
assign ldq_hold_tid_d = ldq_hold_tid & (~ldq_clrHold_tid);
// EX5 Request needs to be dropped
assign ex5_drop_req_val = ctl_lsq_ex5_load_hit | // request was a load hit
ex5_reserved_taken_q | // queue entry is reserved for oldest load
ex5_ldq_hit_q | // request hit outstanding request
stq_ldq_ex5_fwd_val | // STQ Forwarded Load Data, dont need to send an L1 Miss request
stq_ldq_ex5_stq_restart | // STQ Restarted Load due to every other reason
stq_ldq_ex5_stq_restart_miss; // STQ Restarted Load due to loadmiss that didnt forward specifically
assign ex5_drop_gath = ctl_lsq_ex5_load_hit | // request was a load hit
ex5_stg_flush | // request was CP_FLUSHed or will be
ex5_lgq_restart | // request was gathered in EX5 and reload to cTag the same cycle
stq_ldq_ex5_fwd_val | // STQ Forwarded Load Data, dont need to send an L1 Miss request
stq_ldq_ex5_stq_restart | // STQ Restarted Load due to every other reason
stq_ldq_ex5_stq_restart_miss; // STQ Restarted Load due to loadmiss that didnt forward specifically
// State Machines are idle
// Simulation uses this signal, dont delete
assign ldq_state_machines_idle = &(ldqe_available);
// RESTART Request
// 1) Request to Cache line already in LoadMiss Queue
// 2) LoadMiss Queue is full and new loadmiss request
// 3) 1 LoadMiss StateMachine available and not the oldest load request and a loadmiss
assign ex5_ldq_restart_d = (ex4_ldq_full_restart | ex4_reserved_taken) & (~ex4_ld_gath);
assign ex5_lgq_restart = |(ex5_lgqe_restart);
assign ex5_ldq_restart = (ex5_ldq_hit_q & (~ex5_ld_gath_q)) | (ex5_odq_ldreq_val_q & ex5_ldq_restart_q & (~ctl_lsq_ex5_load_hit)) | ex5_lgq_restart;
assign ex6_ldq_full_d = (ex5_ldq_full_q | ex5_reserved_taken_q) & ~ex5_ld_gath_q;
assign ex6_ldq_hit_d = ex5_ldq_hit_q & ~ex5_ld_gath_q;
assign ex5_lgq_full_d = |(ex4_entry_gath_full);
assign ex6_lgq_full_d = ex5_lgq_full_q;
assign ex5_lgq_qwhit_d = |(ex4_entry_gath_qwhit);
assign ex6_lgq_qwhit_d = ex5_lgq_qwhit_q;
assign perf_ex6_ldq_full_restart = ex6_ldq_full_q;
assign perf_ex6_ldq_hit_restart = ex6_ldq_hit_q;
assign perf_ex6_lgq_full_restart = ex6_lgq_full_q;
assign perf_ex6_lgq_qwhit_restart = ex6_lgq_qwhit_q;
// RESTART Due to LoadmissQ and StoreQ
assign ex5_restart_val = ex5_ldq_restart | stq_ldq_ex5_stq_restart | (stq_ldq_ex5_stq_restart_miss & (~ctl_lsq_ex5_load_hit));
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Reload Rotator Select Control
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// 1-Hot opsize
assign ldq_rel0_opsize_1hot = (ldq_rel0_opsize == 3'b110) ? 5'b10000 : // 16Bytes
(ldq_rel0_opsize == 3'b101) ? 5'b01000 : // 8Bytes
(ldq_rel0_opsize == 3'b100) ? 5'b00100 : // 4Bytes
(ldq_rel0_opsize == 3'b010) ? 5'b00010 : // 2Bytes
(ldq_rel0_opsize == 3'b001) ? 5'b00001 : // 1Bytes
5'b00000;
// Store/Reload Pipe Rotator Control Calculations
assign ldq_rel0_rot_size = ldq_rel0_p_addr[59:63] + ldq_rel0_opsize_1hot;
assign ldq_rel0_rot_max_size_le = rot_max_size | ldq_rel0_opsize_1hot;
assign ldq_rel0_rot_sel_le = ldq_rel0_rot_max_size_le - ldq_rel0_rot_size;
// RELOAD PATH LITTLE ENDIAN ROTATOR SELECT CALCULATION
// rel_rot_size = rot_addr + op_size
// rel_rot_sel_le = (rot_max_size or le_op_size) - rel_rot_size
// rel_rot_sel = rel_rot_sel_le => le_mode = 1
// = rel_rot_size => le_mode = 0
// Little Endian Support Reload Data Rotate Select
assign ldq_rel0_rot_sel = ldq_rel0_byte_swap ? ldq_rel0_rot_sel_le[1:4] : ldq_rel0_rot_size[1:4];
// Calculate Algebraic Mux control
assign ldq_rel1_algebraic_sel_d = ldq_rel0_rot_sel - ldq_rel0_opsize_1hot[1:4];
// Calculate Reload Rotator Mux control
assign lvl1_sel = ldq_rel0_byte_swap;
assign lvl2_sel = ldq_rel0_rot_sel[0:1];
assign lvl3_sel = ldq_rel0_rot_sel[2:3];
assign rotate_sel1 = (lvl1_sel == 1'b0) ? 2'b10 :
2'b01;
assign rotate_sel2 = (lvl2_sel == 2'b00) ? 4'b1000 :
(lvl2_sel == 2'b01) ? 4'b0100 :
(lvl2_sel == 2'b10) ? 4'b0010 :
4'b0001;
assign rotate_sel3 = (lvl3_sel == 2'b00) ? 4'b1000 :
(lvl3_sel == 2'b01) ? 4'b0100 :
(lvl3_sel == 2'b10) ? 4'b0010 :
4'b0001;
assign ldq_rel1_rot_sel1_d = {rotate_sel1, rotate_sel1, rotate_sel1, rotate_sel1};
assign ldq_rel1_rot_sel2_d = {rotate_sel2, rotate_sel2};
assign ldq_rel1_rot_sel3_d = {rotate_sel3, rotate_sel3};
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Reload Rotator Select Control
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
lq_ldq_rot rrotl(
// ACT
.ldq_rel1_stg_act(ldq_rel1_val_q),
// Reload Rotator Control
.ldq_rel1_rot_sel1(ldq_rel1_rot_sel1_q),
.ldq_rel1_rot_sel2(ldq_rel1_rot_sel2_q),
.ldq_rel1_rot_sel3(ldq_rel1_rot_sel3_q),
.ldq_rel1_data(ldq_rel1_data),
// Reload Data Fixup Control
.ldq_rel1_opsize(ldq_rel1_opsize_q),
.ldq_rel1_byte_swap(ldq_rel1_byte_swap_q),
.ldq_rel1_algebraic(ldq_rel1_algEn_q),
.ldq_rel1_algebraic_sel(ldq_rel1_algebraic_sel_q),
.ldq_rel1_gpr_val(ldq_rel1_gpr_val),
.ldq_rel1_dvc1_en(ldq_rel1_dvcEn_q[0]),
.ldq_rel1_dvc2_en(ldq_rel1_dvcEn_q[1]),
.ldq_rel2_thrd_id(ldq_rel2_tid_q),
// Data Value Compare Registers
.ctl_lsq_spr_dvc1_dbg(ctl_lsq_spr_dvc1_dbg),
.ctl_lsq_spr_dvc2_dbg(ctl_lsq_spr_dvc2_dbg),
.ctl_lsq_spr_dbcr2_dvc1be(ctl_lsq_spr_dbcr2_dvc1be),
.ctl_lsq_spr_dbcr2_dvc1m(ctl_lsq_spr_dbcr2_dvc1m),
.ctl_lsq_spr_dbcr2_dvc2be(ctl_lsq_spr_dbcr2_dvc2be),
.ctl_lsq_spr_dbcr2_dvc2m(ctl_lsq_spr_dbcr2_dvc2m),
// Reload Rotator Output
.ldq_rel2_rot_data(ldq_rel2_rot_data),
.ldq_rel2_dvc(ldq_rel2_dvc),
// Pervasive
.vdd(vdd),
.gnd(gnd),
.clk(clk),
.rst(rst),
.sg_0(sg_0),
.func_sl_thold_0_b(func_sl_thold_0_b),
.func_sl_force(func_sl_force),
.d_mode_dc(d_mode_dc),
.delay_lclkr_dc(delay_lclkr_dc),
.mpw1_dc_b(mpw1_dc_b),
.mpw2_dc_b(mpw2_dc_b),
.scan_in(siv[rrot_scan_offset]),
.scan_out(sov[rrot_scan_offset])
);
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LOADMISS REQUEST ARBITRATION
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Doing a FIFO scheme
// Request at the bottom will be sent out first
// New Requests should always behind the last valid request
// New request going to FIFO
assign ex5_upd_fifo_val = (ex5_ldreq_val | ex5_pfetch_val) & ~ex5_drop_req_val & (~arb_ldq_ldq_unit_sel | fifo_ldq_req_val_q[0]);
// FIFO ACT
// Want to turn on ACT for the following reasons
// 1) request needs to be sent, will cause a compression
// 2) need to compress in the middle
// 3) new loadmiss might be updating fifo
assign fifo_ldq_act = fifo_ldq_req_val_q[0] | |(fifo_ldq_req_empty_entry) | ex5_ldreq_val_q | ex5_pfetch_val_q;
// FIFO needs compression for 2 reasons
// 1) Bottom of FIFO request was sent
// 2) Entry in between Bottom and Top of FIFO was zapped
assign fifo_ldq_req_compr_val = fifo_ldq_req_sent | |(fifo_ldq_req_empty_entry);
// FIFO Entry WRT Pointer Logic
assign fifo_ldq_req_wrt_ptr = fifo_ldq_req_compr_val ? ({fifo_ldq_req_nxt_ptr_q[1:`LMQ_ENTRIES], 1'b0}) : fifo_ldq_req_nxt_ptr_q;
// FIFO Entry WRT Pointer Logic
assign fifo_ldq_wrt_ptr_cntrl = {fifo_ldq_req_compr_val, ex5_upd_fifo_val};
assign fifo_ldq_req_nxt_ptr = (fifo_ldq_wrt_ptr_cntrl == 2'b10) ? ({fifo_ldq_req_nxt_ptr_q[1:`LMQ_ENTRIES], 1'b0}) :
(fifo_ldq_wrt_ptr_cntrl == 2'b01) ? ({1'b0, fifo_ldq_req_nxt_ptr_q[0:`LMQ_ENTRIES - 1]}) :
fifo_ldq_req_nxt_ptr_q;
// FIFO Reset when write pointer is not at entry 0 and fifo empty
assign fifo_ldq_reset_ptr = (~fifo_ldq_req_wrt_ptr[0]) & (~(|fifo_ldq_req_val)) & (~ex5_upd_fifo_val);
assign fifo_ldq_req_nxt_ptr_d[0] = fifo_ldq_reset_ptr ? 1'b1 : fifo_ldq_req_nxt_ptr[0];
assign fifo_ldq_req_nxt_ptr_d[1:`LMQ_ENTRIES] = fifo_ldq_reset_ptr ? {`LMQ_ENTRIES{1'b0}} : fifo_ldq_req_nxt_ptr[1:`LMQ_ENTRIES];
// FIFO Entry Sent
assign fifo_ldq_req_sent = fifo_ldq_req_val_q[0] & arb_ldq_ldq_unit_sel;
assign fifo_ldq_req0_mkill = |(fifo_ldq_req_tid_q[0] & iu_lq_cp_flush_q);
assign fifo_ldq_req0_avail = (fifo_ldq_req_val_q[0] & ~fifo_ldq_req0_mkill) & ~fifo_ldq_req_pfetch_q[0];
// FIFO Control
generate begin : fifoCtrl
genvar fifo;
for (fifo=0; fifo<`LMQ_ENTRIES; fifo=fifo+1) begin : fifoCtrl
// Fifo Entry Was Zapped
assign fifo_ldq_req_val[fifo] = fifo_ldq_req_val_q[fifo] & |(fifo_ldq_req_q[fifo] & (~ldqe_mkill));
// Fifo Entry Prefetch is allowed to be sent status from ODQ
assign fifo_ldq_req_pfetch_match[fifo] = |(fifo_ldq_req_q[fifo] & ex7_ldqe_pfetch_val_q);
assign fifo_ldq_req_pfetch_send[fifo] = fifo_ldq_req_pfetch_match[fifo] & ~odq_ldq_ex7_pfetch_blk;
assign fifo_ldq_req_pfetch[fifo] = (fifo_ldq_req_pfetch_q[fifo] & ~fifo_ldq_req_pfetch_send[fifo]) | (fifo_ldq_req_pfetch_q[fifo] & ~fifo_ldq_req_pfetch_match[fifo]);
// Figure out if entry behind me is valid and i am not valid, need to push my entry and all entries after mine
if (fifo < `LMQ_ENTRIES - 1) begin : emptyFifo
assign fifo_ldq_req_empty_entry[fifo] = (~fifo_ldq_req_val_q[fifo]) & fifo_ldq_req_val_q[fifo + 1];
end
if (fifo == `LMQ_ENTRIES - 1) begin : lastFifo
assign fifo_ldq_req_empty_entry[fifo] = 1'b0;
end
assign fifo_ldq_req_upd[fifo] = fifo_ldq_req_wrt_ptr[fifo] & ex5_upd_fifo_val;
assign fifo_ldq_req_push[fifo] = |(fifo_ldq_req_empty_entry[0:fifo]) | fifo_ldq_req_sent;
assign fifo_ldq_req_cntrl[fifo] = {fifo_ldq_req_upd[fifo], fifo_ldq_req_push[fifo]};
end
end
endgenerate
// Last entry of FIFO
assign fifo_ldq_req_tid_d[`LMQ_ENTRIES-1] = ~fifo_ldq_req_cntrl[`LMQ_ENTRIES-1][0] ? fifo_ldq_req_tid_q[`LMQ_ENTRIES-1] : ctl_lsq_ex5_thrd_id;
assign fifo_ldq_req_d[`LMQ_ENTRIES-1] = ~fifo_ldq_req_cntrl[`LMQ_ENTRIES-1][0] ? fifo_ldq_req_q[`LMQ_ENTRIES-1] : ex5_ldqe_set_all_q;
assign fifo_ldq_req_pfetch_d[`LMQ_ENTRIES-1] = (fifo_ldq_req_cntrl[`LMQ_ENTRIES-1] == 2'b00) ? fifo_ldq_req_pfetch[`LMQ_ENTRIES-1] :
(fifo_ldq_req_cntrl[`LMQ_ENTRIES-1] == 2'b01) ? 1'b0 :
ex5_pfetch_val_q;
assign fifo_ldq_req_val_d[`LMQ_ENTRIES-1] = (fifo_ldq_req_cntrl[`LMQ_ENTRIES-1] == 2'b00) ? fifo_ldq_req_val[`LMQ_ENTRIES-1] :
(fifo_ldq_req_cntrl[`LMQ_ENTRIES-1] == 2'b01) ? 1'b0 :
1'b1;
// Rest of the entries of FIFO
generate begin : ldqFifo
genvar fifo;
for (fifo=0; fifo<=`LMQ_ENTRIES-2; fifo=fifo+1) begin : ldqFifo
assign fifo_ldq_req_tid_d[fifo] = (fifo_ldq_req_cntrl[fifo] == 2'b00) ? fifo_ldq_req_tid_q[fifo] :
(fifo_ldq_req_cntrl[fifo] == 2'b01) ? fifo_ldq_req_tid_q[fifo+1] :
ctl_lsq_ex5_thrd_id;
assign fifo_ldq_req_d[fifo] = (fifo_ldq_req_cntrl[fifo] == 2'b00) ? fifo_ldq_req_q[fifo] :
(fifo_ldq_req_cntrl[fifo] == 2'b01) ? fifo_ldq_req_q[fifo+1] :
ex5_ldqe_set_all_q;
assign fifo_ldq_req_pfetch_d[fifo] = (fifo_ldq_req_cntrl[fifo] == 2'b00) ? fifo_ldq_req_pfetch[fifo] :
(fifo_ldq_req_cntrl[fifo] == 2'b01) ? fifo_ldq_req_pfetch[fifo+1] :
ex5_pfetch_val_q;
assign fifo_ldq_req_val_d[fifo] = (fifo_ldq_req_cntrl[fifo] == 2'b00) ? fifo_ldq_req_val[fifo] :
(fifo_ldq_req_cntrl[fifo] == 2'b01) ? fifo_ldq_req_val[fifo+1] :
1'b1;
end
end
endgenerate
// Muxing Load Request to send to the L2
always @(*) begin: ldqMux
reg [0:3] usrDef;
reg [0:4] wimge;
reg [64-`REAL_IFAR_WIDTH:63] pAddr;
reg [0:5] tType;
reg [0:2] opsize;
reg [0:`THREADS-1] tid;
//(* analysis_not_referenced="true" *)
integer ldq;
usrDef = {4{1'b0}};
wimge = {5{1'b0}};
pAddr = {`REAL_IFAR_WIDTH{1'b0}};
tType = {6{1'b0}};
opsize = {3{1'b0}};
tid = {`THREADS{1'b0}};
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin
usrDef = (ldqe_usr_def_q[ldq] & { 4{fifo_ldq_req_q[0][ldq]}}) | usrDef;
wimge = (ldqe_wimge_q[ldq] & { 5{fifo_ldq_req_q[0][ldq]}}) | wimge;
pAddr = (ldqe_p_addr_q[ldq] & {`REAL_IFAR_WIDTH{fifo_ldq_req_q[0][ldq]}}) | pAddr;
tType = (ldqe_ttype_q[ldq] & { 6{fifo_ldq_req_q[0][ldq]}}) | tType;
opsize = (ldqe_op_size_q[ldq] & { 3{fifo_ldq_req_q[0][ldq]}}) | opsize;
tid = (ldqe_thrd_id_q[ldq] & { `THREADS{fifo_ldq_req_q[0][ldq]}}) | tid;
end
ldq_mux_usr_def = usrDef;
ldq_mux_wimge = wimge;
ldq_mux_p_addr = pAddr;
ldq_mux_ttype = tType;
ldq_mux_opsize = opsize;
ldq_mux_tid = tid;
end
// Generate Encode Thread ID
always @(*) begin: tidMulti
reg [0:1] ex5Tid;
reg [0:1] ldqTid;
//(* analysis_not_referenced="true" *)
integer tid;
ex5Tid = {2{1'b0}};
ldqTid = {2{1'b0}};
for (tid=1; tid<`THREADS; tid=tid+1) begin
ex5Tid = (tid[1:0] & {2{ctl_lsq_ex5_thrd_id[tid]}}) | ex5Tid;
ldqTid = (tid[1:0] & {2{ ldq_mux_tid[tid]}}) | ldqTid;
end
ex5_tid_enc = ex5Tid;
ldq_mux_tid_enc = ldqTid;
end
// Generate Core Tag
always @(*) begin: ldqcTag
reg [0:3] entryF;
reg [0:3] entryP;
//(* analysis_not_referenced="true" *)
integer ldq;
entryF = 4'b0000;
entryP = 4'b0000;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin
entryF = (ldq[3:0] & {4{ fifo_ldq_req_q[0][ldq]}}) | entryF;
entryP = (ldq[3:0] & {4{ex5_ldqe_set_all_q[ldq]}}) | entryP;
end
ldq_mux_cTag = entryF;
ex5_cTag = entryP;
end
// Select between entry already in LOADMISSQ and
// entry going into LOADMISSQ
assign ldq_arb_usr_def = fifo_ldq_req_val_q[0] ? ldq_mux_usr_def : ctl_lsq_ex5_usr_def;
assign ldq_arb_tid = fifo_ldq_req_val_q[0] ? ldq_mux_tid_enc : ex5_tid_enc;
assign ldq_arb_wimge = fifo_ldq_req_val_q[0] ? ldq_mux_wimge : ex5_wimge_q;
assign ldq_arb_p_addr = fifo_ldq_req_val_q[0] ? ldq_mux_p_addr : ex5_p_addr_q;
assign ldq_arb_ttype = fifo_ldq_req_val_q[0] ? ldq_mux_ttype : ctl_lsq_ex5_ttype;
assign ldq_arb_opsize = fifo_ldq_req_val_q[0] ? ldq_mux_opsize : ctl_lsq_ex5_opsize;
assign ldq_arb_cTag = fifo_ldq_req_val_q[0] ? {ldq_mux_cTag[0], 1'b0, ldq_mux_cTag[1:3]} : {ex5_cTag[0], 1'b0, ex5_cTag[1:3]};
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// RELOAD DATA BEATS ARBITER
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Select Between L2 Reload and Reload Queue
assign ldq_resp_cTag = l2_rel0_resp_ldq_val_q ? l2_rel0_resp_cTag_q : ldq_rel0_arb_cTag;
assign ldq_resp_qw = l2_rel0_resp_ldq_val_q ? l2_rel0_resp_qw_q : ldq_rel0_arb_qw;
// Reload Valid
assign ldq_reload_qw = ldq_resp_qw[57:59];
assign ldq_reload_val = l2_rel0_resp_ldq_val_q | ldq_rel0_arb_val;
assign ldq_rel1_arb_val_d = ldq_rel0_arb_val & ~l2_rel0_resp_ldq_val_q;
assign ldq_rel1_val_d = ldq_reload_val;
assign ldq_rel0_rdat_sel = ldq_rel0_arb_val & (~l2_rel0_resp_ldq_val_q);
assign ldq_rel0_rdat_qw = ldq_reload_qw[57:59];
assign ldq_rel0_arr_wren = |(ldq_rel0_l2_val_q);
assign ldq_rel1_l1_dump_d = l2_rel0_resp_ldq_val_q & l2_rel0_resp_l1_dump_q;
assign ldq_rel2_l1_dump_d = ldq_rel1_l1_dump_q;
assign ldq_rel3_l1_dump_d = ldq_rel2_l1_dump_q & |(ldq_rel2_l2_val_q & ldq_rel2_beats_home_q & (~(ldqe_wimge_i | ldqe_rel_eccdet)));
assign ldq_rel3_l1_dump_val = ldq_rel3_l1_dump_q;
assign ldq_rel3_clr_relq_d = |(ldq_rel2_beats_home_q & ldq_rel2_l2_val_q & ldqe_rel_eccdet);
assign ldq_rel1_resp_qw_d = spr_xucr0_cls_q ? ldq_reload_qw[57:59] : {ldq_rel_mux_p_addr[57], ldq_reload_qw[58:59]};
assign ldq_rel1_cTag_d = ldq_resp_cTag;
assign l2_rel1_resp_val_d = l2_rel0_resp_val_q;
assign l2_rel2_resp_val_d = l2_rel1_resp_val_q;
assign ldq_err_inval_rel_d = |(ldq_relmin1_l2_inval);
assign ldq_err_ecc_det_d = l2_rel2_resp_val_q & l2_lsq_resp_ecc_err;
assign ldq_err_ue_det_d = l2_rel2_resp_val_q & l2_lsq_resp_ecc_err_ue;
// 1-hot of quadword updated
generate begin : relDat
genvar beat;
for (beat=0; beat<8; beat=beat+1) begin : relDat
wire [0:2] beatDummy;
assign beatDummy = beat[2:0];
assign ldq_rel0_beat_upd[beat] = (beatDummy == ldq_reload_qw);
end
end
endgenerate
lq_ldq_relq relq(
// ACT's
.ldq_rel0_stg_act(rel0_stg_act),
.ldq_rel1_stg_act(ldq_rel1_val_q),
.ldqe_ctrl_act(ldqe_ctrl_act),
// Reload Data Beats Control
.ldq_rel0_arb_sent(ldq_rel0_arb_sent),
.ldq_rel0_beat_upd(ldq_rel0_beat_upd),
.ldq_rel0_arr_wren(ldq_rel0_arr_wren),
.ldq_rel0_rdat_qw(ldq_rel0_rdat_qw),
.ldq_rel1_cTag(ldq_rel1_cTag_q),
.ldq_rel1_dbeat_val(ldq_rel1_dbeat_val),
.ldq_rel1_beats_home(ldq_rel1_beats_home),
.ldq_rel2_entrySent(ldq_rel2_entrySent_q),
.ldq_rel2_blk_req(rel2_blk_req_q),
.ldq_rel2_sentL1(ldq_rel2_sentL1),
.ldq_rel2_sentL1_blk(ldq_rel2_sentL1_blk),
.ldqe_rel_eccdet(ldqe_rel_eccdet),
.ldqe_rst_eccdet(ldqe_rst_eccdet_q),
// Reload Data Select Valid
.ldq_rel0_rdat_sel(ldq_rel0_rdat_sel),
.arb_ldq_rel2_wrt_data(arb_ldq_rel2_wrt_data),
// Reload Arbiter Control Outputs
.ldq_rel0_arb_val(ldq_rel0_arb_val),
.ldq_rel0_arb_qw(ldq_rel0_arb_qw),
.ldq_rel0_arb_cTag(ldq_rel0_arb_cTag),
.ldq_rel0_arb_thresh(ldq_rel0_arb_thresh),
.ldq_rel2_rdat_perr(ldq_rel2_rdat_perr),
.ldq_rel3_rdat_par_err(ldq_rel3_rdat_par_err),
.ldqe_rel_rdat_perr(ldqe_rel_rdat_perr),
// Reload Data Arbiter Data
.ldq_arb_rel2_rdat_sel(ldq_arb_rel2_rdat_sel),
.ldq_arb_rel2_rd_data(ldq_arb_rel2_rd_data),
// SPR's
.pc_lq_inj_relq_parity(pc_lq_inj_relq_parity),
.spr_lsucr0_lca_ovrd(spr_lsucr0_lca_ovrd),
// Array Pervasive Controls
.bo_enable_2(bo_enable_2),
.clkoff_dc_b(clkoff_dc_b),
.g8t_clkoff_dc_b(g8t_clkoff_dc_b),
.g8t_d_mode_dc(g8t_d_mode_dc),
.g8t_delay_lclkr_dc(g8t_delay_lclkr_dc),
.g8t_mpw1_dc_b(g8t_mpw1_dc_b),
.g8t_mpw2_dc_b(g8t_mpw2_dc_b),
.pc_lq_ccflush_dc(pc_lq_ccflush_dc),
.an_ac_scan_dis_dc_b(an_ac_scan_dis_dc_b),
.an_ac_scan_diag_dc(an_ac_scan_diag_dc),
.an_ac_lbist_ary_wrt_thru_dc(an_ac_lbist_ary_wrt_thru_dc),
.pc_lq_abist_ena_dc(pc_lq_abist_ena_dc),
.pc_lq_abist_raw_dc_b(pc_lq_abist_raw_dc_b),
.pc_lq_abist_wl64_comp_ena(pc_lq_abist_wl64_comp_ena),
.pc_lq_abist_raddr_0(pc_lq_abist_raddr_0),
.pc_lq_abist_g8t_wenb(pc_lq_abist_g8t_wenb),
.pc_lq_abist_g8t1p_renb_0(pc_lq_abist_g8t1p_renb_0),
.pc_lq_abist_g8t_dcomp(pc_lq_abist_g8t_dcomp),
.pc_lq_abist_g8t_bw_1(pc_lq_abist_g8t_bw_1),
.pc_lq_abist_g8t_bw_0(pc_lq_abist_g8t_bw_0),
.pc_lq_abist_di_0(pc_lq_abist_di_0),
.pc_lq_abist_waddr_0(pc_lq_abist_waddr_0),
.pc_lq_bo_unload(pc_lq_bo_unload),
.pc_lq_bo_repair(pc_lq_bo_repair),
.pc_lq_bo_reset(pc_lq_bo_reset),
.pc_lq_bo_shdata(pc_lq_bo_shdata),
.pc_lq_bo_select(pc_lq_bo_select),
.lq_pc_bo_fail(lq_pc_bo_fail),
.lq_pc_bo_diagout(lq_pc_bo_diagout),
//Pervasive
.vcs(vcs),
.vdd(vdd),
.gnd(gnd),
.clk(clk),
.rst(rst),
.sg_0(sg_0),
.func_sl_thold_0_b(func_sl_thold_0_b),
.func_sl_force(func_sl_force),
.abst_sl_thold_0(abst_sl_thold_0),
.ary_nsl_thold_0(ary_nsl_thold_0),
.time_sl_thold_0(time_sl_thold_0),
.repr_sl_thold_0(repr_sl_thold_0),
.bolt_sl_thold_0(bolt_sl_thold_0),
.d_mode_dc(d_mode_dc),
.delay_lclkr_dc(delay_lclkr_dc),
.mpw1_dc_b(mpw1_dc_b),
.mpw2_dc_b(mpw2_dc_b),
.scan_in(rdat_scan_in),
.abst_scan_in(abst_scan_in),
.time_scan_in(time_scan_in),
.repr_scan_in(repr_scan_in),
.scan_out(rdat_scan_out),
.abst_scan_out(abst_scan_out),
.time_scan_out(time_scan_out),
.repr_scan_out(repr_scan_out)
);
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// RELOAD QUEUE ENTRY SELECT
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Muxing Reload Request to send to the L1
always @(*) begin: relMux
reg [0:2] opsize;
reg wimge_i;
reg byte_swap;
reg [64-`REAL_IFAR_WIDTH:63] pAddr;
reg [0:1] dvcEn;
reg lockSet;
reg watchSet;
reg [0:AXU_TARGET_ENC-1] tGpr;
reg axu;
reg algEn;
reg [0:1] classID;
reg binv;
reg [0:`THREADS-1] tid;
reg [0:`ITAG_SIZE_ENC-1] iTagM1;
reg [0:`THREADS-1] tidM1;
//(* analysis_not_referenced="true" *)
integer ldq;
opsize = {3{1'b0}};
wimge_i = 1'b0;
byte_swap = 1'b0;
pAddr = {`REAL_IFAR_WIDTH{1'b0}};
dvcEn = {2{1'b0}};
lockSet = 1'b0;
watchSet = 1'b0;
tGpr = {AXU_TARGET_ENC{1'b0}};
axu = 1'b0;
algEn = 1'b0;
classID = {2{1'b0}};
binv = 1'b0;
tid = {`THREADS{1'b0}};
iTagM1 = {`ITAG_SIZE_ENC{1'b0}};
tidM1 = {`THREADS{1'b0}};
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin
opsize = (ldqe_op_size_q[ldq] & { 3{ldqe_rel0_cTag[ldq]}}) | opsize;
wimge_i = (ldqe_wimge_i[ldq] & ldqe_rel0_cTag[ldq]) | wimge_i;
byte_swap = (ldqe_byte_swap_q[ldq] & ldqe_rel0_cTag[ldq]) | byte_swap;
pAddr = (ldqe_p_addr_q[ldq] & {`REAL_IFAR_WIDTH{ldqe_rel0_cTag[ldq]}}) | pAddr;
dvcEn = (ldqe_dvc_q[ldq] & { 2{ldqe_rel0_cTag[ldq]}}) | dvcEn;
lockSet = (ldqe_lock_set_q[ldq] & (~ldqe_resent_ecc_err_q[ldq]) & ldqe_rel0_cTag[ldq]) | lockSet;
watchSet = (ldqe_watch_set_q[ldq] & (~ldqe_resent_ecc_err_q[ldq]) & ldqe_rel0_cTag[ldq]) | watchSet;
tGpr = (ldqe_tgpr_q[ldq] & { AXU_TARGET_ENC{ldqe_rel0_cTag[ldq]}}) | tGpr;
axu = (ldqe_axu_q[ldq] & ldqe_rel0_cTag[ldq]) | axu;
algEn = (ldqe_algebraic_q[ldq] & ldqe_rel0_cTag[ldq]) | algEn;
classID = (ldqe_class_id_q[ldq] & { 2{ldqe_rel0_cTag[ldq]}}) | classID;
tid = (ldqe_thrd_id_q[ldq] & { `THREADS{ldqe_rel0_cTag[ldq]}}) | tid;
binv = (ldqe_back_inv_q[ldq] & ldqe_rel1_cTag[ldq]) | binv;
iTagM1 = (ldqe_itag_q[ldq] & {`ITAG_SIZE_ENC{ldqe_relmin1_cTag[ldq]}}) | iTagM1;
tidM1 = (ldqe_thrd_id_q[ldq] & { `THREADS{ldqe_relmin1_cTag[ldq]}}) | tidM1;
end
ldq_rel_mux_opsize = opsize;
ldq_rel_mux_wimge_i = wimge_i;
ldq_rel_mux_byte_swap = byte_swap;
ldq_rel_mux_p_addr = pAddr;
ldq_rel_mux_dvcEn = dvcEn;
ldq_rel_mux_lockSet = lockSet;
ldq_rel_mux_watchSet = watchSet;
ldq_rel_mux_tGpr = tGpr;
ldq_rel_mux_axu = axu;
ldq_rel_mux_algEn = algEn;
ldq_rel_mux_classID = classID;
ldq_rel_mux_tid = tid;
ldq_rel1_mux_back_inv = binv;
ldqe_relmin1_iTag = iTagM1;
ldqe_relmin1_tid = tidM1;
end
// Muxing Reload Request from Gather Queue to send to the L1
always @(*) begin: gath_relMux
reg [0:2] opsize;
reg byte_swap;
reg [0:1] dvcEn;
reg [0:AXU_TARGET_ENC-1] tGpr;
reg axu;
reg algEn;
reg [0:`THREADS-1] tid;
reg [59:63] addr;
reg [0:`ITAG_SIZE_ENC-1] iTagM1;
reg [0:`THREADS-1] tidM1;
//(* analysis_not_referenced="true" *)
integer lgq;
opsize = {3{1'b0}};
byte_swap = 1'b0;
dvcEn = {2{1'b0}};
tGpr = {AXU_TARGET_ENC{1'b0}};
axu = 1'b0;
algEn = 1'b0;
tid = {`THREADS{1'b0}};
addr = {5{1'b0}};
iTagM1 = {`ITAG_SIZE_ENC{1'b0}};
tidM1 = {`THREADS{1'b0}};
for (lgq=0; lgq<`LGQ_ENTRIES; lgq=lgq+1) begin
opsize = (lgqe_op_size_q[lgq] & { 3{lgq_rel0_upd_gpr_q[lgq]}}) | opsize;
byte_swap = (lgqe_byte_swap_q[lgq] & lgq_rel0_upd_gpr_q[lgq]) | byte_swap;
dvcEn = (lgqe_dvc_q[lgq] & { 2{lgq_rel0_upd_gpr_q[lgq]}}) | dvcEn;
tGpr = (lgqe_tgpr_q[lgq] & {AXU_TARGET_ENC{lgq_rel0_upd_gpr_q[lgq]}}) | tGpr;
axu = (lgqe_axu_q[lgq] & lgq_rel0_upd_gpr_q[lgq]) | axu;
algEn = (lgqe_algebraic_q[lgq] & lgq_rel0_upd_gpr_q[lgq]) | algEn;
tid = (lgqe_thrd_id_q[lgq] & { `THREADS{lgq_rel0_upd_gpr_q[lgq]}}) | tid;
addr = (lgqe_p_addr_q[lgq][59:63] & { 5{lgq_rel0_upd_gpr_q[lgq]}}) | addr;
iTagM1 = (lgqe_itag_q[lgq] & {`ITAG_SIZE_ENC{lgqe_relmin1_match[lgq]}}) | iTagM1;
tidM1 = (lgqe_thrd_id_q[lgq] & { `THREADS{lgqe_relmin1_match[lgq]}}) | tidM1;
end
lgq_rel_mux_opsize = opsize;
lgq_rel_mux_byte_swap = byte_swap;
lgq_rel_mux_dvcEn = dvcEn;
lgq_rel_mux_tGpr = tGpr;
lgq_rel_mux_axu = axu;
lgq_rel_mux_algEn = algEn;
lgq_rel_mux_tid = tid;
lgq_rel_mux_p_addr = addr;
lgqe_relmin1_iTag = iTagM1;
lgqe_relmin1_tid = tidM1;
end
// Latch up Reload Interface to other units
assign ldq_rel0_opsize = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_opsize : lgq_rel_mux_opsize;
assign ldq_rel1_opsize_d = ldq_rel0_opsize;
assign ldq_rel1_wimge_i_d = ldq_rel_mux_wimge_i;
assign ldq_rel0_byte_swap = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_byte_swap : lgq_rel_mux_byte_swap;
assign ldq_rel1_byte_swap_d = ldq_rel0_byte_swap;
assign ldq_rel2_byte_swap_d = ldq_rel1_byte_swap_q;
assign ldq_rel1_p_addr_d[64 - `REAL_IFAR_WIDTH:58] = ldq_rel_mux_p_addr[64 - `REAL_IFAR_WIDTH:58];
assign ldq_rel0_p_addr[59:63] = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_p_addr[59:63] : lgq_rel_mux_p_addr;
assign ldq_rel1_p_addr_d[59:63] = ldq_rel0_p_addr[59:63];
assign ldq_rel1_dvcEn_d = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_dvcEn : lgq_rel_mux_dvcEn;
assign ldq_rel1_lockSet_d = ldq_rel_mux_lockSet;
assign ldq_rel1_watchSet_d = ldq_rel_mux_watchSet;
assign ldq_rel1_tGpr_d = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_tGpr : lgq_rel_mux_tGpr;
assign ldq_rel1_axu_d = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_axu : lgq_rel_mux_axu;
assign ldq_rel1_algEn_d = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_algEn : lgq_rel_mux_algEn;
assign ldq_rel1_classID_d = ldq_rel_mux_classID;
assign ldq_rel1_tid_d = l2_rel0_resp_crit_qw_q ? ldq_rel_mux_tid : lgq_rel_mux_tid;
assign ldq_rel1_dir_tid_d = ldq_rel_mux_tid;
assign ldq_rel2_tid_d = ldq_rel1_tid_q;
assign ldq_relmin1_iTag = l2_lsq_resp_crit_qw ? ldqe_relmin1_iTag : lgqe_relmin1_iTag;
assign ldq_relmin1_tid = l2_lsq_resp_crit_qw ? ldqe_relmin1_tid : lgqe_relmin1_tid;
// Need to Mask off bit 57 of Reload Address depending on the Cacheline Size we are running with
assign ldq_rel_mux_p_addr_msk = {ldq_rel_mux_p_addr[64 - (`DC_SIZE - 3):56], (ldq_rel_mux_p_addr[57] | spr_xucr0_cls_q)};
// Back-Invalidate Congruence Class collided with Reload Congruence Class
assign ldq_rel1_collide_binv_d = l2_back_inv_val & ldq_rel0_updating_cache & (l2_back_inv_addr_msk[64-(`DC_SIZE-3):63-`CL_SIZE] == ldq_rel_mux_p_addr_msk);
// Check to see if any of the data beats got any ECC type errors on the reload
assign rel2_eccdet = |(ldqe_rel_eccdet & ldq_rel2_entrySent_q);
assign rel2_eccdet_ue = |(ldqe_rel_eccdet_ue & ldq_rel2_entrySent_q);
assign rel2_eccdet_err = rel2_eccdet | rel2_eccdet_ue;
// Need to lookup in the directory to determine which way to update
// Added ldqe_rst_eccdet_q to cover the case where the last beat on the reload interface
// is in rel3 and it got an ECC error on that beat and the reload_dataq is sending a request
// that is currently in the rel1 stage
assign ldq_rel1_clr_val = |(ldq_rel1_entrySent_q & ~(ldqe_relDir_start | ldqe_rst_eccdet_q));
assign ldq_rel2_cclass_d = {ldq_rel1_p_addr_q[64-(`DC_SIZE-3):56], (ldq_rel1_p_addr_q[57] | spr_xucr0_cls_q)};
assign ldq_rel3_cclass_d = ldq_rel2_cclass_q;
assign ldq_rel4_cclass_d = ldq_rel3_cclass_q;
assign ldq_rel1_set_val = |(ldq_rel1_entrySent_q & ldqe_last_beat & ~ldqe_rst_eccdet_q);
assign ldq_rel2_set_val_d = ldq_rel1_set_val;
assign ldq_rel3_set_val_d = ldq_rel2_set_val_q & (~rel2_blk_req_q);
assign ldq_rel4_set_val_d = ldq_rel3_set_val_q;
// reloadQueue included, dont want to block if the arb is sending request since
// it would be the reload queue sending
// if reloadQueue is not included, want to block data_val since arb is only trying to
// update the directory state, the data cache should have already been updated
assign ldq_rel1_data_val = (|(ldq_rel1_entrySent_q & ~ldqe_rst_eccdet_q)) & ~ldq_rel1_arb_val_q;
assign ldq_rel1_data_sel_d = ldq_rel0_updating_cache;
assign ldq_rel1_gpr_val_d = |(ldq_rel0_upd_gpr_q);
// loadmiss statemachine set itagHold, want to force reload through
// instead of using reload arbitration
assign ldq_l2_rel0_qHitBlk_d = |(ldq_relmin1_l2_qHitBlk);
// Update GPR detection
assign ldq_rel1_upd_gpr_d = ldq_rel0_crit_qw;
assign ldq_rel2_upd_gpr_d = ldq_rel1_upd_gpr_q;
assign ldq_rel3_upd_gpr_d = ldq_rel2_upd_gpr_q;
assign ldq_rel2_gpr_ecc_err = (ldq_rel2_upd_gpr_q & ~ldqe_dGpr_q) & {`LMQ_ENTRIES{l2_lsq_resp_ecc_err | l2_lsq_resp_ecc_err_ue}};
assign ldq_rel2_gpr_eccue_err = (ldq_rel2_upd_gpr_q & ~ldqe_dGpr_q) & {`LMQ_ENTRIES{l2_lsq_resp_ecc_err_ue}};
assign ldq_rel1_upd_gpr = ldq_rel1_upd_gpr_q & (~(ldqe_dGpr_q | ldqe_kill));
// Instruction Complete detection, completion report is dependent on the instruction
assign ldqe_rel2_drop_cpl_rpt = ldqe_lock_set_q | ldqe_watch_set_q | ldqe_resv_q | ldqe_sent_cpl_q | ldqe_need_cpl_q;
assign ldqe_rel3_drop_cpl_rpt_d = ldqe_rel2_drop_cpl_rpt;
assign ldqe_reld_cpl_rpt = (ldqe_lock_set_q | ldqe_watch_set_q | ldqe_resv_q) & (~(ldqe_sent_cpl_q | ldqe_need_cpl_q));
assign ldq_rel2_send_cpl_ok = ldq_rel2_upd_gpr_q & (~ldqe_rel2_drop_cpl_rpt);
assign ldq_rel6_send_cpl_ok = ldq_rel6_req_done_q & ldqe_reld_cpl_rpt;
assign ldq_rel_send_cpl_ok = ldq_rel2_send_cpl_ok | ldq_rel6_send_cpl_ok;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// ORDER QUEUE REPORT COMPLETE CONTROL
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Need to pipe down reload complete indicator to rel3, at rel3,
// we have all the information we need for the reload completion report
// ldawx, dcbt[st]ls, and larx will never send there complete report
// back to the order queue
assign ldq_rel3_odq_cpl = ldq_rel3_upd_gpr_q & (~ldqe_rel3_drop_cpl_rpt_q);
// Muxing Reload Request from LoadMiss Queue and Gather Queue to send to the Order Queue
always @(*) begin: odqCplMux
reg [0:`ITAG_SIZE_ENC-1] iTag;
reg ecc;
reg eccue;
reg [0:1] dvcEn;
reg [0:3] dacrw;
reg [0:`THREADS-1] tid;
reg nFlush;
reg np1Flush;
reg [0:3] pEvents;
//(* analysis_not_referenced="true" *)
integer ldq;
iTag = {`ITAG_SIZE_ENC{1'b0}};
ecc = 1'b0;
eccue = 1'b0;
dvcEn = {2{1'b0}};
dacrw = {4{1'b0}};
tid = {`THREADS{1'b0}};
nFlush = 1'b0;
np1Flush = 1'b0;
pEvents = {4{1'b0}};
for (ldq=0; ldq <= (`LMQ_ENTRIES+`LGQ_ENTRIES)-1; ldq=ldq+1) begin : odqCplMux
if (ldq < `LMQ_ENTRIES) begin : lmqEntry
iTag = (ldqe_itag_q[ldq] & {`ITAG_SIZE_ENC{ldq_rel3_odq_cpl[ldq]}}) | iTag;
ecc = (ldqe_upd_gpr_ecc_q[ldq] & ldq_rel3_odq_cpl[ldq]) | ecc;
eccue = (ldqe_upd_gpr_eccue_q[ldq] & ldq_rel3_odq_cpl[ldq]) | eccue;
dvcEn = (ldqe_dvc_q[ldq] & {2{ldq_rel3_odq_cpl[ldq]}}) | dvcEn;
dacrw = (ldqe_dacrw_q[ldq] & {4{ldq_rel3_odq_cpl[ldq]}}) | dacrw;
tid = (ldqe_thrd_id_q[ldq] & {`THREADS{ldq_rel3_odq_cpl[ldq]}}) | tid;
nFlush = (ldqe_back_inv_nFlush_q[ldq] & ldq_rel3_odq_cpl[ldq]) | nFlush;
np1Flush = (ldqe_back_inv_np1Flush_q[ldq] & ldq_rel3_odq_cpl[ldq]) | np1Flush;
pEvents = (ldqe_perf_events_q[ldq] & {4{ldq_rel3_odq_cpl[ldq]}}) | pEvents;
end
if (ldq >= `LMQ_ENTRIES) begin : lgqEntry
iTag = (lgqe_itag_q[ldq-`LMQ_ENTRIES] & {`ITAG_SIZE_ENC{lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]}}) | iTag;
ecc = (lgqe_upd_gpr_ecc_q[ldq-`LMQ_ENTRIES] & lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]) | ecc;
eccue = (lgqe_upd_gpr_eccue_q[ldq-`LMQ_ENTRIES] & lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]) | eccue;
dvcEn = (lgqe_dvc_q[ldq-`LMQ_ENTRIES] & {2{lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]}}) | dvcEn;
dacrw = (lgqe_dacrw_q[ldq-`LMQ_ENTRIES] & {4{lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]}}) | dacrw;
tid = (lgqe_thrd_id_q[ldq-`LMQ_ENTRIES] & {`THREADS{lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]}}) | tid;
nFlush = (lgqe_back_inv_nFlush_q[ldq-`LMQ_ENTRIES] & lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]) | nFlush;
np1Flush = (lgqe_back_inv_np1Flush_q[ldq-`LMQ_ENTRIES] & lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]) | np1Flush;
pEvents = (lgqe_perf_events_q[ldq-`LMQ_ENTRIES] & {4{lgq_rel3_upd_gpr_q[ldq-`LMQ_ENTRIES]}}) | pEvents;
end
end
ldq_rel3_odq_itag = iTag;
ldq_rel3_odq_ecc = ecc;
ldq_rel3_odq_eccue = eccue;
ldq_rel3_odq_dvc = dvcEn;
ldq_rel3_odq_dacrw = dacrw;
ldq_rel3_odq_tid = tid;
ldq_rel3_odq_nFlush = nFlush;
ldq_rel3_odq_np1Flush = np1Flush;
ldq_rel3_odq_pEvents = pEvents;
end
// Determine if we should be taking a debug interrupt
assign dbg_int_en_d = ctl_lsq_dbg_int_en;
assign ldq_rel3_odq_dbg_int_en = |(ldq_rel3_odq_tid & dbg_int_en_q);
// CritQW got ECC Back-Invalidate and not CP_NEXT
assign ldq_rel3_odq_oth_flush = ldq_rel3_odq_ecc | ldq_rel3_odq_nFlush;
assign ldq_rel3_dacrw[0:1] = (ldq_rel3_odq_dacrw[0:1] | ldq_rel3_odq_dvc) & {2{~(ldq_rel3_odq_oth_flush | ldq_rel3_odq_np1Flush)}};
assign ldq_rel3_dacrw[2:3] = ldq_rel3_odq_dacrw[2:3] & {2{~(ldq_rel3_odq_oth_flush | ldq_rel3_odq_np1Flush)}};
assign ldq_rel3_odq_val = ldq_rel3_odq_cpl & (~(ldqe_resolved_q | ldqe_kill));
assign lgq_rel3_odq_val = lgq_rel3_upd_gpr_q & lgqe_valid_q & (~(lgqe_resolved_q | lgqe_kill));
// Need to pipeline ODQ update for a few cycles
// Need to check at the end to cover the window
// where the Order Queue already reported resolved
assign ldq_rel4_odq_cpl_d = ldq_rel3_odq_val;
assign ldq_rel5_odq_cpl_d = ldq_rel4_odq_cpl_q & (~ldqe_resolved);
assign ldq_rel5_odq_cpl = ldq_rel5_odq_cpl_q & (~ldqe_resolved_q);
assign lgq_rel4_upd_gpr_d = lgq_rel3_upd_gpr_q & (~lgqe_kill);
assign lgq_rel5_upd_gpr_d = lgq_rel4_upd_gpr_q & (~lgqe_kill);
assign lgq_rel5_odq_cpl = lgq_rel5_upd_gpr_q & lgqe_valid_q & (~(lgqe_resolved_q | lgqe_kill));
// Report to ODQ, ODQ needs to update its entry with the following information
assign ldq_odq_upd_val = |(ldq_rel3_odq_val | lgq_rel3_odq_val);
assign ldq_odq_upd_itag = ldq_rel3_odq_itag;
assign ldq_odq_upd_nFlush = ldq_rel3_odq_oth_flush | |(ldq_rel3_dacrw & {4{ldq_rel3_odq_dbg_int_en}});
assign ldq_odq_upd_np1Flush = ldq_rel3_odq_np1Flush;
assign ldq_odq_upd_dacrw = ldq_rel3_dacrw;
assign ldq_odq_upd_tid = ldq_rel3_odq_tid;
assign ldq_odq_upd_pEvents = ldq_rel3_odq_pEvents;
assign ldq_odq_upd_eccue = ldq_rel3_odq_eccue;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// ENTRY REMOVAL and CREDIT RETURN ARBITRATION
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Doing a Round Robin Scheme within each 4 entries (called Groups)
// followed by a Round Robin Scheme within each Group
// Expand LDQ to max supported
generate begin : cplExp
genvar grp;
for (grp=0; grp<=(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4; grp=grp+1) begin : cplExp
genvar b;
for (b=0; b<4; b=b+1) begin : bitSel
if ((grp*4)+b < `LMQ_ENTRIES) begin : ldqExst
assign ldqe_remove[(grp*4)+b] = ldqe_send_cpl[(grp*4)+b];
end
if (((grp*4)+b >= `LMQ_ENTRIES) && ((grp*4)+b < `LMQ_ENTRIES+`LGQ_ENTRIES)) begin : lgqExst
assign ldqe_remove[(grp*4)+b] = lgqe_send_cpl[(grp*4)+b-`LMQ_ENTRIES];
end
if ((grp*4)+b >= `LMQ_ENTRIES+`LGQ_ENTRIES) begin : ldqNExst
assign ldqe_remove[(grp*4)+b] = 1'b0;
end
end
end
end
endgenerate
// Entry Select within Group
// Round Robin Scheme within each 4 entries in a Group
generate begin : cplGrpEntry
genvar grp;
for (grp = 0; grp <= (`LMQ_ENTRIES + `LGQ_ENTRIES - 1)/4; grp = grp + 1) begin : cplGrpEntry
assign cpl_grpEntry_val[grp] = ldqe_remove[grp * 4:(grp * 4) + 3];
assign cpl_grpEntry_sel[grp][0] = (cpl_grpEntry_last_sel_q[grp][0] & ~(|cpl_grpEntry_val[grp][1:3]) & cpl_grpEntry_val[grp][0]) |
(cpl_grpEntry_last_sel_q[grp][1] & ~(|cpl_grpEntry_val[grp][2:3]) & cpl_grpEntry_val[grp][0]) |
(cpl_grpEntry_last_sel_q[grp][2] & ~cpl_grpEntry_val[grp][3] & cpl_grpEntry_val[grp][0]) |
(cpl_grpEntry_last_sel_q[grp][3] & cpl_grpEntry_val[grp][0]);
assign cpl_grpEntry_sel[grp][1] = (cpl_grpEntry_last_sel_q[grp][0] & cpl_grpEntry_val[grp][1]) |
(cpl_grpEntry_last_sel_q[grp][1] & ~(|{cpl_grpEntry_val[grp][0], cpl_grpEntry_val[grp][2:3]}) & cpl_grpEntry_val[grp][1]) |
(cpl_grpEntry_last_sel_q[grp][2] & ~(|{cpl_grpEntry_val[grp][0], cpl_grpEntry_val[grp][3]}) & cpl_grpEntry_val[grp][1]) |
(cpl_grpEntry_last_sel_q[grp][3] & ~cpl_grpEntry_val[grp][0] & cpl_grpEntry_val[grp][1]);
assign cpl_grpEntry_sel[grp][2] = (cpl_grpEntry_last_sel_q[grp][0] & ~cpl_grpEntry_val[grp][1] & cpl_grpEntry_val[grp][2]) |
(cpl_grpEntry_last_sel_q[grp][1] & cpl_grpEntry_val[grp][2]) |
(cpl_grpEntry_last_sel_q[grp][2] & ~(|{cpl_grpEntry_val[grp][0:1], cpl_grpEntry_val[grp][3]}) & cpl_grpEntry_val[grp][2]) |
(cpl_grpEntry_last_sel_q[grp][3] & ~(|cpl_grpEntry_val[grp][0:1]) & cpl_grpEntry_val[grp][2]);
assign cpl_grpEntry_sel[grp][3] = (cpl_grpEntry_last_sel_q[grp][0] & ~(|cpl_grpEntry_val[grp][1:2]) & cpl_grpEntry_val[grp][3]) |
(cpl_grpEntry_last_sel_q[grp][1] & ~cpl_grpEntry_val[grp][2] & cpl_grpEntry_val[grp][3]) |
(cpl_grpEntry_last_sel_q[grp][2] & cpl_grpEntry_val[grp][3]) |
(cpl_grpEntry_last_sel_q[grp][3] & ~(|cpl_grpEntry_val[grp][0:2]) & cpl_grpEntry_val[grp][3]);
// Load Queue Group Selected
assign cpl_grpEntry_sent[grp] = |(ldqe_cpl_sent[grp*4:(grp*4)+3]);
assign cpl_grpEntry_last_sel_d[grp] = cpl_grpEntry_sent[grp] ? cpl_grpEntry_sel[grp] : cpl_grpEntry_last_sel_q[grp];
// Mux Load Queue Entry within a Group
always @(*) begin: cplMux
reg [0:`ITAG_SIZE_ENC-1] iTag;
reg ecc;
reg eccue;
reg [0:3] dacrw;
reg [0:1] dvc;
reg [0:`THREADS-1] tid;
reg nFlush;
reg np1Flush;
reg [0:3] pEvents;
reg larx;
//(* analysis_not_referenced="true" *)
integer ldq;
iTag = {`ITAG_SIZE_ENC{1'b0}};
ecc = 1'b0;
eccue = 1'b0;
dvc = {2{1'b0}};
dacrw = {4{1'b0}};
tid = {`THREADS{1'b0}};
nFlush = 1'b0;
np1Flush = 1'b0;
pEvents = {4{1'b0}};
larx = 1'b0;
for (ldq=0; ldq<4; ldq=ldq+1) begin : cplMux
if ((grp*4)+ldq < `LMQ_ENTRIES) begin : ldqExst
iTag = (ldqe_itag_q[(grp*4)+ldq] & {`ITAG_SIZE_ENC{cpl_grpEntry_sel[grp][ldq]}}) | iTag;
ecc = (ldqe_nFlush_ecc_err[(grp*4)+ldq] & cpl_grpEntry_sel[grp][ldq]) | ecc;
eccue = (ldqe_upd_gpr_eccue_q[(grp*4)+ldq] & cpl_grpEntry_sel[grp][ldq]) | eccue;
dvc = (ldqe_dvc_q[(grp*4)+ldq] & {2{cpl_grpEntry_sel[grp][ldq]}}) | dvc;
dacrw = (ldqe_dacrw_q[(grp*4)+ldq] & {4{cpl_grpEntry_sel[grp][ldq]}}) | dacrw;
tid = (ldqe_thrd_id_q[(grp*4)+ldq] & {`THREADS{cpl_grpEntry_sel[grp][ldq]}}) | tid;
nFlush = (ldqe_back_inv_nFlush_q[(grp*4)+ldq] & cpl_grpEntry_sel[grp][ldq]) | nFlush;
np1Flush = (ldqe_back_inv_np1Flush_q[(grp*4)+ldq] & cpl_grpEntry_sel[grp][ldq]) | np1Flush;
pEvents = (ldqe_perf_events_q[(grp*4)+ldq] & {4{cpl_grpEntry_sel[grp][ldq]}}) | pEvents;
larx = (ldqe_resv_q[(grp*4)+ldq] & cpl_grpEntry_sel[grp][ldq]) | larx;
end
if (((grp*4)+ldq >= `LMQ_ENTRIES) && ((grp*4)+ldq < `LMQ_ENTRIES+`LGQ_ENTRIES)) begin : lgqExst
iTag = (lgqe_itag_q[(grp*4)+ldq-`LMQ_ENTRIES] & {`ITAG_SIZE_ENC{cpl_grpEntry_sel[grp][ldq]}}) | iTag;
ecc = (lgqe_upd_gpr_ecc_q[(grp*4)+ldq-`LMQ_ENTRIES] & cpl_grpEntry_sel[grp][ldq]) | ecc;
eccue = (lgqe_upd_gpr_eccue_q[(grp*4)+ldq-`LMQ_ENTRIES] & cpl_grpEntry_sel[grp][ldq]) | eccue;
dvc = (lgqe_dvc_q[(grp*4)+ldq-`LMQ_ENTRIES] & {2{cpl_grpEntry_sel[grp][ldq]}}) | dvc;
dacrw = (lgqe_dacrw_q[(grp*4)+ldq-`LMQ_ENTRIES] & {4{cpl_grpEntry_sel[grp][ldq]}}) | dacrw;
tid = (lgqe_thrd_id_q[(grp*4)+ldq-`LMQ_ENTRIES] & {`THREADS{cpl_grpEntry_sel[grp][ldq]}}) | tid;
nFlush = (lgqe_back_inv_nFlush_q[(grp*4)+ldq-`LMQ_ENTRIES] & cpl_grpEntry_sel[grp][ldq]) | nFlush;
np1Flush = (lgqe_back_inv_np1Flush_q[(grp*4)+ldq-`LMQ_ENTRIES] & cpl_grpEntry_sel[grp][ldq]) | np1Flush;
pEvents = (lgqe_perf_events_q[(grp*4)+ldq-`LMQ_ENTRIES] & {4{cpl_grpEntry_sel[grp][ldq]}}) | pEvents;
end
end
cpl_grpEntry_iTag[grp] = iTag;
cpl_grpEntry_ecc[grp] = ecc;
cpl_grpEntry_eccue[grp] = eccue;
cpl_grpEntry_dvc[grp] = dvc;
cpl_grpEntry_dacrw[grp] = dacrw;
cpl_grpEntry_tid[grp] = tid;
cpl_grpEntry_nFlush[grp] = nFlush;
cpl_grpEntry_np1Flush[grp] = np1Flush;
cpl_grpEntry_pEvents[grp] = pEvents;
cpl_grpEntry_larx[grp] = larx;
end
end
end
endgenerate
// Group Select Between all Groups
// Round Robin Scheme within Groups
generate begin : cplGrp
genvar grp;
for (grp=0; grp<=3; grp=grp+1) begin : cplGrp
if (grp <= (`LMQ_ENTRIES+`LGQ_ENTRIES- 1)/4) begin : grpExst
assign cpl_group_val[grp] = |(cpl_grpEntry_val[grp]);
end
if (grp > (`LMQ_ENTRIES+`LGQ_ENTRIES- 1)/4) begin : grpNExst
assign cpl_group_val[grp] = 1'b0;
end
end
end
endgenerate
assign cpl_group_sel[0] = (cpl_group_last_sel_q[0] & ~(|cpl_group_val[1:3]) & cpl_group_val[0]) |
(cpl_group_last_sel_q[1] & ~(|cpl_group_val[2:3]) & cpl_group_val[0]) |
(cpl_group_last_sel_q[2] & ~cpl_group_val[3] & cpl_group_val[0]) |
(cpl_group_last_sel_q[3] & cpl_group_val[0]);
assign cpl_group_sel[1] = (cpl_group_last_sel_q[0] & cpl_group_val[1]) |
(cpl_group_last_sel_q[1] & ~(|{cpl_group_val[0], cpl_group_val[2:3]}) & cpl_group_val[1]) |
(cpl_group_last_sel_q[2] & ~(|{cpl_group_val[0], cpl_group_val[3]}) & cpl_group_val[1]) |
(cpl_group_last_sel_q[3] & ~cpl_group_val[0] & cpl_group_val[1]);
assign cpl_group_sel[2] = (cpl_group_last_sel_q[0] & ~cpl_group_val[1] & cpl_group_val[2]) |
(cpl_group_last_sel_q[1] & cpl_group_val[2]) |
(cpl_group_last_sel_q[2] & ~(|{cpl_group_val[0:1], cpl_group_val[3]}) & cpl_group_val[2]) |
(cpl_group_last_sel_q[3] & ~(|cpl_group_val[0:1]) & cpl_group_val[2]);
assign cpl_group_sel[3] = (cpl_group_last_sel_q[0] & ~(|cpl_group_val[1:2]) & cpl_group_val[3]) |
(cpl_group_last_sel_q[1] & ~cpl_group_val[2] & cpl_group_val[3]) |
(cpl_group_last_sel_q[2] & cpl_group_val[3]) |
(cpl_group_last_sel_q[3] & ~(|cpl_group_val[0:2]) & cpl_group_val[3]);
assign cpl_credit_sent = |(ldqe_cpl_sent);
assign cpl_group_last_sel_d = cpl_credit_sent ? cpl_group_sel : cpl_group_last_sel_q;
// Mux Load Queue Entry between Groups
always @(*) begin: cplGrpLqMux
reg [0:`ITAG_SIZE_ENC-1] iTag;
reg ecc;
reg eccue;
reg [0:1] dvc;
reg [0:3] dacrw;
reg [0:`THREADS-1] tid;
reg nFlush;
reg np1Flush;
reg [0:3] pEvents;
reg larx;
//(* analysis_not_referenced="true" *)
integer grp;
iTag = {`ITAG_SIZE_ENC{1'b0}};
ecc = 1'b0;
eccue = 1'b0;
dvc = {2{1'b0}};
dacrw = {4{1'b0}};
tid = {`THREADS{1'b0}};
nFlush = 1'b0;
np1Flush = 1'b0;
pEvents = {4{1'b0}};
larx = 1'b0;
for (grp=0; grp<4; grp=grp+1) begin : cplGrpLqMux
if (grp <= (`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4) begin : GrpExst
iTag = (cpl_grpEntry_iTag[grp] & {`ITAG_SIZE_ENC{cpl_group_sel[grp]}}) | iTag;
ecc = (cpl_grpEntry_ecc[grp] & cpl_group_sel[grp]) | ecc;
eccue = (cpl_grpEntry_eccue[grp] & cpl_group_sel[grp]) | eccue;
dvc = (cpl_grpEntry_dvc[grp] & {2{cpl_group_sel[grp]}}) | dvc;
dacrw = (cpl_grpEntry_dacrw[grp] & {4{cpl_group_sel[grp]}}) | dacrw;
tid = (cpl_grpEntry_tid[grp] & {`THREADS{cpl_group_sel[grp]}}) | tid;
nFlush = (cpl_grpEntry_nFlush[grp] & cpl_group_sel[grp]) | nFlush;
np1Flush = (cpl_grpEntry_np1Flush[grp] & cpl_group_sel[grp]) | np1Flush;
pEvents = (cpl_grpEntry_pEvents[grp] & {4{cpl_group_sel[grp]}}) | pEvents;
larx = (cpl_grpEntry_larx[grp] & cpl_group_sel[grp]) | larx;
end
end
cpl_send_itag = iTag;
cpl_ecc_dec = ecc;
cpl_eccue_dec = eccue;
cpl_dvc = dvc;
cpl_dacrw = dacrw;
cpl_tid = tid;
cpl_nFlush = nFlush;
cpl_np1Flush = np1Flush;
cpl_pEvents = pEvents;
cpl_larx = larx;
end
// Completion Report has been sent
generate begin : credSent
genvar grp;
for (grp = 0; grp <= (`LMQ_ENTRIES + `LGQ_ENTRIES - 1)/4; grp = grp + 1) begin : credSent
genvar ldq;
for (ldq=0; ldq<=3; ldq=ldq+1) begin : ldqEntry
assign ldqe_cpl_sel[ldq+(grp*4)] = cpl_grpEntry_sel[grp][ldq] & cpl_group_sel[grp];
if ((grp*4)+ldq < `LMQ_ENTRIES) begin : ldq_cpl
assign ldqe_cpl_sent[ldq+(grp*4)] = ldqe_cpl_sel[ldq+(grp*4)] & ~(ldqe_kill[ldq+(grp*4)] | ldq_cpl_odq_val);
end
if ((grp*4)+ldq >= `LMQ_ENTRIES) begin : lgq_cpl
assign ldqe_cpl_sent[ldq+(grp*4)] = ldqe_cpl_sel[ldq+(grp*4)] & ~(lgqe_kill[ldq+(grp*4)-`LMQ_ENTRIES] | ldq_cpl_odq_val);
assign lgqe_cpl_sent[ldq+(grp*4)-`LMQ_ENTRIES] = ldqe_cpl_sent[ldq+(grp*4)];
end
end
end
end
endgenerate
// Completion Report bus for exceptions, loadhits, orderq flush, loadmisses, loadmiss with ecc, and storetypes
// Priority Selection
// 1) ORDERQ has highest priority (loadhits or flushes)
// 2) LDQ has last priority (loadmisses)
assign ldq_cpl_odq_zap = |(odq_ldq_report_tid & iu_lq_cp_flush_q);
assign ldq_cpl_odq_val = odq_ldq_resolved & (odq_ldq_n_flush | odq_ldq_report_needed) & (~ldq_cpl_odq_zap);
assign ldq_cpl_odq_dbg_int_en = |(odq_ldq_report_tid & dbg_int_en_q);
assign ldq_cpl_odq_n_flush = |(odq_ldq_report_dacrw &{4{ldq_cpl_odq_dbg_int_en}}) | odq_ldq_n_flush;
assign ldq_cpl_odq_dacrw = odq_ldq_report_dacrw &{4{~odq_ldq_n_flush}};
assign ldq_cpl_odq_eccue = odq_ldq_report_eccue;
assign ldq_cpl_pending = |(ldqe_cpl_sent);
assign ldq_execute_vld = cpl_tid & {`THREADS{ldq_cpl_pending}};
assign odq_execute_vld = odq_ldq_report_tid & {`THREADS{ldq_cpl_odq_val}};
assign lq1_iu_execute_vld_d = ldq_execute_vld | odq_execute_vld;
assign lq1_iu_n_flush_d = (ldq_cpl_odq_val & ldq_cpl_odq_n_flush) | // ODQ N flush report
(ldq_cpl_pending & ldq_cpl_n_flush); // LDQ N flush report
assign lq1_iu_np1_flush_d = (ldq_cpl_odq_val & odq_ldq_np1_flush) | // ODQ NP1 flush report
(ldq_cpl_pending & ldq_cpl_np1_flush); // LDQ NP1 flush report
assign lq1_iu_exception_val_d = (ldq_cpl_odq_val & ldq_cpl_odq_eccue) | // ODQ MCHK report
(ldq_cpl_pending & cpl_eccue_dec); // LDQ MCHK report
assign lq1_iu_itag_d = ldq_cpl_odq_val ? odq_ldq_report_itag : cpl_send_itag;
// Need to report pipelined DVC compare results when completion report is piped reload
assign ldq_cpl_dbg_int_en = |(cpl_tid & dbg_int_en_q);
// CritQW got ECC Back-Invalidate and not CP_NEXT
assign ldq_cpl_oth_flush = cpl_ecc_dec | cpl_nFlush;
// DEBUG INTERRUPT
assign ldq_cpl_n_flush = |(ldq_cpl_dacrw & {4{ldq_cpl_dbg_int_en}}) | ldq_cpl_oth_flush;
assign ldq_cpl_np1_flush = cpl_np1Flush;
// Select LDQ DVC
assign ldq_cpl_dvc = cpl_dvc;
assign ldq_cpl_dacrw[0:1] = (cpl_dacrw[0:1] | ldq_cpl_dvc) & {2{~(ldq_cpl_oth_flush | ldq_cpl_np1_flush)}};
assign ldq_cpl_dacrw[2:3] = cpl_dacrw[2:3] & {2{~(ldq_cpl_oth_flush | ldq_cpl_np1_flush)}};
// DACR report for piped reload
assign lq1_iu_dacrw_d = ldq_cpl_odq_val ? ldq_cpl_odq_dacrw : ldq_cpl_dacrw;
assign lq1_iu_perf_events_d = ldq_cpl_odq_val ? odq_ldq_report_pEvents : cpl_pEvents;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Performance Events
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// LARX Finished Performance Event
assign ldq_cpl_larx_d = ldq_execute_vld & {`THREADS{cpl_larx}};
assign ldq_cpl_binv_d = ldq_execute_vld & {`THREADS{cpl_nFlush}};
assign ldq_rel_cmmt_d = |(ldq_rel2_sentL1);
assign ldq_rel_need_hole_d = ldq_l2_resp_hold_all | ldq_rel_arb_hold_all;
assign ldq_rel_latency_d = ldqe_req_outstanding[0];
assign perf_ldq_cpl_larx = ldq_cpl_larx_q;
assign perf_ldq_cpl_binv = ldq_cpl_binv_q;
assign perf_ldq_rel_attmpt = |ldq_rel1_entrySent_q;
assign perf_ldq_rel_cmmt = ldq_rel_cmmt_q;
assign perf_ldq_rel_need_hole = ldq_rel_need_hole_q;
assign perf_ldq_rel_latency = ldq_rel_latency_q;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Pervasive Error Reporting
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
tri_direct_err_rpt #(.WIDTH(4)) err_rpt(
.vd(vdd),
.gd(gnd),
.err_in({ldq_err_inval_rel_q,
ldq_err_ecc_det_q,
ldq_err_ue_det_q,
ldq_rel3_rdat_par_err}),
.err_out({lq_pc_err_invld_reld,
lq_pc_err_l2intrf_ecc,
lq_pc_err_l2intrf_ue,
lq_pc_err_relq_parity})
);
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// OUTPUTS
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// RV Control
assign ldq_l2_resp_hold_all = l2_rel0_resp_ldq_val_q & ldq_l2_rel0_qHitBlk_q;
assign ldq_rel_arb_hold_all = ldq_rel0_arb_thresh & (~l2_rel0_resp_ldq_val_q);
assign ldq_hold_all_req = ldq_l2_resp_hold_all | ldq_rel_arb_hold_all | l2_back_inv_val;
assign ldq_rel1_gpr_val = ldq_rel1_gpr_val_q | lgq_rel1_gpr_val_q;
assign lsq_ctl_ex5_ldq_restart = ex5_ldq_restart;
assign ldq_rv_set_hold = ex5_setHold;
assign ldq_rv_clr_hold = ldq_clrHold_tid;
// RV Release Dependent ITAGs
assign ldq_itag2_rel_val = |(ldqe_relmin1_upd_gpr | lgqe_relmin1_upd_gpr);
assign lq_rv_itag2_vld = ldq_relmin1_tid & {`THREADS{ldq_itag2_rel_val}};
assign lq_rv_itag2 = ldq_relmin1_iTag;
// Physical Register File update data
assign ldq_rel2_byte_swap = ldq_rel2_byte_swap_q;
assign ldq_rel2_data = ldq_rel2_rot_data;
// Interface to Completion
assign lq1_iu_execute_vld = lq1_iu_execute_vld_q;
assign lq1_iu_itag = lq1_iu_itag_q;
assign lq1_iu_exception_val = lq1_iu_exception_val_q;
assign lq1_iu_exception = 6'b011010;
assign lq1_iu_n_flush = lq1_iu_n_flush_q;
assign lq1_iu_np1_flush = lq1_iu_np1_flush_q;
assign lq1_iu_dacr_type = 1'b1;
assign lq1_iu_dacrw = lq1_iu_dacrw_q;
assign lq1_iu_perf_events = lq1_iu_perf_events_q;
// Performance Events
assign lsq_ctl_ex6_ldq_events = {perf_ex6_ldq_full_restart, perf_ex6_ldq_hit_restart,
perf_ex6_lgq_full_restart, perf_ex6_lgq_qwhit_restart};
assign lsq_perv_ex7_events = ex7_pfetch_blk_tid;
assign lsq_perv_ldq_events = {perf_ldq_rel_attmpt, perf_ldq_rel_cmmt, perf_ldq_rel_need_hole,
perf_ldq_rel_latency, perf_ldq_cpl_larx, perf_ldq_cpl_binv};
// Interface to Store Queue
assign ldq_stq_rel1_blk_store = ldq_stq_rel1_blk_store_q;
// Store Hit LoadMiss Queue Entry
assign ldq_stq_ex5_ldm_hit = ex5_ldm_hit_q;
assign ldq_stq_ex5_ldm_entry = ex5_ldm_entry & {`LMQ_ENTRIES{~(ex5_drop_req_val | ex5_ldreq_flushed | ex5_pfetch_flushed)}};
assign ldq_stq_ldm_cpl = ldqe_req_cmpl_q;
assign ldq_stq_stq4_dir_upd = ldq_rel4_set_val_q;
assign ldq_stq_stq4_cclass = ldq_rel4_cclass_q;
// Reload Update L1 Data Cache
assign ldq_dat_stq1_stg_act = ldq_rel1_val_q;
assign lsq_dat_rel1_data_val = ldq_rel1_data_val;
assign lsq_dat_rel1_qw = ldq_rel1_resp_qw_q;
// Reload Update L1 Directory
assign ldq_ctl_stq1_stg_act = ldq_rel1_val_q;
assign lsq_ctl_rel1_clr_val = ldq_rel1_clr_val;
assign lsq_ctl_rel1_set_val = ldq_rel1_set_val;
assign lsq_ctl_rel2_upd_val = ldq_rel2_set_val_q & ~(rel2_eccdet_err | ldq_rel2_rdat_perr);
assign lsq_ctl_rel1_data_val = ldq_rel1_data_val;
assign lsq_ctl_rel1_thrd_id = ldq_rel1_dir_tid_q;
assign lsq_ctl_rel1_back_inv = ldq_rel1_mux_back_inv;
assign lsq_ctl_rel1_tag = ldq_rel1_cTag_q;
assign lsq_ctl_rel1_classid = ldq_rel1_classID_q;
assign lsq_ctl_rel1_lock_set = ldq_rel1_lockSet_q;
assign lsq_ctl_rel1_watch_set = ldq_rel1_watchSet_q;
assign lsq_ctl_rel3_l1dump_val = ldq_rel3_l1_dump_val;
assign lsq_ctl_rel3_clr_relq = ldq_rel3_clr_relq_q;
// Common between Reload and COMMIT Pipe
assign ldq_arb_rel1_data_sel = ldq_rel1_data_sel_q | ldq_rel1_gpr_val;
assign ldq_arb_rel1_axu_val = ldq_rel1_axu_q;
assign ldq_arb_rel1_op_size = ldq_rel1_opsize_q;
assign ldq_arb_rel1_addr = ldq_rel1_p_addr_q;
assign ldq_arb_rel1_ci = ldq_rel1_wimge_i_q;
assign ldq_arb_rel1_byte_swap = ldq_rel1_byte_swap_q;
assign ldq_arb_rel1_thrd_id = ldq_rel1_tid_q;
assign ldq_arb_rel1_data = ldq_rel1_data;
// Reload Update Physical Register
assign lsq_ctl_rel1_gpr_val = ldq_rel1_gpr_val;
assign lsq_ctl_rel1_ta_gpr = ldq_rel1_tGpr_q;
assign lsq_ctl_rel1_upd_gpr = |(ldq_rel1_upd_gpr) | |(lgq_rel1_upd_gpr);
// Need to block Reloads and Reissue Stores if Load Queue has issued instructions
assign lsq_ctl_rel2_blk_req = rel2_blk_req_q;
// L2 request Available
assign ldq_arb_ld_req_pwrToken = ((ex5_ldreq_val_q | ex5_pfetch_val_q) & (~ldq_l2_req_need_send)) | fifo_ldq_req_val_q[0];
assign ldq_arb_ld_req_avail = (ex5_ldreq_val & (~(ex5_drop_req_val | ldq_l2_req_need_send))) |
fifo_ldq_req0_avail;
assign ldq_odq_vld = ((ex5_odq_ldreq_val_q & (~ex5_restart_val)) | ex5_streq_val_q | (ex5_othreq_val_q & (~ex5_restart_val))) & (~ex5_stg_flush);
assign ldq_odq_pfetch_vld = ex5_pfetch_val;
assign ldq_odq_wimge_i = ex5_wimge_q[1];
assign ldq_odq_ex6_pEvents = ex6_cmmt_perf_events_q;
// All reloads for each Load Queue Entries have completed
assign lq_xu_quiesce = lq_xu_quiesce_q;
assign lq_mm_lmq_stq_empty = lq_mm_lmq_stq_empty_q;
assign lq_pc_ldq_quiesce = lq_pc_ldq_quiesce_q;
assign lq_pc_stq_quiesce = lq_pc_stq_quiesce_q;
assign lq_pc_pfetch_quiesce = lq_pc_pfetch_quiesce_q;
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// REGISTERS
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) spr_xucr0_cls_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[spr_xucr0_cls_offset]),
.scout(sov[spr_xucr0_cls_offset]),
.din(spr_xucr0_cls_d),
.dout(spr_xucr0_cls_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) spr_lsucr0_lge_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[spr_lsucr0_lge_offset]),
.scout(sov[spr_lsucr0_lge_offset]),
.din(spr_lsucr0_lge_d),
.dout(spr_lsucr0_lge_q)
);
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) spr_lsucr0_lca_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[spr_lsucr0_lca_offset:spr_lsucr0_lca_offset + 3 - 1]),
.scout(sov[spr_lsucr0_lca_offset:spr_lsucr0_lca_offset + 3 - 1]),
.din(spr_lsucr0_lca_d),
.dout(spr_lsucr0_lca_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_val_offset]),
.scout(sov[l2_rel0_resp_val_offset]),
.din(l2_rel0_resp_val_d),
.dout(l2_rel0_resp_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_ldq_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_ldq_val_offset]),
.scout(sov[l2_rel0_resp_ldq_val_offset]),
.din(l2_rel0_resp_ldq_val_d),
.dout(l2_rel0_resp_ldq_val_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_cTag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_cTag_offset:l2_rel0_resp_cTag_offset + 4 - 1]),
.scout(sov[l2_rel0_resp_cTag_offset:l2_rel0_resp_cTag_offset + 4 - 1]),
.din(l2_rel0_resp_cTag_d),
.dout(l2_rel0_resp_cTag_q)
);
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_qw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_qw_offset:l2_rel0_resp_qw_offset + 3 - 1]),
.scout(sov[l2_rel0_resp_qw_offset:l2_rel0_resp_qw_offset + 3 - 1]),
.din(l2_rel0_resp_qw_d),
.dout(l2_rel0_resp_qw_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_crit_qw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_crit_qw_offset]),
.scout(sov[l2_rel0_resp_crit_qw_offset]),
.din(l2_rel0_resp_crit_qw_d),
.dout(l2_rel0_resp_crit_qw_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel0_resp_l1_dump_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel0_resp_l1_dump_offset]),
.scout(sov[l2_rel0_resp_l1_dump_offset]),
.din(l2_rel0_resp_l1_dump_d),
.dout(l2_rel0_resp_l1_dump_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_algebraic_sel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_algebraic_sel_offset:ldq_rel1_algebraic_sel_offset + 4 - 1]),
.scout(sov[ldq_rel1_algebraic_sel_offset:ldq_rel1_algebraic_sel_offset + 4 - 1]),
.din(ldq_rel1_algebraic_sel_d),
.dout(ldq_rel1_algebraic_sel_q)
);
tri_rlmreg_p #(.WIDTH(8), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_rot_sel1_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_rot_sel1_offset:ldq_rel1_rot_sel1_offset + 8 - 1]),
.scout(sov[ldq_rel1_rot_sel1_offset:ldq_rel1_rot_sel1_offset + 8 - 1]),
.din(ldq_rel1_rot_sel1_d),
.dout(ldq_rel1_rot_sel1_q)
);
tri_rlmreg_p #(.WIDTH(8), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_rot_sel2_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_rot_sel2_offset:ldq_rel1_rot_sel2_offset + 8 - 1]),
.scout(sov[ldq_rel1_rot_sel2_offset:ldq_rel1_rot_sel2_offset + 8 - 1]),
.din(ldq_rel1_rot_sel2_d),
.dout(ldq_rel1_rot_sel2_q)
);
tri_rlmreg_p #(.WIDTH(8), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_rot_sel3_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_rot_sel3_offset:ldq_rel1_rot_sel3_offset + 8 - 1]),
.scout(sov[ldq_rel1_rot_sel3_offset:ldq_rel1_rot_sel3_offset + 8 - 1]),
.din(ldq_rel1_rot_sel3_d),
.dout(ldq_rel1_rot_sel3_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) iu_lq_cp_flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[iu_lq_cp_flush_offset:iu_lq_cp_flush_offset + `THREADS - 1]),
.scout(sov[iu_lq_cp_flush_offset:iu_lq_cp_flush_offset + `THREADS - 1]),
.din(iu_lq_cp_flush_d),
.dout(iu_lq_cp_flush_q)
);
generate begin : iu_lq_cp_next_itag_tid
genvar tid;
for (tid=0; tid<`THREADS; tid=tid+1) begin : iu_lq_cp_next_itag_tid
tri_rlmreg_p #(.WIDTH(`ITAG_SIZE_ENC), .INIT(0), .NEEDS_SRESET(1)) iu_lq_cp_next_itag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[iu_lq_cp_next_itag_offset + `ITAG_SIZE_ENC * tid:iu_lq_cp_next_itag_offset + `ITAG_SIZE_ENC * (tid + 1) - 1]),
.scout(sov[iu_lq_cp_next_itag_offset + `ITAG_SIZE_ENC * tid:iu_lq_cp_next_itag_offset + `ITAG_SIZE_ENC * (tid + 1) - 1]),
.din(iu_lq_cp_next_itag[`ITAG_SIZE_ENC*tid:`ITAG_SIZE_ENC*(tid+1)-1]),
.dout(iu_lq_cp_next_itag_q[tid])
);
end
end
endgenerate
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) odq_ldq_n_flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[odq_ldq_n_flush_offset]),
.scout(sov[odq_ldq_n_flush_offset]),
.din(odq_ldq_n_flush_d),
.dout(odq_ldq_n_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) odq_ldq_resolved_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[odq_ldq_resolved_offset]),
.scout(sov[odq_ldq_resolved_offset]),
.din(odq_ldq_resolved_d),
.dout(odq_ldq_resolved_q)
);
tri_rlmreg_p #(.WIDTH(`ITAG_SIZE_ENC), .INIT(0), .NEEDS_SRESET(1)) odq_ldq_report_itag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[odq_ldq_report_itag_offset:odq_ldq_report_itag_offset + `ITAG_SIZE_ENC - 1]),
.scout(sov[odq_ldq_report_itag_offset:odq_ldq_report_itag_offset + `ITAG_SIZE_ENC - 1]),
.din(odq_ldq_report_itag_d),
.dout(odq_ldq_report_itag_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) odq_ldq_report_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[odq_ldq_report_tid_offset:odq_ldq_report_tid_offset + `THREADS - 1]),
.scout(sov[odq_ldq_report_tid_offset:odq_ldq_report_tid_offset + `THREADS - 1]),
.din(odq_ldq_report_tid_d),
.dout(odq_ldq_report_tid_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) rv_lq_rvs_empty_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[rv_lq_rvs_empty_offset:rv_lq_rvs_empty_offset + `THREADS - 1]),
.scout(sov[rv_lq_rvs_empty_offset:rv_lq_rvs_empty_offset + `THREADS - 1]),
.din(rv_lq_rvs_empty_d),
.dout(rv_lq_rvs_empty_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) rel2_blk_req_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[rel2_blk_req_offset]),
.scout(sov[rel2_blk_req_offset]),
.din(rel2_blk_req_d),
.dout(rel2_blk_req_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) rel2_rviss_blk_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[rel2_rviss_blk_offset]),
.scout(sov[rel2_rviss_blk_offset]),
.din(rel2_rviss_blk_d),
.dout(rel2_rviss_blk_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_collide_binv_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_collide_binv_offset]),
.scout(sov[ldq_rel1_collide_binv_offset]),
.din(ldq_rel1_collide_binv_d),
.dout(ldq_rel1_collide_binv_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_stq_rel1_blk_store_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_stq_rel1_blk_store_offset]),
.scout(sov[ldq_stq_rel1_blk_store_offset]),
.din(ldq_stq_rel1_blk_store_d),
.dout(ldq_stq_rel1_blk_store_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_ldreq_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldreq_offset]),
.scout(sov[ex4_ldreq_offset]),
.din(ex4_ldreq_d),
.dout(ex4_ldreq_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldreq_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldreq_val_offset]),
.scout(sov[ex5_ldreq_val_offset]),
.din(ex5_ldreq_val_d),
.dout(ex5_ldreq_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_pfetch_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_pfetch_val_offset]),
.scout(sov[ex4_pfetch_val_offset]),
.din(ex4_pfetch_val_d),
.dout(ex4_pfetch_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_pfetch_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_pfetch_val_offset]),
.scout(sov[ex5_pfetch_val_offset]),
.din(ex5_pfetch_val_d),
.dout(ex5_pfetch_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_odq_ldreq_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_odq_ldreq_val_offset]),
.scout(sov[ex5_odq_ldreq_val_offset]),
.din(ex5_odq_ldreq_val_d),
.dout(ex5_odq_ldreq_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_streq_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_streq_val_offset]),
.scout(sov[ex5_streq_val_offset]),
.din(ex5_streq_val_d),
.dout(ex5_streq_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_othreq_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_othreq_val_offset]),
.scout(sov[ex5_othreq_val_offset]),
.din(ex5_othreq_val_d),
.dout(ex5_othreq_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_reserved_taken_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_reserved_taken_offset]),
.scout(sov[ex5_reserved_taken_offset]),
.din(ex5_reserved_taken_d),
.dout(ex5_reserved_taken_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_resv_taken_restart_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_resv_taken_restart_offset]),
.scout(sov[ex5_resv_taken_restart_offset]),
.din(ex5_resv_taken_restart_d),
.dout(ex5_resv_taken_restart_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lq_xu_quiesce_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq_xu_quiesce_offset:lq_xu_quiesce_offset + `THREADS - 1]),
.scout(sov[lq_xu_quiesce_offset:lq_xu_quiesce_offset + `THREADS - 1]),
.din(lq_xu_quiesce_d),
.dout(lq_xu_quiesce_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lq_pc_ldq_quiesce_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq_pc_ldq_quiesce_offset:lq_pc_ldq_quiesce_offset + `THREADS - 1]),
.scout(sov[lq_pc_ldq_quiesce_offset:lq_pc_ldq_quiesce_offset + `THREADS - 1]),
.din(lq_pc_ldq_quiesce_d),
.dout(lq_pc_ldq_quiesce_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lq_pc_stq_quiesce_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq_pc_stq_quiesce_offset:lq_pc_stq_quiesce_offset + `THREADS - 1]),
.scout(sov[lq_pc_stq_quiesce_offset:lq_pc_stq_quiesce_offset + `THREADS - 1]),
.din(lq_pc_stq_quiesce_d),
.dout(lq_pc_stq_quiesce_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lq_pc_pfetch_quiesce_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq_pc_pfetch_quiesce_offset:lq_pc_pfetch_quiesce_offset + `THREADS - 1]),
.scout(sov[lq_pc_pfetch_quiesce_offset:lq_pc_pfetch_quiesce_offset + `THREADS - 1]),
.din(lq_pc_pfetch_quiesce_d),
.dout(lq_pc_pfetch_quiesce_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) lq_mm_lmq_stq_empty_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq_mm_lmq_stq_empty_offset]),
.scout(sov[lq_mm_lmq_stq_empty_offset]),
.din(lq_mm_lmq_stq_empty_d),
.dout(lq_mm_lmq_stq_empty_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldq_full_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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_ldq_full_offset]),
.scout(sov[ex5_ldq_full_offset]),
.din(ex5_ldq_full_d),
.dout(ex5_ldq_full_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldq_full_restart_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldq_full_restart_offset]),
.scout(sov[ex5_ldq_full_restart_offset]),
.din(ex5_ldq_full_restart_d),
.dout(ex5_ldq_full_restart_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldq_hit_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldq_hit_offset]),
.scout(sov[ex5_ldq_hit_offset]),
.din(ex5_ldq_hit_d),
.dout(ex5_ldq_hit_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ld_gath_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ld_gath_offset]),
.scout(sov[ex5_ld_gath_offset]),
.din(ex5_ld_gath_d),
.dout(ex5_ld_gath_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_full_qHit_held_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_full_qHit_held_offset]),
.scout(sov[ldq_full_qHit_held_offset]),
.din(ldq_full_qHit_held_d),
.dout(ldq_full_qHit_held_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_resv_qHit_held_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_resv_qHit_held_offset]),
.scout(sov[ldq_resv_qHit_held_offset]),
.din(ldq_resv_qHit_held_d),
.dout(ldq_resv_qHit_held_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_oth_qHit_clr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_oth_qHit_clr_offset]),
.scout(sov[ldq_oth_qHit_clr_offset]),
.din(ldq_oth_qHit_clr_d),
.dout(ldq_oth_qHit_clr_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldq_set_hold_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldq_set_hold_offset]),
.scout(sov[ex5_ldq_set_hold_offset]),
.din(ex5_ldq_set_hold_d),
.dout(ex5_ldq_set_hold_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_ldq_restart_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldq_restart_offset]),
.scout(sov[ex5_ldq_restart_offset]),
.din(ex5_ldq_restart_d),
.dout(ex5_ldq_restart_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex6_ldq_full_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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_ldq_full_offset]),
.scout(sov[ex6_ldq_full_offset]),
.din(ex6_ldq_full_d),
.dout(ex6_ldq_full_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex6_ldq_hit_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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_ldq_hit_offset]),
.scout(sov[ex6_ldq_hit_offset]),
.din(ex6_ldq_hit_d),
.dout(ex6_ldq_hit_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_lgq_full_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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_lgq_full_offset]),
.scout(sov[ex5_lgq_full_offset]),
.din(ex5_lgq_full_d),
.dout(ex5_lgq_full_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex6_lgq_full_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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_lgq_full_offset]),
.scout(sov[ex6_lgq_full_offset]),
.din(ex6_lgq_full_d),
.dout(ex6_lgq_full_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_lgq_qwhit_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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_lgq_qwhit_offset]),
.scout(sov[ex5_lgq_qwhit_offset]),
.din(ex5_lgq_qwhit_d),
.dout(ex5_lgq_qwhit_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex6_lgq_qwhit_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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_lgq_qwhit_offset]),
.scout(sov[ex6_lgq_qwhit_offset]),
.din(ex6_lgq_qwhit_d),
.dout(ex6_lgq_qwhit_q)
);
tri_rlmreg_p #(.WIDTH(`REAL_IFAR_WIDTH), .INIT(0), .NEEDS_SRESET(1)) ex5_p_addr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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_p_addr_offset:ex5_p_addr_offset + `REAL_IFAR_WIDTH - 1]),
.scout(sov[ex5_p_addr_offset:ex5_p_addr_offset + `REAL_IFAR_WIDTH - 1]),
.din(ex5_p_addr_d),
.dout(ex5_p_addr_q)
);
tri_rlmreg_p #(.WIDTH(5), .INIT(0), .NEEDS_SRESET(1)) ex5_wimge_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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_wimge_offset:ex5_wimge_offset + 5 - 1]),
.scout(sov[ex5_wimge_offset:ex5_wimge_offset + 5 - 1]),
.din(ex5_wimge_d),
.dout(ex5_wimge_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ex6_cmmt_perf_events_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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_cmmt_perf_events_offset:ex6_cmmt_perf_events_offset + 4 - 1]),
.scout(sov[ex6_cmmt_perf_events_offset:ex6_cmmt_perf_events_offset + 4 - 1]),
.din(ex6_cmmt_perf_events_d),
.dout(ex6_cmmt_perf_events_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex5_ldqe_set_all_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldqe_set_all_offset:ex5_ldqe_set_all_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ex5_ldqe_set_all_offset:ex5_ldqe_set_all_offset + `LMQ_ENTRIES - 1]),
.din(ex5_ldqe_set_all_d),
.dout(ex5_ldqe_set_all_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex5_ldqe_set_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldqe_set_val_offset:ex5_ldqe_set_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ex5_ldqe_set_val_offset:ex5_ldqe_set_val_offset + `LMQ_ENTRIES - 1]),
.din(ex5_ldqe_set_val_d),
.dout(ex5_ldqe_set_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex6_ldqe_pfetch_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldqe_pfetch_val_offset:ex6_ldqe_pfetch_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ex6_ldqe_pfetch_val_offset:ex6_ldqe_pfetch_val_offset + `LMQ_ENTRIES - 1]),
.din(ex6_ldqe_pfetch_val_d),
.dout(ex6_ldqe_pfetch_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex7_ldqe_pfetch_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ex7_ldqe_pfetch_val_offset:ex7_ldqe_pfetch_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ex7_ldqe_pfetch_val_offset:ex7_ldqe_pfetch_val_offset + `LMQ_ENTRIES - 1]),
.din(ex7_ldqe_pfetch_val_d),
.dout(ex7_ldqe_pfetch_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex5_ldm_hit_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_ldm_hit_offset:ex5_ldm_hit_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ex5_ldm_hit_offset:ex5_ldm_hit_offset + `LMQ_ENTRIES - 1]),
.din(ex5_ldm_hit_d),
.dout(ex5_ldm_hit_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_hold_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_hold_tid_offset:ldq_hold_tid_offset + `THREADS - 1]),
.scout(sov[ldq_hold_tid_offset:ldq_hold_tid_offset + `THREADS - 1]),
.din(ldq_hold_tid_d),
.dout(ldq_hold_tid_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES + 1), .INIT(2 ** (`LMQ_ENTRIES)), .NEEDS_SRESET(1)) fifo_ldq_req_nxt_ptr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[fifo_ldq_req_nxt_ptr_offset:fifo_ldq_req_nxt_ptr_offset + (`LMQ_ENTRIES+1) - 1]),
.scout(sov[fifo_ldq_req_nxt_ptr_offset:fifo_ldq_req_nxt_ptr_offset + (`LMQ_ENTRIES+1) - 1]),
.din(fifo_ldq_req_nxt_ptr_d),
.dout(fifo_ldq_req_nxt_ptr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) fifo_ldq_req_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[fifo_ldq_req_val_offset:fifo_ldq_req_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[fifo_ldq_req_val_offset:fifo_ldq_req_val_offset + `LMQ_ENTRIES - 1]),
.din(fifo_ldq_req_val_d),
.dout(fifo_ldq_req_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) fifo_ldq_req_pfetch_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[fifo_ldq_req_pfetch_offset:fifo_ldq_req_pfetch_offset + `LMQ_ENTRIES - 1]),
.scout(sov[fifo_ldq_req_pfetch_offset:fifo_ldq_req_pfetch_offset + `LMQ_ENTRIES - 1]),
.din(fifo_ldq_req_pfetch_d),
.dout(fifo_ldq_req_pfetch_q)
);
generate begin : fifo_ldq_req_tid
genvar ldq;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin : fifo_ldq_req_tid
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) fifo_ldq_req_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(fifo_ldq_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[fifo_ldq_req_tid_offset + (`THREADS * ldq):fifo_ldq_req_tid_offset + (`THREADS * (ldq + 1)) - 1]),
.scout(sov[fifo_ldq_req_tid_offset + (`THREADS * ldq):fifo_ldq_req_tid_offset + (`THREADS * (ldq + 1)) - 1]),
.din(fifo_ldq_req_tid_d[ldq]),
.dout(fifo_ldq_req_tid_q[ldq])
);
end
end
endgenerate
generate begin : fifo_ldq_req
genvar ldq0;
for (ldq0=0; ldq0<`LMQ_ENTRIES; ldq0=ldq0+1) begin : fifo_ldq_req
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) fifo_ldq_req_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(fifo_ldq_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[fifo_ldq_req_offset + (`LMQ_ENTRIES * ldq0):fifo_ldq_req_offset + (`LMQ_ENTRIES * (ldq0 + 1)) - 1]),
.scout(sov[fifo_ldq_req_offset + (`LMQ_ENTRIES * ldq0):fifo_ldq_req_offset + (`LMQ_ENTRIES * (ldq0 + 1)) - 1]),
.din(fifo_ldq_req_d[ldq0]),
.dout(fifo_ldq_req_q[ldq0])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_val_offset:ldqe_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_val_offset:ldqe_val_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_val_d),
.dout(ldqe_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_req_cmpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_req_cmpl_offset:ldqe_req_cmpl_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_req_cmpl_offset:ldqe_req_cmpl_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_req_cmpl_d),
.dout(ldqe_req_cmpl_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_cntr_reset_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_cntr_reset_offset:ldqe_cntr_reset_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_cntr_reset_offset:ldqe_cntr_reset_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_cntr_reset_d),
.dout(ldqe_cntr_reset_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_resent_ecc_err_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_resent_ecc_err_offset:ldqe_resent_ecc_err_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_resent_ecc_err_offset:ldqe_resent_ecc_err_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_resent_ecc_err_d),
.dout(ldqe_resent_ecc_err_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_reset_cpl_rpt_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_reset_cpl_rpt_offset:ldqe_reset_cpl_rpt_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_reset_cpl_rpt_offset:ldqe_reset_cpl_rpt_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_reset_cpl_rpt_d),
.dout(ldqe_reset_cpl_rpt_q)
);
generate begin : ldqe_iTag
genvar ldq1;
for (ldq1=0; ldq1<`LMQ_ENTRIES; ldq1=ldq1+1) begin : ldqe_iTag
tri_rlmreg_p #(.WIDTH(`ITAG_SIZE_ENC), .INIT(0), .NEEDS_SRESET(1)) ldqe_iTag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_ldqe_act[ldq1]),
.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[ldqe_itag_offset + (`ITAG_SIZE_ENC * ldq1):ldqe_itag_offset + (`ITAG_SIZE_ENC * (ldq1 + 1)) - 1]),
.scout(sov[ldqe_itag_offset + (`ITAG_SIZE_ENC * ldq1):ldqe_itag_offset + (`ITAG_SIZE_ENC * (ldq1 + 1)) - 1]),
.din(ldqe_itag_d[ldq1]),
.dout(ldqe_itag_q[ldq1])
);
end
end
endgenerate
generate begin : ldqe_thrd_id
genvar ldq2;
for (ldq2=0; ldq2<`LMQ_ENTRIES; ldq2=ldq2+1) begin : ldqe_thrd_id
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldqe_thrd_id_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_ldqe_act[ldq2]),
.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[ldqe_thrd_id_offset + (`THREADS * ldq2):ldqe_thrd_id_offset + (`THREADS * (ldq2 + 1)) - 1]),
.scout(sov[ldqe_thrd_id_offset + (`THREADS * ldq2):ldqe_thrd_id_offset + (`THREADS * (ldq2 + 1)) - 1]),
.din(ldqe_thrd_id_d[ldq2]),
.dout(ldqe_thrd_id_q[ldq2])
);
end
end
endgenerate
generate begin : ldqe_wimge
genvar ldq3;
for (ldq3=0; ldq3<`LMQ_ENTRIES; ldq3=ldq3+1) begin : ldqe_wimge
tri_rlmreg_p #(.WIDTH(5), .INIT(0), .NEEDS_SRESET(1)) ldqe_wimge_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_ldqe_act[ldq3]),
.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[ldqe_wimge_offset + (5 * ldq3):ldqe_wimge_offset + (5 * (ldq3 + 1)) - 1]),
.scout(sov[ldqe_wimge_offset + (5 * ldq3):ldqe_wimge_offset + (5 * (ldq3 + 1)) - 1]),
.din(ldqe_wimge_d[ldq3]),
.dout(ldqe_wimge_q[ldq3])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_byte_swap_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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[ldqe_byte_swap_offset:ldqe_byte_swap_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_byte_swap_offset:ldqe_byte_swap_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_byte_swap_d),
.dout(ldqe_byte_swap_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_resv_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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[ldqe_resv_offset:ldqe_resv_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_resv_offset:ldqe_resv_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_resv_d),
.dout(ldqe_resv_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_pfetch_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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[ldqe_pfetch_offset:ldqe_pfetch_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_pfetch_offset:ldqe_pfetch_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_pfetch_d),
.dout(ldqe_pfetch_q)
);
generate begin : ldqe_op_size
genvar ldq4;
for (ldq4=0; ldq4<`LMQ_ENTRIES; ldq4=ldq4+1) begin : ldqe_op_size
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) ldqe_op_size_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq4]),
.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[ldqe_op_size_offset + (3 * ldq4):ldqe_op_size_offset + (3 * (ldq4 + 1)) - 1]),
.scout(sov[ldqe_op_size_offset + (3 * ldq4):ldqe_op_size_offset + (3 * (ldq4 + 1)) - 1]),
.din(ldqe_op_size_d[ldq4]),
.dout(ldqe_op_size_q[ldq4])
);
end
end
endgenerate
generate begin : ldqe_tgpr
genvar ldq5;
for (ldq5=0; ldq5<`LMQ_ENTRIES; ldq5=ldq5+1) begin : ldqe_tgpr
tri_rlmreg_p #(.WIDTH(AXU_TARGET_ENC), .INIT(0), .NEEDS_SRESET(1)) ldqe_tgpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq5]),
.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[ldqe_tgpr_offset + (AXU_TARGET_ENC * ldq5):ldqe_tgpr_offset + (AXU_TARGET_ENC * (ldq5 + 1)) - 1]),
.scout(sov[ldqe_tgpr_offset + (AXU_TARGET_ENC * ldq5):ldqe_tgpr_offset + (AXU_TARGET_ENC * (ldq5 + 1)) - 1]),
.din(ldqe_tgpr_d[ldq5]),
.dout(ldqe_tgpr_q[ldq5])
);
end
end
endgenerate
generate begin : ldqe_usr_def
genvar ldq6;
for (ldq6=0; ldq6<`LMQ_ENTRIES; ldq6=ldq6+1) begin : ldqe_usr_def
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldqe_usr_def_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq6]),
.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[ldqe_usr_def_offset + (4 * ldq6):ldqe_usr_def_offset + (4 * (ldq6 + 1)) - 1]),
.scout(sov[ldqe_usr_def_offset + (4 * ldq6):ldqe_usr_def_offset + (4 * (ldq6 + 1)) - 1]),
.din(ldqe_usr_def_d[ldq6]),
.dout(ldqe_usr_def_q[ldq6])
);
end
end
endgenerate
generate begin : ldqe_class_id
genvar ldq7;
for (ldq7=0; ldq7<`LMQ_ENTRIES; ldq7=ldq7+1) begin : ldqe_class_id
tri_rlmreg_p #(.WIDTH(2), .INIT(0), .NEEDS_SRESET(1)) ldqe_class_id_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq7]),
.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[ldqe_class_id_offset + (2 * ldq7):ldqe_class_id_offset + (2 * (ldq7 + 1)) - 1]),
.scout(sov[ldqe_class_id_offset + (2 * ldq7):ldqe_class_id_offset + (2 * (ldq7 + 1)) - 1]),
.din(ldqe_class_id_d[ldq7]),
.dout(ldqe_class_id_q[ldq7])
);
end
end
endgenerate
generate begin : ldqe_perf_events
genvar ldq7;
for (ldq7=0; ldq7<`LMQ_ENTRIES; ldq7=ldq7+1) begin : ldqe_perf_events
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldqe_perf_events_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq7]),
.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[ldqe_perf_events_offset + (4 * ldq7):ldqe_perf_events_offset + (4 * (ldq7 + 1)) - 1]),
.scout(sov[ldqe_perf_events_offset + (4 * ldq7):ldqe_perf_events_offset + (4 * (ldq7 + 1)) - 1]),
.din(ldqe_perf_events_d[ldq7]),
.dout(ldqe_perf_events_q[ldq7])
);
end
end
endgenerate
generate begin : ldqe_dvc
genvar ldq8;
for (ldq8=0; ldq8<`LMQ_ENTRIES; ldq8=ldq8+1) begin : ldqe_dvc
tri_rlmreg_p #(.WIDTH(2), .INIT(0), .NEEDS_SRESET(1)) ldqe_dvc_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ldqe_ctrl_act[ldq8]),
.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[ldqe_dvc_offset + (2 * ldq8):ldqe_dvc_offset + (2 * (ldq8 + 1)) - 1]),
.scout(sov[ldqe_dvc_offset + (2 * ldq8):ldqe_dvc_offset + (2 * (ldq8 + 1)) - 1]),
.din(ldqe_dvc_d[ldq8]),
.dout(ldqe_dvc_q[ldq8])
);
end
end
endgenerate
generate begin : ldqe_ttype
genvar ldq9;
for (ldq9=0; ldq9<`LMQ_ENTRIES; ldq9=ldq9+1) begin : ldqe_ttype
tri_rlmreg_p #(.WIDTH(6), .INIT(0), .NEEDS_SRESET(1)) ldqe_ttype_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq9]),
.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[ldqe_ttype_offset + (6 * ldq9):ldqe_ttype_offset + (6 * (ldq9 + 1)) - 1]),
.scout(sov[ldqe_ttype_offset + (6 * ldq9):ldqe_ttype_offset + (6 * (ldq9 + 1)) - 1]),
.din(ldqe_ttype_d[ldq9]),
.dout(ldqe_ttype_q[ldq9])
);
end
end
endgenerate
generate begin : ldqe_dacrw
genvar ldq10;
for (ldq10=0; ldq10<`LMQ_ENTRIES; ldq10=ldq10+1) begin : ldqe_dacrw
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldqe_dacrw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_ldqe_act[ldq10]),
.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[ldqe_dacrw_offset + (4 * ldq10):ldqe_dacrw_offset + (4 * (ldq10 + 1)) - 1]),
.scout(sov[ldqe_dacrw_offset + (4 * ldq10):ldqe_dacrw_offset + (4 * (ldq10 + 1)) - 1]),
.din(ldqe_dacrw_d[ldq10]),
.dout(ldqe_dacrw_q[ldq10])
);
end
end
endgenerate
generate begin : ldqe_p_addr
genvar ldq11;
for (ldq11=0; ldq11<`LMQ_ENTRIES; ldq11=ldq11+1) begin : ldqe_p_addr
tri_rlmreg_p #(.WIDTH(`REAL_IFAR_WIDTH), .INIT(0), .NEEDS_SRESET(1)) ldqe_p_addr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_ldqe_act[ldq11]),
.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[ldqe_p_addr_offset + (`REAL_IFAR_WIDTH * ldq11):ldqe_p_addr_offset + (`REAL_IFAR_WIDTH * (ldq11 + 1)) - 1]),
.scout(sov[ldqe_p_addr_offset + (`REAL_IFAR_WIDTH * ldq11):ldqe_p_addr_offset + (`REAL_IFAR_WIDTH * (ldq11 + 1)) - 1]),
.din(ldqe_p_addr_d[ldq11]),
.dout(ldqe_p_addr_q[ldq11])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_mkill_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_mkill_offset:ldqe_mkill_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_mkill_offset:ldqe_mkill_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_mkill_d),
.dout(ldqe_mkill_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_resolved_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_resolved_offset:ldqe_resolved_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_resolved_offset:ldqe_resolved_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_resolved_d),
.dout(ldqe_resolved_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_back_inv_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_back_inv_offset:ldqe_back_inv_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_back_inv_offset:ldqe_back_inv_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_back_inv_d),
.dout(ldqe_back_inv_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_back_inv_nFlush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_back_inv_nFlush_offset:ldqe_back_inv_nFlush_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_back_inv_nFlush_offset:ldqe_back_inv_nFlush_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_back_inv_nFlush_d),
.dout(ldqe_back_inv_nFlush_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_back_inv_np1Flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_back_inv_np1Flush_offset:ldqe_back_inv_np1Flush_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_back_inv_np1Flush_offset:ldqe_back_inv_np1Flush_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_back_inv_np1Flush_d),
.dout(ldqe_back_inv_np1Flush_q)
);
generate begin : ldqe_beat_cntr
genvar ldq12;
for (ldq12=0; ldq12<`LMQ_ENTRIES; ldq12=ldq12+1) begin : ldqe_beat_cntr
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldqe_beat_cntr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ldqe_ctrl_act[ldq12]),
.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[ldqe_beat_cntr_offset + (4 * ldq12):ldqe_beat_cntr_offset + (4 * (ldq12 + 1)) - 1]),
.scout(sov[ldqe_beat_cntr_offset + (4 * ldq12):ldqe_beat_cntr_offset + (4 * (ldq12 + 1)) - 1]),
.din(ldqe_beat_cntr_d[ldq12]),
.dout(ldqe_beat_cntr_q[ldq12])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_dRel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_dRel_offset:ldqe_dRel_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_dRel_offset:ldqe_dRel_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_dRel_d),
.dout(ldqe_dRel_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_l1_dump_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_l1_dump_offset:ldqe_l1_dump_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_l1_dump_offset:ldqe_l1_dump_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_l1_dump_d),
.dout(ldqe_l1_dump_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_dGpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_dGpr_offset:ldqe_dGpr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_dGpr_offset:ldqe_dGpr_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_dGpr_d),
.dout(ldqe_dGpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_axu_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[ldqe_axu_offset:ldqe_axu_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_axu_offset:ldqe_axu_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_axu_d),
.dout(ldqe_axu_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_lock_set_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[ldqe_lock_set_offset:ldqe_lock_set_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_lock_set_offset:ldqe_lock_set_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_lock_set_d),
.dout(ldqe_lock_set_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_watch_set_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[ldqe_watch_set_offset:ldqe_watch_set_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_watch_set_offset:ldqe_watch_set_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_watch_set_d),
.dout(ldqe_watch_set_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_algebraic_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[ldqe_algebraic_offset:ldqe_algebraic_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_algebraic_offset:ldqe_algebraic_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_algebraic_d),
.dout(ldqe_algebraic_q)
);
generate begin : ldqe_state
genvar ldq13;
for (ldq13=0; ldq13<`LMQ_ENTRIES; ldq13=ldq13+1) begin : ldqe_state
tri_rlmreg_p #(.WIDTH(7), .INIT(64), .NEEDS_SRESET(1)) ldqe_state_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_state_offset + (7 * ldq13):ldqe_state_offset + (7 * (ldq13 + 1)) - 1]),
.scout(sov[ldqe_state_offset + (7 * ldq13):ldqe_state_offset + (7 * (ldq13 + 1)) - 1]),
.din(ldqe_state_d[ldq13]),
.dout(ldqe_state_q[ldq13])
);
end
end
endgenerate
generate begin : ldqe_sentRel_cntr
genvar ldq;
for (ldq=0; ldq<`LMQ_ENTRIES; ldq=ldq+1) begin : ldqe_sentRel_cntr
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldqe_sentRel_cntr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ldqe_ctrl_act[ldq]),
.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[ldqe_sentRel_cntr_offset + (4 * ldq):ldqe_sentRel_cntr_offset + (4 * (ldq + 1)) - 1]),
.scout(sov[ldqe_sentRel_cntr_offset + (4 * ldq):ldqe_sentRel_cntr_offset + (4 * (ldq + 1)) - 1]),
.din(ldqe_sentRel_cntr_d[ldq]),
.dout(ldqe_sentRel_cntr_q[ldq])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex5_lgqe_set_all_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_lgqe_set_all_offset:ex5_lgqe_set_all_offset + `LGQ_ENTRIES - 1]),
.scout(sov[ex5_lgqe_set_all_offset:ex5_lgqe_set_all_offset + `LGQ_ENTRIES - 1]),
.din(ex5_lgqe_set_all_d),
.dout(ex5_lgqe_set_all_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ex5_lgqe_set_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_lgqe_set_val_offset:ex5_lgqe_set_val_offset + `LGQ_ENTRIES - 1]),
.scout(sov[ex5_lgqe_set_val_offset:ex5_lgqe_set_val_offset + `LGQ_ENTRIES - 1]),
.din(ex5_lgqe_set_val_d),
.dout(ex5_lgqe_set_val_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_valid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_valid_offset:lgqe_valid_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_valid_offset:lgqe_valid_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_valid_d),
.dout(lgqe_valid_q)
);
generate begin : lgqe_iTag
genvar lgq;
for (lgq=0; lgq<`LGQ_ENTRIES; lgq=lgq+1) begin : lgqe_iTag
tri_rlmreg_p #(.WIDTH(`ITAG_SIZE_ENC), .INIT(0), .NEEDS_SRESET(1)) lgqe_iTag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_lgqe_act[lgq]),
.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[lgqe_iTag_offset + (`ITAG_SIZE_ENC * lgq):lgqe_iTag_offset + (`ITAG_SIZE_ENC * (lgq + 1)) - 1]),
.scout(sov[lgqe_iTag_offset + (`ITAG_SIZE_ENC * lgq):lgqe_iTag_offset + (`ITAG_SIZE_ENC * (lgq + 1)) - 1]),
.din(lgqe_itag_d[lgq]),
.dout(lgqe_itag_q[lgq])
);
end
end
endgenerate
generate begin : lgqe_ldTag
genvar lgq0;
for (lgq0=0; lgq0<`LGQ_ENTRIES; lgq0=lgq0+1) begin : lgqe_ldTag
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) lgqe_ldTag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_lgqe_act[lgq0]),
.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[lgqe_ldTag_offset + (4 * lgq0):lgqe_ldTag_offset + (4 * (lgq0 + 1)) - 1]),
.scout(sov[lgqe_ldTag_offset + (4 * lgq0):lgqe_ldTag_offset + (4 * (lgq0 + 1)) - 1]),
.din(lgqe_ldTag_d[lgq0]),
.dout(lgqe_ldTag_q[lgq0])
);
end
end
endgenerate
generate begin : lgqe_thrd_id
genvar lgq1;
for (lgq1=0; lgq1<`LGQ_ENTRIES; lgq1=lgq1+1) begin : lgqe_thrd_id
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lgqe_thrd_id_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_lgqe_act[lgq1]),
.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[lgqe_thrd_id_offset + (`THREADS * lgq1):lgqe_thrd_id_offset + (`THREADS * (lgq1 + 1)) - 1]),
.scout(sov[lgqe_thrd_id_offset + (`THREADS * lgq1):lgqe_thrd_id_offset + (`THREADS * (lgq1 + 1)) - 1]),
.din(lgqe_thrd_id_d[lgq1]),
.dout(lgqe_thrd_id_q[lgq1])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_byte_swap_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_stg_act_q),
.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[lgqe_byte_swap_offset:lgqe_byte_swap_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_byte_swap_offset:lgqe_byte_swap_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_byte_swap_d),
.dout(lgqe_byte_swap_q)
);
generate begin : lgqe_op_size
genvar lgq2;
for (lgq2=0; lgq2<`LGQ_ENTRIES; lgq2=lgq2+1) begin : lgqe_op_size
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) lgqe_op_size_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_lgqe_act[lgq2]),
.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[lgqe_op_size_offset + (3 * lgq2):lgqe_op_size_offset + (3 * (lgq2 + 1)) - 1]),
.scout(sov[lgqe_op_size_offset + (3 * lgq2):lgqe_op_size_offset + (3 * (lgq2 + 1)) - 1]),
.din(lgqe_op_size_d[lgq2]),
.dout(lgqe_op_size_q[lgq2])
);
end
end
endgenerate
generate begin : lgqe_tgpr
genvar lgq3;
for (lgq3=0; lgq3<`LGQ_ENTRIES; lgq3=lgq3+1) begin : lgqe_tgpr
tri_rlmreg_p #(.WIDTH(AXU_TARGET_ENC), .INIT(0), .NEEDS_SRESET(1)) lgqe_tgpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_lgqe_act[lgq3]),
.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[lgqe_tgpr_offset + (AXU_TARGET_ENC * lgq3):lgqe_tgpr_offset + (AXU_TARGET_ENC * (lgq3 + 1)) - 1]),
.scout(sov[lgqe_tgpr_offset + (AXU_TARGET_ENC * lgq3):lgqe_tgpr_offset + (AXU_TARGET_ENC * (lgq3 + 1)) - 1]),
.din(lgqe_tgpr_d[lgq3]),
.dout(lgqe_tgpr_q[lgq3])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_gpr_done_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_gpr_done_offset:lgqe_gpr_done_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_gpr_done_offset:lgqe_gpr_done_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_gpr_done_d),
.dout(lgqe_gpr_done_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_resolved_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_resolved_offset:lgqe_resolved_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_resolved_offset:lgqe_resolved_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_resolved_d),
.dout(lgqe_resolved_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_back_inv_nFlush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_back_inv_nFlush_offset:lgqe_back_inv_nFlush_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_back_inv_nFlush_offset:lgqe_back_inv_nFlush_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_back_inv_nFlush_d),
.dout(lgqe_back_inv_nFlush_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_back_inv_np1Flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_back_inv_np1Flush_offset:lgqe_back_inv_np1Flush_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_back_inv_np1Flush_offset:lgqe_back_inv_np1Flush_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_back_inv_np1Flush_d),
.dout(lgqe_back_inv_np1Flush_q)
);
generate begin : lgqe_dacrw
genvar lgq4;
for (lgq4=0; lgq4<`LGQ_ENTRIES; lgq4=lgq4+1) begin : lgqe_dacrw
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) lgqe_dacrw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_lgqe_act[lgq4]),
.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[lgqe_dacrw_offset + (4 * lgq4):lgqe_dacrw_offset + (4 * (lgq4 + 1)) - 1]),
.scout(sov[lgqe_dacrw_offset + (4 * lgq4):lgqe_dacrw_offset + (4 * (lgq4 + 1)) - 1]),
.din(lgqe_dacrw_d[lgq4]),
.dout(lgqe_dacrw_q[lgq4])
);
end
end
endgenerate
generate begin : lgqe_dvc
genvar lgq5;
for (lgq5=0; lgq5<`LGQ_ENTRIES; lgq5=lgq5+1) begin : lgqe_dvc
tri_rlmreg_p #(.WIDTH(2), .INIT(0), .NEEDS_SRESET(1)) lgqe_dvc_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_dvc_offset + (2 * lgq5):lgqe_dvc_offset + (2 * (lgq5 + 1)) - 1]),
.scout(sov[lgqe_dvc_offset + (2 * lgq5):lgqe_dvc_offset + (2 * (lgq5 + 1)) - 1]),
.din(lgqe_dvc_d[lgq5]),
.dout(lgqe_dvc_q[lgq5])
);
end
end
endgenerate
generate begin : lgqe_p_addr
genvar lgq6;
for (lgq6=0; lgq6<`LGQ_ENTRIES; lgq6=lgq6+1) begin : lgqe_p_addr
tri_rlmreg_p #(.WIDTH(7), .INIT(0), .NEEDS_SRESET(1)) lgqe_p_addr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_lgqe_act[lgq6]),
.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[lgqe_p_addr_offset + (7 * lgq6):lgqe_p_addr_offset + (7 * (lgq6 + 1)) - 1]),
.scout(sov[lgqe_p_addr_offset + (7 * lgq6):lgqe_p_addr_offset + (7 * (lgq6 + 1)) - 1]),
.din(lgqe_p_addr_d[lgq6]),
.dout(lgqe_p_addr_q[lgq6])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_algebraic_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[lgqe_algebraic_offset:lgqe_algebraic_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_algebraic_offset:lgqe_algebraic_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_algebraic_d),
.dout(lgqe_algebraic_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_axu_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex5_stg_act_q),
.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[lgqe_axu_offset:lgqe_axu_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_axu_offset:lgqe_axu_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_axu_d),
.dout(lgqe_axu_q)
);
generate begin : lgqe_perf_events
genvar lgq6;
for (lgq6=0; lgq6<`LGQ_ENTRIES; lgq6=lgq6+1) begin : lgqe_perf_events
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) lgqe_perf_events_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ex4_lgqe_act[lgq6]),
.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[lgqe_perf_events_offset + (4 * lgq6):lgqe_perf_events_offset + (4 * (lgq6 + 1)) - 1]),
.scout(sov[lgqe_perf_events_offset + (4 * lgq6):lgqe_perf_events_offset + (4 * (lgq6 + 1)) - 1]),
.din(lgqe_perf_events_d[lgq6]),
.dout(lgqe_perf_events_q[lgq6])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_upd_gpr_ecc_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_upd_gpr_ecc_offset:lgqe_upd_gpr_ecc_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_upd_gpr_ecc_offset:lgqe_upd_gpr_ecc_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_upd_gpr_ecc_d),
.dout(lgqe_upd_gpr_ecc_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_upd_gpr_eccue_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_upd_gpr_eccue_offset:lgqe_upd_gpr_eccue_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_upd_gpr_eccue_offset:lgqe_upd_gpr_eccue_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_upd_gpr_eccue_d),
.dout(lgqe_upd_gpr_eccue_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgqe_need_cpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgqe_need_cpl_offset:lgqe_need_cpl_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgqe_need_cpl_offset:lgqe_need_cpl_offset + `LGQ_ENTRIES - 1]),
.din(lgqe_need_cpl_d),
.dout(lgqe_need_cpl_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_rst_eccdet_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_rst_eccdet_offset:ldqe_rst_eccdet_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_rst_eccdet_offset:ldqe_rst_eccdet_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_rst_eccdet_d),
.dout(ldqe_rst_eccdet_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_beats_home_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_beats_home_offset:ldq_rel2_beats_home_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel2_beats_home_offset:ldq_rel2_beats_home_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel2_beats_home_d),
.dout(ldq_rel2_beats_home_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel3_beats_home_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_beats_home_offset:ldq_rel3_beats_home_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel3_beats_home_offset:ldq_rel3_beats_home_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel3_beats_home_d),
.dout(ldq_rel3_beats_home_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel4_beats_home_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_beats_home_offset:ldq_rel4_beats_home_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel4_beats_home_offset:ldq_rel4_beats_home_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel4_beats_home_d),
.dout(ldq_rel4_beats_home_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel5_beats_home_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel5_beats_home_offset:ldq_rel5_beats_home_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel5_beats_home_offset:ldq_rel5_beats_home_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel5_beats_home_d),
.dout(ldq_rel5_beats_home_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_entrySent_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_entrySent_offset:ldq_rel1_entrySent_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel1_entrySent_offset:ldq_rel1_entrySent_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel1_entrySent_d),
.dout(ldq_rel1_entrySent_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_entrySent_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_entrySent_offset:ldq_rel2_entrySent_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel2_entrySent_offset:ldq_rel2_entrySent_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel2_entrySent_d),
.dout(ldq_rel2_entrySent_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel3_entrySent_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_entrySent_offset:ldq_rel3_entrySent_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel3_entrySent_offset:ldq_rel3_entrySent_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel3_entrySent_d),
.dout(ldq_rel3_entrySent_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel4_sentL1_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_sentL1_offset:ldq_rel4_sentL1_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel4_sentL1_offset:ldq_rel4_sentL1_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel4_sentL1_d),
.dout(ldq_rel4_sentL1_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel5_sentL1_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel5_sentL1_offset:ldq_rel5_sentL1_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel5_sentL1_offset:ldq_rel5_sentL1_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel5_sentL1_d),
.dout(ldq_rel5_sentL1_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel6_req_done_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel6_req_done_offset:ldq_rel6_req_done_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel6_req_done_offset:ldq_rel6_req_done_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel6_req_done_d),
.dout(ldq_rel6_req_done_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel1_resp_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel1_resp_val_offset]),
.scout(sov[l2_rel1_resp_val_offset]),
.din(l2_rel1_resp_val_d),
.dout(l2_rel1_resp_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) l2_rel2_resp_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[l2_rel2_resp_val_offset]),
.scout(sov[l2_rel2_resp_val_offset]),
.din(l2_rel2_resp_val_d),
.dout(l2_rel2_resp_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_err_inval_rel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_err_inval_rel_offset]),
.scout(sov[ldq_err_inval_rel_offset]),
.din(ldq_err_inval_rel_d),
.dout(ldq_err_inval_rel_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_err_ecc_det_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_err_ecc_det_offset]),
.scout(sov[ldq_err_ecc_det_offset]),
.din(ldq_err_ecc_det_d),
.dout(ldq_err_ecc_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_err_ue_det_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_err_ue_det_offset]),
.scout(sov[ldq_err_ue_det_offset]),
.din(ldq_err_ue_det_d),
.dout(ldq_err_ue_det_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_val_offset]),
.scout(sov[ldq_rel1_val_offset]),
.din(ldq_rel1_val_d),
.dout(ldq_rel1_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_arb_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_arb_val_offset]),
.scout(sov[ldq_rel1_arb_val_offset]),
.din(ldq_rel1_arb_val_d),
.dout(ldq_rel1_arb_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_l1_dump_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_l1_dump_offset]),
.scout(sov[ldq_rel1_l1_dump_offset]),
.din(ldq_rel1_l1_dump_d),
.dout(ldq_rel1_l1_dump_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel2_l1_dump_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_l1_dump_offset]),
.scout(sov[ldq_rel2_l1_dump_offset]),
.din(ldq_rel2_l1_dump_d),
.dout(ldq_rel2_l1_dump_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel3_l1_dump_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_l1_dump_offset]),
.scout(sov[ldq_rel3_l1_dump_offset]),
.din(ldq_rel3_l1_dump_d),
.dout(ldq_rel3_l1_dump_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel3_clr_relq_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_clr_relq_offset]),
.scout(sov[ldq_rel3_clr_relq_offset]),
.din(ldq_rel3_clr_relq_d),
.dout(ldq_rel3_clr_relq_q)
);
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_resp_qw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_resp_qw_offset:ldq_rel1_resp_qw_offset + 3 - 1]),
.scout(sov[ldq_rel1_resp_qw_offset:ldq_rel1_resp_qw_offset + 3 - 1]),
.din(ldq_rel1_resp_qw_d),
.dout(ldq_rel1_resp_qw_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_cTag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_cTag_offset:ldq_rel1_cTag_offset + 4 - 1]),
.scout(sov[ldq_rel1_cTag_offset:ldq_rel1_cTag_offset + 4 - 1]),
.din(ldq_rel1_cTag_d),
.dout(ldq_rel1_cTag_q)
);
tri_rlmreg_p #(.WIDTH(3), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_opsize_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_opsize_offset:ldq_rel1_opsize_offset + 3 - 1]),
.scout(sov[ldq_rel1_opsize_offset:ldq_rel1_opsize_offset + 3 - 1]),
.din(ldq_rel1_opsize_d),
.dout(ldq_rel1_opsize_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_wimge_i_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_wimge_i_offset]),
.scout(sov[ldq_rel1_wimge_i_offset]),
.din(ldq_rel1_wimge_i_d),
.dout(ldq_rel1_wimge_i_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_byte_swap_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_byte_swap_offset]),
.scout(sov[ldq_rel1_byte_swap_offset]),
.din(ldq_rel1_byte_swap_d),
.dout(ldq_rel1_byte_swap_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel2_byte_swap_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel2_byte_swap_offset]),
.scout(sov[ldq_rel2_byte_swap_offset]),
.din(ldq_rel2_byte_swap_d),
.dout(ldq_rel2_byte_swap_q)
);
tri_rlmreg_p #(.WIDTH(`REAL_IFAR_WIDTH), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_p_addr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_p_addr_offset:ldq_rel1_p_addr_offset + `REAL_IFAR_WIDTH - 1]),
.scout(sov[ldq_rel1_p_addr_offset:ldq_rel1_p_addr_offset + `REAL_IFAR_WIDTH - 1]),
.din(ldq_rel1_p_addr_d),
.dout(ldq_rel1_p_addr_q)
);
tri_rlmreg_p #(.WIDTH(2), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_dvcEn_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_dvcEn_offset:ldq_rel1_dvcEn_offset + 2 - 1]),
.scout(sov[ldq_rel1_dvcEn_offset:ldq_rel1_dvcEn_offset + 2 - 1]),
.din(ldq_rel1_dvcEn_d),
.dout(ldq_rel1_dvcEn_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_lockSet_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_lockSet_offset]),
.scout(sov[ldq_rel1_lockSet_offset]),
.din(ldq_rel1_lockSet_d),
.dout(ldq_rel1_lockSet_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_watchSet_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_watchSet_offset]),
.scout(sov[ldq_rel1_watchSet_offset]),
.din(ldq_rel1_watchSet_d),
.dout(ldq_rel1_watchSet_q)
);
tri_rlmreg_p #(.WIDTH(AXU_TARGET_ENC), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_tGpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_tGpr_offset:ldq_rel1_tGpr_offset + AXU_TARGET_ENC - 1]),
.scout(sov[ldq_rel1_tGpr_offset:ldq_rel1_tGpr_offset + AXU_TARGET_ENC - 1]),
.din(ldq_rel1_tGpr_d),
.dout(ldq_rel1_tGpr_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_axu_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_axu_offset]),
.scout(sov[ldq_rel1_axu_offset]),
.din(ldq_rel1_axu_d),
.dout(ldq_rel1_axu_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_algEn_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_algEn_offset]),
.scout(sov[ldq_rel1_algEn_offset]),
.din(ldq_rel1_algEn_d),
.dout(ldq_rel1_algEn_q)
);
tri_rlmreg_p #(.WIDTH(2), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_classID_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_classID_offset:ldq_rel1_classID_offset + 2 - 1]),
.scout(sov[ldq_rel1_classID_offset:ldq_rel1_classID_offset + 2 - 1]),
.din(ldq_rel1_classID_d),
.dout(ldq_rel1_classID_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_tid_offset:ldq_rel1_tid_offset + `THREADS - 1]),
.scout(sov[ldq_rel1_tid_offset:ldq_rel1_tid_offset + `THREADS - 1]),
.din(ldq_rel1_tid_d),
.dout(ldq_rel1_tid_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ldq_rel1_val_q),
.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[ldq_rel2_tid_offset:ldq_rel2_tid_offset + `THREADS - 1]),
.scout(sov[ldq_rel2_tid_offset:ldq_rel2_tid_offset + `THREADS - 1]),
.din(ldq_rel2_tid_d),
.dout(ldq_rel2_tid_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_dir_tid_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(rel0_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[ldq_rel1_dir_tid_offset:ldq_rel1_dir_tid_offset + `THREADS - 1]),
.scout(sov[ldq_rel1_dir_tid_offset:ldq_rel1_dir_tid_offset + `THREADS - 1]),
.din(ldq_rel1_dir_tid_d),
.dout(ldq_rel1_dir_tid_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_relDir_start_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_relDir_start_offset:ldqe_relDir_start_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_relDir_start_offset:ldqe_relDir_start_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_relDir_start_d),
.dout(ldqe_relDir_start_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel2_set_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_set_val_offset]),
.scout(sov[ldq_rel2_set_val_offset]),
.din(ldq_rel2_set_val_d),
.dout(ldq_rel2_set_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel3_set_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_set_val_offset]),
.scout(sov[ldq_rel3_set_val_offset]),
.din(ldq_rel3_set_val_d),
.dout(ldq_rel3_set_val_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel4_set_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_set_val_offset]),
.scout(sov[ldq_rel4_set_val_offset]),
.din(ldq_rel4_set_val_d),
.dout(ldq_rel4_set_val_q)
);
tri_rlmreg_p #(.WIDTH((57-(64-(`DC_SIZE-3))+1)), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_cclass_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.act(ldq_rel1_val_q),
.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[ldq_rel2_cclass_offset:ldq_rel2_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.scout(sov[ldq_rel2_cclass_offset:ldq_rel2_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.din(ldq_rel2_cclass_d),
.dout(ldq_rel2_cclass_q)
);
tri_rlmreg_p #(.WIDTH((57-(64-(`DC_SIZE-3))+1)), .INIT(0), .NEEDS_SRESET(1)) ldq_rel3_cclass_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_cclass_offset:ldq_rel3_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.scout(sov[ldq_rel3_cclass_offset:ldq_rel3_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.din(ldq_rel3_cclass_d),
.dout(ldq_rel3_cclass_q)
);
tri_rlmreg_p #(.WIDTH((57-(64-(`DC_SIZE-3))+1)), .INIT(0), .NEEDS_SRESET(1)) ldq_rel4_cclass_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_cclass_offset:ldq_rel4_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.scout(sov[ldq_rel4_cclass_offset:ldq_rel4_cclass_offset + (57-(64-(`DC_SIZE-3))+1) - 1]),
.din(ldq_rel4_cclass_d),
.dout(ldq_rel4_cclass_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_data_sel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_data_sel_offset]),
.scout(sov[ldq_rel1_data_sel_offset]),
.din(ldq_rel1_data_sel_d),
.dout(ldq_rel1_data_sel_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel0_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel0_l2_val_offset:ldq_rel0_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel0_l2_val_offset:ldq_rel0_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel0_l2_val_d),
.dout(ldq_rel0_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_l2_val_offset:ldq_rel1_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel1_l2_val_offset:ldq_rel1_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel1_l2_val_d),
.dout(ldq_rel1_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_l2_val_offset:ldq_rel2_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel2_l2_val_offset:ldq_rel2_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel2_l2_val_d),
.dout(ldq_rel2_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel3_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_l2_val_offset:ldq_rel3_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel3_l2_val_offset:ldq_rel3_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel3_l2_val_d),
.dout(ldq_rel3_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel4_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_l2_val_offset:ldq_rel4_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel4_l2_val_offset:ldq_rel4_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel4_l2_val_d),
.dout(ldq_rel4_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel5_l2_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel5_l2_val_offset:ldq_rel5_l2_val_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel5_l2_val_offset:ldq_rel5_l2_val_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel5_l2_val_d),
.dout(ldq_rel5_l2_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_rel_eccdet_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_rel_eccdet_offset:ldqe_rel_eccdet_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_rel_eccdet_offset:ldqe_rel_eccdet_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_rel_eccdet_d),
.dout(ldqe_rel_eccdet_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_rel_eccdet_ue_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_rel_eccdet_ue_offset:ldqe_rel_eccdet_ue_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_rel_eccdet_ue_offset:ldqe_rel_eccdet_ue_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_rel_eccdet_ue_d),
.dout(ldqe_rel_eccdet_ue_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_upd_gpr_ecc_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_upd_gpr_ecc_offset:ldqe_upd_gpr_ecc_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_upd_gpr_ecc_offset:ldqe_upd_gpr_ecc_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_upd_gpr_ecc_d),
.dout(ldqe_upd_gpr_ecc_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_upd_gpr_eccue_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_upd_gpr_eccue_offset:ldqe_upd_gpr_eccue_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_upd_gpr_eccue_offset:ldqe_upd_gpr_eccue_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_upd_gpr_eccue_d),
.dout(ldqe_upd_gpr_eccue_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_need_cpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_need_cpl_offset:ldqe_need_cpl_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_need_cpl_offset:ldqe_need_cpl_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_need_cpl_d),
.dout(ldqe_need_cpl_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_sent_cpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_sent_cpl_offset:ldqe_sent_cpl_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_sent_cpl_offset:ldqe_sent_cpl_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_sent_cpl_d),
.dout(ldqe_sent_cpl_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel1_gpr_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_gpr_val_offset]),
.scout(sov[ldq_rel1_gpr_val_offset]),
.din(ldq_rel1_gpr_val_d),
.dout(ldq_rel1_gpr_val_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel0_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel0_upd_gpr_offset:ldq_rel0_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel0_upd_gpr_offset:ldq_rel0_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel0_upd_gpr_d),
.dout(ldq_rel0_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel1_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel1_upd_gpr_offset:ldq_rel1_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel1_upd_gpr_offset:ldq_rel1_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel1_upd_gpr_d),
.dout(ldq_rel1_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel2_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel2_upd_gpr_offset:ldq_rel2_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel2_upd_gpr_offset:ldq_rel2_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel2_upd_gpr_d),
.dout(ldq_rel2_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel3_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel3_upd_gpr_offset:ldq_rel3_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel3_upd_gpr_offset:ldq_rel3_upd_gpr_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel3_upd_gpr_d),
.dout(ldq_rel3_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_rel3_drop_cpl_rpt_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_rel3_drop_cpl_rpt_offset:ldqe_rel3_drop_cpl_rpt_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_rel3_drop_cpl_rpt_offset:ldqe_rel3_drop_cpl_rpt_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_rel3_drop_cpl_rpt_d),
.dout(ldqe_rel3_drop_cpl_rpt_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_l2_rel0_qHitBlk_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_l2_rel0_qHitBlk_offset]),
.scout(sov[ldq_l2_rel0_qHitBlk_offset]),
.din(ldq_l2_rel0_qHitBlk_d),
.dout(ldq_l2_rel0_qHitBlk_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) lgq_rel1_gpr_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel1_gpr_val_offset]),
.scout(sov[lgq_rel1_gpr_val_offset]),
.din(lgq_rel1_gpr_val_d),
.dout(lgq_rel1_gpr_val_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel0_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel0_upd_gpr_offset:lgq_rel0_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel0_upd_gpr_offset:lgq_rel0_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel0_upd_gpr_d),
.dout(lgq_rel0_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel1_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel1_upd_gpr_offset:lgq_rel1_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel1_upd_gpr_offset:lgq_rel1_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel1_upd_gpr_d),
.dout(lgq_rel1_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel2_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel2_upd_gpr_offset:lgq_rel2_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel2_upd_gpr_offset:lgq_rel2_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel2_upd_gpr_d),
.dout(lgq_rel2_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel3_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel3_upd_gpr_offset:lgq_rel3_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel3_upd_gpr_offset:lgq_rel3_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel3_upd_gpr_d),
.dout(lgq_rel3_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel4_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel4_upd_gpr_offset:lgq_rel4_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel4_upd_gpr_offset:lgq_rel4_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel4_upd_gpr_d),
.dout(lgq_rel4_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LGQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) lgq_rel5_upd_gpr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lgq_rel5_upd_gpr_offset:lgq_rel5_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.scout(sov[lgq_rel5_upd_gpr_offset:lgq_rel5_upd_gpr_offset + `LGQ_ENTRIES - 1]),
.din(lgq_rel5_upd_gpr_d),
.dout(lgq_rel5_upd_gpr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel4_odq_cpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel4_odq_cpl_offset:ldq_rel4_odq_cpl_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel4_odq_cpl_offset:ldq_rel4_odq_cpl_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel4_odq_cpl_d),
.dout(ldq_rel4_odq_cpl_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel5_odq_cpl_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel5_odq_cpl_offset:ldq_rel5_odq_cpl_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel5_odq_cpl_offset:ldq_rel5_odq_cpl_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel5_odq_cpl_d),
.dout(ldq_rel5_odq_cpl_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldq_rel_qHit_clr_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel_qHit_clr_offset:ldq_rel_qHit_clr_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldq_rel_qHit_clr_offset:ldq_rel_qHit_clr_offset + `LMQ_ENTRIES - 1]),
.din(ldq_rel_qHit_clr_d),
.dout(ldq_rel_qHit_clr_q)
);
tri_rlmreg_p #(.WIDTH(`LMQ_ENTRIES), .INIT(0), .NEEDS_SRESET(1)) ldqe_qHit_held_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldqe_qHit_held_offset:ldqe_qHit_held_offset + `LMQ_ENTRIES - 1]),
.scout(sov[ldqe_qHit_held_offset:ldqe_qHit_held_offset + `LMQ_ENTRIES - 1]),
.din(ldqe_qHit_held_d),
.dout(ldqe_qHit_held_q)
);
generate begin : cpl_grpEntry_last_sel
genvar grp0;
for (grp0=0; grp0<=(`LMQ_ENTRIES+`LGQ_ENTRIES-1)/4; grp0=grp0+1) begin : cpl_grpEntry_last_sel
tri_rlmreg_p #(.WIDTH(4), .INIT(8), .NEEDS_SRESET(1)) cpl_grpEntry_last_sel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[cpl_grpEntry_last_sel_offset + (4 * grp0):cpl_grpEntry_last_sel_offset + (4 * (grp0 + 1)) - 1]),
.scout(sov[cpl_grpEntry_last_sel_offset + (4 * grp0):cpl_grpEntry_last_sel_offset + (4 * (grp0 + 1)) - 1]),
.din(cpl_grpEntry_last_sel_d[grp0]),
.dout(cpl_grpEntry_last_sel_q[grp0])
);
end
end
endgenerate
tri_rlmreg_p #(.WIDTH(4), .INIT(8), .NEEDS_SRESET(1)) cpl_group_last_sel_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[cpl_group_last_sel_offset:cpl_group_last_sel_offset + 4 - 1]),
.scout(sov[cpl_group_last_sel_offset:cpl_group_last_sel_offset + 4 - 1]),
.din(cpl_group_last_sel_d),
.dout(cpl_group_last_sel_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) lq1_iu_execute_vld_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_execute_vld_offset:lq1_iu_execute_vld_offset + `THREADS - 1]),
.scout(sov[lq1_iu_execute_vld_offset:lq1_iu_execute_vld_offset + `THREADS - 1]),
.din(lq1_iu_execute_vld_d),
.dout(lq1_iu_execute_vld_q)
);
tri_rlmreg_p #(.WIDTH(`ITAG_SIZE_ENC), .INIT(1), .NEEDS_SRESET(1)) lq1_iu_itag_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_itag_offset:lq1_iu_itag_offset + `ITAG_SIZE_ENC - 1]),
.scout(sov[lq1_iu_itag_offset:lq1_iu_itag_offset + `ITAG_SIZE_ENC - 1]),
.din(lq1_iu_itag_d),
.dout(lq1_iu_itag_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) lq1_iu_n_flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_n_flush_offset]),
.scout(sov[lq1_iu_n_flush_offset]),
.din(lq1_iu_n_flush_d),
.dout(lq1_iu_n_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) lq1_iu_np1_flush_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_np1_flush_offset]),
.scout(sov[lq1_iu_np1_flush_offset]),
.din(lq1_iu_np1_flush_d),
.dout(lq1_iu_np1_flush_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) lq1_iu_exception_val_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_exception_val_offset]),
.scout(sov[lq1_iu_exception_val_offset]),
.din(lq1_iu_exception_val_d),
.dout(lq1_iu_exception_val_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) lq1_iu_dacrw_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_dacrw_offset:lq1_iu_dacrw_offset + 4 - 1]),
.scout(sov[lq1_iu_dacrw_offset:lq1_iu_dacrw_offset + 4 - 1]),
.din(lq1_iu_dacrw_d),
.dout(lq1_iu_dacrw_q)
);
tri_rlmreg_p #(.WIDTH(4), .INIT(0), .NEEDS_SRESET(1)) lq1_iu_perf_events_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[lq1_iu_perf_events_offset:lq1_iu_perf_events_offset + 4 - 1]),
.scout(sov[lq1_iu_perf_events_offset:lq1_iu_perf_events_offset + 4 - 1]),
.din(lq1_iu_perf_events_d),
.dout(lq1_iu_perf_events_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_cpl_larx_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_cpl_larx_offset:ldq_cpl_larx_offset + `THREADS - 1]),
.scout(sov[ldq_cpl_larx_offset:ldq_cpl_larx_offset + `THREADS - 1]),
.din(ldq_cpl_larx_d),
.dout(ldq_cpl_larx_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) ldq_cpl_binv_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_cpl_binv_offset:ldq_cpl_binv_offset + `THREADS - 1]),
.scout(sov[ldq_cpl_binv_offset:ldq_cpl_binv_offset + `THREADS - 1]),
.din(ldq_cpl_binv_d),
.dout(ldq_cpl_binv_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel_cmmt_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel_cmmt_offset]),
.scout(sov[ldq_rel_cmmt_offset]),
.din(ldq_rel_cmmt_d),
.dout(ldq_rel_cmmt_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel_need_hole_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel_need_hole_offset]),
.scout(sov[ldq_rel_need_hole_offset]),
.din(ldq_rel_need_hole_d),
.dout(ldq_rel_need_hole_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ldq_rel_latency_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[ldq_rel_latency_offset]),
.scout(sov[ldq_rel_latency_offset]),
.din(ldq_rel_latency_d),
.dout(ldq_rel_latency_q)
);
tri_rlmreg_p #(.WIDTH(`THREADS), .INIT(0), .NEEDS_SRESET(1)) dbg_int_en_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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[dbg_int_en_offset:dbg_int_en_offset + `THREADS - 1]),
.scout(sov[dbg_int_en_offset:dbg_int_en_offset + `THREADS - 1]),
.din(dbg_int_en_d),
.dout(dbg_int_en_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex4_stg_act_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_stg_act_offset]),
.scout(sov[ex4_stg_act_offset]),
.din(ex4_stg_act_d),
.dout(ex4_stg_act_q)
);
tri_rlmlatch_p #(.INIT(0), .NEEDS_SRESET(1)) ex5_stg_act_reg(
.vd(vdd),
.gd(gnd),
.clk(clk),
.rst(rst),
.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_stg_act_offset]),
.scout(sov[ex5_stg_act_offset]),
.din(ex5_stg_act_d),
.dout(ex5_stg_act_q)
);
assign rdat_scan_in = scan_in;
assign siv[0:scan_right] = {sov[1:scan_right], rdat_scan_out};
assign scan_out = sov[0];
endmodule
Reference in New Issue View Git Blame Copy Permalink