How is the conditions in an illegal_bin declaration interpreted?

How are the conditions in an illegal_bin declaration handled? Or are they valid at all in the first place?

It looks to me that the illegal_bindeclaration does not consider any condition in the bins coverpoint_range_list i.e. the declaration

illegal_bins invalid_1 = {[0:7]} iff (base == 1600 && basediv == 2);

is same as

illegal_bins invalid_1 = {[0:7]};

The intention of the illegal_bin is that whenever base is 1600 and basediv is 2, any value inside [0:7] of the coverpoint expression is not a valid value.

Is there a way to code illegal_bins with conditions other than using the cross and binsof … intersect way ?

Below is the sample code.

class base_cfg;

  // Divider Values
  rand struct {
    rand bit [ 1: 0] BaseDiv1;
    rand bit [ 2: 0] BaseDiv2;
    rand bit         BaseDiv3;
    rand bit         BaseDiv4;
  } s_basediv;

  rand int BaseVal;


  constraint c_BaseX {
    BaseVal inside {1600, 1400, 1200, 1000, 800};
  }

  constraint c_basediv {
    s_basediv.BaseDiv1      inside {[0: 3]};
    s_basediv.BaseDiv2      inside {[0: 7]};
    s_basediv.BaseDiv3      inside {[0: 1]};
    s_basediv.BaseDiv4      inside {[0: 1]};


    if (BaseVal == 1600) { s_basediv.BaseDiv1 inside {[0:3]}; }
    if (BaseVal == 1400) { s_basediv.BaseDiv1 inside {[0:2]}; }
    if (BaseVal == 1200) { s_basediv.BaseDiv1 inside {[0:2]}; }
    if (BaseVal == 1000) { s_basediv.BaseDiv1 inside {[0:2]}; }
    if (BaseVal == 800 ) { s_basediv.BaseDiv1 inside {[0:2]}; }

    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv2 inside {[0:3]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv2 inside {[0:1]}; }

    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv2 inside {[0:6]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv2 inside {[0:2]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv2 inside {[0:6]}; }

    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv2 inside {[0:5]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv2 inside {[0:2]}; }

    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv2 inside {[0:4]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv2 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv2 inside {[0:7]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv2 inside {[0:3]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv2 inside {[0:1]}; }

    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv3 inside {[0:0]}; }

    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv3 inside {[0:1]}; }

    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv3 inside {[0:1]}; }

    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv3 inside {[0:0]}; }

    if (BaseVal == 800  && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv3 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv3 inside {[0:0]}; }

    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv4 inside {[1:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1600 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv4 inside {[0:1]}; }

    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv4 inside {[1:1]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1400 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv4 inside {[0:0]}; }

    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv4 inside {[1:1]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1200 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv4 inside {[0:0]}; }

    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv4 inside {[1:1]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 1000 && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv4 inside {[0:0]}; }

    if (BaseVal == 800  && s_basediv.BaseDiv1 == 0) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 1) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 2) { s_basediv.BaseDiv4 inside {[0:1]}; }
    if (BaseVal == 800  && s_basediv.BaseDiv1 == 3) { s_basediv.BaseDiv4 inside {[0:0]}; }

  }


  function void post_randomize();
    $display($psprintf("BaseVal     = %d", BaseVal));
    $display($psprintf("BaseDiv1    = %d", s_basediv.BaseDiv1));
    $display($psprintf("BaseDiv2    = %d", s_basediv.BaseDiv2));
    $display($psprintf("BaseDiv3    = %d", s_basediv.BaseDiv3));
    $display($psprintf("BaseDiv4    = %d", s_basediv.BaseDiv4));
    $display($psprintf("----------------------------------"));
  endfunction: post_randomize

endclass: base_cfg

