callgraph.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	CALLGRAPH_INCLUDED
	Warning! Do not modify this file that is automatically generated! More...
#define	CALLGRAPH_NOT_FOUND   NULL
#define	CALLGRAPH_DRAW   "CALLGRAPH_DRAW"
#define	CALLGRAPH_DEBUG   "CALLGRAPH_DEBUG"
#define	CALLGRAPH_DEBUG_LEVEL   "CALLGRAPH_DEBUG_LEVEL"
#define	CALLGRAPH_SHORT_NAMES   "CALLGRAPH_SHORT_NAMES"
#define	CALLGRAPH_INDENT   4

Functions
list	string_to_callees (const string)
	CALLGRAPH_INCLUDED. More...
list	entity_to_callees (entity)
bool	module_is_called_by_main_program_p (entity)
list	callers_to_call_sites (list, entity)
	given a list callers_statement of module statements returns a list of calls to module called_module More...
list	callers_to_statements (list)
	given a list callers of module name calling module called module return a list of their body More...
void	sort_parameters (entity, gen_cmp_func_t)
	change the parameter order for function module using comparison function cmp both compilation unit and callers are touched SG: it may be put in ri-util, but this would create a dependency from callgraph ... More...
bool	module_to_callgraph (entity, text(*)(const string))
callees	compute_callees (const statement)
	Recompute the callees of a module statement. More...
bool	callgraph (const string)
	callgraph computes the caller list of each module, using the callees list of them. More...
void	print_callees (callees)
	print.c More...
bool	print_decorated_call_graph (const string, text(*)(const string))
bool	print_call_graph (const string)
bool	graph_of_calls (const string)
	graph.c More...
bool	full_graph_of_calls (string)
	To be called by pipsmake. More...

Macro Definition Documentation

CALLGRAPH_DEBUG

#define CALLGRAPH_DEBUG   "CALLGRAPH_DEBUG"

Definition at line 42 of file callgraph.h.

CALLGRAPH_DEBUG_LEVEL

#define CALLGRAPH_DEBUG_LEVEL   "CALLGRAPH_DEBUG_LEVEL"

Definition at line 43 of file callgraph.h.

CALLGRAPH_DRAW

#define CALLGRAPH_DRAW   "CALLGRAPH_DRAW"

Definition at line 41 of file callgraph.h.

CALLGRAPH_INCLUDED

#define CALLGRAPH_INCLUDED

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/callgraph/callgraph-local.h instead, to add your own modifications. header file built by cproto callgraph-local.h callgraph.h include file for callgraphs

Definition at line 37 of file callgraph.h.

CALLGRAPH_INDENT

#define CALLGRAPH_INDENT   4

Definition at line 46 of file callgraph.h.

CALLGRAPH_NOT_FOUND

#define CALLGRAPH_NOT_FOUND   NULL

Definition at line 39 of file callgraph.h.

CALLGRAPH_SHORT_NAMES

#define CALLGRAPH_SHORT_NAMES   "CALLGRAPH_SHORT_NAMES"

Definition at line 44 of file callgraph.h.

Function Documentation

callers_to_call_sites()

list callers_to_call_sites	(	list	callers_statement,
		entity	called_module
	)

given a list callers_statement of module statements returns a list of calls to module called_module

Parameters

callers_statement	allers_statement
called_module	alled_module

Definition at line 149 of file callgraph.c.

{
  gather_call_sites_t p ={ NIL,called_module };
  FOREACH(STATEMENT,caller_statement,callers_statement)
    gen_context_multi_recurse(caller_statement,&p,
                statement_domain,gen_true2,gather_call_sites_in_block,
                call_domain,gen_true2,gather_call_sites,0);
  return p.sites;
}

References call_domain, FOREACH, gather_call_sites(), gather_call_sites_in_block(), gen_context_multi_recurse(), gen_true2(), NIL, gather_call_sites_t::sites, STATEMENT, and statement_domain.

