callgraph.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "text.h"
#include "text-util.h"
#include "constants.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "misc.h"
#include "database.h"
#include "pipsdbm.h"
#include "resources.h"
#include "phases.h"
#include "pipsmake.h"
#include "callgraph.h"

Include dependency graph for callgraph.c:

Go to the source code of this file.

Data Structures
struct	gather_call_sites_t

Functions
list	string_to_callees (const string module_name)
	callgraph.c More...
list	entity_to_callees (entity mod)
bool	module_is_called_by_main_program_p (entity mod)
static void	gather_call_sites (call c, gather_call_sites_t *p)
static void	gather_call_sites_in_block (statement s, gather_call_sites_t *p)
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 More...
list	callers_to_statements (list callers)
	given a list callers of module name calling module called module return a list of their body More...
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 ... More...
static void	callgraph_module_name (entity module, FILE *fp, text(*module_to_text)(const string))
bool	module_to_callgraph (entity module, text(*module_to_text)(const string))
static void	add_call_to_callees (const call c, callees *current_callees)
	Add a call to a function to a callees list. More...
static bool	declaration_statement_add_call_to_callees (const statement s, callees *current_callees)
	Add calls hidden in variable declarations to the current callees list. More...
callees	compute_callees (const statement stat)
	Recompute the callees of a module statement. More...
static void	transitive_positions (set vertices, hash_table arcs, hash_table position)
	Global computation of CALLERS, HEIGHT and DEPTH. More...
bool	callgraph (const string name)
	callgraph computes the caller list of each module, using the callees list of them. More...

Function Documentation

add_call_to_callees()

static void add_call_to_callees ( const call  c, callees *  current_callees  )

static

Add a call to a function to a callees list.

Definition at line 300 of file callgraph.c.

                                                            {
  entity called = call_function(c);
  pips_assert("defined entity", !entity_undefined_p(called));
  pips_debug(8,"considering: %s ->",  entity_local_name(called));
  if (type_functional_p(entity_type(called)) &&
      storage_rom_p(entity_storage(called)) &&
      (value_code_p(entity_initial(called)) ||
       value_unknown_p(entity_initial(called)))) {
    const char* name = entity_local_name(called);
    // Only add the callee if not already here:
    FOREACH(STRING, s, callees_callees(*current_callees))
        if (same_string_p(name, s))
            return;
    pips_debug(8,"adding: %s",  entity_local_name(called));
    callees_callees(*current_callees) =
      CONS(STRING, strdup(name), callees_callees(*current_callees));
  }
  pips_debug(8,"\n");
}

References call_function, callees_callees, CONS, entity_initial, entity_local_name(), entity_storage, entity_type, entity_undefined_p, FOREACH, pips_assert, pips_debug, same_string_p, storage_rom_p, strdup(), STRING, type_functional_p, value_code_p, and value_unknown_p.

Referenced by compute_callees(), and declaration_statement_add_call_to_callees().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

callgraph_module_name()

static void callgraph_module_name ( entity  module, FILE *  fp, text(*)(const string)  module_to_text  )

static

Definition at line 242 of file callgraph.c.

{
  const string module_name = (const string) module_resource_name(module);
        string dir = db_get_current_workspace_directory();
  text r = make_text(NIL);
 
  if (module_to_text)
    MERGE_TEXTS(r, (*module_to_text)(module_name));
 
  print_text(fp, r);
  fprintf(fp, " %s\n", module_name);
 
  FOREACH(ENTITY, e, entity_to_callees(module))
  {
    const string n = (const string) module_resource_name(e);
    string f = db_get_memory_resource(DBR_CALLGRAPH_FILE, n, true);
    string full = strdup(concatenate(dir, "/", f, NULL));
    safe_append(fp, full, CALLGRAPH_INDENT, true);
    free(full);
  }
 
  free(dir);
}

References CALLGRAPH_INDENT, concatenate(), db_get_current_workspace_directory(), db_get_memory_resource(), ENTITY, entity_to_callees(), f(), FOREACH, fprintf(), free(), full, make_text(), MERGE_TEXTS, module, module_name(), module_resource_name(), NIL, print_text(), safe_append(), and strdup().

Referenced by module_to_callgraph().

Here is the call graph for this function:

Here is the caller 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:

declaration_statement_add_call_to_callees()

static bool declaration_statement_add_call_to_callees ( const statement  s, callees *  current_callees  )

static

Add calls hidden in variable declarations to the current callees list.

Definition at line 324 of file callgraph.c.