class base_cov;


  covergroup base_cg (string name, ref base_cfg   p_base_cfg);

    option.per_instance = 1;
    option.name         = name;
    option.comment      = $sformatf("covergroup for covering ccr clocks");

    BaseVal_cp:      coverpoint p_base_cfg.BaseVal {
                       bins valid[]     = { 1600, 1400, 1200, 1000, 800 };
                       bins default_val = default;
                     }


    BaseDiv1_cp:     coverpoint p_base_cfg.s_basediv.BaseDiv1  {
                        bins valid[] = {[0:3]};
                      }  


    BaseDiv2_cp:     coverpoint p_base_cfg.s_basediv.BaseDiv2 {
                       bins valid_1600_0[] = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1600_1[] = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1600_2[] = {[0:7]} with ( (item inside {[0:3]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1600_3[] = {[0:7]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1400_0[] = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1400_1[] = {[0:7]} with ( (item inside {[0:6]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1400_2[] = {[0:7]} with ( (item inside {[0:2]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1400_3[] = {[0:7]} with ( (item inside {[0:6]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1200_0[] = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1200_1[] = {[0:7]} with ( (item inside {[0:5]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1200_2[] = {[0:7]} with ( (item inside {[0:2]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       bins valid_1000_0[] = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1000_1[] = {[0:7]} with ( (item inside {[0:4]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1000_2[] = {[0:7]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       bins valid_800_0[]  = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_800_1[]  = {[0:7]} with ( (item inside {[0:3]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_800_2[]  = {[0:7]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       illegal_bins invalid_1600_2 = {[0:7]} with ( (item inside {[4:7]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_1600_3 = {[0:7]} with ( (item inside {[2:7]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1400_1 = {[0:7]} with ( (item inside {[7:7]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       illegal_bins invalid_1400_2 = {[0:7]} with ( (item inside {[3:7]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_1400_3 = {[0:7]} with ( (item inside {[7:7]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1200_1 = {[0:7]} with ( (item inside {[6:7]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       illegal_bins invalid_1200_2 = {[0:7]} with ( (item inside {[3:7]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_1200_3 = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1000_1 = {[0:7]} with ( (item inside {[5:7]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       illegal_bins invalid_1000_2 = {[0:7]} with ( (item inside {[2:7]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_1000_3 = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_800_1  = {[0:7]} with ( (item inside {[4:7]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       illegal_bins invalid_800_2  = {[0:7]} with ( (item inside {[2:7]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_800_3  = {[0:7]} with ( (item inside {[0:7]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 3);
                     }

    BaseDiv3_cp:     coverpoint p_base_cfg.s_basediv.BaseDiv3 {
                       bins valid_1600_0[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1600_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1600_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1600_3[] = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1400_0[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1400_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1400_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       bins valid_1200_0[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1200_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1200_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       bins valid_1000_0[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1000_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1000_2[] = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       bins valid_800_0[]  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_800_1[]  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_800_2[]  = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 2);

                       illegal_bins invalid_1600_0 = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1400_1 = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1200_2 = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1000_2 = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_1000_3 = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_800_2  = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       illegal_bins invalid_800_3  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 3);
                     }

    BaseDiv4_cp:     coverpoint p_base_cfg.s_basediv.BaseDiv4 {
                       bins valid_1600_0[] = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1600_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1600_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1600_3[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1400_0[] = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1400_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1400_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1400_3[] = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1200_0[] = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1200_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1200_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1200_3[] = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_1000_0[] = {[0:1]} with ( (item inside {[1:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_1000_1[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_1000_2[] = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_1000_3[] = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       bins valid_800_0[]  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       bins valid_800_1[]  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 1);
                       bins valid_800_2[]  = {[0:1]} with ( (item inside {[0:1]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 2);
                       bins valid_800_3[]  = {[0:1]} with ( (item inside {[0:0]}) ) iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1600_0 = {[0:0]} iff (p_base_cfg.BaseVal == 1600 && p_base_cfg.s_basediv.BaseDiv1 == 0);

                       illegal_bins invalid_1400_3 = {[1:1]} iff (p_base_cfg.BaseVal == 1400 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1200_0 = {[0:0]} iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       illegal_bins invalid_1200_3 = {[1:1]} iff (p_base_cfg.BaseVal == 1200 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_1000_0 = {[0:0]} iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 0);
                       illegal_bins invalid_1000_3 = {[1:1]} iff (p_base_cfg.BaseVal == 1000 && p_base_cfg.s_basediv.BaseDiv1 == 3);

                       illegal_bins invalid_800_3  = {[1:1]} iff (p_base_cfg.BaseVal == 800  && p_base_cfg.s_basediv.BaseDiv1 == 3);
                     }
  endgroup: base_cg

  function new (ref base_cfg base_cfg_h);
    base_cg  = new($sformatf("base_cg"), base_cfg_h);
  endfunction: new 

endclass: base_cov

class base_env;
  rand base_cfg m_base_cfg;
  base_cov m_base_cov;

  function new ();
    m_base_cfg = new();
    m_base_cov = new(m_base_cfg);
  endfunction: new 

endclass: base_env

module top;

  base_env env;

  initial begin
    int count;
    env = new();
    for (int i=0; i<4; i++) begin
      for (int j=0; j<8; j++) begin
        $display("\n\ncount = %0d, i = %0d, j = %0d", count, i, j);
        $display($psprintf(".................................."));
        if (!env.randomize() with {m_base_cfg.s_basediv.BaseDiv1 == i;}) begin
          $error("env.randomize() with {m_base_cfg.s_basediv.BaseDiv1 == %0d;}", i);
        end
        #1;
        env.m_base_cov.base_cg.sample();
        #1;
        count ++;
      end
    end
  end

endmodule: top

In reply to vvs3693:

According to LRM following should work:
illegal_bins invalid_1 = {[0:7]} iff (base == 1600 && basediv == 2);

The better fit for this problem seems to be with. Have you tried following?
illegal_bins invalid_1 = {[0:7]} with (base == 1600 && basediv == 2);