optimize.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "misc.h"
#include "properties.h"
#include "resources.h"
#include "pipsdbm.h"
#include "control.h"
#include "eole_private.h"
#include "expressions.h"

Include dependency graph for optimize.c:

Go to the source code of this file.

Data Structures
struct	optimization_strategy
	this structure defines a strategy for eole. More...
struct	extract_expr_t
	extract expressions with loop level information. More...
struct	binary_to_nary_t
struct	symetric_opertor_t
struct	cost_expression

Macros
#define	DEBUG_NAME   "TRANSFORMATION_OPTIMIZE_EXPRESSIONS_DEBUG_LEVEL"
#define	OUT_FILE_NAME   "/tmp/pips_to_eole"
	file name prefixes to deal with eole. More...
#define	IN_FILE_NAME   "/tmp/eole_to_pips"
#define	EOLE   "EOLE" /**eole binary */
	property names. More...
#define	EOLE_FLAGS   "EOLE_FLAGS" /**default options */
#define	EOLE_OPTIONS   "EOLE_OPTIONS" /**additionnal options */
#define	SIZE_OF_BUFFER   100
#define	MAX_NAME   "MAX"
#define	MIN_NAME   "MIN"
#define	GRAPH_PREFIX   "optimize_expressions_"
#define	GRAPH_SUFFIX   ".daVinci"

Typedefs
typedef struct optimization_strategy *	poptimization_strategy
typedef struct extract_expr_t *	extract_expr_p

Enumerations
enum	asocom_operator_t {   not_asocom , is_plus , is_mult , is_max ,   is_min , is_and , is_or }
	switch binary to nary expressions where possible. More...

Functions
static string	get_eole_command (const char *in, const char *out, const char *flags)
	returns the eole command to be executed in an allocated string. More...
static bool	is_string_constant (entity e)
static void	eole_okay_call_rwt (call c, bool *okay)
static bool	eole_manageable_expression (expression e)
static void	add_one_more_expression (expression e, extract_expr_p context)
static bool	loop_flt (loop l, extract_expr_p context)
static void	loop_rwt (loop l, extract_expr_p context)
static bool	call_filter (call c, extract_expr_p context)
	rhs expressions of assignments. More...
static bool	expr_filter (expression e, extract_expr_p context)
	other expressions may be found in loops and so? More...
static list	get_list_of_rhs (statement s)
	of expressionwithlevel More...
static void	write_list_of_rhs (FILE *out, list le)
	export a list of expression of the current module. More...
static void	write_to_eole (const char *module, list le, const char *file_name)
	export expressions to eole thru the newgen format. More...
static string	read_and_allocate_string_from_file (FILE *file)
static void	read_new_entities_from_eole (FILE *file, const char *module)
	import a list of entity that have been created during the eole transformations and create them More...
static list	read_from_eole (const char *module, const char *file_name)
	import expressions from eole. More...
static void	swap_syntax_in_expression (list lcode, list lnew)
	swap term to term syntax field in expression list, as a side effect... More...
static void	apply_eole_on_statement (const char *module_name, statement s, const char *flags)
	apply eole on all expressions in s. More...
static expression	is_uminus (expression e)
	returns B if uminus(B), else 0 More...
static void	call_simplify_rwt (call c)
static void	generate_bminus (statement s)
static void	optimize_simplify_patterns (statement s)
	look for some expressions in s and simplify some patterns. More...
static bool	is_inverse (expression e)
static void	call_nary_rwt (call c)
static void	optimize_simplify_nary_patterns (statement s)
static double	expression_gravity_rc (expression e, double depth)
	forward substitute if only there once. More...
static double	expression_gravity (expression e)
static double	expression_gravity_inv (expression e)
static entity	binary_to_nary (entity e)
static bool	nary_operator_p (entity e)
static bool	nary_call_flt (call c)
	top-down: switch calls to nary form. More...
static void	nary_call_rwt (call c)
	bottom-up: + + -> + More...
void	naryfication_of_expressions (statement s)
	optimize.c More...
static symetric_opertor_t *	what_operator (entity e, int which_one)
entity	inverse_operator_of (entity e)
static bool	inv_call_flt (call c)
void	inverse_normalization_of_expressions (statement s)
static int	cost_expression_cmp (const void *v1, const void *v2)
	comparison function for qsort. More...
static void	debug_cost_expression_array (string s, cost_expression *tce, int size)
	debug function More...
static cost_expression *	list_of_expressions_to_array (list le, double(*cost)(expression))
	build an cost_expression array from an expression list. More...
static void	insert_sorted_into_array (cost_expression *tce, int n, cost_expression ce)
	insert ce in tce[0..n-1] by decreassing order. More...
static void	insert_last_into_array (cost_expression *tce, int n, cost_expression ce)
	simply insert. More...
static void	call_rwt (call c)
	apply huffman balancing algorithm if it is a call to huffman_nary_operator. More...
static void	build_binary_operators_with_huffman (statement s, entity nary_operator, entity binary_operator, double(*cost)(expression), bool mode)
	apply the huffman balancing on every call to nary_operator and build calls to binary_operator instead, with cost to chose. More...
static void	switch_nary_to_binary (statement s)
	switch nary operators to binary ones. More...
static void	set_current_optimization_strategy (void)
static void	reset_current_optimization_strategy (void)
static void	davinci_dump_expressions (const char *module_name, string phase, statement s)
	dump all expressions in s as davinci graphs. More...
static void	do_convert_to_c_operator (call c)
void	convert_to_c_operators (void *v)
static void	do_convert_to_standard_operators (call c)
void	convert_to_standard_operators (void *v)
bool	optimize_expressions (const char *module_name)
	pipsmake interface to apply expression optimization according to various strategy. More...

Variables
static poptimization_strategy	strategy = NULL
	current strategy. More...
static entity	bplus = NULL
	A + (–B) -> A - B FMA -> FMS. More...
static entity	uminus = NULL
static entity	bminus = NULL
static entity	fmaop = NULL
static entity	fmsop = NULL
static entity	multiply = NULL
static entity	inverse = NULL
static entity	divide = NULL
static binary_to_nary_t	bton []
static symetric_opertor_t	symop []
static entity	huffman_nary_operator = NULL
	switch nary to binary with huffman algorithm. More...
static entity	huffman_binary_operator = NULL
static double(*	huffman_cost )(expression) = NULL
static bool	huffman_mode = true
	true: Huffman. More...
static optimization_strategy	strategies []
	predefined optimization strategies. More...

Macro Definition Documentation

DEBUG_NAME

#define DEBUG_NAME   "TRANSFORMATION_OPTIMIZE_EXPRESSIONS_DEBUG_LEVEL"

Definition at line 50 of file optimize.c.

EOLE

#define EOLE   "EOLE" /**eole binary */

property names.

Definition at line 106 of file optimize.c.

EOLE_FLAGS

#define EOLE_FLAGS   "EOLE_FLAGS" /**default options */

Definition at line 107 of file optimize.c.

EOLE_OPTIONS

#define EOLE_OPTIONS   "EOLE_OPTIONS" /**additionnal options */

Definition at line 108 of file optimize.c.

GRAPH_PREFIX

#define GRAPH_PREFIX   "optimize_expressions_"

Definition at line 1309 of file optimize.c.

GRAPH_SUFFIX

#define GRAPH_SUFFIX   ".daVinci"

Definition at line 1310 of file optimize.c.

IN_FILE_NAME

#define IN_FILE_NAME   "/tmp/eole_to_pips"

Definition at line 102 of file optimize.c.

MAX_NAME

#define MAX_NAME   "MAX"

Definition at line 722 of file optimize.c.

MIN_NAME

#define MIN_NAME   "MIN"

Definition at line 723 of file optimize.c.

OUT_FILE_NAME

#define OUT_FILE_NAME   "/tmp/pips_to_eole"

file name prefixes to deal with eole.

/tmp should be fast (may be mapped into memory).

Definition at line 101 of file optimize.c.

SIZE_OF_BUFFER

#define SIZE_OF_BUFFER   100

Definition at line 256 of file optimize.c.

Typedef Documentation

extract_expr_p

typedef struct extract_expr_t * extract_expr_p

poptimization_strategy

typedef struct optimization_strategy * poptimization_strategy

Enumeration Type Documentation

asocom_operator_t

enum asocom_operator_t

switch binary to nary expressions where possible.

this is normally done in eole anyway.

Enumerator
not_asocom
is_plus	0
is_mult
is_max
is_min
is_and
is_or

Definition at line 706 of file optimize.c.

{ 
  not_asocom, /* 0 */
  is_plus, is_mult, 
  is_max, is_min, 
  is_and, is_or 
} 

Function Documentation

add_one_more_expression()

static void add_one_more_expression ( expression  e, extract_expr_p  context  )

static

Definition at line 166 of file optimize.c.

{
  expressionwithlevel ewl = 
    make_expressionwithlevel(gen_nreverse(gen_copy_seq(context->indices)), e);
  context->rhs = CONS(EXPRESSIONWITHLEVEL, ewl, context->rhs);
}

References CONS, EXPRESSIONWITHLEVEL, gen_copy_seq(), gen_nreverse(), and make_expressionwithlevel().

Referenced by call_filter(), and expr_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_eole_on_statement()

static void apply_eole_on_statement ( const char *  module_name, statement  s, const char *  flags  )

static

apply eole on all expressions in s.

of expressionwithlevel/expression

not empty list

create temporary files

write informations in out file for EOLE

run eole (Evaluation Optimization for Loops and Expressions) as a separate process.

read optimized expressions from eole

replace the syntax values inside le by the syntax values from ln

must now free the useless expressions

remove temorary files and free allocated memory.

free strings

free lists

Definition at line 383 of file optimize.c.

{
  list /* of expressionwithlevel/expression */ le, ln;
 
  ln = NIL;
  le = get_list_of_rhs(s);
  
  if (gen_length(le)) /* not empty list */
  {
    string in, out, cmd;
 
    /* create temporary files */
    in = safe_new_tmp_file(IN_FILE_NAME);
    out = safe_new_tmp_file(OUT_FILE_NAME);
    
    /* write informations in out file for EOLE */
    write_to_eole(module_name, le, out);
    
    /* run eole (Evaluation Optimization for Loops and Expressions) 
     * as a separate process.
     */
    cmd = get_eole_command(in, out, flags);
    
    pips_debug(2, "executing: %s\n", cmd);
    
    safe_system(cmd);
    
    /* read optimized expressions from eole */
    ln = read_from_eole(module_name, in);
    
    /* replace the syntax values inside le by the syntax values from ln */
    swap_syntax_in_expression(le, ln);
    
    /* must now free the useless expressions */
    
    
    /* remove temorary files and free allocated memory.
     */
    safe_unlink(out);
    safe_unlink(in);
    
    /* free strings */
    free(out), out = NULL;
    free(in), in = NULL;
    free(cmd), cmd = NULL;
  }
  else 
    pips_debug(3, "no expression for module %s\n", module_name);
 
  pips_debug(3,"EOLE transformations done for module %s\n", module_name);
 
  /* free lists */
  gen_free_list(ln);
  gen_free_list(le);
}

References free(), gen_free_list(), gen_length(), get_eole_command(), get_list_of_rhs(), IN_FILE_NAME, module_name(), NIL, out, OUT_FILE_NAME, pips_debug, read_from_eole(), safe_new_tmp_file(), safe_system(), safe_unlink(), swap_syntax_in_expression(), and write_to_eole().

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

binary_to_nary()

static entity binary_to_nary ( entity  e )

static

Definition at line 748 of file optimize.c.

{
  const char* lname = entity_local_name(e);
  binary_to_nary_t * pbn;
 
  for (pbn = bton; pbn->binary; pbn++)
    if (same_string_p(pbn->binary, lname))
      return entity_intrinsic(pbn->nary);
 
  return e;
}

References binary_to_nary_t::binary, bton, entity_intrinsic(), entity_local_name(), lname(), binary_to_nary_t::nary, and same_string_p.

Referenced by nary_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

build_binary_operators_with_huffman()

static void build_binary_operators_with_huffman ( statement  s, entity  nary_operator, entity  binary_operator, double(*)(expression)  cost, bool  mode  )

static

apply the huffman balancing on every call to nary_operator and build calls to binary_operator instead, with cost to chose.

Definition at line 1108 of file optimize.c.

{
  huffman_nary_operator = nary_operator;
  huffman_binary_operator = binary_operator;
  huffman_cost = cost;
  huffman_mode = mode;
 
  ifdebug(8) print_statement(s);
 
  gen_multi_recurse(s,
                    call_domain, gen_true, call_rwt,
                    NULL);
 
  huffman_nary_operator = NULL;
  huffman_binary_operator = NULL;
  huffman_cost = NULL;  
  huffman_mode = true;
}

References call_domain, call_rwt(), gen_multi_recurse(), gen_true(), huffman_binary_operator, huffman_cost, huffman_mode, huffman_nary_operator, ifdebug, and print_statement().

Referenced by switch_nary_to_binary().

Here is the call graph for this function:

Here is the caller graph for this function:

call_filter()

static bool call_filter ( call  c, extract_expr_p  context  )

static

rhs expressions of assignments.

put all manageable expressions arguments...

Definition at line 191 of file optimize.c.

{
  /* put all manageable expressions arguments... */
  MAP(EXPRESSION, e, 
      if (eole_manageable_expression(e)) add_one_more_expression(e, context), 
      call_arguments(c));
  return false;
}

References add_one_more_expression(), call_arguments, eole_manageable_expression(), EXPRESSION, and MAP.

Referenced by get_list_of_rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

call_nary_rwt()

static void call_nary_rwt ( call  c )

static

it is a multiply

nothing to change

Definition at line 562 of file optimize.c.

{
  entity func = call_function(c);
  list numerator = NIL, denominator = NIL;
  int nnum, nden;
  expression enu, eden;
  
  if (func != multiply) return;
  /* it is a multiply */
  
  MAP(EXPRESSION, e,
  {
    if (is_inverse(e))
      denominator = 
        CONS(EXPRESSION, 
          EXPRESSION(CAR(call_arguments(syntax_call(expression_syntax(e))))),
             denominator);
    else
      numerator = CONS(EXPRESSION, e, numerator);
  },
      call_arguments(c));
 
  nden = gen_length(denominator);
  nnum = gen_length(numerator);
 
  switch (nden)
  {
  case 0: /* nothing to change */
    gen_free_list(denominator);
    gen_free_list(numerator);
    return;
  case 1:
    eden = EXPRESSION(CAR(denominator));
    gen_free_list(denominator);
    break;
  default:
    eden = call_to_expression(make_call(multiply, denominator));
    break;
  }
 
  switch (nnum) 
  {
  case 0:
    enu = int_to_expression(1);
    break;
  case 1:
    enu = EXPRESSION(CAR(numerator));
    gen_free_list(numerator);
    break;
  default:
    enu = call_to_expression(make_call(multiply, numerator));
    break;
  }
 
  call_function(c) = divide;
  gen_free_list(call_arguments(c));
  call_arguments(c) = CONS(EXPRESSION, enu, CONS(EXPRESSION, eden, NIL));
}

References call_arguments, call_function, call_to_expression(), CAR, CONS, divide, EXPRESSION, expression_syntax, gen_free_list(), gen_length(), int_to_expression(), is_inverse(), make_call(), MAP, multiply, NIL, and syntax_call.

Referenced by optimize_simplify_nary_patterns().

Here is the call graph for this function:

Here is the caller graph for this function:

call_rwt()

static void call_rwt ( call  c )

static

apply huffman balancing algorithm if it is a call to huffman_nary_operator.

the prettyprint may only reflect this if the PRETTYPRINT_ALL_PARENTHESES property is set to true.

let us switch to a binary tree.

the call is already binary.

else

drop initial list:

last one is done in place.

Definition at line 1046 of file optimize.c.

{
  if (call_function(c)==huffman_nary_operator) 
  {
    /* let us switch to a binary tree. */
    list args = call_arguments(c);
    int nargs = gen_length(args);
    cost_expression * tce;
 
    pips_debug(4, "dealing with operator %s\n", 
               entity_name(huffman_nary_operator));
 
    //pips_assert("several arguments to nary operator", nargs>=2);
    if (nargs < 2)
    {
      fprintf(stderr,"\n[call_rwt] --- (nargs=%d) < 2; Call = %s \n",
              nargs, entity_name(call_function(c)));
      print_expression(EXPRESSION(CAR(args)));
      return;
    }
 
    if (nargs==2) /* the call is already binary. */
    {
      call_function(c) = huffman_binary_operator;
      return;
    }
    /* else */
 
    tce = list_of_expressions_to_array(args, huffman_cost);
    /* drop initial list: */
    gen_free_list(args), args = NIL, call_arguments(c) = NIL;
 
    while (nargs>2)
    {
      cost_expression ce;
      ce.expr = MakeBinaryCall(huffman_binary_operator,
                               tce[nargs-1].expr, tce[nargs-2].expr);
      ce.cost = huffman_cost(ce.expr);
 
      if (huffman_mode) insert_sorted_into_array(tce, nargs-2, ce);
      else              insert_last_into_array(tce,  nargs-2, ce);
 
      ifdebug(3) debug_cost_expression_array("insert done", tce, nargs-1);
 
      nargs--;
    }
 
    /* last one is done in place. */
    call_function(c) = huffman_binary_operator;
    call_arguments(c) = CONS(EXPRESSION, tce[0].expr,
                             CONS(EXPRESSION, tce[1].expr, NIL));
    free(tce), tce = NULL;
  }
  else 
    pips_debug(3,"non huffman operator : %s\n ", 
               entity_local_name(call_function(c)));
}

References call_arguments, call_function, CAR, CONS, cost_expression::cost, debug_cost_expression_array(), entity_local_name(), entity_name, cost_expression::expr, EXPRESSION, fprintf(), free(), gen_free_list(), gen_length(), huffman_binary_operator, huffman_cost, huffman_mode, huffman_nary_operator, ifdebug, insert_last_into_array(), insert_sorted_into_array(), list_of_expressions_to_array(), MakeBinaryCall(), NIL, pips_debug, and print_expression().

Referenced by build_binary_operators_with_huffman().

Here is the call graph for this function:

Here is the caller graph for this function:

call_simplify_rwt()

static void call_simplify_rwt ( call  c )

static

memory leak

memory leak

FMA(A,B,-C) => FMS(A,B,C)

avoid memory leak

Definition at line 466 of file optimize.c.

{
  if (call_function(c)==bplus)
  {
    list la = call_arguments(c);
    expression e1, e2, me;
    
    pips_assert("2 args to binary plus", gen_length(la)==2);
 
    e1 = EXPRESSION(CAR(la));
    e2 = EXPRESSION(CAR(CDR(la)));
 
    me = is_uminus(e2);
    if (me)
    {
      EXPRESSION_(CAR(CDR(la))) = me; /* memory leak */
      call_function(c) = bminus;
      return;
    }
 
    me = is_uminus(e1);
    if (me)
    {
      EXPRESSION_(CAR(CDR(la))) = me;
      EXPRESSION_(CAR(la)) = e2; /* memory leak */
      call_function(c) = bminus;
      return;
    }
  }
  else if (call_function(c)==fmaop) /* FMA(A,B,-C) => FMS(A,B,C) */
  {
    list la = call_arguments(c);
    expression e3 = EXPRESSION(CAR(CDR(CDR(la)))), me;
 
    me = is_uminus(e3);
    if (me) 
    {
      /* avoid memory leak */
      gen_free_list(call_arguments(syntax_call(expression_syntax(e3))));
      call_arguments(syntax_call(expression_syntax(e3))) = NIL;
      free_expression(e3);
      
      call_function(c) = fmsop;
      EXPRESSION_(CAR(CDR(CDR(la)))) = me;
    }
  }
}

References bminus, bplus, call_arguments, call_function, CAR, CDR, EXPRESSION, EXPRESSION_, expression_syntax, fmaop, fmsop, free_expression(), gen_free_list(), gen_length(), is_uminus(), NIL, pips_assert, and syntax_call.

Referenced by generate_bminus().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_c_operators()

void convert_to_c_operators

(

void *

v

)

Definition at line 1343 of file optimize.c.

                                      {
    gen_recurse(v,call_domain,gen_true,do_convert_to_c_operator);
}

References call_domain, do_convert_to_c_operator(), gen_recurse, and gen_true().

Referenced by do_gather_all_expressions_perms(), and optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_standard_operators()

void convert_to_standard_operators

(

void *

v

)

Definition at line 1364 of file optimize.c.

                                             {
    gen_recurse(v,call_domain,gen_true,do_convert_to_standard_operators);
}

References call_domain, do_convert_to_standard_operators(), gen_recurse, and gen_true().

Referenced by expression_substitution(), optimize_expressions(), and set_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

cost_expression_cmp()

static int cost_expression_cmp ( const void *  v1, const void *  v2  )

static

comparison function for qsort.

descending order.

when they are equals another criterion may be used, so as to favor double loads (with neighbor references).

Definition at line 965 of file optimize.c.

{
  cost_expression * c1 = (cost_expression *) v1;
  cost_expression * c2 = (cost_expression *) v2;
  if (c1->cost==c2->cost) 
    /* when they are equals another criterion may be used, so as 
       to favor double loads (with neighbor references).
     */
    return 0;
  return 2*(c1->cost<c2->cost) - 1;
}

References cost_expression::cost.

Referenced by list_of_expressions_to_array().

Here is the caller graph for this function:

davinci_dump_expressions()

static void davinci_dump_expressions ( const char *  module_name, string  phase, statement  s  )

static

dump all expressions in s as davinci graphs.

filename: $current.database/$module/$prefix_$phase.$suffix

directory MUST exist

Definition at line 1314 of file optimize.c.

{
  string dir, filename;
  FILE * out;
 
  /* filename: $current.database/$module/$prefix_$phase.$suffix
   */
  dir = db_get_current_workspace_directory();
  filename = strdup(concatenate
      (dir, "/", module_name, "/", GRAPH_PREFIX, phase, GRAPH_SUFFIX, NULL));
  free(dir), dir = NULL;
 
  out = safe_fopen(filename, "w"); /* directory MUST exist */
  davinci_dump_all_expressions(out, s);
  safe_fclose(out, filename);
 
  free(filename), filename = NULL;
}

