In Specman, how can I tell if a reference to a unit has the do-not-generate modifier in front of it? - verification

Question

In Specman, how can I tell if a reference to a unit has the do-not-generate modifier, '!', at the reference's definition?
e.g.
unit foo_u {
};
extend sys {
foo : foo_u is instance;
foo_ptr_generated : foo_u;
keep foo_ptr_generated == foo;
!foo_ptr_notgenerated : foo_u;
connect_pointers() is also {
foo_ptr_notgenerated = foo;
};
};
Without inspecting the code or relying on a naming convention, how can I tell that foo_ptr_generated went through Specman's constraint solver and foo_ptr_notgenerated was procedurally set?

Answer 1

Finally figured this out. This code will determine which references are generated and which aren't in Specman 6 via the reflection interface:
<'
type my_t : [ A,B,C];
unit foo_u {
sub_typiness : my_t;
other_sub_typiness : my_t;
when A'sub_typiness foo_u {
!bar_ptr : bar_u;
};
when B'other_sub_typiness foo_u {
in_b_sub_type : int;
};
when A'sub_typiness B'other_sub_typiness foo_u {
in_a_b_subtype :int;
};
b : bah_u is instance;
};
unit bar_u {
sub_typiness : my_t;
other_sub_typiness :my_t;
when B'sub_typiness bar_u {
!foo_ptr : foo_u;
};
when C'other_sub_typiness bar_u {
inc_sub_type : int;
};
when A'other_sub_typiness bar_u {
!you_shouldnt_see_this_field : bah_u;
};
when B'sub_typiness C'other_sub_typiness bar_u{
in_b_c_subtype :int;
};
!b : bah_u;
b2 : bah_u;
};
unit bah_u {
};
extend any_unit {
!path_to_parent :string;
!my_e_path : string;
post_generate() is also {
if not me is a sys {
path_to_parent = get_parent_unit().e_path();
};
my_e_path = e_path();
};
print_pointers() is {
for each ( wf ) in rf_manager.get_struct_of_instance(me).as_a(rf_like_struct).sd_.all_when_fields {
if not str_match(wf.name,"/___/"){
};
};
for each (sub_unit) in get_all_units(any_unit) {
sub_unit.print_pointers();
};
};
};
struct wank_s {
oh_joy: int;
};
extend sys {
foo : A'sub_typiness B'other_sub_typiness foo_u is instance;
bar : B'sub_typiness C'other_sub_typiness bar_u is instance;
keep bar.b2 == foo.b;
wank : wank_s;
connect_pointers() is also {
foo.bar_ptr = bar;
bar.foo_ptr = foo;
bar.b = foo.b;
};
!possible_ptr : any_unit;
!is_a_unit : bool;
!an_e_path : string;
!a_unit : any_unit;
!a_field : field;
--
-- rf_manager.get_all_unit_instances
my_specman( cmd : string ) : bool is {
try {
--out(cmd);
specman(cmd);
} else {
return FALSE;
};
return TRUE;
};
check_generation() is also {
out("PRINT OUT FIELDS");
var all_units : list of any_unit;
for each any_unit(u) in get_all_units(any_unit) {
for each ( wf ) in rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.all_when_fields {
--print wf.source_ref;
--print wf.source_ref.to_string().as_a(uint);
--if wf.source_ref.to_string().as_a(uint) > 1000 and not str_match(wf.name,"/___/"){
if not str_match(wf.name,"/___|driver_trans/"){
an_e_path = append(u.e_path(),".",wf.name);
an_e_path = append(an_e_path, " - marked_as_reachable=",wf.fgi.marked_as_reachable);
if wf.base_type is a struct_descriptor (s){
an_e_path = append(an_e_path, " - instantiated == ", s.instantiated);
};
if wf.base_type is a struct_descriptor (s) and not s is a list_descriptor and not s is a long_descriptor {
sys.is_a_unit = FALSE;
if not my_specman(append("sys.is_a_unit = ( ",u.e_path(),".",wf.name,
" != NULL)")) {
sys.is_a_unit = FALSE;
};
if sys.is_a_unit {
if not my_specman(append(" sys.is_a_unit = (",u.e_path(),".",wf.name,
".as_a(any_struct) == ",u.e_path(),".",wf.name,".get_enclosing_unit(any_unit).as_a(any_struct))")) {
sys.is_a_unit = FALSE;
};
};
if sys.is_a_unit and str_match(wf.name,"/([\w_]+'+[\w_']*)[\w_]+/") {
if not my_specman( append( "sys.is_a_unit = ( ",u.e_path(),
" is a ", $1, " ",
rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.name,
")")) {
sys.is_a_unit = FALSE;
};
};
if is_a_unit {
sys.a_unit = NULL;
if not my_specman(append("sys.a_unit = (",u.e_path(),".",wf.name,
".as_a(any_unit))")) {
sys.a_unit = NULL;
};
if sys.a_unit != NULL {
sys.an_e_path = NULL;
var printout := append(":: ",u.e_path(), ".", wf.name);
compute my_specman(append( "sys.an_e_path = ",u.e_path(),".",wf.name,
".my_e_path"));
if append(u.e_path(),".",wf.name) != sys.an_e_path {
printout = append(printout, " -> ");
printout = append(printout, sys.an_e_path);
if wf.fgi != NULL and wf.fgi.gcs.size() > 0 and (
wf.fgi.gcs[0].last_reduction != UNDEF or
wf.fgi.gcs[0].gcois.size() > 0 ) {
printout = append(printout, " GENERATED POINTER");
};
};
out(printout);
};
};
};
--out( " ",an_e_path);
--specman(append("print ",u.e_path(),".",wf.name));
};
};
--for each ( m ) in rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.methods {
-- if m != NULL {
-- out(m.md.name);
-- };
--};
--print u.get_all_attribute_names();
--print u.get_attribute("agent");
--print u.agent_kind();
-- for each (m) in rf_manager.get_struct_of_instance(u).get_declared_methods() {
-- print m;
-- };
-- out("fields at '",u.e_path(),"'s struct level:");
-- for each (f) in rf_manager.get_struct_of_instance(u).get_declared_fields() {
-- out( " ",u.e_path()," -> ",f.f_.short_name);
-- };
-- out("fields at '",u.e_path(),"'s exact sub-type level:");
-- for each (f) in rf_manager.get_exact_subtype_of_instance(u).get_declared_fields() {
-- out( " ",u.e_path()," -> ",f.f_.short_name);
-- };
-- out("");
};
-- out("\nPRINT OUT UNIT INSTANCES");
-- for each any_unit(u) in {sys;foo;bar} {
-- for each (i) in rf_manager.get_all_unit_instances(u) {
-- if i != u {
-- out(u.e_path(), " has unit ", i.e_path());
-- };
-- };
-- };
};
};
'>
Running with:
specman -c 'load rf_test.e; gen'
Produces:
Generating the test using seed 1...
PRINT OUT FIELDS
:: sys.bar.B'sub_typiness'foo_ptr -> sys.foo
:: sys.bar.b -> sys.foo.b
:: sys.bar.b2 -> sys.foo.b GENERATED POINTER
:: sys.foo.A'sub_typiness'bar_ptr -> sys.bar
:: sys.foo.b
:: sys.logger.base_unit -> sys
:: sys.logger
:: sys.foo
:: sys.bar
Starting the test ...
Running the test ...