#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <stdlib.h>
#include "genC.h"
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "matrice.h"
#include "matrix.h"
#include "linear.h"
#include "ri.h"
#include "constants.h"
#include "ri-util.h"
#include "misc.h"
#include "paf_ri.h"
#include "graph.h"
#include "dg.h"
#include "paf-util.h"

Include dependency graph for adg_read_paf.c:

Macros
#define	DOT "."
	include "paf_ri.h" More...

#define	PAF_STRING "paf"

#define	INS_NAME_LENGTH 4

#define	STMT_TO_STCT_SIZE 100 /*hash table max size /

#define	INIT_STATEMENT_SIZE 20

Typedefs
typedef dfg_arc_label	arc_label
	Name : adg_read_paf.c Package : paf-util Author : Alexis Platonoff Date : april 1993 Historic : 16 july 93, changes in paf_ri, AP 2 august 93, moved from (package) array_dfg to paf-util, AP Documents: More...

typedef dfg_vertex_label	vertex_label

Functions
graph	adg_read_paf (char *s)
	Current loop instruction. More...

void	init_new_dfg ()
	=========================================================================== More...

void	new_param (string s)
	=========================================================================== More...

void	init_new_df_sink_ins ()
	=========================================================================== More...

static statement	find_stmt_with_num (int n)
	=========================================================================== More...

void	init_new_df_source (char *s_ins)
	=========================================================================== More...

void	new_df_trans_exp ()
	=========================================================================== More...

void	finish_new_df_source ()
	=========================================================================== More...

void	init_new_df_gov_pred ()
	=========================================================================== More...

void	save_pred (int option)
	=========================================================================== More...

void	elim_last_pred ()
	=========================================================================== More...

void	new_df_gov_pred ()
	=========================================================================== More...

void	init_new_df_ref (char *s_ref)
	=========================================================================== More...

void	save_int (int i)
	=========================================================================== More...

void	save_id (string s)
	=========================================================================== More...

void	init_op_name (string op_name)
	=========================================================================== More...

void	init_op_exp (string op_name)
	=========================================================================== More...

void	save_exp ()
	=========================================================================== More...

void	new_df_ref_ind (string s_ind __attribute__((unused)))
	=========================================================================== More...

void	finish_new_df_ref ()
	=========================================================================== More...

void	new_df_sink_ins (char *s_ins)
	=========================================================================== More...

void	init_new_do_loop (char *s_loop)
	=========================================================================== More...

void	init_loop_ctrl (char *s_ind)
	=========================================================================== More...

void	lbound_exp ()
	=========================================================================== More...

void	step_exp ()
	=========================================================================== More...

void	ubound_exp ()
	=========================================================================== More...

void	finish_new_do_loop ()
	=========================================================================== More...

void	init_new_gd_ins (char *s_ins)
	=========================================================================== More...

static loop	find_loop_with_name (string s)
	=========================================================================== More...

void	new_eng_loop (char *s_loop)
	=========================================================================== More...

void	finish_new_gd_ins ()
	=========================================================================== More...

Variables
graph	dfg
	Global variables More...

list	stmt_list
	The "stmt_list" global variable is the list the assign statement of the program (with all fields empty but two: ordering (the number of the statement) and comments (the string name of the statement)). More...

list	loop_list
	The "loop_list" global variable is the list the loops of the program (with all their characteristics: index, bounds, step). More...

static hash_table	STS
	The "STS" global variable is the hash table that maps the static_control on the statements. More...

static vertex	crt_node
	Internal variables More...

static int	sink_stmt
	Current source node. More...

static int	source_stmt
	Current sink statement. More...

static int	crt_stmt
	Current source statement. More...

static reference	ref
	Current stmt (an integer) More...

static expression	crt_exp
	Current reference. More...

static predicate	gov_pred
	Current expression. More...

static predicate	exec_dom
	Current governing predicate. More...

static list	crt_node_l
	Current execution domain. More...

static list	trans_l
	Current list of nodes. More...

static list	ref_inds
	Current list of transformations. More...

static list	lin_exp_l
	Current list of reference indices. More...

static list	pred_l
	Current list of linear expressions. More...

static list	crt_el
	Current list of predicates. More...

static list	param_l
	Current list of englobing loops. More...

static string	crt_op_name
	Current list of structure parameters. More...

static loop	crt_loop
	Current operator name. More...

Macro Definition Documentation

◆ DOT

#define DOT "."

include "paf_ri.h"

Macro functions

Definition at line 128 of file adg_read_paf.c.

◆ INIT_STATEMENT_SIZE

#define INIT_STATEMENT_SIZE 20

Definition at line 238 of file adg_read_paf.c.

◆ INS_NAME_LENGTH

#define INS_NAME_LENGTH 4

Definition at line 130 of file adg_read_paf.c.

◆ PAF_STRING

#define PAF_STRING "paf"

Definition at line 129 of file adg_read_paf.c.

◆ STMT_TO_STCT_SIZE

#define STMT_TO_STCT_SIZE 100 /**hash table max size */

Definition at line 131 of file adg_read_paf.c.

Typedef Documentation

◆ arc_label

typedef dfg_arc_label arc_label

Name : adg_read_paf.c Package : paf-util Author : Alexis Platonoff Date : april 1993 Historic : 16 july 93, changes in paf_ri, AP 2 august 93, moved from (package) array_dfg to paf-util, AP Documents:

Comments : This functions are used to store a data flow graph in a NEWGEN structure from the reading of three files generate by the PAF parallelizer:

         _ the ".src" file, which contains the DFG nodes
         _ the ".do" file, which contains the LOOP list
         _ the ".gd" file, which contains the DG nodes

The DFG nodes include the source and sink instructions, the reference, the transformation and the governing predicate. The LOOP list gives the description of each loop of the program, i.e. the index parameter, the lower and upper bounds expressions and the step expression. The DG nodes give for each instruction, the list of the englobing loops. From the loop description and the list of the englobing loops, we can compute for each instruction the execution domain.

This program uses two new NEWGEN data structures: "dfg" (which uses the generic graph structure) and "lisp_expression". They are defined in the file paf_ri.f.tex (see comments on them in this file). It also uses the library of PIPS and its RI data structure.

The PAF files are read with YACC and LEX programs. We made one grammar for the three types of files (parse.y) and one characters analyser (scan.l). The "yy" and "YY" prefixes are modified into "adgyy" and "ADGYY".

In order two simplify the parser, this parsing requires the concatenation of the three files in one with the extension ".paf". This concatenation must be like this (see the file parse.y for the grammar): ( .src ) ( .do ) ( .gd )

Thus, the parsing has three steps:

First, the ".src" file is parsed. During this reading we collect the informations for the DFG. All these informations are stored in the global variables "dfg".

Second, we read the ".do" file. All the loops and their description are stored in the global variables "loop_list". This variable is a list of "loop" (from the NEWGEN type defined in the RI of PIPS).

Third, we parse the ".gd" file. In this reading, we only keep the englobing loops of each instruction. The update of the DFG execution domain is done during the parsing (each time all the englobing loops for a given instruction are known). Ansi includes
Newgen includes C3 includes
Pips includes
Types arc_label and vertex_label must be defined although they are not used Local typedef, probably to be found in paf_ri

Definition at line 119 of file adg_read_paf.c.

◆ vertex_label

typedef dfg_vertex_label vertex_label

Definition at line 120 of file adg_read_paf.c.

Function Documentation

◆ adg_read_paf()

graph adg_read_paf ( char * s )

Current loop instruction.

Local typedef =========================================================================== void adg_read_paf(char * s) :

computes the DFG of the PAF program name given in argument and returns it.

The global variables "loop_list" and "stmt_list" are initialized to NIL.

The DFG is put in the variable "dfg", which is the value returned.

Note : This function creates a statement_mapping (i.e. a hash_table) which is initialized in this function. This is done by set_current_stco_map(), see paf-util/utils.c. To use this hash_table, you do not have to know its name, only call get_current_stco_map() which returns it.

Definition at line 198 of file adg_read_paf.c.

 {
  extern list loop_list, stmt_list;
  
  FILE *paf_file;
  char *paf_file_name;
  
  loop_list = NIL;
  stmt_list = NIL;
  
  STS = hash_table_make(hash_int, STMT_TO_STCT_SIZE);
  
  paf_file_name = strdup(concatenate(s, DOT, PAF_STRING, (char *) NULL));
  
  if( (paf_file = fopen(paf_file_name, "r")) == NULL)
    {
      fprintf(stderr, "Cannot open file %s\n", paf_file_name);
      exit(1);
    }
  
 #if defined(HAS_ADGYY)
  
  adgyyin = paf_file;
  (void) adgyyparse();
  
 #else
  
  pips_internal_error("not adgyy{in,parse} compiled in (HAS_ADGYY undef)");
  
 #endif
  
  fclose(paf_file);
  
  set_current_stco_map(STS);
  
  return(dfg);
 }

References concatenate(), dfg, DOT, exit, fprintf(), hash_int, hash_table_make(), loop_list, NIL, PAF_STRING, pips_internal_error, set_current_stco_map(), stmt_list, STMT_TO_STCT_SIZE, strdup(), and STS.

Here is the call graph for this function:

◆ elim_last_pred()

void elim_last_pred ( void )

===========================================================================

void elim_last_pred(): When POSITIVE and NEGATIVE cases of one predicate have been completed, we eliminate the corresponding expression which is the first one of the list "pred_l".

Definition at line 485 of file adg_read_paf.c.

 {
  pred_l = CDR(pred_l);
 }

References CDR, and pred_l.

◆ find_loop_with_name()

static loop find_loop_with_name ( string s )

static

===========================================================================

static loop find_loop_with_name(string s): returns the loop that has a label name equal to the name given in argument ("s"). This function uses the global list of loops "loop_list".

Definition at line 883 of file adg_read_paf.c.

 {
  extern list loop_list;
  
  list aux_l = loop_list;
  
  for(; aux_l != NIL; aux_l = CDR(aux_l))
    {
     loop aux_loop = LOOP(CAR(aux_l));
     const char* loop_name = entity_local_name(loop_label(aux_loop));
     if(strcmp(loop_name, s) == 0)
        return(aux_loop);
    }
  return(loop_undefined);
 }

References CAR, CDR, entity_local_name(), LOOP, loop_label, loop_list, loop_undefined, and NIL.

Referenced by new_eng_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_stmt_with_num()

static statement find_stmt_with_num ( int n )

static

===========================================================================

static statement find_stmt_with_num(int n): returns the statement that has its ordering equal to "n".

This computation is done using the global variable "stmt_list" that contains the list of all the statements.

Definition at line 314 of file adg_read_paf.c.

 {
  extern list stmt_list;
  
  list aux_l = stmt_list;
  
  for(; aux_l != NIL; aux_l = CDR(aux_l))
    {
     statement aux_stmt = STATEMENT(CAR(aux_l));
     int stmt_order = statement_ordering(aux_stmt);
     if(stmt_order == n)
        return(aux_stmt);
    }
  return(statement_undefined);
 }

References CAR, CDR, NIL, STATEMENT, statement_ordering, statement_undefined, and stmt_list.

Referenced by init_new_df_source(), and new_df_sink_ins().

Here is the caller graph for this function:

◆ finish_new_df_ref()

void finish_new_df_ref ( void )

===========================================================================

void finish_new_df_ref(): the parser has completed the reading of the current reference with all its indices. We update our current reference and update all nodes contained in "crt_node_l".

Definition at line 683 of file adg_read_paf.c.

 {
  list aux_l;
  
  reference_indices(ref) = ref_inds;
  
  for(aux_l = crt_node_l; aux_l != NIL; aux_l = CDR(aux_l))
    {
     dataflow df;
  
     df = first_df_of_succ(first_succ_of_vertex(VERTEX(CAR(aux_l))));
     dataflow_reference(df) = ref;
    }
 }

References CAR, CDR, crt_node_l, dataflow_reference, first_df_of_succ(), first_succ_of_vertex(), NIL, ref, ref_inds, reference_indices, and VERTEX.

Here is the call graph for this function:

◆ finish_new_df_source()

void finish_new_df_source ( void )

===========================================================================

void finish_new_df_source(): The reading of source of the current dataflow is completed. We create this dataflow, the successor to which it is attached and the node from which the dataflow comes. This node is put in the global list "crt_node_l" that contains all the computed edges that have the same sink statement (which is still not known).

At this time of the computation, only the source statement and the list of transformations are known. The governing predicate will be added on all the node of "crt_node_l", as well as the reference and the execution domain will be computed afterwards, when all the graph will be made.

Definition at line 399 of file adg_read_paf.c.

 {
  extern predicate exec_dom;
  
  successor source_succ;
  list crt_df;
  
  crt_df = CONS(DATAFLOW, make_dataflow(ref, trans_l, gov_pred,
                                        communication_undefined), NIL);
  source_succ = make_successor(make_dfg_arc_label(crt_df),
                               vertex_undefined);
  
  crt_node = make_vertex(make_dfg_vertex_label(source_stmt, exec_dom,
                                               sccflags_undefined),
                         CONS(SUCCESSOR, source_succ, NIL));
  
  crt_node_l = gen_nconc(crt_node_l, CONS(VERTEX, crt_node, NIL));
 }

References communication_undefined, CONS, crt_node, crt_node_l, DATAFLOW, exec_dom, gen_nconc(), gov_pred, make_dataflow(), make_dfg_arc_label(), make_dfg_vertex_label(), make_successor(), make_vertex(), NIL, ref, sccflags_undefined, source_stmt, SUCCESSOR, trans_l, VERTEX, and vertex_undefined.

Here is the call graph for this function:

◆ finish_new_do_loop()

void finish_new_do_loop ( void )

===========================================================================

void finish_new_do_loop(): This function update the global list of loops with the current loop.

Definition at line 851 of file adg_read_paf.c.

 {
  extern list loop_list;
  
  loop_list = CONS(LOOP, crt_loop, loop_list);
 }

References CONS, crt_loop, LOOP, and loop_list.

◆ finish_new_gd_ins()

void finish_new_gd_ins ( void )

===========================================================================

void finish_new_gd_ins(): completes the parsing of the DFG. We copy the list of englobing loops in order to store it in the global static control map (it contains the static_controls associated to the statements).

We compute the execution domain (for the dfg) for all sink instructions named "crt_stmt". comp_exec_domain(dfg, crt_stmt, crt_el);

Make a copy to store in the hash table "STS"

loop l = EFFECT(CAR(cl));

should be a long int for crt_stmt

Definition at line 950 of file adg_read_paf.c.

 {
     extern list crt_el, param_l;
     extern int crt_stmt;
  
     list new_el;
  
     /* We compute the execution domain (for the dfg) for all sink instructions
      * named "crt_stmt".
      comp_exec_domain(dfg, crt_stmt, crt_el);
      */
  
     /* Make a copy to store in the hash table "STS" */
     new_el = NIL;
     MAPL(cl, {
         /* loop l = EFFECT(CAR(cl)); */
         loop l = LOOP(CAR(cl));
         loop nl = loop_dup(l);
         new_el = gen_nconc(new_el, CONS(LOOP, nl, NIL));
     }, crt_el);
  
     /* should be a long int for crt_stmt */
     hash_put(STS, (void *) ((long)crt_stmt),
              (void *) make_static_control(true, param_l, new_el, NIL));
 }

References CAR, CONS, crt_el, crt_stmt, gen_nconc(), hash_put(), LOOP, loop_dup(), make_static_control(), MAPL, NIL, param_l, and STS.

Here is the call graph for this function:

◆ init_loop_ctrl()

void init_loop_ctrl ( char * s_ind )

===========================================================================

void init_loop_ctrl(char *s_ind): initializes the parsing of the control of a loop. The name that was parsed is the name of the loop index. Then we create the corresponding entity and update our current loop.

U

Parameters

s_ind _ind

Definition at line 784 of file adg_read_paf.c.

 {
  string index_full_name;
  entity var_ind;
  
  index_full_name = strdup(concatenate(DFG_MODULE_NAME, MODULE_SEP_STRING,
                                       s_ind, (char *) NULL));
  
  var_ind = gen_find_tabulated(index_full_name, entity_domain);
  
  if(var_ind == entity_undefined)
     var_ind = make_entity(index_full_name,
                           make_type(is_type_variable,
                                     make_variable(make_basic_int(4/*UU*/),
                                                   NIL, NIL)),
                           make_storage(is_storage_ram, ram_undefined),
                           make_value(is_value_unknown, UU));
  
  loop_index(crt_loop) = var_ind;
  
  lin_exp_l = NIL;
 }

References concatenate(), crt_loop, DFG_MODULE_NAME, entity_domain, entity_undefined, gen_find_tabulated(), is_storage_ram, is_type_variable, is_value_unknown, lin_exp_l, loop_index, make_basic_int(), make_entity, make_storage(), make_type(), make_value(), make_variable(), MODULE_SEP_STRING, NIL, ram_undefined, strdup(), and UU.

Here is the call graph for this function:

◆ init_new_df_gov_pred()

void init_new_df_gov_pred ( void )

===========================================================================

void init_new_df_gov_pred(): Initializes the computation of the governing predicate.

For this, we initialize "pred_l" (expressions that will be contained in the predicate) and "lin_exp_l" (for the parsing of each expression).

Definition at line 426 of file adg_read_paf.c.

 {
  gov_pred = predicate_undefined;
  pred_l = NIL;
  lin_exp_l = NIL;
 }

References gov_pred, lin_exp_l, NIL, pred_l, and predicate_undefined.

◆ init_new_df_ref()

void init_new_df_ref ( char * s_ref )

===========================================================================

void init_new_df_ref(ichar *s_ref): the parser has gotten the name of the reference on which the current dataflow depends. We compute it and update the global variable "ref".

UU

Initialization of global variables

Parameters

s_ref _ref

Definition at line 514 of file adg_read_paf.c.

 {
  entity ent_ref;
  string ref_full_name;
  
  ref_inds = NIL;
  
  ref_full_name = strdup(concatenate(DFG_MODULE_NAME, MODULE_SEP_STRING,
                                     s_ref, (char *) NULL));
  
  ent_ref = gen_find_tabulated(ref_full_name, entity_domain);
  
  if(ent_ref == entity_undefined)
     ent_ref = make_entity(ref_full_name,
                           make_type(is_type_variable,
                                     make_variable(make_basic_int(4 /* UU */),
                                                   NIL, NIL)),
                           make_storage(is_storage_ram, ram_undefined),
                           make_value(is_value_unknown, UU));
  
  ref = make_reference(ent_ref, NIL);
  
 /* Initialization of global variables */
  lin_exp_l = NIL;
 }

References concatenate(), DFG_MODULE_NAME, entity_domain, entity_undefined, gen_find_tabulated(), is_storage_ram, is_type_variable, is_value_unknown, lin_exp_l, make_basic_int(), make_entity, make_reference(), make_storage(), make_type(), make_value(), make_variable(), MODULE_SEP_STRING, NIL, ram_undefined, ref, ref_inds, strdup(), and UU.

Here is the call graph for this function:

◆ init_new_df_sink_ins()

void init_new_df_sink_ins ( void )

===========================================================================

void init_new_df_sink_ins(): initializes the computation of the sink statement of a datadflow. The structure of the file is such that all dependences with the same sink statement are grouped together. As our graph structure groups the dependences on the same source statement, we have to create a node for each dependence found for this sink statement. All these nodes are kept in "crt_node_l". The sink statement will be known when all these nodes will be computed, that's why they are kept in a special list.

Definition at line 297 of file adg_read_paf.c.

 {
  crt_node_l = NIL;
  
  sink_stmt = -1;
  crt_node = vertex_undefined;
  ref = reference_undefined;
 }

References crt_node, crt_node_l, NIL, ref, reference_undefined, sink_stmt, and vertex_undefined.

◆ init_new_df_source()

void init_new_df_source ( char * s_ins )

===========================================================================

void init_new_df_source(char *s_ins): initializes the computation of the source statement of a datadflow. This statement is represented by its ordering contained in its name "s_ins". We initialize the list of transformations that will be associated with source statement ("trans_l"). Also, we initialize "lin_exp_l" which is used for the parsing of the lisp expressions.

Note: We don't forget to update the list of statements "stmt_list".