{
  bool decl_p = declaration_statement_p(s);
 
  if (decl_p)
  {
    FOREACH(ENTITY, e, statement_declarations(s))
    {
      if(type_variable_p(entity_type(e)))
            {
              value v_init = entity_initial(e);
              if (value_expression_p(v_init))
        {
          gen_context_recurse(v_init, current_callees,
                              call_domain, gen_true2, add_call_to_callees);
        }
            }
    }
  }
  // currently, declarations are attached to CONTINUE statements
  return !decl_p;
}

References add_call_to_callees(), call_domain, declaration_statement_p(), ENTITY, entity_initial, entity_type, FOREACH, gen_context_recurse, gen_true2(), statement_declarations, type_variable_p, and value_expression_p.

Referenced by compute_callees().

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:

gather_call_sites()

static void gather_call_sites ( call  c, gather_call_sites_t *  p  )

static

Definition at line 128 of file callgraph.c.

{
    if(same_entity_p(call_function(c), p->m))
        p->sites=CONS(CALL,c,p->sites);
}

References CALL, call_function, CONS, gather_call_sites_t::m, same_entity_p(), and gather_call_sites_t::sites.

Referenced by callers_to_call_sites(), and gather_call_sites_in_block().

Here is the call graph for this function:

Here is the caller graph for this function:

gather_call_sites_in_block()

static void gather_call_sites_in_block ( statement  s, gather_call_sites_t *  p  )

static

Definition at line 134 of file callgraph.c.

{
  if(declaration_statement_p(s)) {
    FOREACH(ENTITY,e,statement_declarations(s)) {
      gen_context_recurse(entity_initial(e), p,
                          call_domain, gen_true2, gather_call_sites);
    }
  }
}

References call_domain, declaration_statement_p(), ENTITY, entity_initial, FOREACH, gather_call_sites(), gen_context_recurse, gen_true2(), and statement_declarations.

Referenced by callers_to_call_sites().

Here is the call graph for this function:

Here is the caller 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:

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.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:

transitive_positions()

static void transitive_positions ( set  vertices, hash_table  arcs, hash_table  position  )

static

Global computation of CALLERS, HEIGHT and DEPTH.

Number of modules processed at the previous iteration

current module position

gdb does not access v1

already processed

do not know when to perform a put or an update...

Check that all vertices are associated to a position... which only is true if no recursive cycle exists.

Definition at line 370 of file callgraph.c.

{
  _int n = 1; /* Number of modules processed at the previous iteration */
  _int iter = 0;
  _int nvertices = 0;
 
  while(n>0) {
    n = 0;
    iter++;
 
    SET_FOREACH(string,v1,vertices) {
      _int cmp = 0; /* current module position */
      string source_module = (string) v1; /* gdb does not access v1 */
      callees c = (callees) hash_get(arcs, (void *) v1);
      list destinations = list_undefined;
 
      if(c == (callees) HASH_UNDEFINED_VALUE) {
        pips_internal_error("Arcs undefined for module %s", source_module);
      }
      else {
        destinations = callees_callees(c);
      }
 
      if(hash_get(position, v1) != HASH_UNDEFINED_VALUE)
        /* already processed */
        ;
      else if(ENDP(destinations)) {
        hash_put(position, v1, (void *) cmp);
        n++;
        nvertices++;
      }
      else {
        FOREACH(STRING, v2,destinations) {
          _int p = 0;
 
          if((p = (_int) hash_get(position, v2)) == (_int) HASH_UNDEFINED_VALUE)
            goto next;
          cmp = p+1>cmp? p+1 : cmp;
        }
        /* do not know when to perform a put or an update... */
        hash_put(position, v1, (void *) cmp);
        n++;
        nvertices++;
      next: ;
      }
    }
    pips_debug(1, "Iteration %td completed with %td vertices processed\n"
               "(total number of vertices processed: %td)\n",
               iter, n, nvertices);
  }
 
  /* Check that all vertices are associated to a position... which only is
     true if no recursive cycle exists. */
  ifdebug(7) {
    SET_FOREACH(string,v1,vertices) {
      _int p = (_int)hash_get(position,  v1);
      pips_assert("p is defined", p != (_int) HASH_UNDEFINED_VALUE);
    }
  }
 
  n = 0;
  SET_FOREACH(string,v1,vertices) {
    if(hash_get(position,  v1) == HASH_UNDEFINED_VALUE) {
      pips_user_warning("Module %s might be part of a recursive call cycle\n", v1);
      n++;
    }
  }
  if(n!=0)
      pips_user_warning("%td module could not be given a position in the call graph,"
                        " probably because of a recursive call cycle.\n", n);
}

References callees_callees, ENDP, FOREACH, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, ifdebug, list_undefined, pips_assert, pips_debug, pips_internal_error, pips_user_warning, SET_FOREACH, and STRING.

Referenced by callgraph().

Here is the call graph for this function:

Here is the caller graph for this function: