Project Full coverage report
Current view: Cores-VeeR-EL2—Cores-VeeR-EL2—design—lib—beh_lib.sv Coverage Hit Total
Test Date: 21-11-2024 Toggle 90.3% 131 145
Test: all Branch 100.0% 7 7

            Line data    Source code
       1              : // SPDX-License-Identifier: Apache-2.0
       2              : // Copyright 2020 Western Digital Corporation or its affiliates.
       3              : //
       4              : // Licensed under the Apache License, Version 2.0 (the "License");
       5              : // you may not use this file except in compliance with the License.
       6              : // You may obtain a copy of the License at
       7              : //
       8              : // http://www.apache.org/licenses/LICENSE-2.0
       9              : //
      10              : // Unless required by applicable law or agreed to in writing, software
      11              : // distributed under the License is distributed on an "AS IS" BASIS,
      12              : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      13              : // See the License for the specific language governing permissions and
      14              : // limitations under the License.
      15              : 
      16              : // all flops call the rvdff flop
      17              : 
      18              : 
      19              : module rvdff #( parameter WIDTH=1, SHORT=0 )
      20              :    (
      21          742 :      input logic [WIDTH-1:0] din,
      22     67266963 :      input logic           clk,
      23          564 :      input logic                   rst_l,
      24              : 
      25          745 :      output logic [WIDTH-1:0] dout
      26              :      );
      27              : 
      28              : if (SHORT == 1) begin
      29              :    assign dout = din;
      30              : end
      31              : else begin
      32              : `ifdef RV_CLOCKGATE
      33              :    always @(posedge tb_top.clk) begin
      34              :       #0 $strobe("CG: %0t %m din %x dout %x clk %b width %d",$time,din,dout,clk,WIDTH);
      35              :    end
      36              : `endif
      37              : 
      38     28311474 :    always_ff @(posedge clk or negedge rst_l) begin
      39         3576 :       if (rst_l == 0)
      40         1850 :         dout[WIDTH-1:0] <= 0;
      41              :       else
      42     28311003 :         dout[WIDTH-1:0] <= din[WIDTH-1:0];
      43              :    end
      44              : 
      45              : end
      46              : endmodule
      47              : 
      48              : // rvdff with 2:1 input mux to flop din iff sel==1
      49              : module rvdffs #( parameter WIDTH=1, SHORT=0 )
      50              :    (
      51        87916 :      input logic [WIDTH-1:0] din,
      52        14536 :      input logic             en,
      53     67637568 :      input logic           clk,
      54          631 :      input logic                   rst_l,
      55          834 :      output logic [WIDTH-1:0] dout
      56              :      );
      57              : 
      58              : if (SHORT == 1) begin : genblock
      59              :    assign dout = din;
      60              : end
      61              : else begin : genblock
      62              :    rvdff #(WIDTH) dffs (.din((en) ? din[WIDTH-1:0] : dout[WIDTH-1:0]), .*);
      63              : end
      64              : 
      65              : endmodule
      66              : 
      67              : // rvdff with en and clear
      68              : module rvdffsc #( parameter WIDTH=1, SHORT=0 )
      69              :    (
      70       778487 :      input logic [WIDTH-1:0] din,
      71       343376 :      input logic             en,
      72       343560 :      input logic             clear,
      73    279536102 :      input logic           clk,
      74         1489 :      input logic                   rst_l,
      75       295190 :      output logic [WIDTH-1:0] dout
      76              :      );
      77              : 
      78       295190 :    logic [WIDTH-1:0]          din_new;
      79              : if (SHORT == 1) begin : genblock
      80              :    assign dout = din;
      81              : end
      82              : else begin : genblock
      83              :    assign din_new = {WIDTH{~clear}} & (en ? din[WIDTH-1:0] : dout[WIDTH-1:0]);
      84              :    rvdff #(WIDTH) dffsc (.din(din_new[WIDTH-1:0]), .*);
      85              : end
      86              : endmodule
      87              : 
      88              : // _fpga versions
      89              : module rvdff_fpga #( parameter WIDTH=1, SHORT=0 )
      90              :    (
      91      3725180 :      input logic [WIDTH-1:0] din,
      92      9473980 :      input logic           clk,
      93         1811 :      input logic           clken,
      94    118062590 :      input logic           rawclk,
      95         1213 :      input logic           rst_l,
      96              : 
      97      3725067 :      output logic [WIDTH-1:0] dout
      98              :      );
      99              : 
     100              : if (SHORT == 1) begin : genblock
     101              :    assign dout = din;
     102              : end
     103              : else begin : genblock
     104              :    `ifdef RV_FPGA_OPTIMIZE
     105              :     rvdffs #(WIDTH) dffs (.clk(rawclk), .en(clken), .*);
     106              : `else
     107              :     rvdff #(WIDTH)  dff (.*);
     108              : `endif
     109              : end
     110              : endmodule
     111              : 
     112              : // rvdff with 2:1 input mux to flop din iff sel==1
     113              : module rvdffs_fpga #( parameter WIDTH=1, SHORT=0 )
     114              :    (
     115          338 :      input logic [WIDTH-1:0] din,
     116         2460 :      input logic             en,
     117        57008 :      input logic           clk,
     118          707 :      input logic           clken,
     119    144008646 :      input logic           rawclk,
     120          737 :      input logic           rst_l,
     121              : 
     122           32 :      output logic [WIDTH-1:0] dout
     123              :      );
     124              : 
     125              : if (SHORT == 1) begin : genblock
     126              :    assign dout = din;
     127              : end
     128              : else begin : genblock
     129              : `ifdef RV_FPGA_OPTIMIZE
     130              :    rvdffs #(WIDTH)   dffs (.clk(rawclk), .en(clken & en), .*);
     131              : `else
     132              :    rvdffs #(WIDTH)   dffs (.*);
     133              : `endif
     134              : end
     135              : 
     136              : endmodule
     137              : 
     138              : // rvdff with en and clear
     139              : module rvdffsc_fpga #( parameter WIDTH=1, SHORT=0 )
     140              :    (
     141         1306 :      input logic [WIDTH-1:0] din,
     142      3540030 :      input logic             en,
     143         3024 :      input logic             clear,
     144      3409728 :      input logic             clk,
     145         1043 :      input logic             clken,
     146    182749542 :      input logic             rawclk,
     147         1103 :      input logic             rst_l,
     148              : 
     149       177433 :      output logic [WIDTH-1:0] dout
     150              :      );
     151              : 
     152            0 :    logic [WIDTH-1:0]          din_new;
     153              : if (SHORT == 1) begin : genblock
     154              :    assign dout = din;
     155              : end
     156              : else begin : genblock
     157              : `ifdef RV_FPGA_OPTIMIZE
     158              :    rvdffs  #(WIDTH)   dffs  (.clk(rawclk), .din(din[WIDTH-1:0] & {WIDTH{~clear}}),.en((en | clear) & clken), .*);
     159              : `else
     160              :    rvdffsc #(WIDTH)   dffsc (.*);
     161              : `endif
     162              : end
     163              : endmodule
     164              : 
     165              : 
     166              : module rvdffe #( parameter WIDTH=1, SHORT=0, OVERRIDE=0 )
     167              :    (
     168      3116512 :      input  logic [WIDTH-1:0] din,
     169         5636 :      input  logic           en,
     170     67468296 :      input  logic           clk,
     171          556 :      input  logic           rst_l,
     172              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     173              :      /*verilator coverage_off*/
     174              :      input  logic             scan_mode,
     175              :      /*verilator coverage_on*/
     176         6731 :      output logic [WIDTH-1:0] dout
     177              :      );
     178              : 
     179        10084 :    logic                      l1clk;
     180              : 
     181              : if (SHORT == 1) begin : genblock
     182              :    if (1) begin : genblock
     183              :       assign dout = din;
     184              :    end
     185              : end
     186              : else begin : genblock
     187              : 
     188              : `ifndef RV_PHYSICAL
     189              :    if (WIDTH >= 8 || OVERRIDE==1) begin: genblock
     190              : `endif
     191              : 
     192              : `ifdef RV_FPGA_OPTIMIZE
     193              :       rvdffs #(WIDTH) dff ( .* );
     194              : `else
     195              :       rvclkhdr clkhdr ( .* );
     196              :       rvdff #(WIDTH) dff (.*, .clk(l1clk));
     197              : `endif
     198              : 
     199              : `ifndef RV_PHYSICAL
     200              :    end
     201              :    else
     202              :       $error("%m: rvdffe must be WIDTH >= 8");
     203              : `endif
     204              : end // else: !if(SHORT == 1)
     205              : 
     206              : endmodule // rvdffe
     207              : 
     208              : 
     209              : module rvdffpcie #( parameter WIDTH=31 )
     210              :    (
     211       140562 :      input  logic [WIDTH-1:0] din,
     212    676564182 :      input  logic             clk,
     213         4104 :      input  logic             rst_l,
     214     47084796 :      input  logic             en,
     215              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     216              :      /*verilator coverage_off*/
     217              :      input  logic             scan_mode,
     218              :      /*verilator coverage_on*/
     219       140213 :      output logic [WIDTH-1:0] dout
     220              :      );
     221              : 
     222              : 
     223              : 
     224              : `ifndef RV_PHYSICAL
     225              :    if (WIDTH == 31) begin: genblock
     226              : `endif
     227              : 
     228              : `ifdef RV_FPGA_OPTIMIZE
     229              :       rvdffs #(WIDTH) dff ( .* );
     230              : `else
     231              : 
     232              :       rvdfflie #(.WIDTH(WIDTH), .LEFT(19)) dff (.*);
     233              : 
     234              : `endif
     235              : 
     236              : `ifndef RV_PHYSICAL
     237              :    end
     238              :    else
     239              :       $error("%m: rvdffpcie width must be 31");
     240              : `endif
     241              : endmodule
     242              : 
     243              : // format: { LEFT, EXTRA }
     244              : // LEFT # of bits will be done with rvdffie, all else EXTRA with rvdffe
     245              : module rvdfflie #( parameter WIDTH=16, LEFT=8 )
     246              :    (
     247          378 :      input  logic [WIDTH-1:0] din,
     248     67178618 :      input  logic             clk,
     249          386 :      input  logic             rst_l,
     250          344 :      input  logic             en,
     251              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     252              :      /*verilator coverage_off*/
     253              :      input  logic             scan_mode,
     254              :      /*verilator coverage_on*/
     255          304 :      output logic [WIDTH-1:0] dout
     256              :      );
     257              : 
     258              :    localparam EXTRA = WIDTH-LEFT;
     259              : 
     260              : 
     261              : 
     262              : 
     263              : 
     264              : 
     265              : 
     266              :    localparam LMSB = WIDTH-1;
     267              :    localparam LLSB = LMSB-LEFT+1;
     268              :    localparam XMSB = LLSB-1;
     269              :    localparam XLSB = LLSB-EXTRA;
     270              : 
     271              : 
     272              : `ifndef RV_PHYSICAL
     273              :    if (WIDTH >= 16 && LEFT >= 8 && EXTRA >= 8) begin: genblock
     274              : `endif
     275              : 
     276              : `ifdef RV_FPGA_OPTIMIZE
     277              :       rvdffs #(WIDTH) dff ( .* );
     278              : `else
     279              : 
     280              :       rvdffiee #(LEFT)  dff_left  (.*, .din(din[LMSB:LLSB]), .dout(dout[LMSB:LLSB]));
     281              : 
     282              : 
     283              :       rvdffe  #(EXTRA)  dff_extra (.*, .din(din[XMSB:XLSB]), .dout(dout[XMSB:XLSB]));
     284              : 
     285              : 
     286              : 
     287              : 
     288              : `endif
     289              : 
     290              : `ifndef RV_PHYSICAL
     291              :    end
     292              :    else
     293              :       $error("%m: rvdfflie musb be WIDTH >= 16 && LEFT >= 8 && EXTRA >= 8");
     294              : `endif
     295              : endmodule
     296              : 
     297              : 
     298              : 
     299              : 
     300              : // special power flop for predict packet
     301              : // format: { LEFT, RIGHT==31 }
     302              : // LEFT # of bits will be done with rvdffe; RIGHT is enabled by LEFT[LSB] & en
     303              : module rvdffppe #( parameter integer WIDTH = 39 )
     304              :    (
     305       219592 :      input  logic [WIDTH-1:0] din,
     306     69840565 :      input  logic             clk,
     307          338 :      input  logic             rst_l,
     308      5989940 :      input  logic             en,
     309              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     310              :      /*verilator coverage_off*/
     311              :      input  logic             scan_mode,
     312              :      /*verilator coverage_on*/
     313       219592 :      output logic [WIDTH-1:0] dout
     314              :      );
     315              : 
     316              :    localparam integer RIGHT = 31;
     317              :    localparam integer LEFT  = WIDTH - RIGHT;
     318              : 
     319              :    localparam integer LMSB  = WIDTH-1;
     320              :    localparam integer LLSB  = LMSB-LEFT+1;
     321              :    localparam integer RMSB  = LLSB-1;
     322              :    localparam integer RLSB  = LLSB-RIGHT;
     323              : 
     324              : 
     325              : `ifndef RV_PHYSICAL
     326              :    if (WIDTH>=32 && LEFT>=8 && RIGHT>=8) begin: genblock
     327              : `endif
     328              : 
     329              : `ifdef RV_FPGA_OPTIMIZE
     330              :       rvdffs #(WIDTH) dff ( .* );
     331              : `else
     332              :       rvdffe #(LEFT)     dff_left (.*, .din(din[LMSB:LLSB]), .dout(dout[LMSB:LLSB]));
     333              : 
     334              :       rvdffe #(RIGHT)   dff_right (.*, .din(din[RMSB:RLSB]), .dout(dout[RMSB:RLSB]), .en(en & din[LLSB]));  // qualify with pret
     335              : 
     336              : 
     337              : `endif
     338              : 
     339              : `ifndef RV_PHYSICAL
     340              :    end
     341              :    else
     342              :       $error("%m: must be WIDTH>=32 && LEFT>=8 && RIGHT>=8");
     343              : `endif
     344              : endmodule
     345              : 
     346              : 
     347              : 
     348              : 
     349              : module rvdffie #( parameter WIDTH=1, OVERRIDE=0 )
     350              :    (
     351       149728 :      input  logic [WIDTH-1:0] din,
     352              : 
     353     69840565 :      input  logic           clk,
     354          338 :      input  logic           rst_l,
     355              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     356              :      /*verilator coverage_off*/
     357              :      input  logic             scan_mode,
     358              :      /*verilator coverage_on*/
     359       149728 :      output logic [WIDTH-1:0] dout
     360              :      );
     361              : 
     362            0 :    logic                      l1clk;
     363        78904 :    logic                      en;
     364              : 
     365              : 
     366              : 
     367              : 
     368              : 
     369              : 
     370              : 
     371              : 
     372              : `ifndef RV_PHYSICAL
     373              :    if (WIDTH >= 8 || OVERRIDE==1) begin: genblock
     374              : `endif
     375              : 
     376              :       assign en = |(din ^ dout);
     377              : 
     378              : `ifdef RV_FPGA_OPTIMIZE
     379              :       rvdffs #(WIDTH) dff ( .* );
     380              : `else
     381              :       rvclkhdr clkhdr ( .* );
     382              :       rvdff #(WIDTH) dff (.*, .clk(l1clk));
     383              : `endif
     384              : 
     385              : `ifndef RV_PHYSICAL
     386              :    end
     387              :    else
     388              :      $error("%m: rvdffie must be WIDTH >= 8");
     389              : `endif
     390              : 
     391              : 
     392              : endmodule
     393              : 
     394              : // ie flop but it has an .en input
     395              : module rvdffiee #( parameter WIDTH=1, OVERRIDE=0 )
     396              :    (
     397            0 :      input  logic [WIDTH-1:0] din,
     398              : 
     399         6150 :      input  logic           clk,
     400           48 :      input  logic           rst_l,
     401              :      // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     402              :      /*verilator coverage_off*/
     403              :      input  logic           scan_mode,
     404              :      /*verilator coverage_on*/
     405            6 :      input  logic           en,
     406            0 :      output logic [WIDTH-1:0] dout
     407              :      );
     408              : 
     409            0 :    logic                      l1clk;
     410            0 :    logic                      final_en;
     411              : 
     412              : `ifndef RV_PHYSICAL
     413              :    if (WIDTH >= 8 || OVERRIDE==1) begin: genblock
     414              : `endif
     415              : 
     416              :       assign final_en = (|(din ^ dout)) & en;
     417              : 
     418              : `ifdef RV_FPGA_OPTIMIZE
     419              :       rvdffs #(WIDTH) dff ( .*, .en(final_en) );
     420              : `else
     421              :       rvdffe #(WIDTH) dff (.*,  .en(final_en));
     422              : `endif
     423              : 
     424              : `ifndef RV_PHYSICAL
     425              :    end
     426              :    else
     427              :       $error("%m: rvdffie width must be >= 8");
     428              : `endif
     429              : 
     430              : endmodule
     431              : 
     432              : 
     433              : 
     434              : module rvsyncss #(parameter WIDTH = 251)
     435              :    (
     436     69840565 :      input  logic                 clk,
     437          338 :      input  logic                 rst_l,
     438            4 :      input  logic [WIDTH-1:0]     din,
     439            0 :      output logic [WIDTH-1:0]     dout
     440              :      );
     441              : 
     442            0 :    logic [WIDTH-1:0]              din_ff1;
     443              : 
     444              :    rvdff #(WIDTH) sync_ff1  (.*, .din (din[WIDTH-1:0]),     .dout(din_ff1[WIDTH-1:0]));
     445              :    rvdff #(WIDTH) sync_ff2  (.*, .din (din_ff1[WIDTH-1:0]), .dout(dout[WIDTH-1:0]));
     446              : 
     447              : endmodule // rvsyncss
     448              : 
     449              : module rvsyncss_fpga #(parameter WIDTH = 251)
     450              :    (
     451      3127890 :      input  logic                 gw_clk,
     452   1750929834 :      input  logic                 rawclk,
     453        10807 :      input  logic                 clken,
     454        10642 :      input  logic                 rst_l,
     455         3439 :      input  logic [WIDTH-1:0]     din,
     456         3436 :      output logic [WIDTH-1:0]     dout
     457              :      );
     458              : 
     459         3436 :    logic [WIDTH-1:0]              din_ff1;
     460              : 
     461              :    rvdff_fpga #(WIDTH) sync_ff1  (.*, .clk(gw_clk), .rawclk(rawclk), .clken(clken), .din (din[WIDTH-1:0]),     .dout(din_ff1[WIDTH-1:0]));
     462              :    rvdff_fpga #(WIDTH) sync_ff2  (.*, .clk(gw_clk), .rawclk(rawclk), .clken(clken), .din (din_ff1[WIDTH-1:0]), .dout(dout[WIDTH-1:0]));
     463              : 
     464              : endmodule // rvsyncss
     465              : 
     466              : module rvlsadder
     467              :   (
     468       475446 :     input logic [31:0] rs1,
     469       269992 :     input logic [11:0] offset,
     470              : 
     471       593287 :     output logic [31:0] dout
     472              :     );
     473              : 
     474       281466 :    logic                cout;
     475       368494 :    logic                sign;
     476              : 
     477      1469587 :    logic [31:12]        rs1_inc;
     478        17396 :    logic [31:12]        rs1_dec;
     479              : 
     480              :    assign {cout,dout[11:0]} = {1'b0,rs1[11:0]} + {1'b0,offset[11:0]};
     481              : 
     482              :    assign rs1_inc[31:12] = rs1[31:12] + 1;
     483              : 
     484              :    assign rs1_dec[31:12] = rs1[31:12] - 1;
     485              : 
     486              :    assign sign = offset[11];
     487              : 
     488              :    assign dout[31:12] = ({20{  sign ^~  cout}} &     rs1[31:12]) |
     489              :                         ({20{ ~sign &   cout}}  & rs1_inc[31:12]) |
     490              :                         ({20{  sign &  ~cout}}  & rs1_dec[31:12]);
     491              : 
     492              : endmodule // rvlsadder
     493              : 
     494              : // assume we only maintain pc[31:1] in the pipe
     495              : 
     496              : module rvbradder
     497              :   (
     498         2534 :     input [31:1] pc,
     499      3676900 :     input [12:1] offset,
     500              : 
     501       140162 :     output [31:1] dout
     502              :     );
     503              : 
     504      4230063 :    logic          cout;
     505      3884599 :    logic          sign;
     506              : 
     507         2852 :    logic [31:13]  pc_inc;
     508       106120 :    logic [31:13]  pc_dec;
     509              : 
     510              :    assign {cout,dout[12:1]} = {1'b0,pc[12:1]} + {1'b0,offset[12:1]};
     511              : 
     512              :    assign pc_inc[31:13] = pc[31:13] + 1;
     513              : 
     514              :    assign pc_dec[31:13] = pc[31:13] - 1;
     515              : 
     516              :    assign sign = offset[12];
     517              : 
     518              : 
     519              :    assign dout[31:13] = ({19{  sign ^~  cout}} &     pc[31:13]) |
     520              :                         ({19{ ~sign &   cout}}  & pc_inc[31:13]) |
     521              :                         ({19{  sign &  ~cout}}  & pc_dec[31:13]);
     522              : 
     523              : 
     524              : endmodule // rvbradder
     525              : 
     526              : 
     527              : // 2s complement circuit
     528              : module rvtwoscomp #( parameter WIDTH=32 )
     529              :    (
     530        16813 :      input logic [WIDTH-1:0] din,
     531              : 
     532        26571 :      output logic [WIDTH-1:0] dout
     533              :      );
     534              : 
     535        27416 :    logic [WIDTH-1:1]          dout_temp;   // holding for all other bits except for the lsb. LSB is always din
     536              : 
     537              :    genvar                     i;
     538              : 
     539              :    for ( i = 1; i < WIDTH; i++ )  begin : flip_after_first_one
     540              :       assign dout_temp[i] = (|din[i-1:0]) ? ~din[i] : din[i];
     541              :    end : flip_after_first_one
     542              : 
     543              :    assign dout[WIDTH-1:0]  = { dout_temp[WIDTH-1:1], din[0] };
     544              : 
     545              : endmodule  // 2'scomp
     546              : 
     547              : // find first
     548              : module rvfindfirst1 #( parameter WIDTH=32, SHIFT=$clog2(WIDTH) )
     549              :    (
     550              :      input logic [WIDTH-1:0] din,
     551              : 
     552              :      output logic [SHIFT-1:0] dout
     553              :      );
     554              :    logic                      done;
     555              : 
     556              :    always_comb begin
     557              :       dout[SHIFT-1:0] = {SHIFT{1'b0}};
     558              :       done    = 1'b0;
     559              : 
     560              :       for ( int i = WIDTH-1; i > 0; i-- )  begin : find_first_one
     561              :          done |= din[i];
     562              :          dout[SHIFT-1:0] += done ? 1'b0 : 1'b1;
     563              :       end : find_first_one
     564              :    end
     565              : endmodule // rvfindfirst1
     566              : 
     567              : module rvfindfirst1hot #( parameter WIDTH=32 )
     568              :    (
     569              :      input logic [WIDTH-1:0] din,
     570              : 
     571              :      output logic [WIDTH-1:0] dout
     572              :      );
     573              :    logic                      done;
     574              : 
     575              :    always_comb begin
     576              :       dout[WIDTH-1:0] = {WIDTH{1'b0}};
     577              :       done    = 1'b0;
     578              :       for ( int i = 0; i < WIDTH; i++ )  begin : find_first_one
     579              :          dout[i] = ~done & din[i];
     580              :          done   |= din[i];
     581              :       end : find_first_one
     582              :    end
     583              : endmodule // rvfindfirst1hot
     584              : 
     585              : // mask and match function matches bits after finding the first 0 position
     586              : // find first starting from LSB. Skip that location and match the rest of the bits
     587              : module rvmaskandmatch #( parameter WIDTH=32 )
     588              :    (
     589         3588 :      input  logic [WIDTH-1:0] mask,     // this will have the mask in the lower bit positions
     590        11560 :      input  logic [WIDTH-1:0] data,     // this is what needs to be matched on the upper bits with the mask's upper bits
     591         1258 :      input  logic             masken,   // when 1 : do mask. 0 : full match
     592        24521 :      output logic             match
     593              :      );
     594              : 
     595         2720 :    logic [WIDTH-1:0]          matchvec;
     596         1258 :    logic                      masken_or_fullmask;
     597              : 
     598              :    assign masken_or_fullmask = masken &  ~(&mask[WIDTH-1:0]);
     599              : 
     600              :    assign matchvec[0]        = masken_or_fullmask | (mask[0] == data[0]);
     601              :    genvar                     i;
     602              : 
     603              :    for ( i = 1; i < WIDTH; i++ )  begin : match_after_first_zero
     604              :       assign matchvec[i] = (&mask[i-1:0] & masken_or_fullmask) ? 1'b1 : (mask[i] == data[i]);
     605              :    end : match_after_first_zero
     606              : 
     607              :    assign match  = &matchvec[WIDTH-1:0];    // all bits either matched or were masked off
     608              : 
     609              : endmodule // rvmaskandmatch
     610              : 
     611              : 
     612              : 
     613              : 
     614              : // Check if the S_ADDR <= addr < E_ADDR
     615              : module rvrangecheck  #(CCM_SADR = 32'h0,
     616              :                        CCM_SIZE  = 128) (
     617      1186893 :    input  logic [31:0]   addr,                             // Address to be checked for range
     618           24 :    output logic          in_range,                            // S_ADDR <= start_addr < E_ADDR
     619       828522 :    output logic          in_region
     620              : );
     621              : 
     622              :    localparam REGION_BITS = 4;
     623              :    localparam MASK_BITS = 10 + $clog2(CCM_SIZE);
     624              : 
     625            0 :    logic [31:0]          start_addr;
     626          708 :    logic [3:0]           region;
     627              : 
     628              :    assign start_addr[31:0]        = CCM_SADR;
     629              :    assign region[REGION_BITS-1:0] = start_addr[31:(32-REGION_BITS)];
     630              : 
     631              :    assign in_region = (addr[31:(32-REGION_BITS)] == region[REGION_BITS-1:0]);
     632              :    if (CCM_SIZE  == 48)
     633              :     assign in_range  = (addr[31:MASK_BITS] == start_addr[31:MASK_BITS]) & ~(&addr[MASK_BITS-1 : MASK_BITS-2]);
     634              :    else
     635              :     assign in_range  = (addr[31:MASK_BITS] == start_addr[31:MASK_BITS]);
     636              : 
     637              : endmodule  // rvrangechecker
     638              : 
     639              : // 16 bit even parity generator
     640              : module rveven_paritygen #(WIDTH = 16)  (
     641              :                                          input  logic [WIDTH-1:0]  data_in,         // Data
     642              :                                          output logic              parity_out       // generated even parity
     643              :                                          );
     644              : 
     645              :    assign  parity_out =  ^(data_in[WIDTH-1:0]) ;
     646              : 
     647              : endmodule  // rveven_paritygen
     648              : 
     649              : module rveven_paritycheck #(WIDTH = 16)  (
     650              :                                            input  logic [WIDTH-1:0]  data_in,         // Data
     651              :                                            input  logic              parity_in,
     652              :                                            output logic              parity_err       // Parity error
     653              :                                            );
     654              : 
     655              :    assign  parity_err =  ^(data_in[WIDTH-1:0]) ^ parity_in ;
     656              : 
     657              : endmodule  // rveven_paritycheck
     658              : 
     659              : module rvecc_encode  (
     660         7586 :                       input [31:0] din,
     661        67488 :                       output [6:0] ecc_out
     662              :                       );
     663        50898 : logic [5:0] ecc_out_temp;
     664              : 
     665              :    assign ecc_out_temp[0] = din[0]^din[1]^din[3]^din[4]^din[6]^din[8]^din[10]^din[11]^din[13]^din[15]^din[17]^din[19]^din[21]^din[23]^din[25]^din[26]^din[28]^din[30];
     666              :    assign ecc_out_temp[1] = din[0]^din[2]^din[3]^din[5]^din[6]^din[9]^din[10]^din[12]^din[13]^din[16]^din[17]^din[20]^din[21]^din[24]^din[25]^din[27]^din[28]^din[31];
     667              :    assign ecc_out_temp[2] = din[1]^din[2]^din[3]^din[7]^din[8]^din[9]^din[10]^din[14]^din[15]^din[16]^din[17]^din[22]^din[23]^din[24]^din[25]^din[29]^din[30]^din[31];
     668              :    assign ecc_out_temp[3] = din[4]^din[5]^din[6]^din[7]^din[8]^din[9]^din[10]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25];
     669              :    assign ecc_out_temp[4] = din[11]^din[12]^din[13]^din[14]^din[15]^din[16]^din[17]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25];
     670              :    assign ecc_out_temp[5] = din[26]^din[27]^din[28]^din[29]^din[30]^din[31];
     671              : 
     672              :    assign ecc_out[6:0] = {(^din[31:0])^(^ecc_out_temp[5:0]),ecc_out_temp[5:0]};
     673              : 
     674              : endmodule // rvecc_encode
     675              : 
     676              : module rvecc_decode  (
     677      2129412 :                       input         en,
     678       505234 :                       input [31:0]  din,
     679       839148 :                       input [6:0]   ecc_in,
     680          678 :                       input         sed_ded,    // only do detection and no correction. Used for the I$
     681       505234 :                       output [31:0] dout,
     682       839148 :                       output [6:0]  ecc_out,
     683           12 :                       output        single_ecc_error,
     684            8 :                       output        double_ecc_error
     685              : 
     686              :                       );
     687              : 
     688         1140 :    logic [6:0]                      ecc_check;
     689            0 :    logic [38:0]                     error_mask;
     690      1008877 :    logic [38:0]                     din_plus_parity, dout_plus_parity;
     691              : 
     692              :    // Generate the ecc bits
     693              :    assign ecc_check[0] = ecc_in[0]^din[0]^din[1]^din[3]^din[4]^din[6]^din[8]^din[10]^din[11]^din[13]^din[15]^din[17]^din[19]^din[21]^din[23]^din[25]^din[26]^din[28]^din[30];
     694              :    assign ecc_check[1] = ecc_in[1]^din[0]^din[2]^din[3]^din[5]^din[6]^din[9]^din[10]^din[12]^din[13]^din[16]^din[17]^din[20]^din[21]^din[24]^din[25]^din[27]^din[28]^din[31];
     695              :    assign ecc_check[2] = ecc_in[2]^din[1]^din[2]^din[3]^din[7]^din[8]^din[9]^din[10]^din[14]^din[15]^din[16]^din[17]^din[22]^din[23]^din[24]^din[25]^din[29]^din[30]^din[31];
     696              :    assign ecc_check[3] = ecc_in[3]^din[4]^din[5]^din[6]^din[7]^din[8]^din[9]^din[10]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25];
     697              :    assign ecc_check[4] = ecc_in[4]^din[11]^din[12]^din[13]^din[14]^din[15]^din[16]^din[17]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25];
     698              :    assign ecc_check[5] = ecc_in[5]^din[26]^din[27]^din[28]^din[29]^din[30]^din[31];
     699              : 
     700              :    // This is the parity bit
     701              :    assign ecc_check[6] = ((^din[31:0])^(^ecc_in[6:0])) & ~sed_ded;
     702              : 
     703              :    assign single_ecc_error = en & (ecc_check[6:0] != 0) & ecc_check[6];   // this will never be on for sed_ded
     704              :    assign double_ecc_error = en & (ecc_check[6:0] != 0) & ~ecc_check[6];  // all errors in the sed_ded case will be recorded as DE
     705              : 
     706              :    // Generate the mask for error correctiong
     707              :    for (genvar i=1; i<40; i++) begin
     708              :       assign error_mask[i-1] = (ecc_check[5:0] == i);
     709              :    end
     710              : 
     711              :    // Generate the corrected data
     712              :    assign din_plus_parity[38:0] = {ecc_in[6], din[31:26], ecc_in[5], din[25:11], ecc_in[4], din[10:4], ecc_in[3], din[3:1], ecc_in[2], din[0], ecc_in[1:0]};
     713              : 
     714              :    assign dout_plus_parity[38:0] = single_ecc_error ? (error_mask[38:0] ^ din_plus_parity[38:0]) : din_plus_parity[38:0];
     715              :    assign dout[31:0]             = {dout_plus_parity[37:32], dout_plus_parity[30:16], dout_plus_parity[14:8], dout_plus_parity[6:4], dout_plus_parity[2]};
     716              :    assign ecc_out[6:0]           = {(dout_plus_parity[38] ^ (ecc_check[6:0] == 7'b1000000)), dout_plus_parity[31], dout_plus_parity[15], dout_plus_parity[7], dout_plus_parity[3], dout_plus_parity[1:0]};
     717              : 
     718              : endmodule // rvecc_decode
     719              : 
     720              : module rvecc_encode_64  (
     721      2036643 :                       input [63:0] din,
     722      4241097 :                       output [6:0] ecc_out
     723              :                       );
     724              :   assign ecc_out[0] = din[0]^din[1]^din[3]^din[4]^din[6]^din[8]^din[10]^din[11]^din[13]^din[15]^din[17]^din[19]^din[21]^din[23]^din[25]^din[26]^din[28]^din[30]^din[32]^din[34]^din[36]^din[38]^din[40]^din[42]^din[44]^din[46]^din[48]^din[50]^din[52]^din[54]^din[56]^din[57]^din[59]^din[61]^din[63];
     725              : 
     726              :    assign ecc_out[1] = din[0]^din[2]^din[3]^din[5]^din[6]^din[9]^din[10]^din[12]^din[13]^din[16]^din[17]^din[20]^din[21]^din[24]^din[25]^din[27]^din[28]^din[31]^din[32]^din[35]^din[36]^din[39]^din[40]^din[43]^din[44]^din[47]^din[48]^din[51]^din[52]^din[55]^din[56]^din[58]^din[59]^din[62]^din[63];
     727              : 
     728              :    assign ecc_out[2] = din[1]^din[2]^din[3]^din[7]^din[8]^din[9]^din[10]^din[14]^din[15]^din[16]^din[17]^din[22]^din[23]^din[24]^din[25]^din[29]^din[30]^din[31]^din[32]^din[37]^din[38]^din[39]^din[40]^din[45]^din[46]^din[47]^din[48]^din[53]^din[54]^din[55]^din[56]^din[60]^din[61]^din[62]^din[63];
     729              : 
     730              :    assign ecc_out[3] = din[4]^din[5]^din[6]^din[7]^din[8]^din[9]^din[10]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25]^din[33]^din[34]^din[35]^din[36]^din[37]^din[38]^din[39]^din[40]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     731              : 
     732              :    assign ecc_out[4] = din[11]^din[12]^din[13]^din[14]^din[15]^din[16]^din[17]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25]^din[41]^din[42]^din[43]^din[44]^din[45]^din[46]^din[47]^din[48]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     733              : 
     734              :    assign ecc_out[5] = din[26]^din[27]^din[28]^din[29]^din[30]^din[31]^din[32]^din[33]^din[34]^din[35]^din[36]^din[37]^din[38]^din[39]^din[40]^din[41]^din[42]^din[43]^din[44]^din[45]^din[46]^din[47]^din[48]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     735              : 
     736              :    assign ecc_out[6] = din[57]^din[58]^din[59]^din[60]^din[61]^din[62]^din[63];
     737              : 
     738              : endmodule // rvecc_encode_64
     739              : 
     740              : 
     741              : module rvecc_decode_64  (
     742      2666063 :                       input         en,
     743       448417 :                       input [63:0]  din,
     744      1167086 :                       input [6:0]   ecc_in,
     745            0 :                       output        ecc_error
     746              :                       );
     747              : 
     748            0 :    logic [6:0]                      ecc_check;
     749              : 
     750              :    // Generate the ecc bits
     751              :    assign ecc_check[0] = ecc_in[0]^din[0]^din[1]^din[3]^din[4]^din[6]^din[8]^din[10]^din[11]^din[13]^din[15]^din[17]^din[19]^din[21]^din[23]^din[25]^din[26]^din[28]^din[30]^din[32]^din[34]^din[36]^din[38]^din[40]^din[42]^din[44]^din[46]^din[48]^din[50]^din[52]^din[54]^din[56]^din[57]^din[59]^din[61]^din[63];
     752              : 
     753              :    assign ecc_check[1] = ecc_in[1]^din[0]^din[2]^din[3]^din[5]^din[6]^din[9]^din[10]^din[12]^din[13]^din[16]^din[17]^din[20]^din[21]^din[24]^din[25]^din[27]^din[28]^din[31]^din[32]^din[35]^din[36]^din[39]^din[40]^din[43]^din[44]^din[47]^din[48]^din[51]^din[52]^din[55]^din[56]^din[58]^din[59]^din[62]^din[63];
     754              : 
     755              :    assign ecc_check[2] = ecc_in[2]^din[1]^din[2]^din[3]^din[7]^din[8]^din[9]^din[10]^din[14]^din[15]^din[16]^din[17]^din[22]^din[23]^din[24]^din[25]^din[29]^din[30]^din[31]^din[32]^din[37]^din[38]^din[39]^din[40]^din[45]^din[46]^din[47]^din[48]^din[53]^din[54]^din[55]^din[56]^din[60]^din[61]^din[62]^din[63];
     756              : 
     757              :    assign ecc_check[3] = ecc_in[3]^din[4]^din[5]^din[6]^din[7]^din[8]^din[9]^din[10]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25]^din[33]^din[34]^din[35]^din[36]^din[37]^din[38]^din[39]^din[40]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     758              : 
     759              :    assign ecc_check[4] = ecc_in[4]^din[11]^din[12]^din[13]^din[14]^din[15]^din[16]^din[17]^din[18]^din[19]^din[20]^din[21]^din[22]^din[23]^din[24]^din[25]^din[41]^din[42]^din[43]^din[44]^din[45]^din[46]^din[47]^din[48]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     760              : 
     761              :    assign ecc_check[5] = ecc_in[5]^din[26]^din[27]^din[28]^din[29]^din[30]^din[31]^din[32]^din[33]^din[34]^din[35]^din[36]^din[37]^din[38]^din[39]^din[40]^din[41]^din[42]^din[43]^din[44]^din[45]^din[46]^din[47]^din[48]^din[49]^din[50]^din[51]^din[52]^din[53]^din[54]^din[55]^din[56];
     762              : 
     763              :    assign ecc_check[6] = ecc_in[6]^din[57]^din[58]^din[59]^din[60]^din[61]^din[62]^din[63];
     764              : 
     765              :    assign ecc_error = en & (ecc_check[6:0] != 0);  // all errors in the sed_ded case will be recorded as DE
     766              : 
     767              :  endmodule // rvecc_decode_64
     768              : 
     769              : `ifndef TECH_SPECIFIC_EC_RV_ICG
     770              : module `TEC_RV_ICG
     771              :   (
     772       101426 :    input logic SE, EN, CK,
     773      1021173 :    output Q
     774              :    );
     775              : 
     776        98075 :    logic  en_ff;
     777       101075 :    logic  enable;
     778              : 
     779              :    assign      enable = EN | SE;
     780              : 
     781          250 :    always @(CK, enable) begin
     782      2158198 :       if(!CK)
     783      2158263 :         en_ff = enable;
     784              :    end
     785              :    assign Q = CK & en_ff;
     786              : 
     787              : endmodule
     788              : `endif
     789              : 
     790              : `ifndef RV_FPGA_OPTIMIZE
     791              : module rvclkhdr
     792              :   (
     793        18367 :    input  logic en,
     794      1559117 :    input  logic clk,
     795              :    // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     796              :    /*verilator coverage_off*/
     797              :    input  logic scan_mode,
     798              :    /*verilator coverage_on*/
     799       900039 :    output logic l1clk
     800              :    );
     801              : 
     802            0 :    logic   SE;
     803              :    assign       SE = 0;
     804              : 
     805              : `ifdef TECH_SPECIFIC_EC_RV_ICG
     806              :    `USER_EC_RV_ICG clkhdr ( .*, .EN(en), .CK(clk), .Q(l1clk));
     807              : `else
     808              :    `TEC_RV_ICG clkhdr ( .*, .EN(en), .CK(clk), .Q(l1clk));
     809              : `endif
     810              : 
     811              : endmodule // rvclkhdr
     812              : `endif
     813              : 
     814              : module rvoclkhdr
     815              :   (
     816     26732256 :    input  logic en,
     817   1886292700 :    input  logic clk,
     818              :    // Excluding scan_mode from coverage as its usage is determined by the integrator of the VeeR core.
     819              :    /*verilator coverage_off*/
     820              :    input  logic scan_mode,
     821              :    /*verilator coverage_on*/
     822   1885816389 :    output logic l1clk
     823              :    );
     824              : 
     825            0 :    logic   SE;
     826              :    assign       SE = 0;
     827              : 
     828              : `ifdef RV_FPGA_OPTIMIZE
     829              :    assign l1clk = clk;
     830              : `else
     831              :    `ifdef TECH_SPECIFIC_EC_RV_ICG
     832              :       `USER_EC_RV_ICG clkhdr ( .*, .EN(en), .CK(clk), .Q(l1clk));
     833              :    `else
     834              :       `TEC_RV_ICG clkhdr ( .*, .EN(en), .CK(clk), .Q(l1clk));
     835              :     `endif
     836              : `endif
     837              : 
     838              : endmodule
     839              : 
     840              : 
     841              :