In PAF, an statement name is a string "ins_#", where "#" is the number associated with the statement. We get this number.

We update the global list of statements

Initialization of global variables

Parameters

s_ins _ins

Definition at line 342 of file adg_read_paf.c.

 {
  extern list trans_l, stmt_list;
  
  trans_l = NIL;
  
  /* In PAF, an statement name is a string "ins_#", where "#" is the number
   * associated with the statement. We get this number.
   */
  source_stmt = atoi(strdup(s_ins + INS_NAME_LENGTH));
  
  /* We update the global list of statements */
  if(find_stmt_with_num(source_stmt) == statement_undefined)
     stmt_list = CONS(STATEMENT,
                      make_statement(entity_undefined, 1, source_stmt,
                                     strdup(s_ins), instruction_undefined,
                                 NIL, // No local declarations
                                 NULL, // null or empty string...
                                 empty_extensions (), make_synchronization_none()),
                      stmt_list);
  
 /* Initialization of global variables */
  lin_exp_l = NIL;
 }

References CONS, empty_extensions(), entity_undefined, find_stmt_with_num(), INS_NAME_LENGTH, instruction_undefined, lin_exp_l, make_statement(), make_synchronization_none(), NIL, source_stmt, STATEMENT, statement_undefined, stmt_list, strdup(), and trans_l.

Here is the call graph for this function:

◆ init_new_dfg()

void init_new_dfg ( void )

===========================================================================

void init_new_dfg() : initializes the computation of the DFG, i.e. the creation of the DFG in the "dfg" variable and the initialization of the global variables "exec_dom" and "gov_pred".

The list of vertices is empty at the beginning

Definition at line 245 of file adg_read_paf.c.

 {
  extern predicate exec_dom, gov_pred;
  extern list param_l;
  
  dfg = make_graph(NIL); /* The list of vertices is empty at the beginning */
  
  param_l = NIL;
  exec_dom = predicate_undefined;
  gov_pred = predicate_undefined;
 }

References dfg, exec_dom, gov_pred, make_graph(), NIL, param_l, and predicate_undefined.

Here is the call graph for this function:

◆ init_new_do_loop()

void init_new_do_loop ( char * s_loop )

===========================================================================

void init_new_do_loop(char *s_loop): initializes the parsing of the paf file ".do". The parser has read the name of a loop. With this name we create a new loop which becomes the current loop. The name of the loop is put in the loop label.

Parameters

s_loop _loop

Definition at line 751 of file adg_read_paf.c.

 {
  extern loop crt_loop;
  entity loop_ent;
  string loop_full_name;
  
  loop_full_name = strdup(concatenate(DFG_MODULE_NAME,
                                      MODULE_SEP_STRING,
                                      s_loop, (char *) NULL));
  
  loop_ent = gen_find_tabulated(loop_full_name, entity_domain);
  
  if(loop_ent == entity_undefined)
     loop_ent = make_entity(loop_full_name,
                            make_type(is_type_statement,UU),
                            make_storage(is_storage_ram, ram_undefined),
                            make_value(is_value_unknown, UU));
  
  crt_loop = make_loop(entity_undefined,
                           make_range(expression_undefined,
                                      expression_undefined,
                                      expression_undefined),
                           statement_undefined,
                           loop_ent, execution_undefined, NIL);
 }

References concatenate(), crt_loop, DFG_MODULE_NAME, entity_domain, entity_undefined, execution_undefined, expression_undefined, gen_find_tabulated(), is_storage_ram, is_type_statement, is_value_unknown, make_entity, make_loop(), make_range(), make_storage(), make_type(), make_value(), MODULE_SEP_STRING, NIL, ram_undefined, statement_undefined, strdup(), and UU.

Here is the call graph for this function:

◆ init_new_gd_ins()

void init_new_gd_ins ( char * s_ins )

===========================================================================

void init_new_gd_ins(char *s_ins): initializes the parsing of the paf file ".gd". The parser has read the name of a statement. We get the number contained in this name and put in our current statement "crt_stmt".

"crt_el" is the list of the current englobing loops, i.e. the englobing loops of the current statement. It is initializes to NIL.

Parameters

s_ins _ins

Definition at line 867 of file adg_read_paf.c.

 {
  extern list crt_el;
  extern int crt_stmt;
  
  crt_stmt = atoi(strdup(s_ins + INS_NAME_LENGTH));
  crt_el = NIL;
 }

References crt_el, crt_stmt, INS_NAME_LENGTH, NIL, and strdup().

Here is the call graph for this function:

◆ init_op_exp()

void init_op_exp ( string op_name )

===========================================================================

void init_op_exp(string op_name): initializes a new lisp expression with the operation "op_name". This expression is put at the beginning of "lin_exp_l", it is the expression the parser is currently reading.

If "op_name" is the string "0" then the operator used is "crt_op_name", else the operator name is contained in "op_name".

Parameters

op_name p_name

Definition at line 618 of file adg_read_paf.c.

 {
  extern list lin_exp_l;
  
  lisp_expression new_le;
  
  if(strncmp(op_name, "0", 1) == 0)
     new_le = make_lisp_expression(crt_op_name, NIL);
  else
     new_le = make_lisp_expression(op_name, NIL);
  
  lin_exp_l = CONS(LISP_EXPRESSION, new_le, lin_exp_l);
 }

References CONS, crt_op_name, lin_exp_l, LISP_EXPRESSION, make_lisp_expression(), and NIL.

Here is the call graph for this function:

◆ init_op_name()

void init_op_name ( string op_name )

===========================================================================

void init_op_name(string op_name): this function initializes the global variable "crt_op_name". It gives the current operation that the parser is dealing with.

Parameters

op_name p_name

Definition at line 601 of file adg_read_paf.c.

 {
  extern string crt_op_name;
  
  crt_op_name = op_name;
 }

References crt_op_name.

◆ lbound_exp()

void lbound_exp ( void )

===========================================================================

void lbound_exp(): The parser has read the lower bound expression of the current loop. This expression is contained in "crt_exp". We update our current loop.

Definition at line 814 of file adg_read_paf.c.

 {
  range_lower(loop_range(crt_loop)) = crt_exp;
  
  lin_exp_l = NIL;
 }

References crt_exp, crt_loop, lin_exp_l, loop_range, NIL, and range_lower.

◆ new_df_gov_pred()

void new_df_gov_pred ( void )

===========================================================================

void new_df_gov_pred(): the parser has found the all predicate of the dataflow of the current node, we have to compute it. This predicate is formed with the list of expressions of "pred_l". The function expressions_to_predicate() translates a list of expressions into a predicate.

Definition at line 498 of file adg_read_paf.c.

 {
  dataflow df;
  
  gov_pred = expressions_to_predicate(pred_l);
  
  df = first_df_of_succ(first_succ_of_vertex(crt_node));
  dataflow_governing_pred(df) = gov_pred;
 }

References crt_node, dataflow_governing_pred, expressions_to_predicate(), first_df_of_succ(), first_succ_of_vertex(), gov_pred, and pred_l.

Here is the call graph for this function:

◆ new_df_ref_ind()

void new_df_ref_ind ( string s_ind __attribute__(unused) )

===========================================================================

void new_df_ref_ind(char *s_ind): the parser has read a new indice of the current reference. We put it in the list of indices "ref_inds".

Initialisation of the global variables used for the reference indices parsing.

Definition at line 667 of file adg_read_paf.c.

 {
  ref_inds = gen_nconc(ref_inds, CONS(EXPRESSION, crt_exp, NIL));
  
  /* Initialisation of the global variables used for the reference indices
   * parsing.
   */
  lin_exp_l = NIL;
 }

References CONS, crt_exp, EXPRESSION, gen_nconc(), lin_exp_l, NIL, and ref_inds.

Here is the call graph for this function:

◆ new_df_sink_ins()

void new_df_sink_ins ( char * s_ins )

===========================================================================

void new_df_sink_ins(char *s_ins): the parser has read the name of the sink statement. With this name we get its number. We update the global list of statements and the list "crt_node_l". At this time, all the informations needed for the nodes of "crt_node_l" are present, we then concatenate these nodes into the list of vertices of the graph.

In PAF, an instruction name is a string "ins_#", where "#" is the number associated with the instruction. We get this number.

FI: removed because of problems. paf_ri.h and/or paf_util.h or something else should be included and might cause conflict between newgen data structures

Parameters

s_ins _ins

Definition at line 706 of file adg_read_paf.c.

 {
  extern list stmt_list;
  extern predicate exec_dom;
  
  list aux_l;
  
  /* In PAF, an instruction name is a string "ins_#", where "#" is the number
   * associated with the instruction. We get this number.
   */
  sink_stmt = atoi(strdup(s_ins + INS_NAME_LENGTH));
  
  if(find_stmt_with_num(sink_stmt) == statement_undefined)
     stmt_list = CONS(STATEMENT,
                      make_statement(entity_undefined, 1, sink_stmt,
                                     strdup(s_ins), instruction_undefined,
                                 NIL, // No local declarations
                                 NULL, // null or empty string...
                                 empty_extensions (), make_synchronization_none()),
                      stmt_list);
  
  for(aux_l = crt_node_l; aux_l != NIL; aux_l = CDR(aux_l))
    {
     successor succ = first_succ_of_vertex(VERTEX(CAR(aux_l)));
     /* FI: removed because of problems. paf_ri.h and/or paf_util.h  or something else
        should be included and might cause conflict between newgen
        data structures */
     successor_vertex(succ) = vertex_undefined;
     successor_vertex(succ) = make_vertex(make_dfg_vertex_label(sink_stmt,
                                                                exec_dom,
                                                                sccflags_undefined),
                                          NIL);
    }
  
  graph_vertices(dfg) = gen_nconc(graph_vertices(dfg), crt_node_l);
 }

References CAR, CDR, CONS, crt_node_l, dfg, empty_extensions(), entity_undefined, exec_dom, find_stmt_with_num(), first_succ_of_vertex(), gen_nconc(), graph_vertices, INS_NAME_LENGTH, instruction_undefined, make_dfg_vertex_label(), make_statement(), make_synchronization_none(), make_vertex(), NIL, sccflags_undefined, sink_stmt, STATEMENT, statement_undefined, stmt_list, strdup(), successor_vertex, VERTEX, and vertex_undefined.

Here is the call graph for this function:

◆ new_df_trans_exp()

void new_df_trans_exp ( void )

===========================================================================

void new_df_trans_exp(): The parser has now completed the reading of one transformation expression. We update "trans_l" and reinitialize "lin_exp_l" for the next expression.

Initialization of global variables

Definition at line 374 of file adg_read_paf.c.

 {
  if(crt_exp == expression_undefined)
     pips_internal_error("current expression is undefined");
  
  trans_l = gen_nconc(trans_l, CONS(EXPRESSION, crt_exp, NIL));
  crt_exp = expression_undefined;
  
 /* Initialization of global variables */
  lin_exp_l = NIL;
 }

References CONS, crt_exp, EXPRESSION, expression_undefined, gen_nconc(), lin_exp_l, NIL, pips_internal_error, and trans_l.

Here is the call graph for this function:

◆ new_eng_loop()

void new_eng_loop ( char * s_loop )

===========================================================================

void new_eng_loop(char *s_loop): the parser has found a new englobing loop. If it does not exist yet (we call find_loop_with_name()) we create it. We update "crt_el" with this loop (at the end): we want to construct an ordered list from the most external list to the innermost loop, and the parsing gets the loops in this order.

Parameters

s_loop _loop

Definition at line 909 of file adg_read_paf.c.

 {
  extern list crt_el;
  
  loop aux_loop;
  
  aux_loop = find_loop_with_name(s_loop);
  if(aux_loop == loop_undefined)
    {
     entity loop_ent;
     string loop_full_name;
  
     loop_full_name = strdup(concatenate(DFG_MODULE_NAME,
                                         MODULE_SEP_STRING,
                                         s_loop, (char *) NULL));
  
     loop_ent = gen_find_tabulated(loop_full_name, entity_domain);
  
     if(loop_ent == entity_undefined)
        loop_ent = make_entity(loop_full_name,
                               make_type(is_type_statement,UU),
                               make_storage(is_storage_ram, ram_undefined),
                               make_value(is_value_unknown, UU));
  
     aux_loop =  make_loop(entity_undefined,
                           make_range(expression_undefined,
                                      expression_undefined,
                                      expression_undefined),
                           statement_undefined,
                           loop_ent, execution_undefined, NIL);
    }
  crt_el = gen_nconc(crt_el, CONS(LOOP, aux_loop, NIL));
 }

References concatenate(), CONS, crt_el, DFG_MODULE_NAME, entity_domain, entity_undefined, execution_undefined, expression_undefined, find_loop_with_name(), gen_find_tabulated(), gen_nconc(), is_storage_ram, is_type_statement, is_value_unknown, LOOP, loop_undefined, make_entity, make_loop(), make_range(), make_storage(), make_type(), make_value(), MODULE_SEP_STRING, NIL, ram_undefined, statement_undefined, strdup(), and UU.

Here is the call graph for this function:

◆ new_param()

void new_param ( string s )

===========================================================================

void new_param(s) : adds a new structure parameters to the global list "param_l".

Fi: UU is not a proper argument for make_basic_int()

UU

