32 #include "pips_config.h"
48 #include "resources.h"
67 return strdup(
" Declared by Pass Outlining\n");
72 return strdup(
" Declared as a patch variable by Pass Outlining\n");
75 #define STAT_ORDER "PRETTYPRINT_STATEMENT_NUMBER"
191 struct cpv p = { .
e=
e, .rm=
false };
213 size_t nb_dims = ctxt->
nb_dims;
253 list referenced_entities =
NIL;
279 set_union(sreferenced_entities,tmp,sreferenced_entities);
283 referenced_entities=
set_to_list(sreferenced_entities);
285 return referenced_entities;
303 list the_constant_indices =
NIL;
345 the_constant_indices=constant_indices=
NIL;
348 else if(
ENDP(the_constant_indices) )
350 the_constant_indices=constant_indices;
361 if(!
ENDP(the_constant_indices))
363 size_t nb_constant_indices =
gen_length(the_constant_indices);
365 size_t nb_dimensions =
gen_length(entity_dimensions);
369 size_t count_dims = 0;
370 for(
list iter = entity_dimensions;!
ENDP(iter);
POP(iter))
412 hash_put(entity_to_init,new_entity,effective_parameter);
418 return entity_to_init;
463 hash_put(entity_to_effective_parameter,holder,
572 declared_entities=
gen_nconc(declared_entities,localized);
617 referenced_entities=tmp_list;
626 return referenced_entities;
637 bool is_struct =
false;
700 list *effective_parameters_,
list *formal_parameters_)
706 list effective_parameters = *effective_parameters_;
707 list formal_parameters = *formal_parameters_;
765 effective_parameters=
CONS(
EXPRESSION,effective_parameter,effective_parameters);
774 *effective_parameters_=
gen_nreverse(effective_parameters);
812 list iter = effective_parameters;
813 list riter = referenced_entities;
826 bool entity_written=
false;
835 entity_written|=write_p;
927 char * the_cu = NULL,*iter, *cun;
928 if((iter=strchr(outline_module_name,
FILE_SEP))) {
929 the_cu =
strndup(outline_module_name,iter-outline_module_name);
931 else the_cu =
strdup(outline_module_name);
1071 char * the_cu = NULL,*iter;
1122 asprintf(&finit_name,
"%s/%s" ,dir_name, init_name);
1169 for (i = 1; i <= nparams; i++) {
1187 char * the_cu = NULL,*iter;
1188 if((iter=strchr(outline_module_name,
FILE_SEP))) {
1189 the_cu =
strndup(outline_module_name,iter-outline_module_name);
1191 else the_cu =
strdup(outline_module_name);
1252 new_stmt=old_statement;
1276 printf(
"formal parameter \n");
1278 printf(
"induction var\n");
1295 printf(
"effective parameter \n");
1297 printf(
"induction var\n");
1329 pips_assert(
"there are some statements to outline",!
ENDP(statements_to_outline));
1344 list referenced_entities =
outliner_scan(new_fun, statements_to_outline, new_body);
1347 list effective_parameters =
NIL;
1349 outliner_parameters(new_fun, new_body, referenced_entities, entity_to_effective_parameter, &effective_parameters, &formal_parameters);
1354 outliner_patch_parameters(statements_to_outline, referenced_entities, effective_parameters, formal_parameters, new_body, new_body, new_body);
1400 char * omn=
strdup(outline_module_name);
1406 if(
ENDP(statements_to_outline)) {
1422 (void)
outliner(omn,statements_to_outline);
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
dummy make_dummy_identifier(entity _field_)
call make_call(entity a1, list a2)
value make_value_unknown(void)
basic make_basic_derived(entity _field_)
parameter make_parameter(type a1, mode a2, dummy a3)
syntax make_syntax_call(call _field_)
expression make_expression(syntax a1, normalized a2)
type make_type_union(list _field_)
subscript make_subscript(expression a1, list a2)
type make_type_variable(variable _field_)
void free_entity(entity p)
mode make_mode_reference(void)
type copy_type(type p)
TYPE.
basic copy_basic(basic p)
BASIC.
void free_callees(callees p)
type make_type_struct(list _field_)
basic make_basic_int(intptr_t _field_)
basic make_basic_pointer(type _field_)
statement copy_statement(statement p)
STATEMENT.
reference make_reference(entity a1, list a2)
void free_extensions(extensions p)
language copy_language(language p)
LANGUAGE.
dimension make_dimension(expression a1, expression a2, list a3)
variable make_variable(basic a1, list a2, list a3)
instruction make_instruction_call(call _field_)
value copy_value(value p)
VALUE.
storage make_storage_formal(formal _field_)
void free_instruction(instruction p)
storage copy_storage(storage p)
STORAGE.
mode make_mode_value(void)
void free_statement(statement p)
syntax make_syntax_subscript(subscript _field_)
formal make_formal(entity a1, intptr_t a2)
bool db_resource_required_or_available_p(const char *rname, const char *oname)
from now on we must not know about the database internals?
bool db_touch_resource(const char *rname, const char *oname)
touch logical time for resource[owner], possibly behind the back of pipsdbm.
void db_delete_resource(const char *rname, const char *oname)
Delete a resource.
struct paramStruct params
void get_variables_to_remove(list, statement, list *)
misc.c
bool has_entity_with_same_name(entity, list)
inlining.c
static statement module_statement
struct _newgen_struct_expression_ * expression
bdt base
Current expression.
bool compilation_unit_parser(const char *module_name)
callees compute_callees(const statement stat)
Recompute the callees of a module statement.
struct _newgen_struct_statement_ * statement
#define contrainte_succ(c)
#define contrainte_vecteur(c)
passage au champ vecteur d'une contrainte "a la Newgen"
bool controlizer(const char *)
The old controlizer user interface.
string compilation_unit_of_module(const char *)
The output is undefined if the module is referenced but not defined in the workspace,...
int dummy
A dummy file, to prevent empty libraries from breaking builds.
#define region_any_reference(reg)
To be avoided.
#define region_action(reg)
#define region_system(reg)
void set_rw_effects(statement_effects)
void set_cumulated_rw_effects(statement_effects)
void store_cumulated_rw_effects_list(statement, list)
list load_rw_effects_list(statement)
bool find_write_effect_on_entity(statement, entity)
void reset_cumulated_rw_effects(void)
void reset_rw_effects(void)
#define action_write_p(x)
bool empty_string_p(const char *s)
const char * module_name(const char *s)
Return the module part of an entity name.
void cleanup_subscripts(void *)
FILE * safe_fopen(const char *filename, const char *what)
char * get_string_property(const char *)
int safe_fclose(FILE *stream, const char *filename)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#define gen_chunk_undefined_p(c)
#define gen_context_recurse(start, ctxt, domain_number, flt, rwt)
void gen_full_free_list(list l)
statement make_block_statement(list)
Make a block statement from a list of statement.
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
const char * get_current_module_name(void)
Get the name of the current module.
statement set_current_module_statement(statement)
Set the current module statement.
statement get_current_module_statement(void)
Get the current module statement.
entity set_current_module_entity(entity)
static.c
entity get_current_module_entity(void)
Get the entity of the current module.
void replace_entity(void *s, entity old, entity new)
per variable version of replace_entities.
void gen_recurse_stop(void *obj)
Tells the recursion not to go in this object.
void gen_context_multi_recurse(void *o, void *context,...)
Multi-recursion with context function visitor.
gen_chunk * gen_get_ancestor(int, const void *)
return the first ancestor object found of the given type.
bool gen_true2(__attribute__((unused)) gen_chunk *u1, __attribute__((unused)) void *u2)
void gen_null(__attribute__((unused)) void *unused)
Ignore the argument.
bool gen_true(__attribute__((unused)) gen_chunk *unused)
Return true and ignore the argument.
instruction make_continue_instruction()
Creates a CONTINUE instruction, that is the FORTRAN nop, the ";" in C or the "pass" in Python for exa...
void clean_enclosing_loops(void)
statement_mapping loops_mapping_of_statement(statement stat)
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
void gen_remove(list *cpp, const void *o)
remove all occurences of item o from list *cpp, which is thus modified.
#define POP(l)
Modify a list pointer to point on the next element of the list.
void gen_remove_once(list *pl, const void *o)
Remove the first occurence of o in list pl:
#define NIL
The empty list (nil in Lisp)
list gen_copy_seq(list l)
Copy a list structure.
size_t gen_length(const list l)
void gen_list_and_not(list *a, const list b)
Compute A = A inter non B:
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
void * gen_find_eq(const void *item, const list seq)
list gen_append(list l1, const list l2)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
void gen_sort_list(list l, gen_cmp_func_t compare)
Sorts a list of gen_chunks in place, to avoid allocations...
bool gen_equals(const list l0, const list l1, gen_eq_func_t equals)
compares two lists using the functor given in parameters returns true if for all n,...
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
#define DB_PUT_MEMORY_RESOURCE(res_name, own_name, res_val)
conform to old interface.
loop statement_loop(statement)
Get the loop of a statement.
bool statement_loop_p(statement)
statement make_assign_statement(expression, expression)
list statements_to_declarations(list)
Returns the declarations contained in a list of statement.
list statement_to_declarations(void *)
Get a list of all variables declared recursively within a statement.
list find_statements_with_pragma(statement, const char *)
Get a list of statements with pragma begining with a prefix.
void pop_generated_variable_commenter(void)
void insert_statement(statement, statement, bool)
This is the normal entry point.
statement make_return_statement(entity)
statement add_declaration_statement(statement, entity)
statement find_statement_from_label_name(statement, const char *, const char *)
void push_generated_variable_commenter(string(*)(entity))
hash_table hash_table_make(hash_key_type key_type, size_t size)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_put(hash_table htp, const void *key, const void *val)
This functions stores a couple (key,val) in the hash table pointed to by htp.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
void add_new_compilation_unit(const char *compilation_unit_name, bool is_fortran, entity module)
Warning! Do not modify this file that is automatically generated!
bool add_new_module_from_text(const char *module_name, text code_text, bool is_fortran, const char *compilation_unit_name)
Add the new resource files associated to a module with its more-or-less correct code.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
int the_current_debug_level
Debugging functions.
#define DUMMY_STRUCT_PREFIX
#define STRUCT_PREFIX_CHAR
#define UNION_PREFIX_CHAR
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
#define DUMMY_UNION_PREFIX
#define MODULE_SEP_STRING
const char * entity_minimal_user_name(entity e)
Do not preserve scope information.
string strupper(string, const char *)
#define HASH_UNDEFINED_VALUE
value returned by hash_get() when the key is not found; could also be called HASH_KEY_NOT_FOUND,...
#define HASH_DEFAULT_SIZE
void * gen_find_tabulated(const char *, int)
set set_assign_list(set, const list)
assigns a list contents to a set all duplicated elements are lost
set set_del_element(set, const set, const void *)
list set_to_list(const set)
create a list from a set the set is not freed
list set_to_sorted_list(const set, gen_cmp_func_t)
set set_difference(set, const set, const set)
#define SET_FOREACH(type_name, the_item, the_set)
enumerate set elements in their internal order.
bool set_belong_p(const set, const void *)
set set_union(set, const set, const set)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
#define string_undefined_p(s)
bool(* gen_eq_func_t)(const void *, const void *)
int(* gen_cmp_func_t)(const void *, const void *)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
static hash_table outliner_smart_references_computation(list outlined_statements, entity new_module)
purge the list of referenced entities by replacing calls to a[i][j] where i is a constant in statemen...
static string outlining_variable_commenter(__attribute__((unused)) entity e)
static bool entity_not_undefined_nor_constant_nor_intrinsic_p(entity e)
void outliner_patch_parameters(list statements_to_outline, list referenced_entities, list effective_parameters, list formal_parameters, statement new_body, statement begin, statement end)
we need to patch parameters , effective parameters and body in C because parameters are passed by cop...
static bool skip_constants_intrinsics_members(entity e)
static void check_private_variables_call_walker(call c, struct cpv *p)
static void do_remove_entity_from_decl(statement s, entity e)
static bool check_private_variables_loop_walker(loop l, struct cpv *p)
hash_table outliner_init(entity new_fun, list statements_to_outline)
static void outliner_smart_replacment(statement in, entity old, entity new, size_t nb_dims)
void remove_from_formal_parameters(list induction_var, list *formal_parameters)
bool outline(const string module_name)
entry point for outline module outlining will be performed using either comment recognition or intera...
static void outliner_extract_loop_bound(statement sloop, hash_table entity_to_effective_parameter)
static void outliner_independent_recursively(entity module, const char *cun, statement s)
static void convert_pointer_to_array(entity e, entity re, expression x, list statements)
static bool anonymous_type_p(entity e)
skipping anonymous enum ...
list outliner_scan(entity new_fun, list statements_to_outline, statement new_body)
void remove_from_effective_parameters(list induction_var, list *effective_parameters)
static void convert_pointer_to_array_aux2(statement s, entity e)
static void get_loop_locals_and_remove_walker(statement st, set s)
static void outline_remove_duplicates(list *entities)
static bool skip_values(void *v)
static list private_variables(statement stat)
static set get_private_entities(statement st)
try hard to reproduce in / out regions with only loop_locals it is time to move to regions ....
void add_induction_var_to_local_declarations(statement *new_body, list induction_var)
static void outliner_independent(const char *module_name, statement body)
redeclare all callees of outlined function in the same compilation unit
static void do_outliner_smart_replacment(reference r, ocontext_t *ctxt)
list outliner_statements_referenced_entities(list statements)
outlining.c
static string outlining_patched_variable_commenter(__attribute__((unused)) entity e)
static type type_to_named_type(type t, entity cu)
create a new type from given type, eventually renaming unnamed structures inside all new entities gen...
statement outliner_call(entity new_fun, list statements_to_outline, list effective_parameters)
void outliner_file(entity new_fun, list formal_parameters, statement *new_body)
void outliner_parameters(entity new_fun, statement new_body, list referenced_entities, hash_table entity_to_effective_parameter, list *effective_parameters_, list *formal_parameters_)
static void do_remove_entity_from_private(loop l, entity e)
static list statements_localize_declarations(list statements, entity module, statement module_statement)
static set get_loop_locals_and_remove(statement st)
static void outliner_compilation_unit(entity new_fun, list formal_parameters __attribute__((unused)))
statement outliner(const char *outline_module_name, list statements_to_outline)
outline the statements in statements_to_outline into a module named outline_module_name the outlined ...
static entity recursive_rename_types(entity e, const char *cun)
static void convert_pointer_to_array_aux(expression exp, entity e)
static void sort_entities_with_dep(list *l)
bool is_entity_in_list(entity e, list l)
Checks if an entity is in a list.
void print_parameters(list lp)
Display a parameter on stderr, useful for debugging.
void unnormalize_expression(void *st)
void unnormalize_expression(expression exp): puts all the normalized field of expressions in "st" to ...
#define db_get_file_resource
string db_get_current_workspace_directory(void)
void print_expressions(list le)
text text_named_module(entity, entity, statement)
list find_statements_interactively(statement)
prompt the user to select contiguous statement in s
void print_statement(statement)
Print a statement on stderr.
bool same_entity_lname_p(entity, entity)
void set_bool_property(const char *, bool)
const char * get_string_property_or_ask(const char *, const char[])
bool module_reorder(statement body)
Reorder a module and recompute order to statement if any.
#define make_expression_list(stats...)
#define MINUS_OPERATOR_NAME
#define PLUS_OPERATOR_NAME
#define DEFAULT_INTEGER_TYPE_SIZE
#define INSTANCE_OF(type, value)
polymorhism thanks to newgen !
#define make_entity(n, t, s, i)
#define DEREFERENCING_OPERATOR_NAME
#define entity_symbolic_p(e)
#define expression_scalar_p(e)
#define entity_declarations(e)
MISC: newgen shorthands.
#define ADDRESS_OF_OPERATOR_NAME
#define entity_variable_p(e)
An entity_variable_p(e) may hide a typedef and hence a functional type.
#define module_language(e)
implemented as a macro to allow lhs
#define make_statement_list(stats...)
easy list constructor
#define empty_comments
Empty comments (i.e.
#define module_functional_parameters(func)
#define entity_constant_p(e)
bool entity_not_constant_or_intrinsic_p(entity e)
Default entity filter for get_referenced_entities()
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
bool entity_enum_member_p(entity e)
entity FindEntity(const char *package, const char *name)
Retrieve an entity from its package/module name and its local name.
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
entity FindOrCreateEntity(const char *package, const char *local_name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
int compare_entities(const entity *pe1, const entity *pe2)
Comparison function for qsort.
bool entity_formal_p(entity p)
is p a formal parameter?
bool same_entity_p(entity e1, entity e2)
predicates on entities
bool c_module_p(entity m)
Test if a module "m" is written in C.
code entity_code(entity e)
set get_referenced_entities_filtered(void *elem, bool(*chunk_filter)(void *), bool(*entity_filter)(entity))
Same as get_referenced_entities, but will only consider entities that fulfills entity_filter and will...
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
entity make_empty_subroutine(const char *name, language l)
bool entity_function_p(entity e)
bool typedef_entity_p(entity e)
basic entity_basic(entity e)
return the basic associated to entity e if it's a function/variable/constant basic_undefined otherwis...
bool entity_field_p(entity e)
e is the field of a structure
void print_entities(list l)
code EntityCode(entity e)
this function checks that e has an initial value code.
bool fortran_module_p(entity m)
Test if a module is in Fortran.
bool top_level_entity_p(entity e)
Check if the scope of entity e is global.
entity entity_field_to_entity_struct_or_union(entity f)
bool member_entity_p(entity e)
entity MakeCompilationUnitEntity(const char *name)
This is useful for the C language only.
set get_referenced_entities(void *elem)
retrieves the set of entities used in elem beware that this entities may be formal parameters,...
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
entity make_entity_copy_with_new_name(entity e, string global_new_name, bool move_initialization_p)
Create a copy of an entity, with (almost) identical type, storage and initial value if move_initializ...
expression reference_to_expression(reference r)
expression Pvecteur_to_expression(Pvecteur vect)
AP, sep 25th 95 : some usefull functions moved from static_controlize/utils.c.
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
void update_expression_syntax(expression e, syntax s)
frees expression syntax of e and replace it by the new syntax s
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
bool expression_reference_p(expression e)
Test if an expression is a reference.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
entity expression_to_entity(expression e)
just returns the entity of an expression, or entity_undefined
bool same_expression_p(expression e1, expression e2)
this is slightly different from expression_equal_p, as it will return true for a+b vs b+a
extensions empty_extensions(void)
extension.c
basic basic_of_expression(expression)
basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
list type_supporting_types(type)
Return the list of types used to define type t.
void AddLocalEntityToDeclarations(entity, entity, statement)
Add the variable entity e to the list of variables of the function module.
entity make_new_array_variable_with_prefix(const char *, entity, basic, list)
J'ai ameliore la fonction make_new_scalar_variable_with_prefix
entity make_new_scalar_variable(entity, basic)
bool type_equal_p(type, type)
type pointed_type(type)
returns the type pointed by the input type if it is a pointer or an array of pointers
bool formal_parameter_p(entity)
entity make_new_scalar_variable_with_prefix(const char *, entity, basic)
Create a new scalar variable of type b in the given module.
void set_enclosing_loops_map(statement_mapping)
bool variable_static_p(entity)
true if v appears in a SAVE statement, or in a DATA statement, or is declared static i C.
entity find_ith_parameter(entity, int)
#define dummy_identifier(x)
#define normalized_undefined
#define expression_domain
newgen_execution_domain_defined
#define functional_result(x)
#define parameter_dummy(x)
#define parameter_type(x)
#define callees_callees(x)
#define reference_variable(x)
#define loop_domain
newgen_language_domain_defined
#define type_functional(x)
#define basic_pointer_p(x)
#define basic_derived_p(x)
#define entity_storage(x)
#define statement_domain
newgen_sizeofexpression_domain_defined
#define code_declarations(x)
#define call_domain
newgen_callees_domain_defined
#define basic_overloaded_p(x)
#define EXPRESSION(x)
EXPRESSION.
#define instruction_undefined
#define type_undefined_p(x)
#define entity_undefined_p(x)
#define reference_domain
newgen_range_domain_defined
#define expression_undefined
#define functional_parameters(x)
#define PARAMETER(x)
PARAMETER.
#define reference_indices(x)
#define statement_extensions(x)
#define variable_qualifiers(x)
#define expression_undefined_p(x)
#define variable_dimensions(x)
#define statement_declarations(x)
#define statement_instruction(x)
#define statement_comments(x)
#define statement_undefined_p(x)
#define expression_syntax(x)
#define language_fortran_p(x)
#define type_variable_p(x)
#define entity_domain
newgen_syntax_domain_defined
#define variable_basic(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
#define entity_initial(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
void vect_chg_sgn(Pvecteur v)
void vect_chg_sgn(Pvecteur v): multiplie v par -1
list statement_to_outline
scalopragma.c
char * strndup(char const *s, size_t n)
A replacement function, for systems that lack strndup.
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
void print_text(FILE *fd, text t)
A gen_chunk is used to store every object.
#define exp
Avoid some warnings from "gcc -Wshadow".
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
void vect_rm(Pvecteur v)
void vect_rm(Pvecteur v): desallocation des couples de v;
Pvecteur vect_del_var(Pvecteur v_in, Variable var)
Pvecteur vect_del_var(Pvecteur v_in, Variable var): allocation d'un nouveau vecteur egal a la project...
Value vect_coeff(Variable var, Pvecteur vect)
Variable vect_coeff(Variable var, Pvecteur vect): coefficient de coordonnee var du vecteur vect —> So...
void AddEntityToCompilationUnit(entity e, entity cu)
Add an entity to the current's module compilation unit declarations we have to generate its statement...
void AddEntityToModuleCompilationUnit(entity e, entity module)
entity module_entity_to_compilation_unit_entity(entity m)
Retrieve the compilation unit containing a module definition.