comEngine_generate_HRECode.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "text-util.h"
#include "properties.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "phrase_tools.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "phrase_distribution.h"
#include "comEngine.h"
#include "comEngine_generate_code.h"
#include "phrase.h"

Include dependency graph for comEngine_generate_HRECode.c:

Go to the source code of this file.

Functions
expression	get_fifo_from_ref (reference ref)
entity	get_HRE_buff_ent_from_ref (reference ref)
statement	make_wait_step_statement ()
static statement	generate_fifo_stat (reference curRef, expression buffIndExp, entity ind, bool bRead)
static void	generate_fifo_stats (list lRef, expression buffIndExp, entity ind, list *lReadStats, list *lWriteStats)
void	replace_array_ref_with_fifos (list lRef, expression buffIndExp, entity ind, statement *newStat)
static void	generate_scalar_variables ()
statement	generate_stat_from_ref_list_HRE (list lRef, statement stat)
list	generate_stat_from_ref_list_HRE_list (list lRef, list lInStats)
void	get_supportedRef_HRE (statement stat, list *lSupportedRef, list *lUnSupportedRef)
void	process_replacement_HRE (list lRef, expression buffIndExp, statement *stat)
list	process_replacement_HRE_OutRef (list lRef, list lStats)
statement	get_call_stat_HRE (statement stat)
list	make_loop_lStats_HRE (statement stat, entity transferSize, statement innerStat, entity newOuterInd, _UNUSED_ list lSupportedRef, _UNUSED_ hash_table htOffset, expression bufferSizeExp)
statement	generate_code_test_HRE (statement stat)
list	process_gLoopToSync_HRE (statement stat, list lInStats)
statement	comEngine_generate_HRECode (statement externalized_code, string new_module_name, _UNUSED_ list l_in, _UNUSED_ list l_out, _UNUSED_ list l_params, _UNUSED_ list l_priv, const char *module_name, _UNUSED_ int hreMemSize)

Variables
hash_table	gRefToHREVar
	comEngine_generate_HRECode.c More...

Function Documentation

comEngine_generate_HRECode()

statement comEngine_generate_HRECode	(	statement	externalized_code,
		string	new_module_name,
		_UNUSED_ list	l_in,
		_UNUSED_ list	l_out,
		_UNUSED_ list	l_params,
		_UNUSED_ list	l_priv,
		const char *	module_name,
		_UNUSED_ int	hreMemSize
	)

Definition at line 636 of file comEngine_generate_HRECode.c.

{
  statement newStat;
 
  gRefToHREVar = hash_table_make(hash_pointer, 0);
 
  if(get_bool_property("COMENGINE_CONTROL_IN_HRE"))
    {
      entity new_fun = make_empty_subroutine(new_module_name,make_language_unknown());
 
      reset_current_module_entity();
 
      set_current_module_entity(new_fun);
 
      // Generate the HRE private variables
      generate_scalar_variables();
 
      // This means the HRE code is going to be generated
      gGenHRE = true;
 
      //This function generates the HRE code if we want to have only 
      //one process on the HRE
      newStat = comEngine_generate_code(externalized_code);
 
      // Create the new HRE module
      create_HRE_module(new_module_name,
                        module_name, newStat, new_fun);
    }
  else
    {
      // Generate the HRE code if several HRE processes can be created
      newStat = HRE_distribute(externalized_code, new_module_name, module_name);
    }
 
  //printf("HRE\n");
  //print_statement(newStat);
 
  hash_table_free(gRefToHREVar);
 
  return newStat;
}

References comEngine_generate_code(), create_HRE_module(), generate_scalar_variables(), get_bool_property(), gGenHRE, gRefToHREVar, hash_pointer, hash_table_free(), hash_table_make(), HRE_distribute(), make_empty_subroutine(), make_language_unknown(), module_name(), reset_current_module_entity(), and set_current_module_entity().

Referenced by comEngine_distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code_test_HRE()

statement generate_code_test_HRE

(

statement

stat

)

Parameters

stat

tat

Definition at line 547 of file comEngine_generate_HRECode.c.

{
  //printf("generate_code_test\n");
  //print_statement(stat);printf("\n");
  statement newStat = statement_undefined;
 
  newStat = get_call_stat_HRE(stat);
 
  test newTest = statement_test(newStat);
 
  if(test_true(newTest) != statement_undefined)
    {
      free_statement(test_true(newTest));
 
      test_true(newTest) = make_empty_statement();
    }
 
  if(test_false(newTest) != statement_undefined)
    {
      free_statement(test_false(newTest));
 
      test_false(newTest) = make_empty_statement();
    }
 
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef != HASH_UNDEFINED_VALUE)
    {
      process_replacement_HRE(lRef, expression_undefined, &newStat);
 
      newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
    }
 
  // Get the new statements for the true statement
  statement trueStat = generate_code_function(test_true(statement_test(stat)), false);
 
  // Get the new statements for the false statement
  statement falseStat = generate_code_function(test_false(statement_test(stat)), false);
 
  free_statement(test_true(newTest));
  free_statement(test_false(newTest));
 
  if(trueStat != statement_undefined)
    {
      test_true(newTest) = trueStat;
    }
  else
    {
      test_true(newTest) = make_empty_statement();
    }
 
  if(falseStat != statement_undefined)
    {
      test_false(newTest) = falseStat;
    }
  else
    {
      test_false(newTest) = make_empty_statement();
    }
 
  return newStat;
}

References expression_undefined, free_statement(), generate_code_function(), generate_stat_from_ref_list_HRE(), get_call_stat_HRE(), gStatToRef, hash_get(), HASH_UNDEFINED_VALUE, make_empty_statement, process_replacement_HRE(), statement_test(), statement_undefined, test_false, and test_true.

Referenced by generate_code_function().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stat()

static statement generate_fifo_stat ( reference  curRef, expression  buffIndExp, entity  ind, bool  bRead  )

static

Definition at line 128 of file comEngine_generate_HRECode.c.

{
  statement newStat = statement_undefined;
 
  string name = NULL;
  list arg = NIL;
 
  expression buffExp = get_fifo_from_ref(curRef);
 
  if(buffExp == expression_undefined)
    {
      return statement_undefined;
    }
 
  if(ind != entity_undefined)
    {
      list addArg = gen_make_list(expression_domain,
                                  buffExp,
                                  entity_to_expression(ind),
                                  NULL);
 
      buffExp = call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                             addArg));
    }
 
  entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
  pips_assert("hreBuffEnt != entity_undefined",
              hreBuffEnt != entity_undefined);
 
  expression realInd;
 
  if(bRead)
    {
      name = strdup(GEN_GET_BUFF);
    }
  else
    {
      name = strdup(GEN_WRITE_BUFF);
    }
 
  if(buffIndExp == expression_undefined)
    {
      realInd = int_to_expression(0);
    }
  else
    {
      realInd = copy_expression(buffIndExp);
    }
 
  arg = gen_make_list(expression_domain,
                      buffExp,
                      realInd,
                      entity_to_expression(hreBuffEnt),
                      NULL);
 
  newStat = call_to_statement(
                              make_call(module_name_to_runtime_entity(name), 
                                        arg));
 
  return newStat;
}

References call_to_expression(), call_to_statement, copy_expression(), entity_intrinsic(), entity_to_expression(), entity_undefined, expression_domain, expression_undefined, GEN_GET_BUFF, gen_make_list(), GEN_WRITE_BUFF, get_fifo_from_ref(), get_HRE_buff_ent_from_ref(), int_to_expression(), make_call(), module_name_to_runtime_entity(), NIL, pips_assert, PLUS_OPERATOR_NAME, statement_undefined, and strdup().

Referenced by generate_fifo_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_fifo_stats()

static void generate_fifo_stats ( list  lRef, expression  buffIndExp, entity  ind, list *  lReadStats, list *  lWriteStats  )

static

Definition at line 196 of file comEngine_generate_HRECode.c.

{
  list lReadDone = NIL;
  list lWriteDone = NIL;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    //printf("fifo ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    if(!strcmp(effAction, R_EFFECT))
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lReadDone);
 
        if(!alreadyDone)
          {
            //printf("read eff\n");
 
            lReadDone = gen_nconc(lReadDone, CONS(REFERENCE, curRef, NIL));
 
            statement readStat = generate_fifo_stat(curRef, buffIndExp,
                                                    ind, true);
 
            if(readStat == statement_undefined)
              {
                continue;
              }
 
            *lReadStats = gen_nconc(*lReadStats, CONS(STATEMENT, readStat, NIL));
            //print_statement(readStat);
          }
      }
    else
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lWriteDone);
 
        if(!alreadyDone)
          {
            //printf("write eff\n");
 
            lWriteDone = gen_nconc(lWriteDone, CONS(REFERENCE, curRef, NIL));
 
            statement writeStat = generate_fifo_stat(curRef, buffIndExp,
                                                     ind, false);
 
            if(writeStat == statement_undefined)
              {
                continue;
              }
 
            *lWriteStats = gen_nconc(*lWriteStats, CONS(STATEMENT, writeStat, NIL));
 
            //print_statement(writeStat);
          }
      }
 
  }, lRef);
 
  gen_free_list(lReadDone);
  gen_free_list(lWriteDone);
}

References CONS, gen_free_list(), gen_nconc(), generate_fifo_stat(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, MAP, NIL, pips_assert, R_EFFECT, REFERENCE, reference_equal_p(), STATEMENT, and statement_undefined.

Referenced by replace_array_ref_with_fifos().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_scalar_variables()

static void generate_scalar_variables ( )

static

Definition at line 327 of file comEngine_generate_HRECode.c.

{
  list lDone = NIL;
 
  HASH_MAP(curRef, curBuff,
  {
    bool alreadyDone = false;
    reference refFound = reference_undefined;
 
    MAP(REFERENCE, ref1,
    {
      if(reference_equal_p(curRef, ref1))
        {
          alreadyDone = true;
          refFound = ref1;
          break;
        }
 
    }, lDone);
 
    if(!alreadyDone)
      {
        //printf("it\n");
        //print_reference(curRef);printf("\n");
 
        string name = strdup(entity_local_name(reference_variable((reference)curRef)));
 
        basic bas = basic_of_reference((reference)curRef);
 
        pips_assert("bas != basic_undefined", bas != basic_undefined);
 
        entity new_ent = make_new_scalar_variable_with_prefix(name,
                                                              get_current_module_entity(),
                                                              bas);
    AddEntityToCurrentModule(new_ent);
 
        hash_put(gRefToHREVar, curRef, new_ent);
 
        lDone = CONS(REFERENCE, curRef, lDone);
      }
    else
      {
        entity scalEnt = hash_get(gRefToHREVar, refFound);
 
        hash_put(gRefToHREVar, curRef, scalEnt);
      }
 
  }, gRefToHREFifo);
 
  gen_free_list(lDone);
}

References AddEntityToCurrentModule(), basic_of_reference(), basic_undefined, CONS, entity_local_name(), gen_free_list(), get_current_module_entity(), gRefToHREFifo, gRefToHREVar, hash_get(), HASH_MAP, hash_put(), make_new_scalar_variable_with_prefix(), MAP, NIL, pips_assert, REFERENCE, reference_equal_p(), reference_undefined, reference_variable, and strdup().

Referenced by comEngine_generate_HRECode().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_HRE()

statement generate_stat_from_ref_list_HRE	(	list	lRef,
		statement	stat
	)

Parameters

lRef	Ref
stat	tat

Definition at line 382 of file comEngine_generate_HRECode.c.

{
  bool writeFound = false;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    if(!strcmp(effAction, W_EFFECT))
      {
        writeFound = true;
        break;
      }
 
  }, lRef);
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
  if(stat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
    }
 
  if(writeFound)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
    }
 
  free_statement(stepStat);
 
  return make_block_statement(lStats);
}

References CONS, copy_statement(), free_statement(), gen_nconc(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, make_block_statement(), make_wait_step_statement(), MAP, NIL, pips_assert, REFERENCE, STATEMENT, statement_undefined, and W_EFFECT.

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_HRE(), process_code_seq(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_stat_from_ref_list_HRE_list()

list generate_stat_from_ref_list_HRE_list	(	list	lRef,
		list	lInStats
	)

Parameters

lRef	Ref
lInStats	InStats

Definition at line 425 of file comEngine_generate_HRECode.c.

{
  bool writeFound = false;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    if(!strcmp(effAction, W_EFFECT))
      {
        writeFound = true;
        break;
      }
 
  }, lRef);
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
 
  lStats = gen_nconc(lStats, lInStats);
 
  if(writeFound)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
      lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
    }
 
  free_statement(stepStat);
 
  return lStats;
}