Definition at line 262 of file adg_read_paf.c.

 {
  extern list param_l;
  
  entity new_ent;
  string param_full_name;
  
  param_full_name = strdup(concatenate(DFG_MODULE_NAME, MODULE_SEP_STRING,
                                       s, (char *) NULL));
  
  new_ent = gen_find_tabulated(param_full_name, entity_domain);
  
  if(new_ent == entity_undefined)
    /* Fi: UU is not a proper argument for make_basic_int() */
     new_ent = make_entity(param_full_name,
                           make_type_variable(
                                              make_variable(make_basic_int(4 /* UU */),
                                                   NIL, NIL)),
                           make_storage(is_storage_ram, ram_undefined),
                           make_value(is_value_unknown, UU));
  
  param_l = CONS(ENTITY, new_ent, param_l);
 }

References concatenate(), CONS, DFG_MODULE_NAME, ENTITY, entity_domain, entity_undefined, gen_find_tabulated(), is_storage_ram, is_value_unknown, make_basic_int(), make_entity, make_storage(), make_type_variable(), make_value(), make_variable(), MODULE_SEP_STRING, NIL, param_l, ram_undefined, strdup(), and UU.

Referenced by make_start_ru_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_exp()

void save_exp ( void )

===========================================================================

void save_exp(): the parser has completed the reading of one lisp expression, this is the first lisp expression of "lin_exp_l". We extract it from this list and translate it into a Pips expression. If there is no other lisp expression in "lin_exp_l", then this expression becomes the current expression, else it becomes an argument of the next lisp expression which is now the first object of "lin_exp_l".

Definition at line 642 of file adg_read_paf.c.

 {
  expression aux_exp;
  lisp_expression aux_le;
  
  aux_le = LISP_EXPRESSION(CAR(lin_exp_l));
  aux_exp = lisp_exp_to_ri_exp(aux_le);
  
  lin_exp_l = CDR(lin_exp_l);
  
  if(lin_exp_l == NIL)
    crt_exp = aux_exp;
  else
    {
     lisp_expression crt_le = LISP_EXPRESSION(CAR(lin_exp_l));
     lisp_expression_args(crt_le) = gen_nconc(lisp_expression_args(crt_le),
                                              CONS(EXPRESSION, aux_exp, NIL));
    }
 }

References CAR, CDR, CONS, crt_exp, EXPRESSION, gen_nconc(), lin_exp_l, lisp_exp_to_ri_exp(), LISP_EXPRESSION, lisp_expression_args, and NIL.

Here is the call graph for this function:

◆ save_id()

void save_id ( string s )

===========================================================================

void save_id(string s): The parser has found a variable as a part of a lisp expression. We save it in our global variable "lin_exp_l".

If "lin_exp_l" is empty, then this variable becomes the current expression. If not, it becomes an argument of the first lisp expression of "lin_exp_l".

Definition at line 576 of file adg_read_paf.c.

 {
  extern list lin_exp_l;
  extern expression crt_exp;
  expression aux_exp;
  
  aux_exp = make_id_expression(s);
  
  if(lin_exp_l == NIL)
     crt_exp = aux_exp;
  else
    {
     lisp_expression crt_le = LISP_EXPRESSION(CAR(lin_exp_l));
     lisp_expression_args(crt_le) = gen_nconc(lisp_expression_args(crt_le),
                                              CONS(EXPRESSION, aux_exp, NIL));
    }
 }

References CAR, CONS, crt_exp, EXPRESSION, gen_nconc(), lin_exp_l, LISP_EXPRESSION, lisp_expression_args, make_id_expression(), and NIL.

Here is the call graph for this function:

◆ save_int()

void save_int ( int i )

===========================================================================

void save_int(int i): The parser has found an integer as a part of a lisp expression. We save it in our global variable "lin_exp_l".

If "lin_exp_l" is empty, then this integer becomes the current expression. If not, it becomes an argument of the first lisp expression of "lin_exp_l".

Definition at line 549 of file adg_read_paf.c.

 {
  extern list lin_exp_l;
  extern expression crt_exp;
  expression aux_exp;
  
  aux_exp = int_to_expression(i);
  
  if(lin_exp_l == NIL)
     crt_exp = aux_exp;
  else
    {
     lisp_expression crt_le = LISP_EXPRESSION(CAR(lin_exp_l));
     lisp_expression_args(crt_le) = gen_nconc(lisp_expression_args(crt_le),
                                              CONS(EXPRESSION, aux_exp, NIL));
    }
 }

References CAR, CONS, crt_exp, EXPRESSION, gen_nconc(), int_to_expression(), lin_exp_l, LISP_EXPRESSION, lisp_expression_args, and NIL.

Here is the call graph for this function:

◆ save_pred()

void save_pred ( int option )

===========================================================================

void save_pred(int option): computes one expression of the predicate. Each expression is used twice ; indeed, an expression may be greater or equal than zero (>=) and smaller than zero (<). "option" says in which case we are: POSITIVE indicates that the predicate is >=, with NEGATIVE it is <. However, the C3 library always represents its inequalities with <=. So, the inequality "A >= 0" becomes "-A <= 0" and "A < 0" becomes "A + 1 <= 0".

This function updates the global list "pred_l" that contains the current list of predicates. When a new predicate expression is parsed, the POSITIVE is always considered first (that is why only in that case we use "crt_exp"). When the NEGATICE case is considered, the corresponding expression (used in the POSITIVE case) is the first expression of the list "pred_l". So, we only have to replace this expression by it equivalent for the NEGATIVE case (that is why the expression is multiplied by -1).

"A >= 0" becomes "-A <= 0"

option == NEGATIVE

"A < 0" becomes "A + 1 <= 0"

Initialization of global variables

Parameters

option ption

Definition at line 450 of file adg_read_paf.c.

 {
  expression aux_pred;
  
  if(option == POSITIVE)
    {
     if(crt_exp == expression_undefined)
        pips_internal_error("current expression is undefined");
  
     /* "A >= 0" becomes "-A <= 0"*/
     pred_l = CONS(EXPRESSION, negate_expression(crt_exp), pred_l);
     crt_exp = expression_undefined;
    }
  else
  /* option == NEGATIVE */
    {
     /* "A < 0" becomes "A + 1 <= 0"*/
     aux_pred = make_op_exp(PLUS_OPERATOR_NAME,
                            negate_expression(EXPRESSION(CAR(pred_l))),
                            int_to_expression(1));
  
     pred_l = CONS(EXPRESSION, aux_pred, CDR(pred_l));
    }
  
 /* Initialization of global variables */
  lin_exp_l = NIL;
 }

References CAR, CDR, CONS, crt_exp, EXPRESSION, expression_undefined, int_to_expression(), lin_exp_l, make_op_exp(), negate_expression(), NIL, pips_internal_error, PLUS_OPERATOR_NAME, POSITIVE, and pred_l.

Here is the call graph for this function:

◆ step_exp()

void step_exp ( void )

===========================================================================

void step_exp(): The parser has read the step expression of the current loop. This expression is contained in "crt_exp". We update our current loop.

Definition at line 826 of file adg_read_paf.c.

 {
  range_increment(loop_range(crt_loop)) = crt_exp;
  
  lin_exp_l = NIL;
 }