References concatenate(), davinci_dump_all_expressions(), db_get_current_workspace_directory(), free(), GRAPH_PREFIX, GRAPH_SUFFIX, module_name(), out, safe_fclose(), safe_fopen(), and strdup().

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_cost_expression_array()

static void debug_cost_expression_array ( string  s, cost_expression *  tce, int  size  )

static

debug function

print informations from an cost_expressions array

Definition at line 980 of file optimize.c.

{
  int i;
  pips_debug(9,"%s \n", s);
  pips_debug(9," %d elements in cost_expression array \n", size);
 
  for (i=0; i<size; i++) {
    pips_debug(9," - %d - expression : ", i); 
    print_expression(tce[i].expr);
    pips_debug(9,"\n - %d - cost : %f \n", i, tce[i].cost);
  }
}

References pips_debug, and print_expression().

Referenced by call_rwt(), and list_of_expressions_to_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_convert_to_c_operator()

static void do_convert_to_c_operator ( call  c )

static

Definition at line 1336 of file optimize.c.

                                      {
    entity op = call_function(c);
    if(ENTITY_PLUS_P(op))
        call_function(c)=entity_intrinsic(PLUS_C_OPERATOR_NAME);
    if(ENTITY_MINUS_P(op))
        call_function(c)=entity_intrinsic(MINUS_C_OPERATOR_NAME);
}

References call_function, entity_intrinsic(), ENTITY_MINUS_P, ENTITY_PLUS_P, MINUS_C_OPERATOR_NAME, and PLUS_C_OPERATOR_NAME.

Referenced by convert_to_c_operators().

Here is the call graph for this function:

Here is the caller graph for this function:

do_convert_to_standard_operators()

static void do_convert_to_standard_operators ( call  c )

static

Definition at line 1348 of file optimize.c.

                                              {
    entity op = call_function(c);
    if(ENTITY_PLUS_C_P(op) || ENTITY_MINUS_C_P(op) ) {
        basic b0 = basic_of_expression(binary_call_lhs(c)),
              b1 = basic_of_expression(binary_call_rhs(c));
        if(!basic_pointer_p(b0)  && !basic_pointer_p(b1)) {
            if(ENTITY_PLUS_C_P(op))
                call_function(c)=entity_intrinsic(PLUS_OPERATOR_NAME);
            if(ENTITY_MINUS_C_P(op))
                call_function(c)=entity_intrinsic(MINUS_OPERATOR_NAME);
        }
        free_basic(b0);
        free_basic(b1);
    }
}

References b1, basic_of_expression(), basic_pointer_p, binary_call_lhs, binary_call_rhs, call_function, entity_intrinsic(), ENTITY_MINUS_C_P, ENTITY_PLUS_C_P, free_basic(), MINUS_OPERATOR_NAME, and PLUS_OPERATOR_NAME.

Referenced by convert_to_standard_operators().

Here is the call graph for this function:

Here is the caller graph for this function:

eole_manageable_expression()

static bool eole_manageable_expression ( expression  e )

static

Definition at line 147 of file optimize.c.

{
  bool okay = true;
  gen_context_multi_recurse(e, &okay,
                            call_domain, gen_true, eole_okay_call_rwt,
                            NULL);
  return okay;
} 

References call_domain, eole_okay_call_rwt(), gen_context_multi_recurse(), and gen_true().

Referenced by call_filter(), and expr_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

eole_okay_call_rwt()

static void eole_okay_call_rwt ( call  c, bool *  okay  )

static

IMPLIED-DO ? others ?

Definition at line 139 of file optimize.c.

{
  if (is_string_constant(call_function(c)))
    *okay = false;
 
  /* IMPLIED-DO ? others ? */
}

References call_function, and is_string_constant().

Referenced by eole_manageable_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_filter()

static bool expr_filter ( expression  e, extract_expr_p  context  )

static

other expressions may be found in loops and so?

Definition at line 202 of file optimize.c.

{
  if (eole_manageable_expression(e))
    add_one_more_expression(e, context);
  return false;
}

References add_one_more_expression(), and eole_manageable_expression().

Referenced by get_list_of_rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_gravity()

static double expression_gravity ( expression  e )

static

Definition at line 691 of file optimize.c.

{
  return expression_gravity_rc(e, 0.0E0);
}

References expression_gravity_rc().

Referenced by expression_gravity_inv().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_gravity_inv()

static double expression_gravity_inv ( expression  e )

static

Definition at line 696 of file optimize.c.

{
  return -expression_gravity(e);
}

References expression_gravity().

Here is the call graph for this function:

expression_gravity_rc()

static double expression_gravity_rc ( expression  e, double  depth  )

static

forward substitute if only there once.

not implemented. WG

?

too simple?

Definition at line 677 of file optimize.c.

{
  double cost = 0.0E0;
  syntax s = expression_syntax(e);
  if (syntax_call_p(s))
  {
    MAP(EXPRESSION, e, 
        cost += expression_gravity_rc(e, depth+1.0E0), /* ? */
        call_arguments(syntax_call(s)));
    cost += 1.0E0; /* too simple? */
  }
  return cost;
}

References call_arguments, depth, EXPRESSION, expression_syntax, MAP, syntax_call, and syntax_call_p.

Referenced by expression_gravity().

Here is the caller graph for this function:

generate_bminus()

static void generate_bminus ( statement  s )

static

Definition at line 514 of file optimize.c.

{
  bplus  = entity_intrinsic(PLUS_OPERATOR_NAME);
  uminus = entity_intrinsic(UNARY_MINUS_OPERATOR_NAME);
  bminus = entity_intrinsic(MINUS_OPERATOR_NAME);
  fmaop  = entity_intrinsic(EOLE_FMA_OPERATOR_NAME);
  fmsop  = entity_intrinsic(EOLE_FMS_OPERATOR_NAME);
 
  gen_recurse(s, call_domain, gen_true, call_simplify_rwt);
 
  bplus  = NULL;
  uminus = NULL;
  bminus = NULL;
  fmaop  = NULL;
  fmsop  = NULL;
}

References bminus, bplus, call_domain, call_simplify_rwt(), entity_intrinsic(), EOLE_FMA_OPERATOR_NAME, EOLE_FMS_OPERATOR_NAME, fmaop, fmsop, gen_recurse, gen_true(), MINUS_OPERATOR_NAME, PLUS_OPERATOR_NAME, uminus, and UNARY_MINUS_OPERATOR_NAME.

Referenced by optimize_simplify_patterns().

Here is the call graph for this function:

Here is the caller graph for this function:

get_eole_command()

static string get_eole_command ( const char *  in, const char *  out, const char *  flags  )

static

returns the eole command to be executed in an allocated string.

Parameters

out	input file from eole.
flags	output file to eole.

Definition at line 113 of file optimize.c.

{
  return strdup(concatenate(get_string_property(EOLE), " ", 
                            flags, " ",
                            get_string_property(EOLE_OPTIONS), 
                            " -S ", strategy->eole_strategy,
                            " -o ", in, " ", out, NULL));
}

References concatenate(), EOLE, EOLE_OPTIONS, optimization_strategy::eole_strategy, get_string_property(), out, strategy, and strdup().

Referenced by apply_eole_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_list_of_rhs()