Referenced by do_linearize_array_manage_callers(), normalize_microcode(), and sort_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

callers_to_statements()

list callers_to_statements

(

list

callers

)

given a list callers of module name calling module called module return a list of their body

Parameters

callers

allers

Definition at line 163 of file callgraph.c.

{
  list statements = NIL;
  FOREACH(STRING,caller_name,callers)
  {
    statement caller_statement =
      (statement) db_get_memory_resource(DBR_CODE, caller_name, true);
    statements = CONS(STATEMENT, caller_statement, statements);
  }
  return gen_nreverse(statements);
}

References caller_name, CONS, db_get_memory_resource(), FOREACH, gen_nreverse(), NIL, STATEMENT, and STRING.

Referenced by delay_communications_interprocedurally(), do_linearize_array_manage_callers(), normalize_microcode(), and sort_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

callgraph()

bool callgraph

(

const string

name

)

callgraph computes the caller list of each module, using the callees list of them.

As a side effect, it also computes their heights and depths in the call graph and detects recursive call cycles.

callgraph is not able to generate missing source code.

Note: although callgraph is directly and internally used by pipsmake which needs to know about the callers of a module to chain its rules, it might be better to store it in a future (new) callgraph library (FI)

Argument "name" is not used. It is instantiated as a specific module by make() but this routine process the whole program.

Number of modules called whose source code is missing but synthesized by PIPS

Should we deal with strings or with entities?

Define the module_set and initialize the module callers, except for modules whose source code is missing.

Compute iteratively the callers from the callees. Synthesize missing codes if necessary and if the corresponding property is set.

The number of iterations depends on the order of the modules in the hash-tables.

Simple but inefficient implementation for Cathar-2

Should not be an error as PIPS can synthesize missing code and does it elsewhere...

set_pips_current_computation(DBR_CALLEES, module_called);

push_pips_current_computation(DBR_CALLEES, module_called);

It has no callees to exploit anyway; it does not matter that it is not looped over by the main loop. module_callers is going to be updated and will be used to store the results.

You cannot call pips_user_error() again, as it has just been called by rmake via apply_a_rule()

pop_pips_current_computation(DBR_CALLEES, module_called);

reset_pips_current_computation();

Since Fabien is not available to help with pipsdbm... Let's move on with Cathare-2!

Parameters

name

ame

Definition at line 460 of file callgraph.c.

