codegen.c File Reference

#include "local.h"

Include dependency graph for codegen.c:

Go to the source code of this file.

Macros
#define	INTEGER_DECL   " INTEGER"
	We define a set of constant in order to a more generic function for the insert of the declarations of the new created variables. More...
#define	REAL_DECL   " REAL"
#define	COMPLEX_DECL   " COMPLEX"
#define	LOGICAL_DECL   " LOGICAL"
#define	DOUBLE_DECL   " DOUBLE PRECISION"
#define	CHARACTER_DECL   " CHARACTER"
#define	SPACE   " "
#define	COMA   ","
#define	NEWLINE   "\n *"
#define	ENDLINE   "\nC\n"
#define	LINE_LENGHT   68
#define	MARGIN_LENGHT   7

Functions
static expression	find_tmp_of_exp (expression exp)
	=========================================================================== More...
void	put_stmt_in_Block (statement new_stmt, Block *cb)
	=========================================================================== More...
expression	assign_tmp_to_exp (expression exp, Block *cb)
	=========================================================================== More...
void	insert_one_type_declaration (entity mod_entity, list var_to_decl, string type_decl)
	=========================================================================== More...
void	insert_new_declarations (char *mod_name)
	=========================================================================== More...
void	store_expression (expression exp, Block *cb)
	=========================================================================== More...

Variables
hash_table	MemToTmp
	– codegen.c More...

Macro Definition Documentation

CHARACTER_DECL

#define CHARACTER_DECL   " CHARACTER"

Definition at line 215 of file codegen.c.

COMA

#define COMA   ","

Definition at line 217 of file codegen.c.

COMPLEX_DECL

#define COMPLEX_DECL   " COMPLEX"

Definition at line 212 of file codegen.c.

DOUBLE_DECL

#define DOUBLE_DECL   " DOUBLE PRECISION"

Definition at line 214 of file codegen.c.

ENDLINE

#define ENDLINE   "\nC\n"

Definition at line 219 of file codegen.c.

INTEGER_DECL

#define INTEGER_DECL   " INTEGER"

We define a set of constant in order to a more generic function for the insert of the declarations of the new created variables.

Definition at line 210 of file codegen.c.

LINE_LENGHT

#define LINE_LENGHT   68

Definition at line 220 of file codegen.c.

LOGICAL_DECL

#define LOGICAL_DECL   " LOGICAL"

Definition at line 213 of file codegen.c.

MARGIN_LENGHT

#define MARGIN_LENGHT   7

Definition at line 221 of file codegen.c.

NEWLINE

#define NEWLINE   "\n *"

Definition at line 218 of file codegen.c.

REAL_DECL

#define REAL_DECL   " REAL"

Definition at line 211 of file codegen.c.

SPACE

#define SPACE   " "

Definition at line 216 of file codegen.c.

Function Documentation

assign_tmp_to_exp()

expression assign_tmp_to_exp	(	expression	exp,
		Block *	cb
	)

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

expression assign_tmp_to_exp(expression exp, Block *cb): Produces an assign statement of "exp" in a temporary (this is a load), puts it in "cb" and returns the expression of the temporary.

There are two cases:

1. "exp" is found to be a scalar variable already loaded in a temporary, then the expression of the temporary is returned.
2. otherwise, we do the following manipulations: _ Firstly, we compute a new basic of the same kind as "exp". _ Secondly, we create a new temporary with the basic found above. _ Thirdly, the new assign statement is created. _ Fourthly, this new statement is put in the current block ("cb"). _ Finaly, we return the expression of the new temporary.

The variable "cb" memorises the information about the block of statements that contains the expressions.

Called functions : _ entity_scalar_p() : ri-util/entity.c _ make_entity_expression() : ri-util/util.c _ make_assign_statement() : ri-util/statement.c

If this expression is a scalar variable already loaded in a temporary, then it is unnecessary to loaded it again. The only thing to do is to find the temporary that was used and return it.

We compute the basic of "exp".

We create a new temporary with the basic "tmp_basic".

If "exp_ent" is a scalar variable, this temporary is placed in MemToTmp at the key "exp_ent".

We create a new expression with this temporary.

The new assign statement is created ...

... and put in the current Block.

The new temporary is returned.

Parameters

exp	xp
cb	b

Definition at line 155 of file codegen.c.

{
expression tmp;
entity tmp_ent, exp_ent = entity_undefined;
basic tmp_basic;
statement new_stmt;
 
/* If this expression is a scalar variable already loaded in a
 * temporary, then it is unnecessary to loaded it again. The only
 * thing to do is to find the temporary that was used and return it.
 */
if(syntax_tag(expression_syntax(exp)) == is_syntax_reference)
  {
  exp_ent = reference_variable(syntax_reference(expression_syntax(exp)));
  if(entity_scalar_p(exp_ent))
    {
    tmp = find_tmp_of_exp(exp);
    if(tmp != expression_undefined)
      return(tmp);
    }
  }
 
/* We compute the basic of "exp". */
tmp_basic = basic_of_expression(exp);
 
/* We create a new temporary with the basic "tmp_basic". */
tmp_ent = make_new_entity(tmp_basic, TMP_ENT);
 
/* If "exp_ent" is a scalar variable, this temporary is placed in
 * MemToTmp at the key "exp_ent".
 */
if(syntax_tag(expression_syntax(exp)) == is_syntax_reference)
  if(entity_scalar_p(exp_ent))
    hash_put(MemToTmp, (char *) exp_ent, (char *) tmp_ent);
 
/* We create a new expression with this temporary. */
tmp = make_entity_expression(tmp_ent, NIL);
 
/* The new assign statement is created ... */
new_stmt = make_assign_statement(tmp, exp);
 
/* ... and put in the current Block. */
put_stmt_in_Block(new_stmt, cb);
 
/* The new temporary is returned. */
return(tmp);
}

References basic_of_expression(), entity_scalar_p(), entity_undefined, exp, expression_syntax, expression_undefined, find_tmp_of_exp(), hash_put(), is_syntax_reference, make_assign_statement(), make_entity_expression(), make_new_entity(), MemToTmp, NIL, put_stmt_in_Block(), reference_variable, syntax_reference, syntax_tag, and TMP_ENT.

Referenced by atomizer_of_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

find_tmp_of_exp()

static expression find_tmp_of_exp ( expression  exp )

static

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

expression find_tmp_of_exp(expression exp): Returns the expression of the temporary in which the variable of "exp" was loaded. If "exp" is not atomic, or, if "exp" was not yet loaded, this function returns "expression_undefined".

This function uses the hash table MemToTmp. For a given memory variable you may have an associated temporary. This association is built when such a variable is loaded for the first time.

Called functions : _ entity_scalar_p() : ri-util/entity.c _ make_entity_expression() : ri-util/util.c

Definition at line 58 of file codegen.c.

{
expression ret_exp = expression_undefined;
 
if(syntax_tag(expression_syntax(exp)) == is_syntax_reference)
  {
  entity exp_ent, tmp_ent;
  exp_ent = reference_variable(syntax_reference(expression_syntax(exp)));
  if(entity_scalar_p(exp_ent))
    {
    tmp_ent = (entity) hash_get(MemToTmp, (char *) exp_ent);
    if(tmp_ent != entity_undefined)
      ret_exp = make_entity_expression(tmp_ent, NIL);
    }
  }
return(ret_exp);
}

References entity_scalar_p(), entity_undefined, exp, expression_syntax, expression_undefined, hash_get(), is_syntax_reference, make_entity_expression(), MemToTmp, NIL, reference_variable, syntax_reference, and syntax_tag.

Referenced by assign_tmp_to_exp().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_new_declarations()

void insert_new_declarations

(

char *

mod_name

)

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

void insert_new_declarations(char *mod_name): puts in the declaration text of the module "mod_name" the declarations for the temporary, auxiliary and NLC variables.

Called functions : _ local_name_to_top_level_entity() : ri-util/entity.c

We declare only variables that are not INTEGER or REAL simple precision.

Parameters

mod_name

od_name

Definition at line 285 of file codegen.c.