References crt_exp, crt_loop, lin_exp_l, loop_range, NIL, and range_increment.

◆ ubound_exp()

void ubound_exp ( void )

===========================================================================

void ubound_exp(): The parser has read the upper bound expression of the current loop. This expression is contained in "crt_exp". We update our current loop.

Definition at line 839 of file adg_read_paf.c.

 {
  range_upper(loop_range(crt_loop)) = crt_exp;
  
  lin_exp_l = NIL;
 }

References crt_exp, crt_loop, lin_exp_l, loop_range, NIL, and range_upper.

Variable Documentation

◆ crt_el

list crt_el

static

Current list of predicates.

Definition at line 172 of file adg_read_paf.c.

Referenced by finish_new_gd_ins(), init_new_gd_ins(), and new_eng_loop().

◆ crt_exp

expression crt_exp

static

Current reference.

Definition at line 164 of file adg_read_paf.c.

Referenced by lbound_exp(), new_df_ref_ind(), new_df_trans_exp(), save_exp(), save_id(), save_int(), save_pred(), step_exp(), and ubound_exp().

◆ crt_loop

loop crt_loop

static

Current operator name.

Definition at line 175 of file adg_read_paf.c.

Referenced by finish_new_do_loop(), init_loop_ctrl(), init_new_do_loop(), lbound_exp(), step_exp(), and ubound_exp().

◆ crt_node

vertex crt_node

static

Internal variables

Definition at line 159 of file adg_read_paf.c.

Referenced by finish_new_df_source(), init_new_df_sink_ins(), and new_df_gov_pred().

◆ crt_node_l

list crt_node_l

static

Current execution domain.

Definition at line 167 of file adg_read_paf.c.

Referenced by finish_new_df_ref(), finish_new_df_source(), init_new_df_sink_ins(), and new_df_sink_ins().

◆ crt_op_name

string crt_op_name

static

Current list of structure parameters.

Definition at line 174 of file adg_read_paf.c.

Referenced by init_op_exp(), and init_op_name().

◆ crt_stmt

int crt_stmt

static

Current source statement.

Definition at line 162 of file adg_read_paf.c.

Referenced by finish_new_gd_ins(), fprint_bdt(), fprint_bdt_with_stat(), init_new_gd_ins(), and partial_broadcast_coefficients().

◆ dfg

graph dfg

Global variables

cproto-generated files

The "dfg" global variable is the current DFG being computed. Its type is defined in graph.h and paf_ri.h.

Definition at line 138 of file adg_read_paf.c.

Referenced by adg_read_paf(), init_new_dfg(), new_df_sink_ins(), and scheduling().

◆ exec_dom

predicate exec_dom

static

Current governing predicate.

Definition at line 166 of file adg_read_paf.c.

Referenced by adg_fprint_dfg(), finish_new_df_source(), fprint_dfg(), init_new_dfg(), and new_df_sink_ins().

◆ gov_pred

predicate gov_pred

static

Current expression.

Definition at line 165 of file adg_read_paf.c.

Referenced by adg_fprint_dataflow(), broadcast_of_dataflow(), edge_weight(), finish_new_df_source(), fprint_dataflow(), init_new_df_gov_pred(), init_new_dfg(), new_df_gov_pred(), and plc_make_distance().

◆ lin_exp_l

list lin_exp_l

static

Current list of reference indices.

Definition at line 170 of file adg_read_paf.c.

Referenced by init_loop_ctrl(), init_new_df_gov_pred(), init_new_df_ref(), init_new_df_source(), init_op_exp(), lbound_exp(), new_df_ref_ind(), new_df_trans_exp(), save_exp(), save_id(), save_int(), save_pred(), step_exp(), and ubound_exp().

◆ loop_list

list loop_list

The "loop_list" global variable is the list the loops of the program (with all their characteristics: index, bounds, step).

The loop type is "loop" defined in ri.h.

Definition at line 150 of file adg_read_paf.c.

Referenced by adg_read_paf(), find_loop_with_name(), and finish_new_do_loop().

◆ param_l

list param_l

static

Current list of englobing loops.

Definition at line 173 of file adg_read_paf.c.

Referenced by finish_new_gd_ins(), init_new_dfg(), and new_param().

◆ pred_l

list pred_l

static

Current list of linear expressions.

Definition at line 171 of file adg_read_paf.c.

Referenced by elim_last_pred(), init_new_df_gov_pred(), new_df_gov_pred(), and save_pred().

◆ ref

reference ref

static

Current stmt (an integer)

Definition at line 163 of file adg_read_paf.c.

