comp_util.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "linear.h"
#include "genC.h"
#include "database.h"
#include "ri.h"
#include "effects.h"
#include "complexity_ri.h"
#include "resources.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "text-util.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "misc.h"
#include "constants.h"
#include "properties.h"
#include "matrice.h"
#include "polynome.h"
#include "complexity.h"

Include dependency graph for comp_util.c:

Go to the source code of this file.

Macros
#define	INDENT_BLANKS   " "
	comp_util.c More...
#define	INDENT_VLINE   "| "
#define	INDENT_BACK   "-"
#define	INDENT_INTERVAL   2

Functions
bool	complexity_check (complexity comp)
	return true if allright More...
void	complexity_check_and_warn (char *s, complexity comp) const
void	good_complexity_assert (_UNUSED_ string function, complexity comp)
complexity	complexity_dup (complexity comp)
	duplicates complexity comp More...
void	complexity_rm (complexity *pcomp)
	remove complexity comp More...
char *	complexity_sprint (complexity comp, bool print_stats_p, bool print_local_names_p)
void	complexity_fprint (FILE *fd, complexity comp, bool print_stats_p, bool print_local_names_p)
void	complexity_dump (complexity comp)
void	prc (complexity comp)
void	prp (Ppolynome pp)
void	prv (Pvecteur pv)
void	fprint_statement_complexity (entity module, statement stat, hash_table hash_statement_to_complexity)
void	fprint_cost_table (FILE *fd)
void	init_cost_table ()
	Completes the intrinsic cost table with the costs read from the files specified in the "COMPLEXITY_COST_TABLE" string property See properties.rc and ~pips/Pips/pipsrc.csh for more information. More...
void	load_cost_file (FILE *fd, float file_factor)
	Load (some) intrinsics costs from file "fd", multiplying them by "file_factor". More...
int	intrinsic_cost (char *s, basic *pargsbasic) const
	Return the cost of the intrinsic named s, knowing that the "basic" type of its biggest argument is *pargsbasic. More...
float	constant_entity_to_float (entity e)
	Return if possible the value of e in a float. More...
void	trace_on (char *fmt,...)
void	trace_off ()
	"trace off" More...
bool	is_linear_unstructured (unstructured unstr)
	return true if unstr is simply a linear string of controls More...
list	entity_list_reverse (list l)
void	add_formal_parameters_to_hash_table (entity mod, hash_table hash_complexity_params)
void	remove_formal_parameters_from_hash_table (entity mod, hash_table hash_complexity_params)
hash_table	free_callees_complexities (hash_table h)
hash_table	fetch_callees_complexities (char *module_name)
hash_table	fetch_complexity_parameters (char *module_name)
void	add_common_variables_to_hash_table (entity module, hash_table hash_complexity_params)
void	remove_common_variables_from_hash_table (entity module, hash_table hash_complexity_params)
bool	is_must_be_written_var (list effects_list, char *var_name)
complexity	final_statement_to_complexity_evaluation (complexity comp, transformer precond, list effects_list)
complexity	translate_complexity_from_local_to_current_name (complexity callee_comp, string oldname, string newname)
	translate_complexity_from_local_to_current_name(callee_comp,oldname,newname) B:M -> A:M if A calls B 5 Feb. More...
bool	complexity_is_monomial_p (complexity c)
int	complexity_degree (complexity c)

Variables
intrinsic_cost_record	intrinsic_cost_table []
	The table intrinsic_cost_table[] gathers cost information of each intrinsic's cost; those costs are dynamically loaded from user files. More...
static int	call_level =0
	"trace on" More...

Macro Definition Documentation

INDENT_BACK

#define INDENT_BACK   "-"

Definition at line 92 of file comp_util.c.

INDENT_BLANKS

#define INDENT_BLANKS   " "

comp_util.c

useful routines for evaluation of the complexity of a program

bool complexity_check(comp) void complexity_check_and_warn(function_name, comp) void good_complexity_assert(function_name, comp) void complexity_fprint(fd, comp, print_stats_p, print_local_names_p) char *complexity_sprint(comp, print_stats_p, print_local_names_p) void fprint_statement_complexity(module, stat, hash_statement_to_complexity) void prc(comp) (for dbx) void prp(pp) (for dbx) void prv(pv) (for dbx) void fprint_cost_table(fd) void init_cost_table(); int intrinsic_cost(name, argstype) bool is_inferior_basic(basic1, basic2) basic simple_basic_dup(b) float constant_entity_to_float(e) void trace_on(va_alist) void trace_off() list entity_list_reverse(l) bool is_linear_unstructured(unstr) void add_formal_parameters_to_hash_table(mod, hash_complexity_params) void remove_formal_parameters_from_hash_table(mod, hash_complexity_params) hash_table fetch_callees_complexities(module_name) hash_table fetch_complexity_parameters(module_name) Modif: – entity_local_name is replaced by module_local_name. LZ 230993 – add of missing operators to intrinsic_cost_table. Molka Becher 08.03.2011 To have strndup(): getenv print_text IMPLIED_DO_NAME is defined there get_string_property is defined there for debugging

Definition at line 90 of file comp_util.c.

INDENT_INTERVAL

#define INDENT_INTERVAL   2

Definition at line 93 of file comp_util.c.

INDENT_VLINE

#define INDENT_VLINE   "| "

Definition at line 91 of file comp_util.c.

Function Documentation

add_common_variables_to_hash_table()

void add_common_variables_to_hash_table	(	entity	module,
		hash_table	hash_complexity_params
	)

Parameters

module	odule
hash_complexity_params	ash_complexity_params

Definition at line 946 of file comp_util.c.