static list get_list_of_rhs ( statement  s )

static

of expressionwithlevel

Definition at line 210 of file optimize.c.

{
  extract_expr_t context;
 
  context.rhs = NIL;
  context.indices = NIL;
 
  gen_context_multi_recurse(s, &context,
                            expression_domain, expr_filter, gen_null,
                            call_domain, call_filter, gen_null,
                            loop_domain, loop_flt, loop_rwt,
                            NULL);
 
  pips_assert("no indices", context.indices==NIL);
  
  return gen_nreverse(context.rhs);
}

References call_domain, call_filter(), expr_filter(), expression_domain, gen_context_multi_recurse(), gen_nreverse(), gen_null(), loop_domain, loop_flt(), loop_rwt(), NIL, and pips_assert.

Referenced by apply_eole_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_last_into_array()

static void insert_last_into_array ( cost_expression *  tce, int  n, cost_expression  ce  )

static

simply insert.

Definition at line 1035 of file optimize.c.

{
  tce[n] = ce;
}

Referenced by call_rwt().

Here is the caller graph for this function:

insert_sorted_into_array()

static void insert_sorted_into_array ( cost_expression *  tce, int  n, cost_expression  ce  )

static

insert ce in tce[0..n-1] by decreassing order.

find where to insert.

shift tail.

insert.

Definition at line 1024 of file optimize.c.

{
  int i=0;
  while (i<n && ce.cost<tce[i].cost) i++; /* find where to insert. */
  while (n>=i) tce[n]=tce[n-1], n--;      /* shift tail. */
  tce[i] = ce;                            /* insert. */
}

References cost_expression::cost.

Referenced by call_rwt().

Here is the caller graph for this function:

inv_call_flt()

static bool inv_call_flt ( call  c )

static

switch asymetric operation if needed

should use the type_checker results... maybe it could be implemented also as an analyses and not only a transformation? Well, I don't know how to store expression to type data, as expressions cannot be shared and are not "named" as statements are. FC.

we have to substitute.

push down inverse operators if needed.

memory leak...

now insert invop

Definition at line 859 of file optimize.c.

{
  entity op = call_function(c);
  symetric_opertor_t * so;
 
  /* switch asymetric operation if needed */
  so = what_operator(op, true);
  if (so)
    {
      bool doit = true;
 
      if (so->not_ints)
        {
          /* should use the type_checker results...
           * maybe it could be implemented also as an analyses
           * and not only a transformation? Well, I don't know
           * how to store expression to type data, as expressions
           * cannot be shared and are not "named" as statements are. FC.
           */
          expression tmp = call_to_expression(c);
          basic b =  basic_of_expression(tmp);
          if (basic_int_p(b)) doit = false;
          syntax_call(expression_syntax(tmp)) = call_undefined;
          free_expression(tmp);
        }
      
      if (doit) /* we have to substitute. */
        {
          list largs = call_arguments(c);
          expression second;
          pips_assert("binary call", gen_length(largs)==2);
          second = EXPRESSION(CAR(CDR(largs)));
 
          call_function(c) = entity_intrinsic(so->syme);
          expression_syntax(second) = 
            make_syntax(is_syntax_call,
                        make_call(entity_intrinsic(so->inv),
                CONS(EXPRESSION, 
                     make_expression(expression_syntax(second), 
                                     normalized_undefined),
                     NIL)));
        }
    }
 
  /* push down inverse operators if needed. */     
  so = what_operator(op, false);
  if (so)
    {
      list largs = call_arguments(c);
      syntax s;
      pips_assert("one arg to inverse op", gen_length(largs)==1);
      s = expression_syntax(EXPRESSION(CAR(largs)));
      if (syntax_call_p(s))
        {
          call called = syntax_call(s);
          if (same_string_p(so->syme, 
                            entity_local_name(call_function(called))))
            {
              /* memory leak... */
              entity invop = call_function(c);
              call_function(c) = call_function(called);
              call_arguments(c) = call_arguments(called);
              /* now insert invop */
              MAP(EXPRESSION, e, 
              {
                expression_syntax(e) = 
                  make_syntax(is_syntax_call,
                      make_call(invop, 
                                CONS(EXPRESSION, 
                                     make_expression(expression_syntax(e),
                                                     normalized_undefined),
                                     NIL)));
              },
                  call_arguments(called));
            }
        }
    }
  
  return true;
}

References basic_int_p, basic_of_expression(), call_arguments, call_function, call_to_expression(), call_undefined, CAR, CDR, CONS, entity_intrinsic(), entity_local_name(), EXPRESSION, expression_syntax, free_expression(), gen_length(), symetric_opertor_t::inv, is_syntax_call, make_call(), make_expression(), make_syntax(), MAP, NIL, normalized_undefined, symetric_opertor_t::not_ints, pips_assert, same_string_p, symetric_opertor_t::syme, syntax_call, syntax_call_p, and what_operator().

Referenced by inverse_normalization_of_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

inverse_normalization_of_expressions()

void inverse_normalization_of_expressions

(

statement

s

)

Definition at line 940 of file optimize.c.

{
  gen_recurse(s, call_domain, inv_call_flt, gen_null);
}

References call_domain, gen_null(), gen_recurse, and inv_call_flt().

Here is the call graph for this function:

inverse_operator_of()

entity inverse_operator_of

(

entity

e

)

Definition at line 852 of file optimize.c.

{
  symetric_opertor_t * sot = what_operator(e, 2);
  if (sot) return entity_intrinsic(sot->inv);
  else return NULL;
}

References entity_intrinsic(), symetric_opertor_t::inv, and what_operator().

Here is the call graph for this function:

is_inverse()

static bool is_inverse ( expression  e )

static

Definition at line 555 of file optimize.c.

{
  syntax s = expression_syntax(e);
  if (!syntax_call_p(s)) return false;
  return call_function(syntax_call(s)) == inverse;
}

References call_function, expression_syntax, inverse, syntax_call, and syntax_call_p.

Referenced by call_nary_rwt().

Here is the caller graph for this function:

is_string_constant()

static bool is_string_constant ( entity  e )

static

Definition at line 127 of file optimize.c.

{
  basic b = entity_basic(e);
 
  if (type_functional_p(entity_type(e)) && 
      value_constant_p(entity_initial(e)) && 
      !basic_undefined_p(b))
    return basic_string_p(b);
 
  return false;
}

References basic_string_p, basic_undefined_p, entity_basic(), entity_initial, entity_type, type_functional_p, and value_constant_p.

Referenced by eole_okay_call_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

is_uminus()

static expression is_uminus ( expression  e )

static

returns B if uminus(B), else 0

Definition at line 454 of file optimize.c.

{
  syntax s = expression_syntax(e);
  if (syntax_call_p(s))
  {
    call c = syntax_call(s);
    if (call_function(c)==uminus && gen_length(call_arguments(c))==1)
      return EXPRESSION(CAR(call_arguments(c)));
  }
  return NULL;
}

References call_arguments, call_function, CAR, EXPRESSION, expression_syntax, gen_length(), syntax_call, syntax_call_p, and uminus.

Referenced by call_simplify_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_expressions_to_array()

static cost_expression* list_of_expressions_to_array ( list  le, double(*)(expression)  cost  )

static

build an cost_expression array from an expression list.

Parameters

le	of expression

Definition at line 998 of file optimize.c.

{
  int len = gen_length(le), i=0;
  cost_expression * tce = malloc(len * sizeof(cost_expression));
  pips_assert("enough memory", tce!=NULL);
  
  MAP(EXPRESSION, e, 
  {
    tce[i].expr = e;
    tce[i].cost = cost(e);
    i++;
  },
    le);
 
  qsort(tce, len, sizeof(cost_expression), cost_expression_cmp);
 
  ifdebug(3) debug_cost_expression_array("qsort output", tce, len);
 
  return tce;
}

References cost_expression::cost, cost_expression_cmp(), debug_cost_expression_array(), cost_expression::expr, EXPRESSION, gen_length(), ifdebug, malloc(), MAP, and pips_assert.

Referenced by call_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_flt()

static bool loop_flt ( loop  l, extract_expr_p  context  )

static

keep on.

Definition at line 173 of file optimize.c.

{
  entity index = loop_index(l);
  context->indices = CONS(ENTITY, index, context->indices);
  return true; /* keep on. */
}

References CONS, ENTITY, and loop_index.

Referenced by get_list_of_rhs().

Here is the caller graph for this function:

loop_rwt()

static void loop_rwt ( loop  l, extract_expr_p  context  )

static

Definition at line 180 of file optimize.c.

{
  list tmp = context->indices;
  pips_assert("same index", ENTITY(CAR(context->indices))==loop_index(l));
  context->indices = CDR(context->indices);
  CDR(tmp) = NIL;
  gen_free_list(tmp);
}

References CAR, CDR, ENTITY, gen_free_list(), loop_index, NIL, and pips_assert.

Referenced by get_list_of_rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

nary_call_flt()

static bool nary_call_flt ( call  c )

static

top-down: switch calls to nary form.

Definition at line 774 of file optimize.c.

{
  call_function(c) = binary_to_nary(call_function(c));
  return true;
}

References binary_to_nary(), and call_function.

Referenced by naryfication_of_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

nary_call_rwt()

static void nary_call_rwt ( call  c )

static

bottom-up: + + -> +

Definition at line 782 of file optimize.c.

{
  entity called = call_function(c);
  list newl = NIL, oldl = call_arguments(c);
 
  if (nary_operator_p(called))
    {
      MAP(EXPRESSION, e, 
      {
        syntax s = expression_syntax(e);
        if (syntax_call_p(s) && call_function(syntax_call(s))==called)
          {
            newl = gen_nconc(newl, call_arguments(syntax_call(s)));
            call_arguments(syntax_call(s)) = NIL;
            free_expression(e);
          }
        else
          {
            newl = gen_nconc(newl, CONS(EXPRESSION, e, NIL));
          }
      },
          oldl);
    }
 
  call_arguments(c) = newl;
  gen_free_list(oldl);
}

References call_arguments, call_function, CONS, EXPRESSION, expression_syntax, free_expression(), gen_free_list(), gen_nconc(), MAP, nary_operator_p(), NIL, syntax_call, and syntax_call_p.

Referenced by naryfication_of_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

nary_operator_p()

static bool nary_operator_p ( entity  e )

static

Definition at line 760 of file optimize.c.

{
  binary_to_nary_t * pbn;
  const char* lname = entity_local_name(e);
 
  for (pbn = bton; pbn->nary; pbn++)
    if (same_string_p(pbn->nary, lname))
      return true;
 
  return false;
}

References bton, entity_local_name(), lname(), binary_to_nary_t::nary, and same_string_p.

Referenced by nary_call_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

naryfication_of_expressions()

void naryfication_of_expressions

(

statement

s

)

optimize.c

Definition at line 810 of file optimize.c.

{
  gen_recurse(s, call_domain, nary_call_flt, nary_call_rwt);
}

References call_domain, gen_recurse, nary_call_flt(), and nary_call_rwt().

Here is the call graph for this function:

optimize_expressions()

bool optimize_expressions

(

const char *

module_name

)

pipsmake interface to apply expression optimization according to various strategy.

The strategy to use is specified with the EOLE_OPTIMIZATION_STRATEGY property. The strategies themselves are defined into the strategies[] array.

In general, strategies involve an external optimization tool that is not provided with PIPS, so they cannot be used...

At least the CSE, ICM and ICMCSE work without this tool and can be safely used. See the common_subexpression_elimination and icm phase to have a direct access to these 2 common working case. Well, it is not clear that ICMCSE would work since it would need to refresh the effects, which is not done. So the safe way is to use separately these 2 phases.

Parameters

[in]

module_name

Returns

true since it is supposed to always work

get needed stuff.

check consistency before optimizations

do something here.

Could perform more optimizations here...

EOLE Stuff

Could perform more optimizations here...

CSE/ICM + atom

EOLE Stuff, second pass for FMA.

others?

check consistency after optimizations

return result to pipsdbm

okay !

Parameters

module_name

odule_name

Definition at line 1391 of file optimize.c.

{
    statement s;
 
    debug_on(DEBUG_NAME);
 
    /* get needed stuff.
     */
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_current_module_statement((statement)
        db_get_memory_resource(DBR_CODE, module_name, true));
    set_current_optimization_strategy();
 
 
    s = get_current_module_statement();
    convert_to_c_operators(s);
 
    /* check consistency before optimizations */
    pips_assert("consistency checking before optimizations",
                statement_consistent_p(s));
 
    ifdebug(1) davinci_dump_expressions(module_name, "initial", s);
 
    /* do something here.
     */
 
    /* Could perform more optimizations here...
     */
 
    /* EOLE Stuff
     */
 
    if (strategy->apply_eole1)
      apply_eole_on_statement(module_name, s, get_string_property(EOLE_FLAGS));
 
    /* Could perform more optimizations here...
     */
    /* CSE/ICM + atom
     */
 
    if (strategy->apply_gcm)
      perform_icm_association(module_name, s);
 
    if (strategy->apply_cse)
      perform_ac_cse(module_name, s);
 
    /* EOLE Stuff, second pass for FMA.
     */
    if (strategy->apply_eole2)
      apply_eole_on_statement(module_name, s, strategy->apply_eole2_flags);
 
    if (strategy->apply_nary_simplify)
      optimize_simplify_nary_patterns(s);
 
    if (strategy->apply_balancing)
      switch_nary_to_binary(s);
 
    if (strategy->apply_simplify)
      optimize_simplify_patterns(s);
 
    /* others?
     */
 
    /* check consistency after optimizations */
    unnormalize_expression(s);
    clean_up_sequences(s);
    convert_to_standard_operators(s);
    simplify_expressions(s);
    pips_assert("consistency checking after optimizations",
                statement_consistent_p(s));
 
    ifdebug(1) davinci_dump_expressions(module_name, "final", s);
 
    module_reorder(s);
 
    /* return result to pipsdbm
     */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, s);
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_current_optimization_strategy();
 
    debug_off();
 
    return true; /* okay ! */
}

References optimization_strategy::apply_balancing, optimization_strategy::apply_cse, optimization_strategy::apply_eole1, optimization_strategy::apply_eole2, optimization_strategy::apply_eole2_flags, apply_eole_on_statement(), optimization_strategy::apply_gcm, optimization_strategy::apply_nary_simplify, optimization_strategy::apply_simplify, clean_up_sequences(), convert_to_c_operators(), convert_to_standard_operators(), davinci_dump_expressions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, DEBUG_NAME, debug_off, debug_on, EOLE_FLAGS, get_current_module_statement(), get_string_property(), ifdebug, local_name_to_top_level_entity(), module_name(), module_reorder(), optimize_simplify_nary_patterns(), optimize_simplify_patterns(), perform_ac_cse(), perform_icm_association(), pips_assert, reset_current_module_entity(), reset_current_module_statement(), reset_current_optimization_strategy(), set_current_module_entity(), set_current_module_statement(), set_current_optimization_strategy(), simplify_expressions(), statement_consistent_p(), strategy, switch_nary_to_binary(), and unnormalize_expression().

Referenced by common_subexpression_elimination(), and icm().

Here is the call graph for this function:

Here is the caller graph for this function:

optimize_simplify_nary_patterns()

static void optimize_simplify_nary_patterns ( statement  s )

static

N-ARY * and 1/ -> N-ARY* / N-ARY*

Definition at line 621 of file optimize.c.

{
  /* N-ARY * and 1/ -> N-ARY* / N-ARY*
   */
  multiply = entity_intrinsic(EOLE_PROD_OPERATOR_NAME);
  inverse  = entity_intrinsic(INVERSE_OPERATOR_NAME);
  divide   = entity_intrinsic("/");
 
  gen_recurse(s, call_domain, gen_true, call_nary_rwt);
 
  multiply = NULL;
  inverse  = NULL;
  divide   = NULL;
}

References call_domain, call_nary_rwt(), divide, entity_intrinsic(), EOLE_PROD_OPERATOR_NAME, gen_recurse, gen_true(), inverse, INVERSE_OPERATOR_NAME, and multiply.

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

optimize_simplify_patterns()

static void optimize_simplify_patterns ( statement  s )

static

look for some expressions in s and simplify some patterns.

not implemented yet.

a + (-b) -> a - b

(-b) + a -> a - b

fma(a,b,-c) => fms(a,b,c)

a * (1/ b) -> a / b

(1/ b) * a -> a / b

a + (-b * c) -> a - (b * c)

Definition at line 533 of file optimize.c.

{
  /* not implemented yet. */
 
  /* a + (-b)       -> a - b */
  /* (-b) + a       -> a - b */
  /* fma(a,b,-c) => fms(a,b,c) */
  generate_bminus(s);
 
  /* a * (1/ b)     -> a / b */
  /* (1/ b) * a     -> a / b */
  /* a + (-b * c)   -> a - (b * c) */
}

References generate_bminus().

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

read_and_allocate_string_from_file()

static string read_and_allocate_string_from_file ( FILE *  file )

static

Definition at line 259 of file optimize.c.

{
  int test; 
  char buffer[SIZE_OF_BUFFER];
 
  test = fscanf(file, "%s",buffer);
  pips_assert("fscanf - read string from file \n",(test==1));
 
  return strdup(buffer);
}

References buffer, pips_assert, SIZE_OF_BUFFER, and strdup().

Referenced by read_new_entities_from_eole().

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_eole()

static list read_from_eole ( const char *  module, const char *  file_name  )

static

import expressions from eole.

of expression

read entities to create... should use some newgen type to do so (to share buffers...)

Definition at line 335 of file optimize.c.

{
    FILE * fromeole;
    reference astuce;
    list result;
 
    pips_debug(3, "reading from eole for module %s\n", module);
    
    fromeole = safe_fopen(file_name, "r");
 
    /* read entities to create... 
     * should use some newgen type to do so (to share buffers...)
     */
    read_new_entities_from_eole(fromeole, module);
 
    astuce = read_reference(fromeole);
    result = reference_indices(astuce);
    reference_indices(astuce) = NIL;
    free_reference(astuce);
 
    return result;
}

References file_name, free_reference(), module, NIL, pips_debug, read_new_entities_from_eole(), read_reference(), reference_indices, and safe_fopen().

Referenced by apply_eole_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

read_new_entities_from_eole()

static void read_new_entities_from_eole ( FILE *  file, const char *  module  )

static

import a list of entity that have been created during the eole transformations and create them

read the number of new entities to create

constant

int

create integer entity

float

create float entity

double

Definition at line 275 of file optimize.c.

                                                            {
  int num = 0;
  int i, test;
  string ent_type;
  string const_type;
  int const_size = 0;
  string const_value;
  
  entity e; 
  
  /* read the number of new entities to create */
  test = fscanf(file,"%d\n",&num);
  pips_assert("fscanf - read number of entity",(test==1));
  pips_debug(3,"reading %d new entity from module %s\n", num, module);
 
  for (i=0;i<num;i++)
  {
    ent_type = read_and_allocate_string_from_file(file);
    
    if (!strcmp(ent_type,"constant")) { /* constant */
      
      const_type = read_and_allocate_string_from_file(file);
      
      test = fscanf(file," %d\n", &const_size);
      pips_assert("fscanf - read entity basic type size\n",(test==1));
 
      const_value = read_and_allocate_string_from_file(file);
 
      if (same_string_p(const_type,"int")) {/* int */
        
        /* create integer entity */
        e = make_constant_entity(const_value, is_basic_int, const_size);
        pips_assert("make integer constant entity", entity_consistent_p(e));  
      }
      else if (same_string_p(const_type,"float")) {/* float */
        /* create float entity */
        e = make_constant_entity(const_value, is_basic_float, const_size);
        pips_assert("make float constant entity", entity_consistent_p(e));  
      }
      else if (same_string_p(const_type, "double")) { /* double */
        e = make_constant_entity(const_value, is_basic_float, const_size);
        pips_assert("make float constant entity", entity_consistent_p(e));  
      }
      else
        pips_internal_error("can't create this kind of constant entity: %s",
                            const_type);
      free(const_type);
      free(const_value);
    }
    else 
      pips_internal_error("can't create this kind of entity: %s", ent_type);
    
    free(ent_type);
  }
}   

References entity_consistent_p(), free(), is_basic_float, is_basic_int, make_constant_entity(), module, num, pips_assert, pips_debug, pips_internal_error, read_and_allocate_string_from_file(), and same_string_p.

Referenced by read_from_eole().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_current_optimization_strategy()

static void reset_current_optimization_strategy ( void  )

static

Definition at line 1297 of file optimize.c.

{
  strategy = NULL;
}

References strategy.

Referenced by optimize_expressions().

Here is the caller graph for this function:

set_current_optimization_strategy()

static void set_current_optimization_strategy ( void  )

static

Definition at line 1286 of file optimize.c.

{
  const char* name = get_string_property("EOLE_OPTIMIZATION_STRATEGY");
  for (strategy = strategies; strategy->name!=NULL; strategy++)
  {
    if (same_string_p(name, strategy->name))
      return;
  }
  pips_user_warning("'%s' strategy not found, default assumed.\n", name);
}

References get_string_property(), optimization_strategy::name, pips_user_warning, same_string_p, strategies, and strategy.

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

swap_syntax_in_expression()

static void swap_syntax_in_expression ( list  lcode, list  lnew  )

static

swap term to term syntax field in expression list, as a side effect...

Parameters

lcode	of expressionwithlevel
lnew	of expression

Definition at line 361 of file optimize.c.

{
  pips_assert("equal length lists", gen_length(lcode)==gen_length(lnew));
  
  for(; lcode; lcode=CDR(lcode), lnew=CDR(lnew))
    {
      expression old, new;
      syntax tmp;
 
      old = expressionwithlevel_expression(EXPRESSIONWITHLEVEL(CAR(lcode)));
      new = EXPRESSION(CAR(lnew));
      
      tmp = expression_syntax(old);
      expression_syntax(old) = expression_syntax(new);
      expression_syntax(new) = tmp;     
    }
}