Referenced by add_non_declared_reference_to_declaration(), add_parameter_variable_to_module(), add_private_variable_to_module(), adg_fprint_dataflow(), alloc_instrumentation(), AllocateSimpleSection(), array_argument_p(), array_formal_parameter_to_stub_points_to(), array_indices_check(), atom_cse_expression(), atomize_call(), atomize_this_expression(), build_esv_list(), call_rwt(), cell_reference_sc_exact_projection_along_variable(), cell_reference_system_remove_psi_variables(), cell_reference_system_remove_rho_variables(), cell_reference_to_type(), cell_to_type(), check_common_inclusion(), check_for_conflict(), check_the_reference(), checkReplaceReference(), code_has_write_eff_ref_p(), comEngine_replace_reference_in_stat(), comp_regions_of_implied_do(), comp_regions_of_loop(), comp_regions_of_read(), comp_regions_of_write(), compact_phi_functions(), comparable_entity_in_list_p(), compile_reduction(), compute_fifo_from_ref(), convex_effect_to_constant_path_effects_with_pointer_values(), convex_effect_to_constant_path_effects_with_points_to(), copy_n_reference(), create_module_with_statement(), daCallReplaceReference(), daCheckCallReplace(), daExpressionReplaceReference(), distribute_code(), do_check_isolate_statement_preconditions_on_call(), do_group_statement_constant(), do_group_statement_constant_filter(), do_group_statement_constant_prune(), do_grouping_filter_out_self(), do_grouping_replace_reference_by_expression_walker(), do_isolate_statement_preconditions_satisified_p(), effect_may_union(), effect_must_union(), effect_reference_contains_pointer_dimension_p(), effect_reference_dereferencing_p(), effect_reference_first_pointer_dimension_rank(), effect_reference_to_string(), effect_to_constant_path_effects_with_points_to(), entity_in_ref(), entity_in_ref_list(), eval_var(), expr_has_write_eff_ref_p(), expression_in_array_subscript(), expression_to_expression_newbase(), expression_try_find_size(), FILE_star_effect_reference_p(), find_bd_reference(), find_effect_actions_for_entity(), find_or_create_fifo_from_ref(), finish_new_df_ref(), finish_new_df_source(), fprint_dataflow(), functionnal_on(), functionnal_on_effects(), fusion_buffer(), gen_may_constant_paths(), gen_must_constant_paths(), generate_c1_alpha(), generate_compute_local_indices(), generate_get_value_locally(), generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_receive_from_computer(), generate_send_to_computer(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), generic_eval_cell_with_points_to(), genref_any_loop(), genref_one_statement(), genref_test(), genref_unstructured(), get_const_off(), get_dma_dimension(), get_fifo_from_ref(), get_HRE_buff_ent_from_ref(), get_sizeofexpression_for_region(), GetAccVec(), gfc2pips_expr2expression(), indirection_test(), init_new_df_ref(), init_new_df_sink_ins(), InitCompDesc(), initialize_array_variable(), inout_unstructured(), io_comp_regions(), is_expression_in_list(), list_of_same_or_equivalence_arguments(), loop_index_in_several_indices(), make_array_communication_statement(), make_global_common_and_initialize(), make_start_ru_module(), make_statement_copy_i(), make_substitution(), MakeAtom(), name_end_p(), new_local_image_variable(), new_system_with_only_live_variable(), normal_expression_of_expression(), other_cool_enough_for_a_last_substitution(), phrase_check_reference(), points_to_cell_to_type(), points_to_reference_to_type(), potential_reduction_substitution_valid_p(), print_reduction(), print_variables(), process_true_call_stat(), proper_to_summary_simple_effect(), reduction_as_expr(), reduction_star_p(), reductions_on_scalar(), ref_found_p(), reference_dependence_variable_check_and_add(), reference_indices_entity_list(), reference_ith_index(), reference_offset(), reference_to_complexity(), reference_to_polynome(), reference_to_type(), references_for_regions(), region_range_nul_p(), region_to_com_nest(), region_to_loop_nest(), region_to_minimal_dimensions(), replace_entities_in_cusq_context(), replace_indices_region(), replace_indices_region_com(), replace_reductions_in_statement(), replace_sender_entity_by_receiver_entity_in_reference(), same_section_common_variable_in_list_p(), same_section_formal_variable_in_list_p(), ScanAllDims(), simple_effect_to_constant_path_effects_with_pointer_values(), simple_pv_translate(), simple_reference_to_convex_reference_conversion(), simple_reference_to_simple_reference_conversion(), st_compute_current_computer(), st_compute_current_owners(), st_get_value_for_all(), st_get_value_for_computer(), st_get_value_locally_and_send(), st_receive_from(), st_send_to_computer_if_necessary(), st_send_to_host_and_nodes(), stat_has_write_eff_ref_p(), store_reference(), substitute_ghost_variable_in_expression(), substitution_candidate(), supported_ref_p(), terapix_mcu_img(), terapix_mcu_int(), terapix_mcu_pval(), Tiling_buffer_allocation(), top_down_abc_call(), top_down_abc_flt(), translate_reduction(), translate_reference_region(), translate_to_module_frame(), unary_into_binary_ref(), update_reference_for_module_rewrite(), variable_declaration_verify(), verify_array_variable(), verify_used_before_set_call(), verify_used_before_set_expression(), vertex_partially_invariant_p(), write_conf_on_ref(), xml_array_in_task(), xml_call_from_assignation(), xml_call_from_indice(), xml_GlobalVariables(), xml_Pattern_Paving(), xml_references(), xml_Region_Parameter(), xml_Region_Range(), xml_TaskParameter(), and xml_tiling().

◆ ref_inds

list ref_inds

static

Current list of transformations.

Definition at line 169 of file adg_read_paf.c.

Referenced by finish_new_df_ref(), init_new_df_ref(), and new_df_ref_ind().

◆ sink_stmt

int sink_stmt

static

Current source node.

Definition at line 160 of file adg_read_paf.c.

Referenced by adg_fprint_dfg(), broadcast(), cutting_conditions(), edge_weight(), fprint_dfg(), fprint_sccs(), init_new_df_sink_ins(), new_df_sink_ins(), plc_fprint_distance(), and plc_make_distance().

◆ source_stmt

int source_stmt

static

Current sink statement.

Definition at line 161 of file adg_read_paf.c.

Referenced by adg_fprint_dfg(), edge_weight(), finish_new_df_source(), fprint_dfg(), fprint_sccs(), init_new_df_source(), and plc_make_distance().

◆ stmt_list

list stmt_list

The "stmt_list" global variable is the list the assign statement of the program (with all fields empty but two: ordering (the number of the statement) and comments (the string name of the statement)).

Definition at line 144 of file adg_read_paf.c.

Referenced by adg_read_paf(), find_stmt_with_num(), init_new_df_source(), loop_normalize_of_loop(), and new_df_sink_ins().

◆ STS

hash_table STS

static

The "STS" global variable is the hash table that maps the static_control on the statements.

Definition at line 155 of file adg_read_paf.c.

Referenced by adg_read_paf(), comp_exec_domain(), finish_new_gd_ins(), get_stco_from_current_map(), prgm_mapping(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), reindexing(), scheduling(), and single_assign().

◆ trans_l

list trans_l

static

Current list of nodes.

Definition at line 168 of file adg_read_paf.c.

Referenced by adg_fprint_dataflow(), broadcast_of_dataflow(), edge_weight(), finish_new_df_source(), fprint_dataflow(), init_new_df_source(), new_df_trans_exp(), and plc_make_distance().

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DOT

◆ INIT_STATEMENT_SIZE

◆ INS_NAME_LENGTH

◆ PAF_STRING

◆ STMT_TO_STCT_SIZE

Typedef Documentation

◆ arc_label

◆ vertex_label

Function Documentation

◆ adg_read_paf()

◆ elim_last_pred()

◆ find_loop_with_name()

◆ find_stmt_with_num()

◆ finish_new_df_ref()

◆ finish_new_df_source()

◆ finish_new_do_loop()

◆ finish_new_gd_ins()

◆ init_loop_ctrl()

◆ init_new_df_gov_pred()

◆ init_new_df_ref()

◆ init_new_df_sink_ins()

◆ init_new_df_source()

◆ init_new_dfg()

◆ init_new_do_loop()

◆ init_new_gd_ins()

◆ init_op_exp()

◆ init_op_name()

◆ lbound_exp()

◆ new_df_gov_pred()

◆ new_df_ref_ind()

◆ new_df_sink_ins()

◆ new_df_trans_exp()

◆ new_eng_loop()

◆ new_param()

◆ save_exp()

◆ save_id()

◆ save_int()

◆ save_pred()

◆ step_exp()

◆ ubound_exp()

Variable Documentation

◆ crt_el

◆ crt_exp

◆ crt_loop

◆ crt_node

◆ crt_node_l

◆ crt_op_name

◆ crt_stmt

◆ dfg

◆ exec_dom

◆ gov_pred

◆ lin_exp_l

◆ loop_list

◆ param_l

◆ pred_l

◆ ref

◆ ref_inds

◆ sink_stmt

◆ source_stmt

◆ stmt_list

◆ STS

◆ trans_l