{
  entity mod_entity;
 
  mod_entity = local_name_to_top_level_entity(mod_name);
 
  /* We declare only variables that are not INTEGER or
   * REAL simple precision.
   */
/*
  integer_entities = gen_nreverse(integer_entities);
  real_entities = gen_nreverse(real_entities);
*/
  logical_entities = gen_nreverse(logical_entities);
  double_entities = gen_nreverse(double_entities);
  complex_entities = gen_nreverse(complex_entities);
  char_entities = gen_nreverse(char_entities);
 
/*
  insert_one_type_declaration(mod_entity, integer_entities, INTEGER_DECL);
  insert_one_type_declaration(mod_entity, real_entities, REAL_DECL);
*/
  insert_one_type_declaration(mod_entity, logical_entities, LOGICAL_DECL);
  insert_one_type_declaration(mod_entity, double_entities, DOUBLE_DECL);
  insert_one_type_declaration(mod_entity, complex_entities, COMPLEX_DECL);
  insert_one_type_declaration(mod_entity, char_entities, CHARACTER_DECL);
 
  // ??? dandling pointers to be cleaned up later
  gen_free_list(integer_entities);
  gen_free_list(real_entities);
  gen_free_list(logical_entities);
  gen_free_list(double_entities);
  gen_free_list(complex_entities);
  gen_free_list(char_entities);
}

References char_entities, CHARACTER_DECL, COMPLEX_DECL, complex_entities, DOUBLE_DECL, double_entities, gen_free_list(), gen_nreverse(), insert_one_type_declaration(), integer_entities, local_name_to_top_level_entity(), LOGICAL_DECL, logical_entities, and real_entities.

Here is the call graph for this function:

insert_one_type_declaration()

void insert_one_type_declaration	(	entity	mod_entity,
		list	var_to_decl,
		string	type_decl
	)

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

void insert_one_type_declaration(entity mod_entity, list var_to_decl, string type_decl): Inserts in the module "mod_entity" the declarations of the entities in the list "var_to_decl" with the type "type_decl".

Type declaration.

Lenght of the declaration to insert.

If the line is to long ..., we begin a new line!!

We separate the variables between comas.

Parameters

mod_entity	od_entity
var_to_decl	ar_to_decl
type_decl	ype_decl

Definition at line 229 of file codegen.c.

{
string new_decls;
code mod_code;
list l;
int counter = strlen(type_decl);
 
if(var_to_decl != NIL)
  {
  /* Type declaration. */
  new_decls = strdup(concatenate(type_decl, (char *) NULL));
  for(l = var_to_decl; l != NIL;)
    {
    entity e = ENTITY(CAR(l));
 
    /* Lenght of the declaration to insert. */
    int decl_len = strlen(SPACE) + strlen(COMA) + strlen(entity_local_name(e));
 
    /* If the line is to long ..., we begin a new line!! */
    if( (counter + decl_len) > LINE_LENGHT)
      {
      counter = MARGIN_LENGHT;
      new_decls = strdup(concatenate(new_decls, NEWLINE, (char *) NULL));
      }
    new_decls = strdup(concatenate(new_decls, SPACE,
                                   entity_local_name(e), (char *) NULL));
    l = CDR(l);
 
    /* We separate the variables between comas. */
    if(l != NIL)
      new_decls = strdup(concatenate(new_decls, COMA, (char *) NULL));
 
    counter += decl_len;
    }
 
  new_decls = strdup(concatenate(new_decls, ENDLINE, (char *) NULL));
 
  mod_code = entity_code(mod_entity);
  code_decls_text(mod_code) = strdup(concatenate(code_decls_text(mod_code),
                                                 new_decls, (char *) NULL));
  }
}

References CAR, CDR, code_decls_text, COMA, concatenate(), ENDLINE, ENTITY, entity_code(), entity_local_name(), LINE_LENGHT, MARGIN_LENGHT, NEWLINE, NIL, SPACE, and strdup().

Referenced by insert_new_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

put_stmt_in_Block()

void put_stmt_in_Block	(	statement	new_stmt,
		Block *	cb
	)

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

codegen.c

void put_stmt_in_Block(statement new_stmt, Block *cb): Puts "new_stmt" at the end of the list "cb->first".

First, if "new_stmt" is the first statement generated by the statement being translated (the current statement), then the caracteritics of "new_stmt" are taken from those of the current statement.

Second, "new_stmt" is added to the list of statements of "cb".

The current statement is the first element of the list "cb->last".

"stmt_generated" is false if the current statement has not produced any statement yet, in which case the new statement gets the "label", "number", "ordering" and "comments" (cf. RI) of the current statement.

The new statement gets the caracteristic of the current statement, while the latter gets the caracteristics of the new statement.

The current statement has, now, generated at least one statement.

The new statement is put just before the current statement in the block. Thus, it is put in last position in the list "cb->first".

Parameters

new_stmt	ew_stmt
cb	b

Definition at line 89 of file codegen.c.

{
statement current_stmt;
 
/* The current statement is the first element of the list "cb->last". */
current_stmt= STATEMENT(CAR(cb->last));
 
/* "stmt_generated" is false if the current statement has not produced
 * any statement yet, in which case the new statement gets the "label",
 * "number", "ordering" and "comments" (cf. RI) of the current statement.
 */
if (! cb->stmt_generated)
  {
  entity new_label;
  /* The new statement gets the caracteristic of the current statement,
   * while the latter gets the caracteristics of the new statement.
   */
  new_label = statement_label(new_stmt);
  statement_label(new_stmt) = statement_label(current_stmt);
  statement_number(new_stmt) = statement_number(current_stmt);
  statement_ordering(new_stmt) = statement_ordering(current_stmt);
  statement_comments(new_stmt) = statement_comments(current_stmt);
 
  statement_label(current_stmt) = new_label;
  statement_number(current_stmt) = STATEMENT_NUMBER_UNDEFINED;
  statement_ordering(current_stmt) = STATEMENT_ORDERING_UNDEFINED;
  statement_comments(current_stmt) = string_undefined;
 
  /* The current statement has, now, generated at least one statement. */
  cb->stmt_generated = true;
  }
 
/* The new statement is put just before the current statement in the block.
 * Thus, it is put in last position in the list "cb->first".
 */
cb->first = gen_nconc(cb->first, CONS(STATEMENT, new_stmt, NIL));
}

References CAR, CONS, current_stmt, Block::first, gen_nconc(), Block::last, NIL, STATEMENT, statement_comments, statement_label, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, STATEMENT_ORDERING_UNDEFINED, Block::stmt_generated, and string_undefined.

Referenced by assign_tmp_to_exp(), and atomizer_of_external().

Here is the call graph for this function:

Here is the caller graph for this function:

store_expression()

void store_expression	(	expression	exp,
		Block *	cb
	)

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

void store_expression(expression exp, Block *cb): Removes the key of the hash table MemToTmp corresponding to the variable contained in "exp". It means that the value of this variable is no longer equal to the value of the temporary stored in MemToTmp.

Note: "exp" must have a "syntax_tag" equal to "reference".

Called functions : _ entity_scalar_p() : ri-util/entity.c _ make_entity_expression() : ri-util/util.c _ make_assign_statement() : ri-util/statement.c

entity tmp_ent;

Parameters

exp	xp
cb	b

Definition at line 335 of file codegen.c.

{
  entity ent;
 
  pips_assert("true", cb==cb);
 
  if(syntax_tag(expression_syntax(exp)) != is_syntax_reference)
    pips_user_error("Expression is not a reference");
 
  ent = reference_variable(syntax_reference(expression_syntax(exp)));
  if(entity_scalar_p(ent))
    {
      /* entity tmp_ent; */
 
      (void) hash_del(MemToTmp, (char *) ent);
 
      /*
        tmp_ent = (entity) hash_get(MemToTmp, (char *) ent);
        if(tmp_ent != entity_undefined)
        {
        expression tmp;
        tmp = make_entity_expression(tmp_ent, NIL);
        put_stmt_in_Block(make_assign_statement(exp, tmp), cb);
        (void) hash_del(MemToTmp, (char *) ent);
        }
      */
    }
}

References entity_scalar_p(), exp, expression_syntax, hash_del(), is_syntax_reference, MemToTmp, pips_assert, pips_user_error, reference_variable, syntax_reference, and syntax_tag.

Here is the call graph for this function:

Variable Documentation

MemToTmp

hash_table MemToTmp

extern

– codegen.c

package atomizer : Alexis Platonoff, juillet 91

Functions that generates the new instructions. A hash table to map temporary variables (entities) to memory variables (entities).

– codegen.c

They are used for the declarations of the temporaries and the auxiliaries. A hash table to map temporary variables (entities) to memory variables (entities).

Definition at line 95 of file atomizer.c.

Referenced by assign_tmp_to_exp(), atomizer_of_external(), atomizer_of_intrinsic(), atomizer_of_loop(), atomizer_of_unstructured(), find_tmp_of_exp(), initialize_global_variables(), reset_global_variables(), and store_expression().