{
    const char* module_name = module_local_name(module);
    list sefs_list = list_undefined;
    list ce = list_undefined;
 
    pips_assert("add_common_variables_to_hash_table",
                entity_module_p(module));
 
    sefs_list = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    ifdebug(5) {
        debug(5, "add_common_variables_to_hash_table",
              "Effect list for %s\n",
              module_name);
        print_effects(sefs_list);
    }
 
    for(ce= sefs_list; !ENDP(ce); POP(ce)) {
        effect obj = EFFECT(CAR(ce));
        reference r = effect_any_reference(obj);
        action ac = effect_action(obj);
        approximation ap = effect_approximation(obj);
        entity e = reference_variable(r);
        storage s = entity_storage(e);
 
        if ( !storage_formal_p(s) &&
            action_read_p(ac) && approximation_exact_p(ap) ) {
            debug(5,"add_common_variables_to_hash_table",
                  "%s added\n", module_local_name(e));
            hash_put(hash_complexity_params, (char *) module_local_name(e),
                     HASH_COMMON_VARIABLE);
        }
    }
}

References action_read_p, approximation_exact_p, CAR, db_get_memory_resource(), debug(), EFFECT, effect_action, effect_any_reference, effect_approximation, effects_to_list(), ENDP, entity_module_p(), entity_storage, HASH_COMMON_VARIABLE, hash_put(), ifdebug, list_undefined, module, module_local_name(), module_name(), pips_assert, POP, print_effects, reference_variable, and storage_formal_p.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_formal_parameters_to_hash_table()

void add_formal_parameters_to_hash_table	(	entity	mod,
		hash_table	hash_complexity_params
	)

Parameters

mod	od
hash_complexity_params	ash_complexity_params

Definition at line 768 of file comp_util.c.

{
    list decl;
 
    pips_assert("add_formal_parameters_to_hash_table",
                entity_module_p(mod));
    decl = code_declarations(value_code(entity_initial(mod)));
 
    MAPL(pe, {
        entity param = ENTITY(CAR(pe));
        if (storage_formal_p(entity_storage(param))) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"\nstorage_formal %s\n",
                        entity_name(param));
            }
            hash_put(hash_complexity_params, (char *) strdup(module_local_name(param)),
                     HASH_FORMAL_PARAM);
        }
    }, decl);
}

References CAR, code_declarations, ENTITY, entity_initial, entity_module_p(), entity_name, entity_storage, fprintf(), get_bool_property(), HASH_FORMAL_PARAM, hash_put(), MAPL, module_local_name(), pips_assert, storage_formal_p, strdup(), and value_code.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_check()

bool complexity_check

(

complexity

comp

)

return true if allright

comp_util.c

Parameters

comp

omp

Definition at line 96 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("complexity undefined");
 
    if ( !complexity_zero_p(comp) ) {
        return (polynome_check(complexity_polynome(comp)));
    }
    return (true);
}

References complexity_polynome(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), pips_internal_error, and polynome_check().

Referenced by complexity_check_and_warn(), and good_complexity_assert().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_check_and_warn()

void complexity_check_and_warn	(	char *	s,
		complexity	comp
	)		const

Definition at line 108 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp) ) {
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr,"complexity ZERO for %s\n",s);
        }
    }   
    if (!complexity_check(comp))
        user_warning(s,"Bad internal complexity representation!\n");
}    

References complexity_check(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), fprintf(), get_bool_property(), pips_internal_error, and user_warning.

Referenced by arguments_to_complexity(), block_to_complexity(), call_to_complexity(), controls_to_hash_table(), expression_to_complexity(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), range_to_complexity(), reference_to_complexity(), statement_to_complexity(), syntax_to_complexity(), test_to_complexity(), text_complexity(), unstructured_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_degree()

int complexity_degree

(

complexity

c

)

Definition at line 1167 of file comp_util.c.

{
    Ppolynome p = complexity_eval(c);
    int degree = polynome_max_degree(p);
 
    return degree;
}

References complexity_eval, and polynome_max_degree().

Referenced by loop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_dump()

void complexity_dump

(

complexity

comp

)

Parameters

comp

omp

Definition at line 228 of file comp_util.c.

{
    complexity_fprint(stderr, comp, false, true);
}

References complexity_fprint().

Here is the call graph for this function:

complexity_dup()

complexity complexity_dup

(

complexity

comp

)

duplicates complexity comp

Parameters

comp

omp

Definition at line 131 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp) ) 
        return (make_zero_complexity());
    else {
        varcount   vc = complexity_varcount(comp);
        rangecount rc = complexity_rangecount(comp);
        ifcount    ic = complexity_ifcount(comp);
 
        varcount newvc = make_varcount(varcount_symbolic(vc), 
                                       varcount_guessed(vc),
                                       varcount_bounded(vc), 
                                       varcount_unknown(vc));
        rangecount newrc = make_rangecount(rangecount_profiled(rc), 
                                           rangecount_guessed(rc),
                                           rangecount_bounded(rc),
                                           rangecount_unknown(rc));
        ifcount newic = make_ifcount(ifcount_profiled(ic), 
                                     ifcount_computed(ic),
                                     ifcount_halfhalf(ic));
    
        Ppolynome ppdup = polynome_dup(complexity_polynome(comp));
        complexity compl = make_complexity(ppdup, newvc, newrc, newic);
 
        return(compl);
    }
}

References complexity_ifcount, complexity_polynome(), complexity_rangecount, COMPLEXITY_UNDEFINED_P, complexity_varcount, complexity_zero_p(), ifcount_computed, ifcount_halfhalf, ifcount_profiled, make_complexity(), make_ifcount(), make_rangecount(), make_varcount(), make_zero_complexity(), pips_internal_error, polynome_dup(), rangecount_bounded, rangecount_guessed, rangecount_profiled, rangecount_unknown, varcount_bounded, varcount_guessed, varcount_symbolic, and varcount_unknown.