{
  gen_array_t module_array = db_get_module_list();
  int nmodules = gen_array_nitems(module_array);
  int i = 0;
  int n_new_modules = 0; /* Number of modules called whose source code is
                            missing but synthesized by PIPS */
  /* Should we deal with strings or with entities? */
  set modules = set_make(set_string);
  hash_table module_callers = hash_table_make(hash_string, 2*nmodules);
  hash_table module_callees =  hash_table_make(hash_string, 2*nmodules);
  hash_table module_depth =  hash_table_make(hash_string, 2*nmodules);
  hash_table module_height =  hash_table_make(hash_string, 2*nmodules);
 
  pips_assert("To silence gcc", name==name);
  pips_assert("The workspace contains at least one module", nmodules>0);
 
  /* Define the module_set and initialize the module callers, except for
     modules whose source code is missing. */
  for(i=0; i<nmodules; i++) {
    const char* module_name = gen_array_item(module_array, i);
    callees c = callees_undefined;
 
    set_add_element(modules, modules, module_name);
 
    c = make_callees(NIL);
    hash_put(module_callers, (void *) module_name, (void *) c);
  }
 
  /* Compute iteratively the callers from the callees. Synthesize missing
   * codes if necessary and if the corresponding property is set.
   *
   * The number of iterations depends on the order of the modules in the
   * hash-tables.
   *
   * Simple but inefficient implementation for Cathar-2
   */
  for(i=0; i<nmodules; i++) {
    const char* module_name = gen_array_item(module_array, i);
    callees called_modules = callees_undefined;
    list ccm = list_undefined;
 
    called_modules = (callees)
      db_get_memory_resource(DBR_CALLEES, module_name, true);
    hash_put(module_callees, (void *) module_name, (void *) called_modules);
 
    for( ccm = callees_callees(called_modules);
         !ENDP(ccm);
         POP(ccm)) {
      string module_called = STRING(CAR(ccm));
      callees c = callees_undefined;
      bool found = set_belong_p(modules, module_called);
 
      /* Should not be an error as PIPS can synthesize missing code
         and does it elsewhere... */
      if(!found) {
 
        pips_user_warning("no source file for module %s, let's try so synthesize code\n",
                          module_called);
        reset_current_phase_context();
 
        /* set_pips_current_computation(DBR_CALLEES, module_called); */
        /* push_pips_current_computation(DBR_CALLEES, module_called); */
        if(rmake(DBR_CALLEES, module_called)) {
          /* It has no callees to exploit anyway; it does not matter that
             it is not looped over by the main loop. module_callers is
             going to be updated and will be used to store the results. */
          callees c = callees_undefined;
 
          n_new_modules++;
 
          set_add_element(modules, modules, module_called);
 
          c = make_callees(NIL);
          hash_put(module_callers, (void *) module_called, (void *) c);
          c =  (callees)
            db_get_memory_resource(DBR_CALLEES, module_called, true);
          hash_put(module_callees, (void *) module_called, (void *) c);
      rmake(DBR_CALLERS, module_called);
        }
        else {
          /* You cannot call pips_user_error() again, as it has just been
             called by rmake via apply_a_rule()*/
          /*
            pips_user_error("Provide or let PIPS synthesize source code for module %s\n",
            module_called);*/
          set_current_phase_context(BUILDER_CALLGRAPH, name);
 
          return false;
        }
        /* pop_pips_current_computation(DBR_CALLEES, module_called); */
        /* reset_pips_current_computation(); */
        set_current_phase_context(BUILDER_CALLGRAPH, name);
      }
 
      c = (callees) hash_get(module_callers, (void *) module_called);
      pips_assert("callers are always initialized",
                  c != (callees) HASH_UNDEFINED_VALUE);
      callees_callees(c) =
        gen_nconc(callees_callees(c),
                  CONS(STRING, strdup(module_name), NIL));
    }
  }
 
  pips_debug(1, "Compute heights from callee arcs");
  transitive_positions(modules, module_callees, module_height);
  pips_debug(1, "Compute depths from caller arcs");
  transitive_positions(modules, module_callers, module_depth);
 
  ifdebug(7) {
    HASH_MAP(module_name, callers,
    {
      pips_debug(7, "adding %p as %s for module %s\n",
                 callers, DBR_CALLERS, (string) module_name);
      print_callees((callees) callers);
      fprintf(stderr, "HEIGHT = %td\n", (_int) hash_get(module_height, (string) module_name));
      fprintf(stderr, "DEPTH = %td\n", (_int) hash_get(module_depth, (string) module_name));
    }, module_callers);
  }
 
  /* Since Fabien is not available to help with pipsdbm... Let's move on with Cathare-2! */
  /*
  if(true) {
    FILE * h_file = safe_fopen("height", "w");
    FILE * d_file = safe_fopen("depth", "w");
    HASH_MAP(module_name, callers,
    {
      fprintf(h_file,"%s\t%d\n", (string) module_name,
              (int) hash_get(module_height, (string) module_name));
      fprintf(d_file,"%s\t%d\n", (string) module_name,
              (int) hash_get(module_depth, (string) module_name));
    }, module_callers);
    safe_fclose(h_file, "height");
    safe_fclose(d_file, "depth");
  }
  */
 
  i=0;
 
  HASH_MAP(module_name, callers,
  {
    char *depth;
    char *height;
 
    DB_PUT_MEMORY_RESOURCE(DBR_CALLERS, (string) module_name, (void *) callers);
 
    asprintf(&depth,"%td", (_int) hash_get(module_depth, (string) module_name));
    DB_PUT_MEMORY_RESOURCE(DBR_DEPTH, (string) module_name, (void *) depth);
 
    asprintf(&height,"%td", (_int) hash_get(module_height, (string) module_name));
    DB_PUT_MEMORY_RESOURCE(DBR_HEIGHT, (string) module_name, (void *) height);
    i++;
  }, module_callers);
 
  pips_assert("The number of modules is unchanged", i==nmodules+n_new_modules);
 
  hash_table_free(module_callees);
  hash_table_free(module_callers);
  hash_table_free(module_height);
  hash_table_free(module_depth);
  set_free(modules);
  gen_array_full_free(module_array);
  return true;
}

References asprintf, called_modules, callees_callees, callees_undefined, CAR, CONS, db_get_memory_resource(), db_get_module_list(), DB_PUT_MEMORY_RESOURCE, depth, ENDP, fprintf(), gen_array_full_free(), gen_array_item(), gen_array_nitems(), gen_nconc(), hash_get(), HASH_MAP, hash_put(), hash_string, hash_table_free(), hash_table_make(), HASH_UNDEFINED_VALUE, ifdebug, list_undefined, make_callees(), module_name(), NIL, pips_assert, pips_debug, pips_user_warning, POP, print_callees(), reset_current_phase_context(), rmake(), set_add_element(), set_belong_p(), set_current_phase_context(), set_free(), set_make(), set_string, strdup(), STRING, and transitive_positions().

Here is the call graph for this function:

compute_callees()

callees compute_callees

(

const statement

stat

)

Recompute the callees of a module statement.

Parameters

stat	is the module statement

Returns

the callees of the module

Parameters

stat

tat

Definition at line 355 of file callgraph.c.

                                      {
  callees current_callees = make_callees(NIL);
  // Visit all the call site of the module:
  gen_context_multi_recurse(stat, &current_callees,
                      statement_domain, declaration_statement_add_call_to_callees, gen_null,
                      call_domain, gen_true2, add_call_to_callees,
                      NULL);
  return current_callees;
}

References add_call_to_callees(), call_domain, declaration_statement_add_call_to_callees(), gen_context_multi_recurse(), gen_null(), gen_true2(), make_callees(), NIL, and statement_domain.

Referenced by delay_communications(), delay_communications_interprocedurally(), delay_load_communications(), delay_store_communications(), do_isolate_statement_preconditions_satisified_p(), do_kernelize(), do_unfolding(), expression_substitution(), freia_compiler(), fsm_generation(), fsm_merge_states(), fsm_split_state(), full_fsm_generation(), full_spaghettify(), generate_starpu_pragma(), gpu_ify(), gpu_memory(), if_conversion(), inline_calls(), isolate_statement(), kernel_load_store_engine(), kernelize(), old__gpu_ify(), outline(), outliner_independent_recursively(), phrase_comEngine_distributor(), phrase_distributor(), phrase_distributor_control_code(), phrase_distributor_init(), pragma_outliner(), prepend_call(), process_reduced_loops(), redundant_load_store_elimination(), rename_operator(), safescale_distributor(), safescale_distributor_init(), scalopify(), scalopragma(), sesamify(), simd_remove_reductions(), simdizer(), spaghettify(), taskify(), and wrap_kernel_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_callees()

list entity_to_callees

(

entity

mod

)

Parameters

mod

od

Definition at line 89 of file callgraph.c.

{
    list callees_list=NIL;
    const string module_name = entity_name(mod);
    list rl = NIL;
 
    callees_list = string_to_callees(module_name);
 
    FOREACH(STRING, e,callees_list)
      rl = CONS(ENTITY, module_name_to_entity(e), rl);
 
    return rl;
}

References CONS, ENTITY, entity_name, FOREACH, module_name(), module_name_to_entity(), NIL, STRING, and string_to_callees().