References CONS, copy_statement(), free_statement(), gen_nconc(), gRefToEff, hash_get(), HASH_UNDEFINED_VALUE, make_wait_step_statement(), MAP, NIL, pips_assert, REFERENCE, STATEMENT, and W_EFFECT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_call_stat_HRE()

statement get_call_stat_HRE

(

statement

stat

)

Parameters

stat

tat

Definition at line 513 of file comEngine_generate_HRECode.c.

{
  statement newStat = copy_statement(stat);
 
  statement_comments(newStat) = string_undefined;
 
  return newStat;
}

References copy_statement(), statement_comments, and string_undefined.

Referenced by generate_code_call(), and generate_code_test_HRE().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fifo_from_ref()

expression get_fifo_from_ref

(

reference

ref

)

Parameters

ref

ef

Definition at line 74 of file comEngine_generate_HRECode.c.

{
  expression retExp = expression_undefined;
 
  intptr_t fifoNum = (intptr_t)hash_get(gRefToHREFifo, ref);
 
  if(fifoNum != (intptr_t)HASH_UNDEFINED_VALUE)
    {
      retExp = int_to_expression(fifoNum);
    }
 
  return retExp;
}

References expression_undefined, gRefToHREFifo, hash_get(), HASH_UNDEFINED_VALUE, int_to_expression(), intptr_t, and ref.

Referenced by generate_fifo_stat(), and generate_fifo_stat2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_HRE_buff_ent_from_ref()

entity get_HRE_buff_ent_from_ref

(

reference

ref

)

Parameters

ref

ef

Definition at line 91 of file comEngine_generate_HRECode.c.

{
  entity buffEnt = entity_undefined;
 
  HASH_MAP(curRef, hreBuff,
  {
    if(reference_equal_p(curRef, ref))
      {
        buffEnt = hreBuff;
        break;
      }
 
  }, gRefToHREVar);
 
  return buffEnt;
}

References entity_undefined, gRefToHREVar, HASH_MAP, ref, and reference_equal_p().

Referenced by generate_fifo_stat(), generate_fifo_stat2(), replace_array_ref_with_fifos(), and replace_array_ref_with_fifos2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedRef_HRE()

void get_supportedRef_HRE	(	statement	stat,
		list *	lSupportedRef,
		list *	lUnSupportedRef
	)

Parameters

stat	tat
lSupportedRef	SupportedRef
lUnSupportedRef	UnSupportedRef

Definition at line 467 of file comEngine_generate_HRECode.c.

{
  *lSupportedRef = hash_get(gLoopToSupRef, stat);
  *lUnSupportedRef = hash_get(gLoopToUnSupRef, stat);
 
  pips_assert("*lSupportedRef != HASH_UNDEFINED_VALUE",
              *lSupportedRef != HASH_UNDEFINED_VALUE);
 
  pips_assert("*lUnSupportedRef != HASH_UNDEFINED_VALUE",
              *lUnSupportedRef != HASH_UNDEFINED_VALUE);
}

References gLoopToSupRef, gLoopToUnSupRef, hash_get(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_lStats_HRE()

list make_loop_lStats_HRE	(	statement	stat,
		entity	transferSize,
		statement	innerStat,
		entity	newOuterInd,
		_UNUSED_ list	lSupportedRef,
		_UNUSED_ hash_table	htOffset,
		expression	bufferSizeExp
	)

Definition at line 525 of file comEngine_generate_HRECode.c.

{
  list lStats = NIL;
 
  statement transStat = make_transStat(stat, newOuterInd,
                                       transferSize, bufferSizeExp);
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, transStat, NIL));
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, innerStat, NIL));
 
  return lStats;
}

References CONS, gen_nconc(), make_transStat(), NIL, and STATEMENT.

Referenced by make_loopStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

make_wait_step_statement()

statement make_wait_step_statement

(

void

)

Definition at line 113 of file comEngine_generate_HRECode.c.

{
  statement newStat = statement_undefined;
 
  newStat = call_to_statement(
                              make_call(module_name_to_runtime_entity(WAIT_FOR_NEXT_STEP),
                                        NIL));
 
  return newStat;
}

References call_to_statement, make_call(), module_name_to_runtime_entity(), NIL, statement_undefined, and WAIT_FOR_NEXT_STEP.

Referenced by generate_code_call(), generate_stat_from_ref_list_HRE(), generate_stat_from_ref_list_HRE_list(), make_loop_step_stat(), and process_gLoopToSync_HRE().

Here is the call graph for this function:

Here is the caller graph for this function:

process_gLoopToSync_HRE()

list process_gLoopToSync_HRE	(	statement	stat,
		list	lInStats
	)

Parameters

stat	tat
lInStats	InStats

Definition at line 613 of file comEngine_generate_HRECode.c.

{
  bool loopSync = (intptr_t)hash_get(gLoopToSync, stat);
 
  if(loopSync == (intptr_t)HASH_UNDEFINED_VALUE)
    {
      return lInStats;
    }
 
  statement stepStat = make_wait_step_statement();
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lInStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stepStat, NIL));
  lStats = gen_nconc(lStats, CONS(STATEMENT, copy_statement(stepStat), NIL));
 
  return lStats;
}

References CONS, copy_statement(), gen_nconc(), gLoopToSync, hash_get(), HASH_UNDEFINED_VALUE, intptr_t, make_wait_step_statement(), NIL, and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

process_replacement_HRE()

void process_replacement_HRE	(	list	lRef,
		expression	buffIndExp,
		statement *	stat
	)

Parameters

lRef	Ref
buffIndExp	uffIndExp
stat	tat

Definition at line 483 of file comEngine_generate_HRECode.c.

{
  replace_array_ref_with_fifos(lRef, buffIndExp, entity_undefined, stat);
}

References entity_undefined, and replace_array_ref_with_fifos().

Referenced by generate_code_call(), generate_code_loop(), generate_code_test_HRE(), make_loopStat1(), process_code_seq(), process_opt_replace(), and usual_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

process_replacement_HRE_OutRef()

list process_replacement_HRE_OutRef	(	list	lRef,
		list	lStats
	)

Parameters

lRef	Ref
lStats	Stats

Definition at line 493 of file comEngine_generate_HRECode.c.

{
  statement stat = STATEMENT(CAR(lStats));
 
  list savedList = CDR(lStats);
 
  CDR(lStats) = NIL;
  gen_free_list(lStats);
 
  replace_array_ref_with_fifos(lRef, expression_undefined,
                               entity_undefined, &stat);
 
  lStats = gen_nconc(CONS(STATEMENT, stat, NIL), savedList);
 
  return lStats;
}

References CAR, CDR, CONS, entity_undefined, expression_undefined, gen_free_list(), gen_nconc(), NIL, replace_array_ref_with_fifos(), and STATEMENT.

Referenced by generate_code_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_array_ref_with_fifos()

void replace_array_ref_with_fifos	(	list	lRef,
		expression	buffIndExp,
		entity	ind,
		statement *	newStat
	)

Parameters

lRef	Ref
buffIndExp	uffIndExp
ind	nd
newStat	ewStat

Definition at line 286 of file comEngine_generate_HRECode.c.

{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
 
  // Generate the read or write fifo statements
  generate_fifo_stats(lRef, buffIndExp, ind, &lReadStats, &lWriteStats);
 
  // Replace the references by the private variables
  MAP(REFERENCE, curRef,
  {
    //printf("replace_array_ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
    pips_assert("hreBuffEnt != entity_undefined",
                hreBuffEnt != entity_undefined);
 
    reference hreBuffRef = make_reference(hreBuffEnt, NIL);
 
    comEngine_replace_reference_in_stat(*newStat, curRef, reference_to_expression(hreBuffRef));
 
  }, lRef);
 
  lStats = lReadStats;
  if(*newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, *newStat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  *newStat = make_block_statement(lStats);
}

References comEngine_replace_reference_in_stat(), CONS, entity_undefined, gen_nconc(), generate_fifo_stats(), get_HRE_buff_ent_from_ref(), make_block_statement(), make_reference(), MAP, NIL, pips_assert, REFERENCE, reference_to_expression(), STATEMENT, and statement_undefined.

Referenced by process_replacement_HRE(), and process_replacement_HRE_OutRef().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gRefToHREVar

hash_table gRefToHREVar

comEngine_generate_HRECode.c

Definition at line 68 of file comEngine_generate_HRECode.c.

Referenced by comEngine_generate_HRECode(), generate_code(), generate_scalar_variables(), generate_scalar_variables_from_list(), and get_HRE_buff_ent_from_ref().