Referenced by complexity_add(), complexity_stats_add(), complexity_sub(), final_statement_to_complexity_evaluation(), replace_formal_parameters_by_real_ones(), test_to_complexity(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_fprint()

void complexity_fprint	(	FILE *	fd,
		complexity	comp,
		bool	print_stats_p,
		bool	print_local_names_p
	)

Parameters

fd	d
comp	omp
print_stats_p	rint_stats_p
print_local_names_p	rint_local_names_p

Definition at line 217 of file comp_util.c.

{
    char *s = complexity_sprint(comp, print_stats_p, print_local_names_p);
 
    fprintf(fd, "%s\n", s);
    free(s);
}

References complexity_sprint(), fprintf(), and free().

Referenced by arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), complexity_dump(), complexity_var_subst(), controls_to_hash_table(), expression_to_complexity_polynome(), fetch_callees_complexities(), final_statement_to_complexity_evaluation(), fprint_statement_complexity(), loop_to_complexity(), prc(), range_to_complexity(), reference_to_complexity(), statement_to_complexity(), test_to_complexity(), unstructured_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_is_monomial_p()

bool complexity_is_monomial_p

(

complexity

c

)

Definition at line 1159 of file comp_util.c.

{
    Ppolynome p = complexity_eval(c);
    bool monomial_p = is_single_monome(p);
 
    return monomial_p;
}

References complexity_eval, and is_single_monome.

Referenced by loop_to_complexity().

Here is the caller graph for this function:

complexity_rm()

void complexity_rm

(

complexity *

pcomp

)

remove complexity comp

Parameters

pcomp

comp

Definition at line 164 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(*pcomp) )
        pips_internal_error("undefined complexity");
 
    if ( !complexity_zero_p(*pcomp) ) 
        free_complexity(*pcomp);
    *pcomp = make_zero_complexity();// complexity_undefined;
}

References COMPLEXITY_UNDEFINED_P, complexity_zero_p(), free_complexity(), make_zero_complexity(), and pips_internal_error.

Referenced by complexity_mult(), complexity_scalar_mult(), divide_op_handler(), field_op_handler(), indices_to_complexity(), loop_to_complexity(), minus_op_handler(), multiply_op_handler(), plus_op_handler(), power_op_handler(), range_to_complexity(), reference_to_complexity(), replace_formal_parameters_by_real_ones(), simplify_sc_to_complexity(), subscript_to_complexity(), syntax_to_complexity(), test_to_complexity(), and unary_minus_op_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_sprint()

char* complexity_sprint	(	complexity	comp,
		bool	print_stats_p,
		bool	print_local_names_p
	)

Parameters

comp	omp
print_stats_p	rint_stats_p
print_local_names_p	rint_local_names_p

Definition at line 175 of file comp_util.c.

{
 
    char *s=NULL;
 
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("complexity undefined");
    else {
        varcount vc   = complexity_varcount(comp);
        rangecount rc = complexity_rangecount(comp);
        ifcount ic    = complexity_ifcount(comp);
 
        char * p = polynome_sprint(complexity_polynome(comp),
                (print_local_names_p ? variable_local_name 
                 : variable_name),
                is_inferior_pvarval);
 
        if ( print_stats_p ) {
            asprintf(&s,"[(var:%td/%td/%td/%td)"
                    " (rng:%td/%td/%td/%td)"
                    " (ifs:%td/%td/%td)]  %s",
                    varcount_symbolic(vc),
                    varcount_guessed(vc),
                    varcount_bounded(vc), 
                    varcount_unknown(vc),
                    rangecount_profiled(rc),
                    rangecount_guessed(rc),
                    rangecount_bounded(rc), 
                    rangecount_unknown(rc),
                    ifcount_profiled(ic), 
                    ifcount_computed(ic),
                    ifcount_halfhalf(ic),p);
            free(p);
        }
        else
            s=p;
    }
    return s;
}

References asprintf, complexity_ifcount, complexity_polynome(), complexity_rangecount, COMPLEXITY_UNDEFINED_P, complexity_varcount, free(), ifcount_computed, ifcount_halfhalf, ifcount_profiled, is_inferior_pvarval(), pips_internal_error, polynome_sprint(), rangecount_bounded, rangecount_guessed, rangecount_profiled, rangecount_unknown, varcount_bounded, varcount_guessed, varcount_symbolic, varcount_unknown, variable_local_name(), and variable_name().

Referenced by complexity_fprint(), task_complexity(), task_time_polynome(), text_complexity(), and text_summary_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

constant_entity_to_float()

float constant_entity_to_float

(

entity

e

)

Return if possible the value of e in a float.

it is supposed to be an int or a float.

Definition at line 664 of file comp_util.c.

{
    const char *cste = module_local_name(e);
    basic b = entity_basic(e);
    float f;
 
    if (basic_int_p(b) || basic_float_p(b)) {
        sscanf(cste, "%f", &f);
        return (f);
    }
    else {
        user_warning("constant_entity_to_float",
                     "Basic tag:%d, not 4->9, (entity %s)\n",basic_tag(b),cste);
        return (0.0);
    }
}

References basic_float_p, basic_int_p, basic_tag, entity_basic(), f(), module_local_name(), and user_warning.

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_list_reverse()

list entity_list_reverse

(

list

l

)

Definition at line 757 of file comp_util.c.

{
    entity e;
 
    if ((l == NIL) || (l->cdr == NIL)) 
        return l;
    e = ENTITY(CAR(l));
    return (CONS(ENTITY, e, entity_list_reverse(l->cdr)));
}

References CAR, CONS, ENTITY, and NIL.

fetch_callees_complexities()

hash_table fetch_callees_complexities

(

char *

module_name

)

translate the local name to current module name. LZ 5 Feb.93

i.e. SUB:M -> MAIN:M