Referenced by callgraph_module_name().

Here is the call graph for this function:

Here is the caller graph for this function:

full_graph_of_calls()

bool full_graph_of_calls

(

string

name

)

To be called by pipsmake.

Generate a global resource, hence name is ignored.

build file name... and open it.

prolog, per module stuff, epilog.

close and clean...

put resulting resource into pipsdbm.

Parameters

name

ame

Definition at line 147 of file graph.c.

{
    gen_array_t modules = db_get_module_list();
    int n = gen_array_nitems(modules), i;
    FILE * out;
    bool first = true;
    string dir_name, file_name, full_name;
 
    pips_debug(7, "global call graph requested for %s (PROGRAM)\n", name);
 
    /* build file name... and open it. */
    dir_name = db_get_current_workspace_directory();
 
    file_name = db_build_file_resource_name
      (DBR_DVCG_FILE, PROGRAM_RESOURCE_OWNER, DV_SUFFIX);
 
    full_name = strdup(concatenate(dir_name, "/", file_name, NULL));
 
    out = safe_fopen(full_name, "w");
 
    /* prolog, per module stuff, epilog. */
    fprintf(out, "[\n");
 
    for (i=0; i<n; i++)
    {
        if (!first) fprintf(out, ",\n");
        first=false;
        node(out, gen_array_item(modules, i));
    }
 
    fprintf(out, "]\n");
 
    /* close and clean... */
    safe_fclose(out, full_name);
    gen_array_free(modules);
    free(dir_name), dir_name=NULL;
    free(full_name), full_name=NULL;
 
    /* put resulting resource into pipsdbm. */
    DB_PUT_FILE_RESOURCE(DBR_DVCG_FILE, PROGRAM_RESOURCE_OWNER, file_name);
 
    return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_module_list(), DB_PUT_FILE_RESOURCE, DV_SUFFIX, file_name, fprintf(), free(), full_name, gen_array_free(), gen_array_item(), gen_array_nitems(), node(), out, pips_debug, PROGRAM_RESOURCE_OWNER, safe_fclose(), safe_fopen(), and strdup().

Here is the call graph for this function:

graph_of_calls()

bool graph_of_calls

(

const string

name

)

graph.c

graph.c

builds the daVinci file for module "name".

do the job here.

Parameters

name

ame

Definition at line 120 of file graph.c.

{
    FILE * out;
    string dir_name, file_name, full_name;
    dir_name = db_get_current_workspace_directory();
    file_name = db_build_file_resource_name(DBR_DVCG_FILE, name, DV_SUFFIX);
    full_name = strdup(concatenate(dir_name, "/", file_name, NULL));
    free(dir_name), dir_name = NULL;
    out = safe_fopen(full_name, "w");
    init_seen();
 
    /* do the job here. */
    fprintf(out, "[\n");
    recursive_append(out, name);
    fprintf(out, "]\n");
 
    close_seen();
    safe_fclose(out, full_name);
    free(full_name), full_name = NULL;
    DB_PUT_FILE_RESOURCE(DBR_DVCG_FILE, name, file_name);
 
    return true;
}

References close_seen(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, DV_SUFFIX, file_name, fprintf(), free(), full_name, init_seen(), out, recursive_append(), safe_fclose(), safe_fopen(), and strdup().

Here is the call graph for this function:

module_is_called_by_main_program_p()

bool module_is_called_by_main_program_p

(

entity

mod

)

Parameters

mod

od

Definition at line 103 of file callgraph.c.

{
  if (!entity_main_module_p(mod))
  {
    const char* mod_name = module_local_name(mod);
    callees callers =
      (callees) db_get_memory_resource(DBR_CALLERS,mod_name,true);
    list l_callers = callees_callees(callers);
    while (!ENDP(l_callers))
    {
      string caller_name = STRING(CAR(l_callers));
      entity current_caller = module_name_to_entity(caller_name);
      if (module_is_called_by_main_program_p(current_caller)) return true;
      l_callers = CDR(l_callers);
    }
    return false;
  }
  return true;
}

References callees_callees, caller_name, CAR, CDR, current_caller, db_get_memory_resource(), ENDP, entity_main_module_p(), module_local_name(), module_name_to_entity(), and STRING.

Referenced by alias_propagation(), and alias_propagation_callers().

Here is the call graph for this function:

Here is the caller graph for this function:

module_to_callgraph()

bool module_to_callgraph	(	entity	module,
		text(*)(const string)	module_to_text
	)

Parameters

module

odule

Definition at line 270 of file callgraph.c.

{
  string dir, local, full;
  FILE * fp;
 
  const string name = (const string) module_resource_name(module);
  local = db_build_file_resource_name(DBR_CALLGRAPH_FILE, name, ".cg");
  dir = db_get_current_workspace_directory();
  full = strdup(concatenate(dir, "/", local, NULL));
  free(dir);
 
  fp = safe_fopen(full, "w");
  callgraph_module_name(module, fp, module_to_text);
  safe_fclose(fp, full);
  free(full);
 
  DB_PUT_FILE_RESOURCE(DBR_CALLGRAPH_FILE, name, local);
  return true;
}

References callgraph_module_name(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, free(), full, module, module_resource_name(), safe_fclose(), safe_fopen(), and strdup().

Referenced by print_decorated_call_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_call_graph()

bool print_call_graph

(

const

string

)

Parameters

string

odule_name

Definition at line 82 of file print.c.

{
  bool success = false;
  success = print_decorated_call_graph(module_name, NULL);
  return success;
}

References module_name(), and print_decorated_call_graph().

Here is the call graph for this function:

print_callees()

void print_callees

(

callees

c

)

print.c

print.c

They should be called by pipsmake

Lei Zhou, February 91 Modification:

• Callgraph prints only callees, nothing else. January 93
• GO: Decoration of callgraphs, with some analyze results June 95 Print callees for debugging purpose

Definition at line 52 of file print.c.

{
  list l = callees_callees(c);
 
  MAP(STRING, mn, {
      printf("%s\n", mn);
    }, l);
}

References callees_callees, MAP, printf(), and STRING.

Referenced by callgraph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_decorated_call_graph()

bool print_decorated_call_graph	(	const	string,
		text(*)(const string)	module_to_text
	)

Parameters

string

odule_name

Definition at line 64 of file print.c.

{
    bool success = false;
    entity mod = module_name_to_entity(module_name);
 
    debug_on(CALLGRAPH_DEBUG_LEVEL);
    pips_debug(1, "===%s===\n", module_name);
    success = module_to_callgraph(mod, module_to_text);
    debug_off();
 
    return success;
}

References CALLGRAPH_DEBUG_LEVEL, debug_off, debug_on, module_name(), module_name_to_entity(), module_to_callgraph(), and pips_debug.

Referenced by print_call_graph(), print_call_graph_with_complexities(), print_call_graph_with_preconditions(), print_call_graph_with_total_preconditions(), and print_call_graph_with_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_parameters()

void sort_parameters	(	entity	module,
		gen_cmp_func_t	cmp
	)

change the parameter order for function module using comparison function cmp both compilation unit and callers are touched SG: it may be put in ri-util, but this would create a dependency from callgraph ...

retrieve the formal parameters

order them

update offset

update parameter list

change call sites

for each call site , reorder arguments according to table reordering

tell dbm of the update

yes! some people use free in pips !

Parameters

module	odule
cmp	mp

Definition at line 180 of file callgraph.c.

{
  /* retrieve the formal parameters */
  list fn = module_formal_parameters(module);
  /* order them */
  gen_sort_list(fn,cmp);
  /* update offset */
  intptr_t offset=0;
  // holds correspondence between old and new offset
  int reordering[gen_length(fn)];
  FOREACH(ENTITY,f,fn) {
    reordering[formal_offset(storage_formal(entity_storage(f)))-1] = offset;
    formal_offset(storage_formal(entity_storage(f)))=++offset;
  }
  /* update parameter list */
  list parameters = module_functional_parameters(module);
  list new_parameters = NIL;
  for(size_t i=0;i<gen_length(fn);i++) {
    new_parameters =
      CONS(PARAMETER,PARAMETER(gen_nth((int)reordering[i],parameters)),
           new_parameters);
    }
  new_parameters=gen_nreverse(new_parameters);
  module_functional_parameters(module)=new_parameters;
  /* change call sites */
  list callers = callees_callees(
    (callees)db_get_memory_resource(DBR_CALLERS, get_current_module_name(),
                                    true));
  list callers_statement = callers_to_statements(callers);
  list call_sites = callers_to_call_sites(callers_statement,module);
  /* for each call site , reorder arguments according to table reordering */
  FOREACH(CALL,c,call_sites) {
    list args = call_arguments(c);
    list new_args = NIL;
    for(size_t i=0;i<gen_length(fn);i++) {
      new_args = CONS(EXPRESSION, EXPRESSION(gen_nth((int)reordering[i],args)),
                      new_args);
    }
    new_args=gen_nreverse(new_args);
    gen_free_list(args);
    call_arguments(c)=new_args;
  }
  /* tell dbm of the update */
  for(list citer=callers, siter=callers_statement;
      !ENDP(citer); POP(citer), POP(siter))
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, STRING(CAR(citer)),STATEMENT(CAR(siter)));
  db_touch_resource(DBR_CODE,
                    compilation_unit_of_module(get_current_module_name()));
 
  /* yes! some people use free in pips ! */
  gen_free_list(call_sites);
  gen_free_list(callers_statement);
 
  gen_free_list(fn);
  gen_free_list(parameters);
}

References CALL, call_arguments, callees_callees, callers_to_call_sites(), callers_to_statements(), CAR, compilation_unit_of_module(), CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_touch_resource(), ENDP, ENTITY, entity_storage, EXPRESSION, f(), FOREACH, formal_offset, gen_free_list(), gen_length(), gen_nreverse(), gen_nth(), gen_sort_list(), get_current_module_name(), intptr_t, module, module_formal_parameters(), module_functional_parameters, NIL, offset, PARAMETER, POP, STATEMENT, storage_formal, and STRING.

Referenced by normalize_microcode_parameter_orders().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_callees()

list string_to_callees

(

const string

module_name

)

CALLGRAPH_INCLUDED.

cproto-generated files callgraph.c

CALLGRAPH_INCLUDED.

Entry point:

Pierre Berthomier, May 1990 Lei Zhou, January 1991 Guillaume Oget, June 1995 To have asprintf(): DB_PUT_FILE_RESOURCE is defined there get all the callees of the module module_name,return the no-empty list of string. if the module has callee(s),the first element of the return list is the mudule's last callee.

Parameters

module_name

odule_name

Definition at line 69 of file callgraph.c.

{
  callees cl = callees_undefined;
 
  if(false && static_module_name_p(module_name))
    cl = (callees)db_get_memory_resource(DBR_CALLEES,module_name,true);
  else {
    // Should be dealt with in ri-util
    // string ln = global_name_to_user_name(module_name);
    const char* ln = local_name(module_name);
    ln += strspn(ln, MAIN_PREFIX)
      + strspn(ln, BLOCKDATA_PREFIX)
      + strspn(ln, COMMON_PREFIX);
    cl = (callees)db_get_memory_resource(DBR_CALLEES,ln,true);
  }
  return callees_callees(cl);
}

References BLOCKDATA_PREFIX, callees_callees, callees_undefined, COMMON_PREFIX, db_get_memory_resource(), local_name(), MAIN_PREFIX, module_name(), and static_module_name_p().

Referenced by entity_to_callees().

Here is the call graph for this function:

Here is the caller graph for this function: