702 lines
35 KiB
Systemverilog
702 lines
35 KiB
Systemverilog
//********************************************************************************
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
// Copyright 2020 Western Digital Corporation or its affiliates.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// 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.
|
|
//********************************************************************************
|
|
|
|
//********************************************************************************
|
|
// Function: Instruction aligner
|
|
//********************************************************************************
|
|
module el2_ifu_aln_ctl
|
|
import el2_pkg::*;
|
|
#(
|
|
`include "el2_param.vh"
|
|
)
|
|
(
|
|
|
|
input logic scan_mode, // Flop scan mode control
|
|
input logic rst_l, // reset, active low
|
|
input logic clk, // Clock only while core active. Through one clock header. For flops with second clock header built in. Connected to ACTIVE_L2CLK.
|
|
input logic active_clk, // Clock only while core active. Through two clock headers. For flops without second clock header built in.
|
|
|
|
input logic ifu_async_error_start, // ecc/parity related errors with current fetch - not sent down the pipe
|
|
|
|
input logic [1:0] iccm_rd_ecc_double_err, // This fetch has a double ICCM ecc error.
|
|
|
|
input logic [1:0] ic_access_fault_f, // Instruction access fault for the current fetch.
|
|
input logic [1:0] ic_access_fault_type_f, // Instruction access fault types
|
|
|
|
input logic exu_flush_final, // Flush from the pipeline.
|
|
|
|
input logic dec_i0_decode_d, // Valid instruction at D-stage and not blocked
|
|
|
|
input logic [31:0] ifu_fetch_data_f, // fetch data in memory format - not right justified
|
|
|
|
input logic [1:0] ifu_fetch_val, // valids on a 2B boundary, right justified
|
|
input logic [31:1] ifu_fetch_pc, // starting pc of fetch
|
|
|
|
|
|
|
|
output logic ifu_i0_valid, // Instruction 0 is valid
|
|
output logic ifu_i0_icaf, // Instruction 0 has access fault
|
|
output logic [1:0] ifu_i0_icaf_type, // Instruction 0 access fault type
|
|
output logic ifu_i0_icaf_second, // Instruction 0 has access fault on second 2B of 4B inst
|
|
|
|
output logic ifu_i0_dbecc, // Instruction 0 has double bit ecc error
|
|
output logic [31:0] ifu_i0_instr, // Instruction 0
|
|
output logic [31:1] ifu_i0_pc, // Instruction 0 PC
|
|
output logic ifu_i0_pc4,
|
|
|
|
output logic ifu_fb_consume1, // Consumed one buffer. To fetch control fetch for buffer mass balance
|
|
output logic ifu_fb_consume2, // Consumed two buffers.To fetch control fetch for buffer mass balance
|
|
|
|
|
|
input logic [pt.BHT_GHR_SIZE-1:0] ifu_bp_fghr_f, // fetch GHR
|
|
input logic [31:1] ifu_bp_btb_target_f, // predicted RET target
|
|
input logic [11:0] ifu_bp_poffset_f, // predicted target offset
|
|
input logic [1:0] [$clog2(pt.BTB_SIZE)-1:0] ifu_bp_fa_index_f, // predicted branch index (fully associative option)
|
|
|
|
input logic [1:0] ifu_bp_hist0_f, // history counters for all 4 potential branches, bit 1, right justified
|
|
input logic [1:0] ifu_bp_hist1_f, // history counters for all 4 potential branches, bit 1, right justified
|
|
input logic [1:0] ifu_bp_pc4_f, // pc4 indication, right justified
|
|
input logic [1:0] ifu_bp_way_f, // way indication, right justified
|
|
input logic [1:0] ifu_bp_valid_f, // branch valid, right justified
|
|
input logic [1:0] ifu_bp_ret_f, // predicted ret indication, right justified
|
|
|
|
|
|
output el2_br_pkt_t i0_brp, // Branch packet for I0.
|
|
output logic [pt.BTB_ADDR_HI:pt.BTB_ADDR_LO] ifu_i0_bp_index, // BP index
|
|
output logic [pt.BHT_GHR_SIZE-1:0] ifu_i0_bp_fghr, // BP FGHR
|
|
output logic [pt.BTB_BTAG_SIZE-1:0] ifu_i0_bp_btag, // BP tag
|
|
|
|
output logic [$clog2(pt.BTB_SIZE)-1:0] ifu_i0_fa_index, // Fully associt btb index
|
|
|
|
output logic ifu_pmu_instr_aligned, // number of inst aligned this cycle
|
|
|
|
output logic [15:0] ifu_i0_cinst // 16b compress inst for i0
|
|
);
|
|
|
|
|
|
|
|
logic ifvalid;
|
|
logic shift_f1_f0, shift_f2_f0, shift_f2_f1;
|
|
logic fetch_to_f0, fetch_to_f1, fetch_to_f2;
|
|
|
|
logic [1:0] f2val_in, f2val;
|
|
logic [1:0] f1val_in, f1val;
|
|
logic [1:0] f0val_in, f0val;
|
|
logic [1:0] sf1val, sf0val;
|
|
|
|
logic [31:0] aligndata;
|
|
logic first4B, first2B;
|
|
|
|
logic [31:0] uncompress0;
|
|
logic i0_shift;
|
|
logic shift_2B, shift_4B;
|
|
logic f1_shift_2B;
|
|
logic f2_valid, sf1_valid, sf0_valid;
|
|
|
|
logic [31:0] ifirst;
|
|
logic [1:0] alignval;
|
|
logic [31:1] firstpc, secondpc;
|
|
|
|
logic [11:0] f1poffset;
|
|
logic [11:0] f0poffset;
|
|
logic [pt.BHT_GHR_SIZE-1:0] f1fghr;
|
|
logic [pt.BHT_GHR_SIZE-1:0] f0fghr;
|
|
logic [1:0] f1hist1;
|
|
logic [1:0] f0hist1;
|
|
logic [1:0] f1hist0;
|
|
logic [1:0] f0hist0;
|
|
|
|
logic [1:0][$clog2(pt.BTB_SIZE)-1:0] f0index, f1index, alignindex;
|
|
|
|
logic [1:0] f1ictype;
|
|
logic [1:0] f0ictype;
|
|
|
|
logic [1:0] f1pc4;
|
|
logic [1:0] f0pc4;
|
|
|
|
logic [1:0] f1ret;
|
|
logic [1:0] f0ret;
|
|
logic [1:0] f1way;
|
|
logic [1:0] f0way;
|
|
|
|
logic [1:0] f1brend;
|
|
logic [1:0] f0brend;
|
|
|
|
logic [1:0] alignbrend;
|
|
logic [1:0] alignpc4;
|
|
|
|
logic [1:0] alignret;
|
|
logic [1:0] alignway;
|
|
logic [1:0] alignhist1;
|
|
logic [1:0] alignhist0;
|
|
logic [1:1] alignfromf1;
|
|
logic i0_ends_f1;
|
|
logic i0_br_start_error;
|
|
|
|
logic [31:1] f1prett;
|
|
logic [31:1] f0prett;
|
|
logic [1:0] f1dbecc;
|
|
logic [1:0] f0dbecc;
|
|
logic [1:0] f1icaf;
|
|
logic [1:0] f0icaf;
|
|
|
|
logic [1:0] aligndbecc;
|
|
logic [1:0] alignicaf;
|
|
logic i0_brp_pc4;
|
|
|
|
logic [pt.BTB_ADDR_HI:pt.BTB_ADDR_LO] firstpc_hash, secondpc_hash;
|
|
|
|
logic first_legal;
|
|
|
|
logic [1:0] wrptr, wrptr_in;
|
|
logic [1:0] rdptr, rdptr_in;
|
|
logic [2:0] qwen;
|
|
logic [31:0] q2,q1,q0;
|
|
logic q2off_in, q2off;
|
|
logic q1off_in, q1off;
|
|
logic q0off_in, q0off;
|
|
logic f0_shift_2B;
|
|
|
|
logic [31:0] q0eff;
|
|
logic [31:0] q0final;
|
|
logic q0ptr;
|
|
logic [1:0] q0sel;
|
|
|
|
logic [31:0] q1eff;
|
|
logic [15:0] q1final;
|
|
logic q1ptr;
|
|
logic [1:0] q1sel;
|
|
|
|
logic [2:0] qren;
|
|
|
|
logic consume_fb1, consume_fb0;
|
|
logic [1:0] icaf_eff;
|
|
|
|
localparam BRDATA_SIZE = pt.BTB_ENABLE ? 16+($clog2(pt.BTB_SIZE)*2*pt.BTB_FULLYA) : 4;
|
|
localparam BRDATA_WIDTH = pt.BTB_ENABLE ? 8+($clog2(pt.BTB_SIZE)*pt.BTB_FULLYA) : 2;
|
|
logic [BRDATA_SIZE-1:0] brdata_in, brdata2, brdata1, brdata0;
|
|
logic [BRDATA_SIZE-1:0] brdata1eff, brdata0eff;
|
|
logic [BRDATA_SIZE-1:0] brdata1final, brdata0final;
|
|
|
|
localparam MHI = 1+(pt.BTB_ENABLE * (43+pt.BHT_GHR_SIZE));
|
|
localparam MSIZE = 2+(pt.BTB_ENABLE * (43+pt.BHT_GHR_SIZE));
|
|
|
|
logic [MHI:0] misc_data_in, misc2, misc1, misc0;
|
|
logic [MHI:0] misc1eff, misc0eff;
|
|
|
|
logic [pt.BTB_BTAG_SIZE-1:0] firstbrtag_hash, secondbrtag_hash;
|
|
|
|
logic error_stall_in, error_stall;
|
|
|
|
assign error_stall_in = (error_stall | ifu_async_error_start) & ~exu_flush_final;
|
|
|
|
rvdff #(.WIDTH(7)) bundle1ff (.*,
|
|
.clk(active_clk),
|
|
.din ({wrptr_in[1:0],rdptr_in[1:0],q2off_in,q1off_in,q0off_in}),
|
|
.dout({wrptr[1:0], rdptr[1:0], q2off, q1off, q0off})
|
|
);
|
|
|
|
rvdffie #(.WIDTH(7),.OVERRIDE(1)) bundle2ff (.*,
|
|
.din ({error_stall_in,f2val_in[1:0],f1val_in[1:0],f0val_in[1:0]}),
|
|
.dout({error_stall, f2val[1:0], f1val[1:0], f0val[1:0] })
|
|
);
|
|
|
|
if(pt.BTB_ENABLE==1) begin
|
|
rvdffe #(BRDATA_SIZE) brdata2ff (.*, .clk(clk), .en(qwen[2]), .din(brdata_in[BRDATA_SIZE-1:0]), .dout(brdata2[BRDATA_SIZE-1:0]));
|
|
rvdffe #(BRDATA_SIZE) brdata1ff (.*, .clk(clk), .en(qwen[1]), .din(brdata_in[BRDATA_SIZE-1:0]), .dout(brdata1[BRDATA_SIZE-1:0]));
|
|
rvdffe #(BRDATA_SIZE) brdata0ff (.*, .clk(clk), .en(qwen[0]), .din(brdata_in[BRDATA_SIZE-1:0]), .dout(brdata0[BRDATA_SIZE-1:0]));
|
|
rvdffe #(MSIZE) misc2ff (.*, .clk(clk), .en(qwen[2]), .din(misc_data_in[MHI:0]), .dout(misc2[MHI:0]));
|
|
rvdffe #(MSIZE) misc1ff (.*, .clk(clk), .en(qwen[1]), .din(misc_data_in[MHI:0]), .dout(misc1[MHI:0]));
|
|
rvdffe #(MSIZE) misc0ff (.*, .clk(clk), .en(qwen[0]), .din(misc_data_in[MHI:0]), .dout(misc0[MHI:0]));
|
|
end
|
|
else begin
|
|
|
|
rvdffie #((MSIZE*3)+(BRDATA_SIZE*3)) miscff (.*,
|
|
.din({qwen[2] ? {misc_data_in[MHI:0], brdata_in[BRDATA_SIZE-1:0]} : {misc2[MHI:0], brdata2[BRDATA_SIZE-1:0]},
|
|
qwen[1] ? {misc_data_in[MHI:0], brdata_in[BRDATA_SIZE-1:0]} : {misc1[MHI:0], brdata1[BRDATA_SIZE-1:0]},
|
|
qwen[0] ? {misc_data_in[MHI:0], brdata_in[BRDATA_SIZE-1:0]} : {misc0[MHI:0], brdata0[BRDATA_SIZE-1:0]}}),
|
|
.dout({misc2[MHI:0], brdata2[BRDATA_SIZE-1:0],
|
|
misc1[MHI:0], brdata1[BRDATA_SIZE-1:0],
|
|
misc0[MHI:0], brdata0[BRDATA_SIZE-1:0]})
|
|
);
|
|
end
|
|
|
|
logic [31:1] q2pc, q1pc, q0pc;
|
|
|
|
rvdffe #(31) q2pcff (.*, .clk(clk), .en(qwen[2]), .din(ifu_fetch_pc[31:1]), .dout(q2pc[31:1]));
|
|
rvdffe #(31) q1pcff (.*, .clk(clk), .en(qwen[1]), .din(ifu_fetch_pc[31:1]), .dout(q1pc[31:1]));
|
|
rvdffe #(31) q0pcff (.*, .clk(clk), .en(qwen[0]), .din(ifu_fetch_pc[31:1]), .dout(q0pc[31:1]));
|
|
|
|
rvdffe #(32) q2ff (.*, .clk(clk), .en(qwen[2]), .din(ifu_fetch_data_f[31:0]), .dout(q2[31:0]));
|
|
rvdffe #(32) q1ff (.*, .clk(clk), .en(qwen[1]), .din(ifu_fetch_data_f[31:0]), .dout(q1[31:0]));
|
|
rvdffe #(32) q0ff (.*, .clk(clk), .en(qwen[0]), .din(ifu_fetch_data_f[31:0]), .dout(q0[31:0]));
|
|
|
|
|
|
// new queue control logic
|
|
|
|
assign qren[2:0] = { rdptr[1:0] == 2'b10,
|
|
rdptr[1:0] == 2'b01,
|
|
rdptr[1:0] == 2'b00 };
|
|
|
|
assign qwen[2:0] = { (wrptr[1:0] == 2'b10) & ifvalid,
|
|
(wrptr[1:0] == 2'b01) & ifvalid,
|
|
(wrptr[1:0] == 2'b00) & ifvalid };
|
|
|
|
|
|
assign rdptr_in[1:0] = ({2{ qren[0] & ifu_fb_consume1 & ~exu_flush_final}} & 2'b01 ) |
|
|
({2{ qren[1] & ifu_fb_consume1 & ~exu_flush_final}} & 2'b10 ) |
|
|
({2{ qren[2] & ifu_fb_consume1 & ~exu_flush_final}} & 2'b00 ) |
|
|
({2{ qren[0] & ifu_fb_consume2 & ~exu_flush_final}} & 2'b10 ) |
|
|
({2{ qren[1] & ifu_fb_consume2 & ~exu_flush_final}} & 2'b00 ) |
|
|
({2{ qren[2] & ifu_fb_consume2 & ~exu_flush_final}} & 2'b01 ) |
|
|
({2{~ifu_fb_consume1 & ~ifu_fb_consume2 & ~exu_flush_final}} & rdptr[1:0]);
|
|
|
|
assign wrptr_in[1:0] = ({2{ qwen[0] & ~exu_flush_final}} & 2'b01 ) |
|
|
({2{ qwen[1] & ~exu_flush_final}} & 2'b10 ) |
|
|
({2{ qwen[2] & ~exu_flush_final}} & 2'b00 ) |
|
|
({2{~ifvalid & ~exu_flush_final}} & wrptr[1:0]);
|
|
|
|
|
|
|
|
assign q2off_in = ( ~qwen[2] & (rdptr[1:0]==2'd2) & (q2off | f0_shift_2B) ) |
|
|
( ~qwen[2] & (rdptr[1:0]==2'd1) & (q2off | f1_shift_2B) ) |
|
|
( ~qwen[2] & (rdptr[1:0]==2'd0) & q2off );
|
|
|
|
assign q1off_in = ( ~qwen[1] & (rdptr[1:0]==2'd1) & (q1off | f0_shift_2B) ) |
|
|
( ~qwen[1] & (rdptr[1:0]==2'd0) & (q1off | f1_shift_2B) ) |
|
|
( ~qwen[1] & (rdptr[1:0]==2'd2) & q1off );
|
|
|
|
assign q0off_in = ( ~qwen[0] & (rdptr[1:0]==2'd0) & (q0off | f0_shift_2B) ) |
|
|
( ~qwen[0] & (rdptr[1:0]==2'd2) & (q0off | f1_shift_2B) ) |
|
|
( ~qwen[0] & (rdptr[1:0]==2'd1) & q0off );
|
|
|
|
|
|
|
|
assign q0ptr = ( (rdptr[1:0]==2'b00) & q0off ) |
|
|
( (rdptr[1:0]==2'b01) & q1off ) |
|
|
( (rdptr[1:0]==2'b10) & q2off );
|
|
|
|
assign q1ptr = ( (rdptr[1:0]==2'b00) & q1off ) |
|
|
( (rdptr[1:0]==2'b01) & q2off ) |
|
|
( (rdptr[1:0]==2'b10) & q0off );
|
|
|
|
assign q0sel[1:0] = {q0ptr,~q0ptr};
|
|
|
|
assign q1sel[1:0] = {q1ptr,~q1ptr};
|
|
|
|
// end new queue control logic
|
|
|
|
|
|
// misc data that is associated with each fetch buffer
|
|
|
|
if(pt.BTB_ENABLE==1)
|
|
assign misc_data_in[MHI:0] = {
|
|
|
|
ic_access_fault_type_f[1:0],
|
|
ifu_bp_btb_target_f[31:1],
|
|
ifu_bp_poffset_f[11:0],
|
|
ifu_bp_fghr_f[pt.BHT_GHR_SIZE-1:0]
|
|
};
|
|
else
|
|
assign misc_data_in[MHI:0] = {
|
|
ic_access_fault_type_f[1:0]
|
|
};
|
|
|
|
|
|
assign {misc1eff[MHI:0],misc0eff[MHI:0]} = (({MSIZE*2{qren[0]}} & {misc1[MHI:0],misc0[MHI:0]}) |
|
|
({MSIZE*2{qren[1]}} & {misc2[MHI:0],misc1[MHI:0]}) |
|
|
({MSIZE*2{qren[2]}} & {misc0[MHI:0],misc2[MHI:0]}));
|
|
|
|
if(pt.BTB_ENABLE==1) begin
|
|
assign {
|
|
f1ictype[1:0],
|
|
f1prett[31:1],
|
|
f1poffset[11:0],
|
|
f1fghr[pt.BHT_GHR_SIZE-1:0]
|
|
} = misc1eff[MHI:0];
|
|
|
|
assign {
|
|
f0ictype[1:0],
|
|
f0prett[31:1],
|
|
f0poffset[11:0],
|
|
f0fghr[pt.BHT_GHR_SIZE-1:0]
|
|
} = misc0eff[MHI:0];
|
|
|
|
if(pt.BTB_FULLYA) begin
|
|
assign brdata_in[BRDATA_SIZE-1:0] = {
|
|
ifu_bp_fa_index_f[1], iccm_rd_ecc_double_err[1],ic_access_fault_f[1],ifu_bp_hist1_f[1],ifu_bp_hist0_f[1],ifu_bp_pc4_f[1],ifu_bp_way_f[1],ifu_bp_valid_f[1],ifu_bp_ret_f[1],
|
|
ifu_bp_fa_index_f[0], iccm_rd_ecc_double_err[0],ic_access_fault_f[0],ifu_bp_hist1_f[0],ifu_bp_hist0_f[0],ifu_bp_pc4_f[0],ifu_bp_way_f[0],ifu_bp_valid_f[0],ifu_bp_ret_f[0]
|
|
};
|
|
assign {f0index[1],f0dbecc[1],f0icaf[1],f0hist1[1],f0hist0[1],f0pc4[1],f0way[1],f0brend[1],f0ret[1],
|
|
f0index[0],f0dbecc[0],f0icaf[0],f0hist1[0],f0hist0[0],f0pc4[0],f0way[0],f0brend[0],f0ret[0]} = brdata0final[BRDATA_SIZE-1:0];
|
|
|
|
assign {f1index[1],f1dbecc[1],f1icaf[1],f1hist1[1],f1hist0[1],f1pc4[1],f1way[1],f1brend[1],f1ret[1],
|
|
f1index[0],f1dbecc[0],f1icaf[0],f1hist1[0],f1hist0[0],f1pc4[0],f1way[0],f1brend[0],f1ret[0]} = brdata1final[BRDATA_SIZE-1:0];
|
|
|
|
end
|
|
else begin
|
|
assign brdata_in[BRDATA_SIZE-1:0] = {
|
|
iccm_rd_ecc_double_err[1],ic_access_fault_f[1],ifu_bp_hist1_f[1],ifu_bp_hist0_f[1],ifu_bp_pc4_f[1],ifu_bp_way_f[1],ifu_bp_valid_f[1],ifu_bp_ret_f[1],
|
|
iccm_rd_ecc_double_err[0],ic_access_fault_f[0],ifu_bp_hist1_f[0],ifu_bp_hist0_f[0],ifu_bp_pc4_f[0],ifu_bp_way_f[0],ifu_bp_valid_f[0],ifu_bp_ret_f[0]
|
|
};
|
|
assign {f0dbecc[1],f0icaf[1],f0hist1[1],f0hist0[1],f0pc4[1],f0way[1],f0brend[1],f0ret[1],
|
|
f0dbecc[0],f0icaf[0],f0hist1[0],f0hist0[0],f0pc4[0],f0way[0],f0brend[0],f0ret[0]} = brdata0final[BRDATA_SIZE-1:0];
|
|
|
|
assign {f1dbecc[1],f1icaf[1],f1hist1[1],f1hist0[1],f1pc4[1],f1way[1],f1brend[1],f1ret[1],
|
|
f1dbecc[0],f1icaf[0],f1hist1[0],f1hist0[0],f1pc4[0],f1way[0],f1brend[0],f1ret[0]} = brdata1final[BRDATA_SIZE-1:0];
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
assign {brdata1eff[BRDATA_SIZE-1:0],brdata0eff[BRDATA_SIZE-1:0]} = (({BRDATA_SIZE*2{qren[0]}} & {brdata1[BRDATA_SIZE-1:0],brdata0[BRDATA_SIZE-1:0]}) |
|
|
({BRDATA_SIZE*2{qren[1]}} & {brdata2[BRDATA_SIZE-1:0],brdata1[BRDATA_SIZE-1:0]}) |
|
|
({BRDATA_SIZE*2{qren[2]}} & {brdata0[BRDATA_SIZE-1:0],brdata2[BRDATA_SIZE-1:0]}));
|
|
|
|
assign brdata0final[BRDATA_SIZE-1:0] = (({BRDATA_SIZE{q0sel[0]}} & { brdata0eff[2*BRDATA_WIDTH-1:0]}) |
|
|
({BRDATA_SIZE{q0sel[1]}} & {{BRDATA_WIDTH{1'b0}},brdata0eff[BRDATA_SIZE-1:BRDATA_WIDTH]}));
|
|
|
|
assign brdata1final[BRDATA_SIZE-1:0] = (({BRDATA_SIZE{q1sel[0]}} & { brdata1eff[2*BRDATA_WIDTH-1:0]}) |
|
|
({BRDATA_SIZE{q1sel[1]}} & {{BRDATA_WIDTH{1'b0}},brdata1eff[BRDATA_SIZE-1:BRDATA_WIDTH]}));
|
|
|
|
end // if (pt.BTB_ENABLE==1)
|
|
else begin
|
|
assign {
|
|
f1ictype[1:0]
|
|
} = misc1eff[MHI:0];
|
|
|
|
assign {
|
|
f0ictype[1:0]
|
|
} = misc0eff[MHI:0];
|
|
|
|
assign brdata_in[BRDATA_SIZE-1:0] = {
|
|
iccm_rd_ecc_double_err[1],ic_access_fault_f[1],
|
|
iccm_rd_ecc_double_err[0],ic_access_fault_f[0]
|
|
};
|
|
assign {f0dbecc[1],f0icaf[1],
|
|
f0dbecc[0],f0icaf[0]} = brdata0final[BRDATA_SIZE-1:0];
|
|
|
|
assign {f1dbecc[1],f1icaf[1],
|
|
f1dbecc[0],f1icaf[0]} = brdata1final[BRDATA_SIZE-1:0];
|
|
|
|
assign {brdata1eff[BRDATA_SIZE-1:0],brdata0eff[BRDATA_SIZE-1:0]} = (({BRDATA_SIZE*2{qren[0]}} & {brdata1[BRDATA_SIZE-1:0],brdata0[BRDATA_SIZE-1:0]}) |
|
|
({BRDATA_SIZE*2{qren[1]}} & {brdata2[BRDATA_SIZE-1:0],brdata1[BRDATA_SIZE-1:0]}) |
|
|
({BRDATA_SIZE*2{qren[2]}} & {brdata0[BRDATA_SIZE-1:0],brdata2[BRDATA_SIZE-1:0]}));
|
|
|
|
assign brdata0final[BRDATA_SIZE-1:0] = (({BRDATA_SIZE{q0sel[0]}} & { brdata0eff[2*BRDATA_WIDTH-1:0]}) |
|
|
({BRDATA_SIZE{q0sel[1]}} & {{BRDATA_WIDTH{1'b0}},brdata0eff[BRDATA_SIZE-1:BRDATA_WIDTH]}));
|
|
|
|
assign brdata1final[BRDATA_SIZE-1:0] = (({BRDATA_SIZE{q1sel[0]}} & { brdata1eff[2*BRDATA_WIDTH-1:0]}) |
|
|
({BRDATA_SIZE{q1sel[1]}} & {{BRDATA_WIDTH{1'b0}},brdata1eff[BRDATA_SIZE-1:BRDATA_WIDTH]}));
|
|
|
|
end // else: !if(pt.BTB_ENABLE==1)
|
|
|
|
|
|
// possible states of { sf0_valid, sf1_valid, f2_valid }
|
|
//
|
|
// 000 if->f0
|
|
// 100 if->f1
|
|
// 101 illegal
|
|
// 010 if->f1, f1->f0
|
|
// 110 if->f2
|
|
// 001 if->f1, f2->f0
|
|
// 011 if->f2, f2->f1, f1->f0
|
|
// 111 !if, no shift
|
|
|
|
assign f2_valid = f2val[0];
|
|
assign sf1_valid = sf1val[0];
|
|
assign sf0_valid = sf0val[0];
|
|
|
|
// interface to fetch
|
|
|
|
assign consume_fb0 = ~sf0val[0] & f0val[0];
|
|
|
|
assign consume_fb1 = ~sf1val[0] & f1val[0];
|
|
|
|
assign ifu_fb_consume1 = consume_fb0 & ~consume_fb1 & ~exu_flush_final;
|
|
assign ifu_fb_consume2 = consume_fb0 & consume_fb1 & ~exu_flush_final;
|
|
|
|
assign ifvalid = ifu_fetch_val[0];
|
|
|
|
assign shift_f1_f0 = ~sf0_valid & sf1_valid;
|
|
assign shift_f2_f0 = ~sf0_valid & ~sf1_valid & f2_valid;
|
|
assign shift_f2_f1 = ~sf0_valid & sf1_valid & f2_valid;
|
|
|
|
assign fetch_to_f0 = ~sf0_valid & ~sf1_valid & ~f2_valid & ifvalid;
|
|
|
|
assign fetch_to_f1 = (~sf0_valid & ~sf1_valid & f2_valid & ifvalid) |
|
|
(~sf0_valid & sf1_valid & ~f2_valid & ifvalid) |
|
|
( sf0_valid & ~sf1_valid & ~f2_valid & ifvalid);
|
|
|
|
assign fetch_to_f2 = (~sf0_valid & sf1_valid & f2_valid & ifvalid) |
|
|
( sf0_valid & sf1_valid & ~f2_valid & ifvalid);
|
|
|
|
|
|
assign f2val_in[1:0] = ({2{ fetch_to_f2 & ~exu_flush_final}} & ifu_fetch_val[1:0]) |
|
|
({2{~fetch_to_f2 & ~shift_f2_f1 & ~shift_f2_f0 & ~exu_flush_final}} & f2val[1:0] );
|
|
|
|
|
|
assign sf1val[1:0] = ({2{ f1_shift_2B}} & {1'b0,f1val[1]}) |
|
|
({2{~f1_shift_2B}} & f1val[1:0] );
|
|
|
|
assign f1val_in[1:0] = ({2{ fetch_to_f1 & ~exu_flush_final}} & ifu_fetch_val[1:0]) |
|
|
({2{ shift_f2_f1 & ~exu_flush_final}} & f2val[1:0] ) |
|
|
({2{~fetch_to_f1 & ~shift_f2_f1 & ~shift_f1_f0 & ~exu_flush_final}} & sf1val[1:0] );
|
|
|
|
|
|
|
|
assign sf0val[1:0] = ({2{ shift_2B }} & {1'b0,f0val[1]}) |
|
|
({2{~shift_2B & ~shift_4B}} & f0val[1:0]);
|
|
|
|
assign f0val_in[1:0] = ({2{fetch_to_f0 & ~exu_flush_final}} & ifu_fetch_val[1:0]) |
|
|
({2{ shift_f2_f0 & ~exu_flush_final}} & f2val[1:0] ) |
|
|
({2{ shift_f1_f0 & ~exu_flush_final}} & sf1val[1:0] ) |
|
|
({2{~fetch_to_f0 & ~shift_f2_f0 & ~shift_f1_f0 & ~exu_flush_final}} & sf0val[1:0] );
|
|
|
|
assign {q1eff[31:0],q0eff[31:0]} = (({64{qren[0]}} & {q1[31:0],q0[31:0]}) |
|
|
({64{qren[1]}} & {q2[31:0],q1[31:0]}) |
|
|
({64{qren[2]}} & {q0[31:0],q2[31:0]}));
|
|
|
|
assign q0final[31:0] = ({32{q0sel[0]}} & { q0eff[31:0]}) |
|
|
({32{q0sel[1]}} & {16'b0,q0eff[31:16]});
|
|
|
|
assign q1final[15:0] = ({16{q1sel[0]}} & q1eff[15:0] ) |
|
|
({16{q1sel[1]}} & q1eff[31:16]);
|
|
logic [31:1] q0pceff, q0pcfinal;
|
|
logic [31:1] q1pceff;
|
|
|
|
assign {q1pceff[31:1],q0pceff[31:1]} = (({62{qren[0]}} & {q1pc[31:1],q0pc[31:1]}) |
|
|
({62{qren[1]}} & {q2pc[31:1],q1pc[31:1]}) |
|
|
({62{qren[2]}} & {q0pc[31:1],q2pc[31:1]}));
|
|
|
|
|
|
assign q0pcfinal[31:1] = ({31{q0sel[0]}} & ( q0pceff[31:1])) |
|
|
({31{q0sel[1]}} & ( q0pceff[31:1] + 31'd1));
|
|
|
|
assign aligndata[31:0] = ({32{ f0val[1] }} & {q0final[31:0]}) |
|
|
({32{~f0val[1] & f0val[0]}} & {q1final[15:0],q0final[15:0]});
|
|
|
|
assign alignval[1:0] = ({ 2{ f0val[1] }} & {2'b11}) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1val[0],1'b1});
|
|
|
|
assign alignicaf[1:0] = ({ 2{ f0val[1] }} & f0icaf[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1icaf[0],f0icaf[0]});
|
|
|
|
assign aligndbecc[1:0] = ({ 2{ f0val[1] }} & f0dbecc[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1dbecc[0],f0dbecc[0]});
|
|
|
|
if (pt.BTB_ENABLE==1) begin
|
|
|
|
// for branch prediction
|
|
|
|
assign alignbrend[1:0] = ({ 2{ f0val[1] }} & f0brend[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1brend[0],f0brend[0]});
|
|
|
|
assign alignpc4[1:0] = ({ 2{ f0val[1] }} & f0pc4[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1pc4[0],f0pc4[0]});
|
|
|
|
if(pt.BTB_FULLYA) begin
|
|
assign alignindex[0] = f0index[0];
|
|
assign alignindex[1] = f0val[1] ? f0index[1] : f1index[0];
|
|
end
|
|
|
|
assign alignret[1:0] = ({ 2{ f0val[1] }} & f0ret[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1ret[0],f0ret[0]});
|
|
|
|
assign alignway[1:0] = ({ 2{ f0val[1] }} & f0way[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1way[0],f0way[0]});
|
|
|
|
assign alignhist1[1:0] = ({ 2{ f0val[1] }} & f0hist1[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1hist1[0],f0hist1[0]});
|
|
|
|
assign alignhist0[1:0] = ({ 2{ f0val[1] }} & f0hist0[1:0] ) |
|
|
({ 2{~f0val[1] & f0val[0]}} & {f1hist0[0],f0hist0[0]});
|
|
|
|
assign secondpc[31:1] = ({31{ f0val[1] }} & (q0pceff[31:1] + 31'd1)) |
|
|
// you need the base pc for 2nd one only (4B max, 2B for the 1st and 2B for the 2nd)
|
|
({31{~f0val[1] & f0val[0]}} & q1pceff[31:1] );
|
|
|
|
|
|
assign firstpc[31:1] = q0pcfinal[31:1];
|
|
end // if (pt.BTB_ENABLE==1)
|
|
|
|
assign alignfromf1[1] = ~f0val[1] & f0val[0];
|
|
|
|
|
|
assign ifu_i0_pc[31:1] = q0pcfinal[31:1];
|
|
|
|
|
|
assign ifu_i0_pc4 = first4B;
|
|
|
|
|
|
assign ifu_i0_cinst[15:0] = aligndata[15:0];
|
|
|
|
assign first4B = (aligndata[1:0] == 2'b11);
|
|
assign first2B = ~first4B;
|
|
|
|
assign ifu_i0_valid = (first4B & alignval[1]) |
|
|
(first2B & alignval[0]);
|
|
|
|
// inst access fault on any byte of inst results in access fault for the inst
|
|
assign ifu_i0_icaf = (first4B & (|alignicaf[1:0])) |
|
|
(first2B & alignicaf[0] );
|
|
|
|
assign ifu_i0_icaf_type[1:0] = (first4B & ~f0val[1] & f0val[0] & ~alignicaf[0] & ~aligndbecc[0]) ? f1ictype[1:0] : f0ictype[1:0];
|
|
|
|
|
|
assign icaf_eff[1:0] = alignicaf[1:0] | aligndbecc[1:0];
|
|
|
|
assign ifu_i0_icaf_second = first4B & ~icaf_eff[0] & icaf_eff[1];
|
|
|
|
assign ifu_i0_dbecc = (first4B & (|aligndbecc[1:0])) |
|
|
(first2B & aligndbecc[0] );
|
|
|
|
|
|
assign ifirst[31:0] = aligndata[31:0];
|
|
|
|
|
|
assign ifu_i0_instr[31:0] = ({32{first4B & alignval[1]}} & ifirst[31:0]) |
|
|
({32{first2B & alignval[0]}} & uncompress0[31:0]);
|
|
|
|
if(pt.BTB_ENABLE==1) begin
|
|
|
|
// if you detect br does not start on instruction boundary
|
|
|
|
el2_btb_addr_hash #(.pt(pt)) firsthash (.pc(firstpc [pt.BTB_INDEX3_HI:pt.BTB_INDEX1_LO]),
|
|
.hash(firstpc_hash [pt.BTB_ADDR_HI:pt.BTB_ADDR_LO]));
|
|
el2_btb_addr_hash #(.pt(pt)) secondhash(.pc(secondpc[pt.BTB_INDEX3_HI:pt.BTB_INDEX1_LO]),
|
|
.hash(secondpc_hash[pt.BTB_ADDR_HI:pt.BTB_ADDR_LO]));
|
|
|
|
if(pt.BTB_FULLYA) begin
|
|
assign firstbrtag_hash = firstpc;
|
|
assign secondbrtag_hash = secondpc;
|
|
end
|
|
else begin
|
|
if(pt.BTB_BTAG_FOLD) begin : btbfold
|
|
el2_btb_tag_hash_fold #(.pt(pt)) first_brhash (.pc(firstpc [pt.BTB_ADDR_HI+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE:pt.BTB_ADDR_HI+1]),
|
|
.hash(firstbrtag_hash [pt.BTB_BTAG_SIZE-1:0]));
|
|
el2_btb_tag_hash_fold #(.pt(pt)) second_brhash(.pc(secondpc[pt.BTB_ADDR_HI+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE:pt.BTB_ADDR_HI+1]),
|
|
.hash(secondbrtag_hash[pt.BTB_BTAG_SIZE-1:0]));
|
|
end
|
|
else begin
|
|
el2_btb_tag_hash #(.pt(pt)) first_brhash (.pc(firstpc [pt.BTB_ADDR_HI+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE:pt.BTB_ADDR_HI+1]),
|
|
.hash(firstbrtag_hash [pt.BTB_BTAG_SIZE-1:0]));
|
|
el2_btb_tag_hash #(.pt(pt)) second_brhash(.pc(secondpc[pt.BTB_ADDR_HI+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE+pt.BTB_BTAG_SIZE:pt.BTB_ADDR_HI+1]),
|
|
.hash(secondbrtag_hash[pt.BTB_BTAG_SIZE-1:0]));
|
|
end
|
|
end // else: !if(pt.BTB_FULLYA)
|
|
|
|
|
|
// start_indexing - you want pc to be based on where the end of branch is prediction
|
|
// normal indexing pc based that's incorrect now for pc4 cases it's pc4 + 2
|
|
|
|
always_comb begin
|
|
|
|
i0_brp = '0;
|
|
|
|
i0_br_start_error = (first4B & alignval[1] & alignbrend[0]);
|
|
|
|
i0_brp.valid = (first2B & alignbrend[0]) |
|
|
(first4B & alignbrend[1]) |
|
|
i0_br_start_error;
|
|
|
|
i0_brp_pc4 = (first2B & alignpc4[0]) |
|
|
(first4B & alignpc4[1]);
|
|
|
|
i0_brp.ret = (first2B & alignret[0]) |
|
|
(first4B & alignret[1]);
|
|
|
|
i0_brp.way = (first2B | alignbrend[0]) ? alignway[0] : alignway[1];
|
|
|
|
i0_brp.hist[1] = (first2B & alignhist1[0]) |
|
|
(first4B & alignhist1[1]);
|
|
|
|
i0_brp.hist[0] = (first2B & alignhist0[0]) |
|
|
(first4B & alignhist0[1]);
|
|
|
|
i0_ends_f1 = first4B & alignfromf1[1];
|
|
|
|
i0_brp.toffset[11:0] = (i0_ends_f1) ? f1poffset[11:0] : f0poffset[11:0];
|
|
|
|
i0_brp.prett[31:1] = (i0_ends_f1) ? f1prett[31:1] : f0prett[31:1];
|
|
|
|
i0_brp.br_start_error = i0_br_start_error;
|
|
|
|
i0_brp.bank = (first2B | alignbrend[0]) ? firstpc[1] : secondpc[1];
|
|
|
|
i0_brp.br_error = (i0_brp.valid & i0_brp_pc4 & first2B) |
|
|
(i0_brp.valid & ~i0_brp_pc4 & first4B);
|
|
|
|
if(pt.BTB_FULLYA)
|
|
ifu_i0_fa_index = (first2B | alignbrend[0]) ? alignindex[0] : alignindex[1];
|
|
else
|
|
ifu_i0_fa_index = '0;
|
|
|
|
end
|
|
|
|
|
|
assign ifu_i0_bp_index[pt.BTB_ADDR_HI:pt.BTB_ADDR_LO] = (first2B | alignbrend[0]) ? firstpc_hash[pt.BTB_ADDR_HI:pt.BTB_ADDR_LO] :
|
|
secondpc_hash[pt.BTB_ADDR_HI:pt.BTB_ADDR_LO];
|
|
|
|
assign ifu_i0_bp_fghr[pt.BHT_GHR_SIZE-1:0] = (i0_ends_f1) ? f1fghr[pt.BHT_GHR_SIZE-1:0] :
|
|
f0fghr[pt.BHT_GHR_SIZE-1:0];
|
|
|
|
assign ifu_i0_bp_btag[pt.BTB_BTAG_SIZE-1:0] = (first2B | alignbrend[0]) ? firstbrtag_hash[pt.BTB_BTAG_SIZE-1:0] :
|
|
secondbrtag_hash[pt.BTB_BTAG_SIZE-1:0];
|
|
end
|
|
else begin
|
|
assign i0_brp = '0;
|
|
assign ifu_i0_bp_index = '0;
|
|
assign ifu_i0_bp_fghr = '0;
|
|
assign ifu_i0_bp_btag = '0;
|
|
end // else: !if(pt.BTB_ENABLE==1)
|
|
|
|
// decompress
|
|
|
|
// quiet inputs for 4B inst
|
|
el2_ifu_compress_ctl compress0 (.din((first2B) ? aligndata[15:0] : '0), .dout(uncompress0[31:0]));
|
|
|
|
|
|
|
|
assign i0_shift = dec_i0_decode_d & ~error_stall;
|
|
|
|
assign ifu_pmu_instr_aligned = i0_shift;
|
|
|
|
|
|
// compute how many bytes are being shifted from f0
|
|
|
|
assign shift_2B = i0_shift & first2B;
|
|
|
|
assign shift_4B = i0_shift & first4B;
|
|
|
|
// exact equations for the queue logic
|
|
assign f0_shift_2B = (shift_2B & f0val[0] ) |
|
|
(shift_4B & f0val[0] & ~f0val[1]);
|
|
|
|
|
|
// f0 valid states
|
|
// 11
|
|
// 10
|
|
// 00
|
|
|
|
assign f1_shift_2B = f0val[0] & ~f0val[1] & shift_4B;
|
|
|
|
|
|
|
|
endmodule
|