FI: this seems to be wrong in general because the formal parameter and actual argument are assumed to have the same name; see DemoStd/q and variables IM/IMM; 3 March 1994

Parameters

module_name

odule_name

Definition at line 821 of file comp_util.c.

{
    hash_table hash_callees_comp = hash_table_make(hash_pointer, 0);
    callees cl;
    list callees_list;
    complexity callee_comp;
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching callees complexities ...\n");
    }
 
    cl = (callees)db_get_memory_resource(DBR_CALLEES, module_name, true);
    callees_list = callees_callees(cl);
 
    if ( callees_list == NIL ) { 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "Module %s has no callee! Done\n", module_name);
        }
        return(hash_callees_comp);
    }
 
    MAPL(pc, {
        string callee_name = STRING(CAR(pc));
        entity callee = module_name_to_entity(callee_name);
        type t = entity_type(callee);
 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "%s has callee %s!\n",module_name,callee_name);
        }
        pips_assert("call_to_complexity",
                    type_functional_p(t) || type_void_p(t));
 
        if (value_code_p(entity_initial(callee))) {
            complexity new_comp;
            callee_comp = (complexity)
                db_get_memory_resource(DBR_SUMMARY_COMPLEXITY, 
                                       (char *) callee_name,
                                       true);
 
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "fetched complexity for callee %s",
                                 callee_name);
                fprintf(stderr, " of module %s:\n", module_name);
                complexity_fprint(stderr, callee_comp, 
                                          DO_PRINT_STATS, 
                                          ! PRINT_LOCAL_NAMES);
            }
 
            debug(5,"fetch_callees_complexities","callee_name %s\n",callee_name);
 
            /* translate the local name to current module name. LZ 5 Feb.93 */
            /* i.e. SUB:M -> MAIN:M */
            /* FI: this seems to be wrong in general because the 
             * formal parameter and actual argument are assumed to
             * have the same name; see DemoStd/q and variables IM/IMM;
             * 3 March 1994
             */
            new_comp = translate_complexity_from_local_to_current_name(callee_comp, 
                                                            callee_name,module_name);
 
            hash_put(hash_callees_comp, (char *)callee, (char *)new_comp);
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "translated complexity for callee %s",
                                 callee_name);
                fprintf(stderr, " of module %s:\n", module_name);
                complexity_fprint(stderr, new_comp, 
                                          DO_PRINT_STATS, 
                                          ! PRINT_LOCAL_NAMES);
            }
        }
    }, callees_list );
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching callees complexities ... done\n");
    }
 
    return(hash_callees_comp);
}

References callee, callees_callees, CAR, complexity_fprint(), db_get_memory_resource(), debug(), DO_PRINT_STATS, entity_initial, entity_type, fprintf(), get_bool_property(), hash_pointer, hash_put(), hash_table_make(), MAPL, module_name(), module_name_to_entity(), NIL, pips_assert, PRINT_LOCAL_NAMES, STRING, translate_complexity_from_local_to_current_name(), type_functional_p, type_void_p, and value_code_p.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_complexity_parameters()

hash_table fetch_complexity_parameters

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 901 of file comp_util.c.

{
    hash_table hash_comp_params = hash_table_make(hash_pointer, 0);
    char *parameters = strdup(get_string_property("COMPLEXITY_PARAMETERS"));
    char *sep_chars = strdup(", ");
    char *token = (char*) malloc(30);
    entity e;
 
    hash_warn_on_redefinition();
   
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching complexity parameters for module %s:\n",
                module_name);
    }
 
    token = strtok(parameters, sep_chars);
 
    while (token != NULL) {
        e = gen_find_tabulated(concatenate(module_name,
                                           MODULE_SEP_STRING,
                                           token,
                                           (char *) NULL),
                               entity_domain);
        if (e != entity_undefined) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "{\t Defined entity  %s }\n", entity_name(e));
            }
            hash_put(hash_comp_params,(char *)e,HASH_USER_VARIABLE);
        }
        else {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "{\t Undefined token  %s }\n", token);
            }
        }
        token = strtok(NULL, sep_chars);
    }
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching complexity parameters: ...done.\n");
    }
 
    return(hash_comp_params);
}

References concatenate(), entity_domain, entity_name, entity_undefined, fprintf(), gen_find_tabulated(), get_bool_property(), get_string_property(), hash_pointer, hash_put(), hash_table_make(), HASH_USER_VARIABLE, hash_warn_on_redefinition(), malloc(), module_name(), MODULE_SEP_STRING, and strdup().

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

final_statement_to_complexity_evaluation()

complexity final_statement_to_complexity_evaluation	(	complexity	comp,
		transformer	precond,
		list	effects_list
	)

Parameters

comp	omp
precond	recond
effects_list	ffects_list

Definition at line 1052 of file comp_util.c.

{
    complexity final_comp = complexity_dup(comp);
    Ppolynome pp = complexity_polynome(comp);
    Pbase pb = vect_dup(polynome_used_var(pp, default_is_inferior_pvarval));
 
 
    fprintf(stderr, "Final evaluation\n");
 
    for ( ; !VECTEUR_NUL_P(pb); pb = pb->succ) {
        bool mustbewritten;
        char *var = variable_local_name(pb->var);
 
        fprintf(stderr, "Variable is %s\n", var);
 
        mustbewritten = is_must_be_written_var(effects_list, var);
 
        if ( mustbewritten ) {
            complexity compsubst;
            fprintf(stderr, "YES once\n");
            compsubst = evaluate_var_to_complexity((entity)pb->var, 
                                                   precond, 
                                                   effects_list, 1);
            complexity_fprint( stderr, compsubst, false, false);
/*
 
            final_comp = complexity_var_subst(comp, pb->var, compsubst);
*/
        }
        comp = complexity_dup(final_comp);
    }
 
    complexity_fprint( stderr, final_comp, false, false);
 
    return ( final_comp );
}

References complexity_dup(), complexity_fprint(), complexity_polynome(), default_is_inferior_pvarval(), evaluate_var_to_complexity(), fprintf(), is_must_be_written_var(), polynome_used_var(), Svecteur::succ, Svecteur::var, variable_local_name(), vect_dup(), and VECTEUR_NUL_P.

Here is the call graph for this function:

fprint_cost_table()

void fprint_cost_table

(

FILE *

fd

)

Parameters

fd

d

Definition at line 481 of file comp_util.c.

{
    struct intrinsic_cost_rec *p = intrinsic_cost_table;
    bool skip_one_line = false;
    
    fprintf(fd, "\nIntrinsic cost table:\n\n");
    fprintf(fd, "        Intrinsic name        int    float   double   complex   dcomplex\n");
    fprintf(fd, "------------------------------------------------------------------------\n");
            
    for(; p->name != NULL ;p++) {
        if (1 ||(p->int_cost      != 0) ||
            (p->float_cost    != 0) ||
            (p->double_cost   != 0) ||
            (p->complex_cost  != 0) ||
            (p->dcomplex_cost != 0)) {
            if (skip_one_line) {
                fprintf(fd, "%25s|\n", "");
                skip_one_line = false;
            }
            fprintf(fd, "%22.21s   |%6td %6td %7td %8td %8td\n",
                    p->name, p->int_cost, p->float_cost,
                    p->double_cost, p->complex_cost, p->dcomplex_cost);
        }
        else
            skip_one_line = true;
    }
    fprintf(fd, "\n");
}

References intrinsic_cost_rec::complex_cost, intrinsic_cost_rec::dcomplex_cost, intrinsic_cost_rec::double_cost, intrinsic_cost_rec::float_cost, fprintf(), intrinsic_cost_rec::int_cost, intrinsic_cost_table, and intrinsic_cost_rec::name.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_statement_complexity()

void fprint_statement_complexity	(	entity	module,
		statement	stat,
		hash_table	hash_statement_to_complexity
	)

Parameters

module	odule
stat	tat
hash_statement_to_complexity	ash_statement_to_complexity

Definition at line 253 of file comp_util.c.

{
  text t = Text_Statement(module, 0, stat);
    complexity comp;
 
    comp = ((complexity) hash_get(hash_statement_to_complexity,(char *)stat));
    if (COMPLEXITY_UNDEFINED_P(comp))
        pips_internal_error("undefined complexity");
    else {
        fprintf(stderr, "C -- ");
        complexity_fprint(stderr, comp, DO_PRINT_STATS, PRINT_LOCAL_NAMES);
    }
    print_text(stderr, t);
}

References complexity_fprint(), COMPLEXITY_UNDEFINED_P, DO_PRINT_STATS, fprintf(), hash_get(), module, pips_internal_error, PRINT_LOCAL_NAMES, print_text(), and Text_Statement().

Here is the call graph for this function:

free_callees_complexities()

hash_table free_callees_complexities

(

hash_table

h

)

Modified copies of the summary complexities are stored

Definition at line 812 of file comp_util.c.

{
    /* Modified copies of the summary complexities are stored */
    hash_table_clear(h);
    hash_table_free(h);
 
    return hash_table_undefined;
}

References hash_table_clear(), hash_table_free(), and hash_table_undefined.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

good_complexity_assert()

void good_complexity_assert	(	_UNUSED_ string	function,
		complexity	comp
	)

Definition at line 124 of file comp_util.c.

{
  if (!complexity_check(comp))
    pips_internal_error("bad internal complexity representation");
}

References complexity_check(), and pips_internal_error.

Here is the call graph for this function:

init_cost_table()

void init_cost_table

(

void

)

Completes the intrinsic cost table with the costs read from the files specified in the "COMPLEXITY_COST_TABLE" string property See properties.rc and ~pips/Pips/pipsrc.csh for more information.

L. ZHOU 13/03/91

COST_DATA are names of five data files

Definition at line 519 of file comp_util.c.

{
    char *token, *comma, *filename ;
    float file_factor;
 
    char *cost_data = strdup(COST_DATA);
    char *tmp=NULL;
 
        for(token = strtok(cost_data, " "); (token != NULL);token = strtok(NULL, " ")) {
                comma = strchr(token, ',');
 
                if (comma == NULL) {
                        tmp=strdup(token);
                        file_factor = 1.0;
                }
                else {
                        int ii = comma - token;
                        tmp=strndup( token, ii);
                        sscanf(++comma, "%f", &file_factor);
                }
 
 
                filename = strdup(concatenate( COMPLEXITY_COST_TABLES "/", get_string_property("COMPLEXITY_COST_TABLE"), "/", tmp, NULL));
 
                debug(5,"init_cost_table","file_factor is %f\n", file_factor);
                debug(1,"init_cost_table","cost file is %s\n",filename);
 
                load_cost_file(fopen_config(filename,NULL,"PIPS_COSTDIR"), file_factor);
                free(tmp);
                free(filename);
        }
 
}

References concatenate(), COST_DATA, debug(), fopen_config(), free(), get_string_property(), load_cost_file(), strdup(), and strndup().

Referenced by any_complexities(), generic_print_xml_application(), and print_xml_code().

Here is the call graph for this function:

Here is the caller graph for this function:

intrinsic_cost()

int intrinsic_cost	(	char *	s,
		basic *	pargsbasic
	)		const

Return the cost of the intrinsic named s, knowing that the "basic" type of its biggest argument is *pargsbasic.

Update *pargsbasic if the intrinsic returns a number of bigger complexity.

Inserted by AP, oct 24th 1995

To satisfy cproto . LZ 02 Feb. 93

Definition at line 617 of file comp_util.c.