References CAR, CDR, EXPRESSION, expression_syntax, EXPRESSIONWITHLEVEL, expressionwithlevel_expression, gen_length(), and pips_assert.

Referenced by apply_eole_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_nary_to_binary()

static void switch_nary_to_binary ( statement  s )

static

switch nary operators to binary ones.

n+ -> +, n* -> * missing: & | and so on.

options: another expression cost function could be used. for instance, defining -expression_gravity would build the most unbalanced possible expression tree wrt WG.

Definition at line 1137 of file optimize.c.

{
  entity
    plus = entity_intrinsic(PLUS_OPERATOR_NAME),
    nplus = entity_intrinsic(EOLE_SUM_OPERATOR_NAME),
    mult = entity_intrinsic(MULTIPLY_OPERATOR_NAME),
    nmult = entity_intrinsic(EOLE_PROD_OPERATOR_NAME);
 
  /* options: another expression cost function could be used.
   * for instance, defining -expression_gravity would build
   * the most unbalanced possible expression tree wrt WG.
   */
  build_binary_operators_with_huffman
    (s, nplus, plus, strategy->huffman_cost, strategy->huffman_mode);
  build_binary_operators_with_huffman
    (s, nmult, mult, strategy->huffman_cost, strategy->huffman_mode);
}

References build_binary_operators_with_huffman(), entity_intrinsic(), EOLE_PROD_OPERATOR_NAME, EOLE_SUM_OPERATOR_NAME, optimization_strategy::huffman_cost, optimization_strategy::huffman_mode, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, and strategy.

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

what_operator()

static symetric_opertor_t* what_operator ( entity  e, int  which_one  )

static

Definition at line 838 of file optimize.c.

{
  const char* lname = entity_local_name(e);
  symetric_opertor_t * sot;
  for (sot = symop; sot->asym; sot++)
    {
      if ((which_one==1 && same_string_p(lname, sot->asym)) ||
          (which_one==0 && same_string_p(lname, sot->inv)) ||
          (which_one==2 && same_string_p(lname, sot->syme)))
        return sot;
    }
  return NULL;
}

References symetric_opertor_t::asym, entity_local_name(), symetric_opertor_t::inv, lname(), same_string_p, symetric_opertor_t::syme, and symop.

Referenced by inv_call_flt(), and inverse_operator_of().

Here is the call graph for this function:

Here is the caller graph for this function:

write_list_of_rhs()

static void write_list_of_rhs ( FILE *  out, list  le  )

static

export a list of expression of the current module.

done thru a convenient reference.

reference astuce = make_reference(get_current_module_entity(), le);

Parameters

le	of expressionwithlevel

Definition at line 231 of file optimize.c.

{
  /* reference astuce = make_reference(get_current_module_entity(), le);*/
  lexpressionwithlevel lewl = make_lexpressionwithlevel(le);
  write_lexpressionwithlevel(out, lewl);
  lexpressionwithlevel_list(lewl) = NIL;
  free_lexpressionwithlevel(lewl);
}

References free_lexpressionwithlevel(), lexpressionwithlevel_list, make_lexpressionwithlevel(), NIL, out, and write_lexpressionwithlevel().

Referenced by write_to_eole().

Here is the call graph for this function:

Here is the caller graph for this function:

write_to_eole()

static void write_to_eole ( const char *  module, list  le, const char *  file_name  )

static

export expressions to eole thru the newgen format.

both entities and rhs expressions are exported.

Definition at line 243 of file optimize.c.

{
  FILE * toeole;
  
  pips_debug(3, "writing to eole for module %s\n", module);
  
  toeole = safe_fopen(file_name, "w");
  write_tabulated_entity(toeole);
  write_list_of_rhs(toeole, le);
 
  safe_fclose(toeole, file_name);
}

References file_name, module, pips_debug, safe_fclose(), safe_fopen(), write_list_of_rhs(), and write_tabulated_entity().

Referenced by apply_eole_on_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

bminus

entity bminus = NULL

static

Definition at line 448 of file optimize.c.

Referenced by call_simplify_rwt(), and generate_bminus().

bplus

entity bplus = NULL

static

A + (–B) -> A - B FMA -> FMS.

Definition at line 446 of file optimize.c.

Referenced by call_simplify_rwt(), and generate_bminus().

bton

binary_to_nary_t bton[]

static

Initial value:

= 
{
  { "+", EOLE_SUM_OPERATOR_NAME },
  { "*", EOLE_PROD_OPERATOR_NAME },
 
  { "MAX",   MAX_NAME },
  { "MIN",   MIN_NAME },
 
  { "MAX0",  MAX_NAME },
  { "DMAX1", MAX_NAME },
  { "AMAX1", MAX_NAME },
  { "AMAX0", MAX_NAME },
 
  { "MIN0",  MIN_NAME },
  { "DMIN1", MIN_NAME },
  { "AMIN1", MIN_NAME },
  { "AMIN0", MIN_NAME },
  
  
  { NULL, NULL }
}

Definition at line 725 of file optimize.c.

Referenced by binary_to_nary(), and nary_operator_p().

divide

entity divide = NULL

static

Definition at line 553 of file optimize.c.

Referenced by call_nary_rwt(), and optimize_simplify_nary_patterns().

fmaop

entity fmaop = NULL

static

Definition at line 449 of file optimize.c.

Referenced by call_simplify_rwt(), and generate_bminus().

fmsop

entity fmsop = NULL

static

Definition at line 450 of file optimize.c.

Referenced by call_simplify_rwt(), and generate_bminus().

huffman_binary_operator

entity huffman_binary_operator = NULL

static

Definition at line 950 of file optimize.c.

Referenced by build_binary_operators_with_huffman(), and call_rwt().

huffman_cost

double(* huffman_cost) (expression) ( expression  ) = NULL

static

Definition at line 951 of file optimize.c.

Referenced by build_binary_operators_with_huffman(), and call_rwt().

huffman_mode

bool huffman_mode = true

static

true: Huffman.

false: rateau.

Definition at line 955 of file optimize.c.

Referenced by build_binary_operators_with_huffman(), and call_rwt().

huffman_nary_operator

entity huffman_nary_operator = NULL

static

switch nary to binary with huffman algorithm.

Definition at line 949 of file optimize.c.

Referenced by build_binary_operators_with_huffman(), and call_rwt().

inverse

entity inverse = NULL

static

Definition at line 552 of file optimize.c.

Referenced by is_inverse(), and optimize_simplify_nary_patterns().

multiply

entity multiply = NULL

static

Definition at line 551 of file optimize.c.

Referenced by call_nary_rwt(), and optimize_simplify_nary_patterns().

strategies

optimization_strategy strategies[]

static

predefined optimization strategies.

Definition at line 1160 of file optimize.c.

Referenced by set_current_optimization_strategy().

strategy

poptimization_strategy strategy = NULL

static

current strategy.

Definition at line 94 of file optimize.c.

Referenced by get_eole_command(), optimize_expressions(), reset_current_optimization_strategy(), set_current_optimization_strategy(), and switch_nary_to_binary().

symop

symetric_opertor_t symop[]

static

Initial value:

=
{ { "-", "+", "--", false },
  { "/", "*", INVERSE_OPERATOR_NAME, true },
  { NULL, NULL, NULL, false }
}

Definition at line 832 of file optimize.c.

Referenced by what_operator().

uminus

entity uminus = NULL

static

Definition at line 447 of file optimize.c.

Referenced by generate_bminus(), incrementation_expression_to_increment(), and is_uminus().