{
  struct intrinsic_cost_rec *p;
  basic b;
 
  for (p = intrinsic_cost_table; p->name != NULL; p++) {
    if (same_string_p(p->name, s)) {
 
      /* Inserted by AP, oct 24th 1995 */
      if (same_string_p(p->name, "LOG") || same_string_p(p->name, "LOG10")) {
        user_warning("intrinsic_cost", "LOG or LOG10 functions used\n");
      }
 
      b = make_basic(p->min_basic_result, (void *) p->min_nbytes_result);
      if (is_inferior_basic(*pargsbasic, b)) {
        free_basic(*pargsbasic);
        *pargsbasic = simple_basic_dup(b);
      }
 
      switch (basic_tag(*pargsbasic)) {
        case is_basic_int:
          return(p->int_cost);
        case is_basic_float:
          return (basic_float(*pargsbasic) <= FLOAT_NBYTES ?
                  p->float_cost : p->double_cost);
        case is_basic_complex:
          return (basic_complex(*pargsbasic) <= COMPLEX_NBYTES ?
                  p->complex_cost : p->dcomplex_cost);
        case is_basic_string:
          return (STRING_INTRINSICS_COST);
        case is_basic_logical:
          return (LOGICAL_INTRINSICS_COST);
        default:
          pips_internal_error("basic tag is %d", basic_tag(*pargsbasic));
        }
    }
  }
  /* To satisfy cproto . LZ 02 Feb. 93 */
  return (STRING_INTRINSICS_COST);
}

References basic_complex, basic_float, basic_tag, intrinsic_cost_rec::complex_cost, COMPLEX_NBYTES, intrinsic_cost_rec::dcomplex_cost, intrinsic_cost_rec::double_cost, intrinsic_cost_rec::float_cost, FLOAT_NBYTES, free_basic(), intrinsic_cost_rec::int_cost, intrinsic_cost_table, is_basic_complex, is_basic_float, is_basic_int, is_basic_logical, is_basic_string, is_inferior_basic(), LOGICAL_INTRINSICS_COST, make_basic(), intrinsic_cost_rec::min_basic_result, intrinsic_cost_rec::min_nbytes_result, intrinsic_cost_rec::name, pips_internal_error, same_string_p, simple_basic_dup(), STRING_INTRINSICS_COST, and user_warning.

Referenced by call_to_complexity(), loop_to_complexity(), reference_to_complexity(), and syntax_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

is_linear_unstructured()

bool is_linear_unstructured

(

unstructured

unstr

)

return true if unstr is simply a linear string of controls

Parameters

unstr

nstr

Definition at line 738 of file comp_util.c.

{
    control current = unstructured_control(unstr);
    control exit = unstructured_exit(unstr);
 
    while (current != exit) {
        list succs = control_successors(current);
 
        if (succs == NIL)
            pips_internal_error("control != exit one,it has no successor");
        if (CDR(succs) != NIL) 
            return (false);
        current = CONTROL(CAR(succs));
    }
 
    return(true);
}

References CAR, CDR, CONTROL, control_successors, current, exit, NIL, pips_internal_error, unstructured_control, and unstructured_exit.

is_must_be_written_var()

bool is_must_be_written_var	(	list	effects_list,
		char *	var_name
	)

fprintf(stderr, "is_must_be_written_var for entity %s\n", module_local_name(e) );

Parameters

effects_list	ffects_list
var_name	ar_name

Definition at line 1014 of file comp_util.c.

{
    MAPL(ce, { 
        effect eff = EFFECT(CAR(ce));
 
        if(eff == effect_undefined)
            pips_internal_error("unexpected effect undefined");
 
        if ( action_write_p(effect_action(eff)) 
            && approximation_exact_p(effect_approximation(eff)) ) {
            reference r = effect_any_reference(eff);
            entity e = reference_variable(r);
/*          
            fprintf(stderr, "is_must_be_written_var for entity %s\n", 
                    module_local_name(e) );
*/
            if ( strcmp(module_local_name(e), var_name) == 0 ) {
                return (true);
            }
        }
/*
        else {
            fprintf(stderr, "is_must_be_written_var for NOT entity %s\n", 
                    module_local_name(reference_variable(effect_any_reference(eff))) );
        }
*/
    },effects_list);
 
    return (false);
}

References action_write_p, approximation_exact_p, CAR, EFFECT, effect_action, effect_any_reference, effect_approximation, effect_undefined, MAPL, module_local_name(), pips_internal_error, and reference_variable.

Referenced by final_statement_to_complexity_evaluation().

Here is the call graph for this function:

Here is the caller graph for this function:

load_cost_file()

void load_cost_file	(	FILE *	fd,
		float	file_factor
	)

Load (some) intrinsics costs from file "fd", multiplying them by "file_factor".

Definition at line 557 of file comp_util.c.

{
    char *line = (char*) malloc(199);
    char *intrinsic_name = (char*) malloc(30);
    int int_cost, float_cost, double_cost, complex_cost, dcomplex_cost;
    struct intrinsic_cost_rec *p;
    float scale_factor = 1.0;
    bool recognized;
 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "\nReading cost file ");
            if (file_factor != 1.0) 
                fprintf(stderr, "(x %.2f)", file_factor);
        }
        
        while (fgets(line, 99, fd) != NULL) {
            if (*line == '%')
                sscanf(line+1, "%f", &scale_factor);
            else if ((*line != '#') && (*line != '\n')) {
                sscanf(line, "%s %d %d %d %d %d", intrinsic_name,
                       &int_cost, &float_cost, &double_cost,
                       &complex_cost, &dcomplex_cost);
                recognized = false;
                for (p = intrinsic_cost_table; p->name != NULL; p++) {
                    if (same_string_p(p->name, intrinsic_name)) {
                        p->int_cost = (int)
                            (int_cost * scale_factor * file_factor + 0.5);
                        p->float_cost = (int)
                            (float_cost * scale_factor * file_factor + 0.5);
                        p->double_cost = (int)
                            (double_cost * scale_factor * file_factor + 0.5);
                        p->complex_cost = (int)
                            (complex_cost * scale_factor * file_factor + 0.5);
                        p->dcomplex_cost = (int)
                            (dcomplex_cost * scale_factor * file_factor + 0.5);
                        recognized = true;
                        break;
                    }
                }
                if (!recognized)
                    user_warning("load_cost_file",
                                 "%s:unrecognized intrinsic\n",intrinsic_name);
            }
        }
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "\nScale factor is %f\n", scale_factor);
        }
        fclose(fd);
 
    free(intrinsic_name);
    free(line);
}

References intrinsic_cost_rec::complex_cost, intrinsic_cost_rec::dcomplex_cost, intrinsic_cost_rec::double_cost, intrinsic_cost_rec::float_cost, fprintf(), free(), get_bool_property(), int, intrinsic_cost_rec::int_cost, intrinsic_cost_table, line, malloc(), intrinsic_cost_rec::name, same_string_p, and user_warning.

Referenced by init_cost_table().

Here is the call graph for this function:

Here is the caller graph for this function:

prc()

void prc

(

complexity

comp

)

Parameters

comp	for dbxtool: "print complexity"

Definition at line 233 of file comp_util.c.

{
    complexity_fprint(stderr, comp, true, true);
}

References complexity_fprint().

Referenced by pvecteur_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

prp()

void prp

(

Ppolynome

pp

)

Parameters

pp	for dbxtool: "print polynome"

Definition at line 239 of file comp_util.c.

{
    polynome_fprint(stderr, pp, variable_name, is_inferior_pvarval);
    fprintf(stderr, "\n");
}

References fprintf(), is_inferior_pvarval(), polynome_fprint(), and variable_name().

Referenced by complexity_sigma().

Here is the call graph for this function:

Here is the caller graph for this function:

prv()

void prv

(

Pvecteur

pv

)

Parameters

pv	for dbxtool: "print vecteur (as a monome)"

Definition at line 246 of file comp_util.c.

{
    vect_fprint_as_monome(stderr, pv, BASE_NULLE, variable_name, ".");
    fprintf(stderr, "\n");
}

References BASE_NULLE, fprintf(), variable_name(), and vect_fprint_as_monome().

Referenced by sc_projection_optim_along_vecteur_ofl().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_common_variables_from_hash_table()

void remove_common_variables_from_hash_table	(	entity	module,
		hash_table	hash_complexity_params
	)

Parameters

module	odule
hash_complexity_params	ash_complexity_params

Definition at line 985 of file comp_util.c.

{
    const char* module_name = module_local_name(module);
    list sefs_list;
 
    pips_assert("remove_common_variables_from_hash_table",
                entity_module_p(module));
 
    sefs_list = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    MAPL(ce, { 
        effect obj = EFFECT(CAR(ce));
        reference r = effect_any_reference(obj);
        action ac = effect_action(obj);
        approximation ap = effect_approximation(obj);
        entity e = reference_variable(r);
 
        if ( action_read_p(ac) && approximation_exact_p(ap) ) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "%s deleted\n", module_local_name(e));
            }
            hash_del(hash_complexity_params, (char *) module_local_name(e));
        }
    }, sefs_list);
}

References action_read_p, approximation_exact_p, CAR, db_get_memory_resource(), EFFECT, effect_action, effect_any_reference, effect_approximation, effects_to_list(), entity_module_p(), fprintf(), get_bool_property(), hash_del(), MAPL, module, module_local_name(), module_name(), pips_assert, and reference_variable.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_formal_parameters_from_hash_table()

void remove_formal_parameters_from_hash_table	(	entity	mod,
		hash_table	hash_complexity_params
	)

Parameters

mod	od
hash_complexity_params	ash_complexity_params

Definition at line 791 of file comp_util.c.

{
    list decl;
 
    pips_assert("remove_formal_parameters_from_hash_table",
                entity_module_p(mod));
    decl = code_declarations(value_code(entity_initial(mod)));
 
    MAPL(pe, {
        entity param = ENTITY(CAR(pe));
        if (storage_formal_p(entity_storage(param)))
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"storage_formal %s to be deleted\n",
                        entity_name(param));
            }
            hash_del(hash_complexity_params, (char *) module_local_name(param));
    }, decl);
}

References CAR, code_declarations, ENTITY, entity_initial, entity_module_p(), entity_name, entity_storage, fprintf(), get_bool_property(), hash_del(), MAPL, module_local_name(), pips_assert, storage_formal_p, and value_code.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

trace_off()

void trace_off

(

void

)

"trace off"

Definition at line 714 of file comp_util.c.

{
    if (get_bool_property("COMPLEXITY_TRACE_CALLS")) {
        char *indentstring = (char*) malloc(99);
        bool b = (call_level >= 0);
        int i,k=1;
 
        indentstring[0] = '\0';
        call_level--;
        for (i=0; i< (b ? call_level : - call_level); i++) {
            indentstring = strcat(indentstring,
                                  strdup(b ? ( (k>0) ? INDENT_BLANKS
                                                     : INDENT_VLINE )
                                           : INDENT_BACK));
            k = ( k<INDENT_INTERVAL ? k+1 : 0 );
        }
        fprintf(stderr, "%s<\n", indentstring);
        free(indentstring);
    }
}

References call_level, fprintf(), free(), get_bool_property(), INDENT_BACK, INDENT_BLANKS, INDENT_INTERVAL, INDENT_VLINE, malloc(), and strdup().

Referenced by any_complexities(), arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), evaluate_var_to_complexity(), expression_to_complexity(), expression_to_complexity_polynome(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), normalized_to_polynome(), pvecteur_to_polynome(), range_to_complexity(), range_to_polynome(), reference_to_complexity(), reference_to_polynome(), statement_to_complexity(), summary_complexity(), syntax_to_complexity(), syntax_to_polynome(), test_to_complexity(), and unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

trace_on()

void trace_on	(	char *	fmt,
			...
	)

Parameters

fmt

mt

Definition at line 684 of file comp_util.c.

{
    if (get_bool_property("COMPLEXITY_TRACE_CALLS")) {
        va_list args;
        char *indentstring = (char*) malloc(99);
        bool b = (call_level >= 0);
        int i,k=1;
 
        indentstring[0] = '\0';
 
        for (i=0; i< (b ? call_level : - call_level); i++) {
            indentstring = strcat(indentstring,
                                  strdup(b ? ( (k>0) ? INDENT_BLANKS
                                                     : INDENT_VLINE )
                                           : INDENT_BACK));
            k = ( k<INDENT_INTERVAL ? k+1 : 0 );
        }
 
        fprintf(stderr, "%s>", indentstring);
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        fprintf(stderr, "\n");
        va_end(args);
 
        free(indentstring);
        call_level++;
    }
}

References call_level, fprintf(), free(), get_bool_property(), INDENT_BACK, INDENT_BLANKS, INDENT_INTERVAL, INDENT_VLINE, malloc(), and strdup().

Referenced by any_complexities(), arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), evaluate_var_to_complexity(), expression_to_complexity(), expression_to_complexity_polynome(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), normalized_to_polynome(), pvecteur_to_polynome(), range_to_complexity(), range_to_polynome(), reference_to_complexity(), reference_to_polynome(), statement_to_complexity(), summary_complexity(), syntax_to_complexity(), syntax_to_polynome(), test_to_complexity(), and unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_complexity_from_local_to_current_name()

complexity translate_complexity_from_local_to_current_name	(	complexity	callee_comp,
		string	oldname,
		string	newname
	)

translate_complexity_from_local_to_current_name(callee_comp,oldname,newname) B:M -> A:M if A calls B 5 Feb.

93 LZ

This is not general enough to handle: B:M -> A:N or B:M to A:N+1 FI, 3 March 1994

constant complexity

The basis associated to a polynomial includes the constant term!

constant complexity

Parameters

callee_comp	allee_comp
oldname	ldname
newname	ewname

Definition at line 1100 of file comp_util.c.

{
    Ppolynome pp = complexity_polynome(callee_comp);
    Pbase pb = polynome_used_var(pp, is_inferior_pvarval);
    Pbase pbcur = BASE_UNDEFINED;
    complexity comp = make_zero_complexity();
    complexity old_comp = complexity_dup(callee_comp);
 
    if(BASE_NULLE_P(pb)) {
        /* constant complexity */
        comp = complexity_dup(callee_comp);
        return comp;
    }
 
    /* The basis associated to a polynomial includes the constant term! */
    if(base_dimension(pb)==1 && term_cst(pb)) {
        /* constant complexity */
        comp = complexity_dup(callee_comp);
        return comp;
    }
 
    for (pbcur=pb; pbcur != VECTEUR_NUL ; pbcur = pbcur->succ ) {
        Variable var = pbcur->var;
        char * stmp = strdup(variable_name(var));
 
        char *s = stmp;
        char *t = strchr(stmp,':');
 
        if ( t != NULL ) {
            int length = (int)(t - s);
            char *cur_name = (char *)malloc(100);
 
            (void) strncpy(cur_name,stmp,length);
            * (cur_name+length) = '\0';
 
            if ( 1 || strncmp(cur_name, oldname, length) == 0 ) {
                Variable newvar = name_to_variable(concatenate(strdup(newname),
                                                               ":",strdup(t+1),NULL));
                if ( newvar != (Variable) chunk_undefined ) {
                    complexity compsubst = make_single_var_complexity(1.0, newvar);
 
/*
                    polynome_chg_var(&pp, var, newvar);
*/
                    comp = complexity_var_subst(old_comp, var, compsubst);
                    old_comp = complexity_dup(comp);
                }
                else {
                    comp = complexity_dup(old_comp);
                    old_comp = complexity_dup(comp);
                }                   
            }
        }
    }
    return (comp);
}

References base_dimension, BASE_NULLE_P, BASE_UNDEFINED, chunk_undefined, complexity_dup(), complexity_polynome(), complexity_var_subst(), concatenate(), int, is_inferior_pvarval(), make_single_var_complexity(), make_zero_complexity(), malloc(), name_to_variable(), polynome_used_var(), strdup(), Svecteur::succ, term_cst, Svecteur::var, variable_name(), and VECTEUR_NUL.

Referenced by fetch_callees_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

call_level

int call_level =0

static

"trace on"

Definition at line 683 of file comp_util.c.

Referenced by trace_off(), and trace_on().

intrinsic_cost_table

intrinsic_cost_record intrinsic_cost_table[]

The table intrinsic_cost_table[] gathers cost information of each intrinsic's cost; those costs are dynamically loaded from user files.

It also returns the "minimum" type of the result of each intrinsic, specified by its basic_tag and number of memory bytes. ("bigger" and "minimum" refer to the order relation defined in the routine "is_inferior_basic"; the tag is_basic_overloaded is used as a don't care tag) (ex: SIN has a type of FLOAT even if its arg is an INT)

Modif: – LOOP_OVERHEAD and CALL_OVERHEAD are added, 280993 LZ – LOOP_OVERHEAD is divided into two: INIT and BRAANCH 081093 LZ

Definition at line 286 of file comp_util.c.

Referenced by fprint_cost_table(), intrinsic_cost(), and load_cost_file().