comEngine_generate_code.c

Go to the documentation of this file.

/*
 
  $Id: comEngine_generate_code.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
This file contains functions used to generate the MMCDs generation code and
The HRE code if we want to have only one process on the HRE
 */
 
#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 "prettyprint.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 "phrase.h"
 
hash_table gLoopToOuterInd;
 
// These variable is used to know if we are generating the MMCD code
// or the HRE code
bool gGenHRE = false;
 
static bool COM_OPT;
 
// This variable if the execution MMCD have been put for the current
// computation kernel
static bool gExecPut;
 
static list glCurRep = NIL;
static hash_table gHtCurNewInd;
static list glCurLoop = NIL;
 
// This is used to make sure that the loop indices out effects are correct
static list glOutEffStats = NIL;
 
// This stores the initialization for the toggle variables. These variables
// perform a switch mechanism to make sure that, because of the
// pipeline, one fifo will not be used to load data, compute data and store
// data at the same step.
list glToggleInitStats;
 
/*
This function create a new scalar variable
 */
entity comEngine_make_new_scalar_variable(const char* prefix,
                                          basic bas)
{
  entity retEnt = entity_undefined;
  make_new_scalar_variable_with_prefix(prefix,
                                             get_current_module_entity(),
                                             bas);
  AddEntityToCurrentModule(retEnt);
 
  return retEnt;
}
 
/*
This function is called to prevent the optimization phase if a loop contains
some data dependence
 */
static void fill_gLoopToOpt(list lRef)
{
  if(lRef != NIL)
    {
      MAP(STATEMENT, loopStat,
      {
        hash_put(gLoopToOpt, loopStat, (void *)false);
      }, glCurLoop);
    }
}
 
/*
This function associate a toggle entities list to a loop statement 
from the list of reference lRef.
 */
static void fill_gLoopToToggleEnt(statement stat, list lRef)
{
  list lDone = NIL;
 
  // Go through the reference list attached to this loop
  FOREACH(REFERENCE, curRef, lRef)
  {
    // Get the fifo number for the current reference
    intptr_t fifoNum = (intptr_t)hash_get(gRefToFifo, curRef);
 
    pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
                fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
    // Get the fifo offset for the cureent reference
    intptr_t inc = (intptr_t)hash_get(gRefToFifoOff, (void *)fifoNum);
 
    pips_assert("inc != HASH_UNDEFINED_VALUE",
                inc != (intptr_t)HASH_UNDEFINED_VALUE);
 
    bool bDone = false;
 
    // If a toggle variable has already been created for this loop,
    // then continue
    MAP(INT, incDone,
    {
      if(inc == incDone)
        {
          bDone = true;
          break;
        }
    }, lDone);
 
    if(bDone)
      continue;
 
    lDone = CONS(INT, inc, lDone);
 
    // Create a new toggle variable
    entity toggleEnt = 
      comEngine_make_new_scalar_variable(strdup("toggle"),
                                         make_basic(is_basic_int, (void *)4));
 
    list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
 
    if(lToggleEnt == HASH_UNDEFINED_VALUE)
      {
        lToggleEnt = NIL;
      }
 
    // Store the new variable in the list of toggle variables
    lToggleEnt = CONS(ENTITY, toggleEnt, lToggleEnt);
 
    hash_put(gLoopToToggleEnt, stat, lToggleEnt);
 
    // Associate the value corresponding to the fifo offset to the toggle
    // variable
    hash_put(gToggleToInc, toggleEnt, (void *)inc);
 
  }
}
 
/*
This function makes a statement to initialize a toggle variable
 */
statement make_toggle_init_statement(entity toggleEnt)
{
  return make_assign_statement(entity_to_expression(toggleEnt),
                               int_to_expression(0));
}
 
/*
This function updates the toggle variables initialization statements list.
 */
static void update_toggle_init_stats_list(statement stat)
{
  list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
 
  pips_assert("lToggleEnt != HASH_UNDEFINED_VALUE",
              lToggleEnt != HASH_UNDEFINED_VALUE);
 
  list lStats = NIL;
 
  MAP(ENTITY, toggleEnt,
  {
    // Create an initialization statement for the curren toggle variable
    statement toggleStat = make_toggle_init_statement(toggleEnt);
 
    lStats = gen_nconc(lStats, CONS(STATEMENT, toggleStat, NIL));
  }, lToggleEnt);
 
  glToggleInitStats = gen_nconc(glToggleInitStats, lStats);
}
 
/*
This function makes a statement to increment the value of the toggle
variable toggleEnt.
 */
statement make_toggle_inc_statement(entity toggleEnt, int val)
{
  list modArg = gen_make_list(expression_domain,
                              entity_to_expression(toggleEnt),
                              int_to_expression(val),
                              NULL);
 
  expression modExp =
    call_to_expression(make_call(entity_intrinsic(C_MODULO_OPERATOR_NAME),
                                 modArg));
 
  return make_assign_statement(entity_to_expression(toggleEnt),
                               modExp);
}
 
/*
This function makes statements to increment the value of the toggle
variables associated to the loop
 */
static void add_toggle_inc_statements(statement stat, list lInStats)
{
  list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
 
  pips_assert("lToggleEnt != HASH_UNDEFINED_VALUE",
               lToggleEnt!= HASH_UNDEFINED_VALUE);
 
  // The loop we consider is the first statement of the list lInStats
  statement newLoopStat = STATEMENT(CAR(lInStats));
 
  pips_assert("newLoopStat is a loop statement",
              statement_loop_p(newLoopStat));
 
  statement body = loop_body(statement_loop(newLoopStat));
 
  list lStats = CONS(STATEMENT, body, NIL);
 
  MAP(STATEMENT, loopStat,
  {
    if(loopStat == STATEMENT(CAR(glCurLoop)))
      {
        continue;
      }
 
    entity inInd = hash_get(gHtCurNewInd, loopStat);
 
    statement indStat = make_init_newInd_stat(loopStat, inInd);
 
    if(indStat != statement_undefined)
      {
        lStats = gen_nconc(CONS(STATEMENT, indStat, NIL), lStats);
      }
  }, glCurLoop);
 
  // For each toggle variable, create a statement to increment it
  MAP(ENTITY, toggleEnt,
  {
    statement mmcdStat = make_toggle_mmcd(toggleEnt);
 
    lStats = gen_nconc(CONS(STATEMENT, mmcdStat, NIL), lStats);
 
    intptr_t inc = (intptr_t)hash_get(gToggleToInc, toggleEnt);
 
    statement toggleStat =
      make_toggle_inc_statement(toggleEnt, inc);
 
    lStats = gen_nconc(lStats, CONS(STATEMENT, toggleStat, NIL));
  }, lToggleEnt);
 
  loop_body(statement_loop(newLoopStat)) = make_block_statement(lStats);
}
 
/*
This function performs some transformation on the inner loop of the 
loop tiling operation
 */
static statement make_loopStat1(statement stat, entity transferSize,
                                statement innerStat, entity newOuterInd,
                                list lSupportedRef, hash_table htOffset, 
                                expression bufferSizeExp, entity newInnerInd)
{
  loop curLoop = statement_loop(stat);
 
  if(innerStat != statement_undefined)
    {
      expression indExp = entity_to_expression(newInnerInd);
 
      // If we are generating the HRE code, then replace the references by
      // the private HRE references
      if(gGenHRE)
        {
          if(!COM_OPT)
            {
              process_replacement_HRE(lSupportedRef, indExp, &loop_body(statement_loop(innerStat)));
            }
        }
 
      free_expression(indExp);
    }
 
  // Add some statements to the innerStat
  list lStats = NIL;
  if(gGenHRE)
    {
      lStats = make_loop_lStats_HRE(stat, transferSize,
                                    innerStat, newOuterInd,
                                    lSupportedRef, htOffset,
                                    bufferSizeExp);
    }
  else
    {
      lStats = make_loop_lStats_proc(stat, transferSize,
                                     innerStat, newOuterInd,
                                     lSupportedRef, htOffset,
                                     bufferSizeExp);
    }
 
  innerStat = make_block_statement(lStats);
 
  // The following lines create the outer loop of the loop tiling
  // operation
  range outerRange1 = make_range(copy_expression(range_lower(loop_range(curLoop))),
                                 copy_expression(range_upper(loop_range(curLoop))),
                                 copy_expression(bufferSizeExp));
 
  loop outerLoop1 = make_loop(newOuterInd,
                              outerRange1,
                              innerStat,
                              loop_label(curLoop),
                              make_execution(is_execution_sequential, UU),
                              NIL);
 
  return make_statement(entity_empty_label(),
                        STATEMENT_NUMBER_UNDEFINED,
                        STATEMENT_ORDERING_UNDEFINED,
                        empty_comments,
                        make_instruction_loop(outerLoop1),NIL,NULL,
                        empty_extensions (), make_synchronization_none());
}
 
#if 0
static statement make_init_prev_ind(statement oldBody)
{
  list lStats = NIL;
 
  MAP(STATEMENT, loopStat,
  {
    if(loopStat == STATEMENT(CAR(glCurLoop)))
      {
        continue;
      }
 
    entity inInd = hash_get(gHtCurNewInd, loopStat);
 
    statement indStat = make_init_newInd_stat(loopStat, inInd);
 
    if(indStat != statement_undefined)
      {
        lStats = gen_nconc(CONS(STATEMENT, indStat, NIL), lStats);
      }
  }, glCurLoop);
 
  lStats = gen_nconc(lStats, CONS(STATEMENT, oldBody, NIL));
 
  return make_block_statement(lStats);
}
#endif
 
/*
This function performs a loop tiling operation from the loop statement
stat.
 */
static statement usual_loop_tiling(statement stat, statement newBody,
                                   list lSupportedRef, list lUnSupportedRef,
                                   hash_table htOffset, expression bufferSizeExp,
                                   entity newOuterInd, entity newInnerInd)
{
  loop curLoop = statement_loop(stat);
 
  statement innerStat1 = statement_undefined;
 
  statement loopStat1 = statement_undefined;
 
  entity transferSize =
    comEngine_make_new_scalar_variable(strdup("transSize"),
                                       make_basic(is_basic_int, (void*)4));
 
  // If the new body is not undefined, then create the inner loop.
  if((newBody != statement_undefined) ||
     (lUnSupportedRef != NIL))
    {
      // If there are some unsupported references, then let us add some
      // statements to the code to support them
      if(lUnSupportedRef != NIL)
        {
          // Let us do what needs to be done to handle the references list
          if(gGenHRE)
            {
              if(!COM_OPT)
                {
                  process_replacement_HRE(lUnSupportedRef, expression_undefined, &newBody);
                }
 
              newBody = generate_stat_from_ref_list_HRE(lUnSupportedRef, newBody);
            }
          else
            {
              list lToggleEnt = hash_get(gLoopToToggleEnt,
                                         loop_body(statement_loop(stat)));
 
              if(lToggleEnt == HASH_UNDEFINED_VALUE)
                {
                  lToggleEnt = NIL;
                }
 
              newBody = generate_stat_from_ref_list_proc(lUnSupportedRef,
                                                         lToggleEnt,
                                                         newBody);
 
              fill_gLoopToOpt(lUnSupportedRef);
            }
        }
      else if(newBody == statement_undefined)
        {
          newBody = make_block_statement(NIL);
        }
 
      //newBody = make_init_prev_ind(newBody);
 
      // The following lines create the inner loop of the loop tiling
      // operation
      range innerRange = make_range(int_to_expression(0),
                                    entity_to_expression(transferSize),
                                    int_to_expression(1));
 
      loop innerLoop = make_loop(newInnerInd,
                                 innerRange,
                                 newBody,
                                 loop_label(curLoop),
                                 make_execution(is_execution_sequential, UU),
                                 NIL);
 
      innerStat1 = make_statement(entity_empty_label(),
                                  STATEMENT_NUMBER_UNDEFINED,
                                  STATEMENT_ORDERING_UNDEFINED,
                                  empty_comments,
                                  make_instruction_loop(innerLoop),NIL,NULL,
                                  empty_extensions (), make_synchronization_none());
 
      if(!gGenHRE)
        {
          process_innerStat1_proc(innerStat1, loop_index(curLoop),
                                  newOuterInd, newInnerInd);
        }
 
      //printf("innerStat1\n");
      //print_statement(innerStat1);
 
      // Let us try and see if we can optimize the transfers
      if(COM_OPT)
        {
          innerStat1 = comEngine_opt_loop_interchange(stat, innerStat1,
          newOuterInd);
        }
 
    }
 
  // This function finishes the loop tiling operation
  loopStat1 = make_loopStat1(stat, transferSize,
                             innerStat1, newOuterInd,
                             lSupportedRef, htOffset,
                             bufferSizeExp, newInnerInd);
 
  return loopStat1;
}
 
/*
This function generates the MMCD code or the HRE code from a loop
statement.
 */
static statement generate_code_loop(statement stat)
{
  printf("generate_code_loop\n");
  print_statement(stat);
 
  statement newBody = statement_undefined;
 
  list lStats = NIL;
 
  hash_table htOffset = hash_get(gStatToHtOffset, stat);
 
  if(!gGenHRE)
    {
      pips_assert("htOffset != HASH_UNDEFINED_VALUE",
                  htOffset != HASH_UNDEFINED_VALUE);
    }
 
  loop curLoop = statement_loop(stat);
 
  list lRef = hash_get(gLoopToRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      lRef = NIL;
    }
 
  list lSupportedRef = NIL;
  list lUnSupportedRef = NIL;
 
  // Store the list of supported and unsupported references for loop
  // statement stat.
  get_supportedRef_HRE(stat,
                       &lSupportedRef, &lUnSupportedRef);
 
  // Create a new index
  entity newOuterInd =
    comEngine_make_new_scalar_variable(entity_local_name(loop_index(curLoop)),
                                       copy_basic(entity_basic(loop_index(curLoop))));
 
  // Memorize the index created in the hash_table gLoopToOuterInd
  hash_put(gLoopToOuterInd, stat, newOuterInd);
 
  // Create a new index
  entity newInnerInd = 
    comEngine_make_new_scalar_variable(entity_local_name(loop_index(curLoop)),
                                       copy_basic(entity_basic(loop_index(curLoop))));
 
  // If we are generating the MMCD code, then create the fifos for the
  // supported and unsupported references
  if(!gGenHRE)
    {
      create_realFifo_proc(stat, lSupportedRef);
      create_realFifo_proc(stat, lUnSupportedRef);
    }
 
  // Create the toggle references and store them in gLoopToToggleEnt
  fill_gLoopToToggleEnt(stat, lSupportedRef);
  fill_gLoopToToggleEnt(loop_body(statement_loop(stat)), lUnSupportedRef);
 
  // Add the loop to the current loops list
  glCurLoop = CONS(STATEMENT, stat, glCurLoop);
 
  // Memorize the current newInnerInd in gHtCurNewInd
  hash_put(gHtCurNewInd, stat, newInnerInd);
 
  hash_put(gLoopToOpt, stat, (void *)true);
 
  gExecPut = false;
 
  // Get the new statements for the loop body
  newBody = generate_code_function(loop_body(curLoop), false);
 
  gExecPut = false;
 
  printf("newBody real\n");
  if(newBody == statement_undefined)
    {
      printf("undefined\n");
    }
  else
    {
      print_statement(newBody);
    }
 
  // If there are some supported references, the let us perform a loop
  // tiling operation
  if(lSupportedRef != NIL)
    {
      expression bufferSizeExp = expression_undefined;
 
      bufferSizeExp = copy_expression(gBufferSizeEnt);
 
      statement newStat = usual_loop_tiling(stat, newBody,
                                            lSupportedRef, lUnSupportedRef,
                                            htOffset, bufferSizeExp,
                                            newOuterInd, newInnerInd);
 
      list lToggleEnt = hash_get(gLoopToToggleEnt, stat);
 
      if(lToggleEnt != HASH_UNDEFINED_VALUE)
        {
          printf("put lToggleEnt\n");
          print_statement(newStat);
          hash_put(gLoopToToggleEnt, newStat, gen_copy_seq(lToggleEnt));
        }
 
      lStats = CONS(STATEMENT, newStat, NIL);
 
      if(!gGenHRE)
        {
          glOutEffStats = add_index_out_effect_proc(curLoop, glOutEffStats);
        }
    }
  // else if the new body is not undefined, then just create a loop without
  // loop tiling
  else if(newBody != statement_undefined)
    {
      // If there are some unsupported references, then let us add some
      // statements to the code to support them
      if(lUnSupportedRef != NIL)
        {
          // Let us do what needs to be done to handle the references list
          if(gGenHRE)
            {
              if(!COM_OPT)
                {
                  process_replacement_HRE(lUnSupportedRef, expression_undefined, &newBody);
                }
 
              newBody = generate_stat_from_ref_list_HRE(lUnSupportedRef, newBody);
            }
          else
            {
              list lToggleEnt = hash_get(gLoopToToggleEnt,
                                         loop_body(statement_loop(stat)));
 
              if(lToggleEnt == HASH_UNDEFINED_VALUE)
                {
                  lToggleEnt = NIL;
                }
 
              newBody = generate_stat_from_ref_list_proc(lUnSupportedRef,
                                                         lToggleEnt,
                                                         newBody);
 
              fill_gLoopToOpt(lUnSupportedRef);
            }
        }
 
      // The following lines create the loop
      loop outerLoop = make_loop(newInnerInd,
                                 copy_range(loop_range(curLoop)),
                                 newBody,
                                 loop_label(curLoop),
                                 make_execution(is_execution_sequential, UU),
                                 NIL);
 
      statement newStat = make_statement(entity_empty_label(),
                                         STATEMENT_NUMBER_UNDEFINED,
                                         STATEMENT_ORDERING_UNDEFINED,
                                         empty_comments,
                                         make_instruction_loop(outerLoop),NIL,NULL,
                                         empty_extensions (), make_synchronization_none());
 
      lStats = CONS(STATEMENT, newStat, NIL);
 
      comEngine_replace_reference_in_stat(newBody,
                                          make_reference(loop_index(curLoop), NIL),
                                          entity_to_expression(newInnerInd));
 
      if(!gGenHRE)
        {
          glOutEffStats = add_index_out_effect_proc(curLoop, glOutEffStats);
        }
    }
  else
    {
      return make_block_statement(NIL);
    }
 
  if(!gGenHRE)
    {
      add_toggle_inc_statements(stat, lStats);
 
      update_toggle_init_stats_list(stat);
    }
 
  //pips_assert("newStat != statement_undefined",
  //newStat != statement_undefined);
 
  // If some references attached to the loop statement but are not
  // some supported or unsupported references, then let us handle them
  list lOutRef = hash_get(gStatToRef, stat);
 
  if(lOutRef != HASH_UNDEFINED_VALUE)
    {
      // Let us do what needs to be done to handle the references list
      if(gGenHRE)
        {
          if(!COM_OPT)
            {
              lStats = process_replacement_HRE_OutRef(lOutRef, lStats);
            }
 
          lStats = generate_stat_from_ref_list_HRE_list(lOutRef, lStats);
        }
      else
        {
          lStats = generate_stat_from_ref_list_proc_list(lOutRef, lStats);
 
          fill_gLoopToOpt(lOutRef);
        }
    }
 
  // Add some bubbles in the pipeline if needed
  if(gGenHRE)
    {
      lStats = process_gLoopToSync_HRE(stat, lStats);
 
      //fill_gLoopToOpt(!NIL);
    }
  else
    {
      lStats = process_gLoopToSync_proc(stat, lStats);
 
      //fill_gLoopToOpt(!NIL);
    }
  
  if(!gGenHRE)
    {
      hash_table_free(htOffset);
    }
 
  // Remove the loop statement to the current loops list
  gen_remove(&glCurLoop, stat);
 
  statement newStat = make_block_statement(lStats);
 
  printf("newStat real\n");
  if(newStat == statement_undefined)
    {
      printf("newStat == statement_undefined\n");
    }
  else
    {
      print_statement(newStat);
    }
 
  hash_put(gIsNewLoop, newStat, (void *)true);
 
  return newStat;
}
 
/*
This function add to references list lInRef the supported references of
the loop statement stat
 */
static void process_ref_lists(statement stat, list * lInRef)
{
  list lRef = NIL;
 
  lRef = hash_get(gLoopToSupRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      lRef = NIL;
    }
 
  MAP(REFERENCE, curRef,
  {
    bool bInRef = false;
 
    MAP(REFERENCE, supRef,
    {
      if(reference_equal_p(curRef, supRef))
        {
          bInRef = true;
          break;
        }
    }, lRef);
 
    if(bInRef)
      {
        *lInRef = CONS(REFERENCE, curRef, *lInRef);
      }
 
  }, glCurRep);
 
  MAP(REFERENCE, curRef,
  {
    gen_remove(&glCurRep, curRef);
  }, *lInRef);
}
 
/*
This function replaces the old references by the HRE private references
for a call statement
 */
static void process_opt_replace(statement * newStat)
{
  MAP(STATEMENT, loopStat,
  {
    list lIn = NIL;
 
    process_ref_lists(loopStat, &lIn);
 
    entity curNewInd = hash_get(gHtCurNewInd, loopStat);
 
    pips_assert("curNewInd != HASH_UNDEFINED_VALUE",
                curNewInd != HASH_UNDEFINED_VALUE);
 
    expression indExp = entity_to_expression(curNewInd);
 
    process_replacement_HRE(lIn, indExp, newStat);
 
    free_expression(indExp);
 
    gen_free_list(lIn);
 
  }, glCurLoop);
 
  process_replacement_HRE(glCurRep, expression_undefined, newStat);
 
  fill_gLoopToOpt(glCurRep);
 
  gen_free_list(glCurRep);
  glCurRep = NIL;
}
 
/*
This function replaces the old references by the HRE private references
for block statement
 */
static list replace_glCurRep_in_seq(list lStats, list lPrevSeq, list lSeq)
{
  list newLStats = NIL;
 
  if(lStats == NIL)
    {
      return lSeq;
    }
 
  statement newStat = make_block_statement(lStats);
 
  process_opt_replace(&newStat);
 
  newLStats = CONS(STATEMENT, newStat, NIL);
 
  if(lPrevSeq != NIL)
    {
      CDR(lPrevSeq) = newLStats;
    }
  else
    {
      lSeq = newLStats;
    }
 
  return lSeq;
}
 
/*
This function generates the MMCD code or the HRE code from a block
statement.
 */
static statement generate_code_seq(statement stat)
{
  statement newStat = statement_undefined;
 
  instruction instr = statement_instruction(stat);
 
  list lSeq = NIL;
  list lTempSeq = NIL;
  list lPrevSeq = NIL;
 
  //printf("generate_code_seq\n");
 
  // Go through each statement of the sequence
  MAP(STATEMENT, curStat,
  {
    if((COM_OPT && gGenHRE)&& !statement_call_p(curStat) &&
       !statement_test_p(curStat))
      {
        lSeq = replace_glCurRep_in_seq(lTempSeq, lPrevSeq, lSeq);
 
        lTempSeq = NIL;
      }
 
    // Let us get the new statement for the current sequence statement
    statement seqNewStat = generate_code_function(curStat, true);
 
    if(seqNewStat != statement_undefined)
      {
        list newStatCons = CONS(STATEMENT, seqNewStat, NIL);
 
        lSeq = gen_nconc(lSeq, newStatCons);
 
        if((COM_OPT && gGenHRE)&&!statement_call_p(curStat) &&
           !statement_test_p(curStat))
          {
            lPrevSeq = newStatCons;
          }
 
        if((COM_OPT && gGenHRE)&&(lTempSeq == NIL) &&
           (statement_call_p(curStat) ||
            statement_test_p(curStat)))
          {
            lTempSeq = newStatCons;
          }
      }
 
  }, sequence_statements(instruction_sequence(instr)));
 
  if(COM_OPT && gGenHRE)
    {
      lSeq = replace_glCurRep_in_seq(lTempSeq, lPrevSeq, lSeq);
    }
 
  if(lSeq == NIL)
    {
      newStat = statement_undefined;
    }
  else if(gen_length(lSeq) == 1)
    {
      newStat = STATEMENT(CAR(lSeq));
    }
  else
    {
      newStat = make_block_statement(lSeq);
    }
 
  return newStat;
}
 
/*
This function generate an execute mmcd statement and create a block statement
with this new statement and statement stat.
 */
static statement add_exec_mmcd(statement stat)
{
  statement mmcdStat = make_exec_mmcd();
 
  statement stepStat = make_step_inc_statement(1);
 
  mmcdStat = make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                            CONS(STATEMENT, mmcdStat, NIL)));
 
  if(glCurLoop != NIL)
    {
      statement loopStat = STATEMENT(CAR(glCurLoop));
 
      list lUnSupportedRef = hash_get(gLoopToUnSupRef, loopStat);
 
      pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
                  lUnSupportedRef != HASH_UNDEFINED_VALUE);
 
      if(lUnSupportedRef == NIL)
        {
          loop curLoop = statement_loop(loopStat);
 
          entity newInd = hash_get(gHtCurNewInd, loopStat);
 
          list neArg = gen_make_list(expression_domain,
                                     entity_to_expression(newInd),
                                     copy_expression(range_lower(loop_range(curLoop))),
                                     NULL);
 
          expression neExp = 
            call_to_expression(make_call(entity_intrinsic(C_EQUAL_OPERATOR_NAME),
                                         neArg));
 
          test t = make_test(neExp, mmcdStat, make_empty_statement());
 
          mmcdStat = make_statement(entity_empty_label(), 
                                    STATEMENT_NUMBER_UNDEFINED,
                                    STATEMENT_ORDERING_UNDEFINED,
                                    empty_comments,
                                    make_instruction(is_instruction_test, t),
                                    NIL,NULL,
                                    empty_extensions (), make_synchronization_none());
        }
    }
 
  if(stat == statement_undefined)
    {
      return mmcdStat;
    }
  else
    {
      return make_block_statement(gen_nconc(CONS(STATEMENT, stat, NIL),
                                            CONS(STATEMENT, mmcdStat, NIL)));
    }
}
 
/*
This function generates the MMCD code or the HRE code from a call
statement.
 */
static statement generate_code_call(statement stat, bool bCalledFromSeq)
{
  //printf("generate_code_call\n");
  //print_statement(stat);printf("\n");
  statement newStat = statement_undefined;
 
  if(gGenHRE)
    {
      newStat = get_call_stat_HRE(stat);
    }
  else
    {
      newStat = get_call_stat_proc(stat);
    }
 
  if(COM_OPT && gGenHRE)
    {
      list lCallRef = NIL;
      call curCall = instruction_call(statement_instruction(stat));
 
      MAP(EXPRESSION, exp,
      {
        list old = lCallRef;
        list new = NIL;
        new = comEngine_expression_to_reference_list(exp, new);
 
        lCallRef = gen_concatenate(old, new);
 
        gen_free_list(old);
        gen_free_list(new);
 
      }, call_arguments(curCall));
 
      glCurRep = gen_nconc(glCurRep, lCallRef);
 
      if(!bCalledFromSeq)
        {
          process_opt_replace(&newStat);
        }
    }
 
  if(!get_bool_property("COMENGINE_CONTROL_IN_HRE")
     && !gGenHRE && !gExecPut)
    {
      newStat = add_exec_mmcd(newStat);
 
      gExecPut = true;
    }
 
  if(get_bool_property("COMENGINE_CONTROL_IN_HRE") &&
     !gExecPut)
    {
      statement stepStat;
 
      if(gGenHRE)
        {
          stepStat = make_wait_step_statement();
        }
      else
        {
          stepStat = make_step_inc_statement(1);
        }
 
      if(newStat == statement_undefined)
        {
          newStat = stepStat;
        }
      else
        {
          newStat =
            make_block_statement(gen_nconc(CONS(STATEMENT, stepStat, NIL),
                                           CONS(STATEMENT, newStat, NIL)));
        }
 
      gExecPut = true;
    }
 
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      return newStat;
    }
 
  if(gGenHRE)
    {
      if(!COM_OPT)
        {
          process_replacement_HRE(lRef, expression_undefined, &newStat);
        }
 
      newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
    }
  else
    {
      newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
 
      fill_gLoopToOpt(lRef);
    }
      printf("generate_code_call 2\n");
  return newStat;
}
 
/*
This functions handles the references that have been attached to the 
g_externalized_code during the analysis phase
 */
static statement process_code_seq(statement newStat, statement stat)
{
  list lRef = hash_get(gStatToRef, stat);
 
  if(lRef == HASH_UNDEFINED_VALUE)
    {
      return newStat;
    }
 
  if(gGenHRE)
    {
      if(!COM_OPT)
        {
          process_replacement_HRE(lRef, expression_undefined, &newStat);
        }
 
      newStat = generate_stat_from_ref_list_HRE(lRef, newStat);
    }
  else
    {
      newStat = generate_stat_from_ref_list_proc(lRef, NIL, newStat);
 
      fill_gLoopToOpt(lRef);
    }
 
  return newStat;
}
 
/*
This function generates the MMCD code or the HRE code from any
statements.
 */
statement generate_code_function(statement stat, bool bCalledFromSeq)
{
  statement newStat = statement_undefined;
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        newStat = generate_code_seq(stat);
 
        break;
      }
    case is_instruction_loop:
      {
        newStat = generate_code_loop(stat);
        break;
      }
    case is_instruction_call:
      {
        newStat = generate_code_call(stat, bCalledFromSeq);
        break;
      }
    case is_instruction_test:
      {
        if(gGenHRE)
          {
            newStat = generate_code_test_HRE(stat);
          }
        else
          {
            newStat = generate_code_test_proc(stat);
          }
        break;
      }
    default:
      {
        pips_assert("FALSE", false);
        break;
      }
    }
 
  return newStat;
}
 
/*
This function generates the MMCDs generation code and
the HRE code if we want to have only one process on the HRE
 */
statement comEngine_generate_code(statement stat)
{
  statement newStat = statement_undefined;
 
  // Initialize some global variables
  COM_OPT = true;
  gExecPut = false;
  gLoopToOuterInd = hash_table_make(hash_pointer, 0);
  gHtCurNewInd = hash_table_make(hash_pointer, 0);
  glCurLoop = NIL;
  glCurRep = NIL;
  gLoopToOpt = hash_table_make(hash_pointer, 0);
  glOutEffStats = NIL;
  glToggleInitStats = NIL;
 
  // Do the job
  newStat = generate_code_function(stat, false);
 
  if(statement_block_p(stat))
    {
      newStat = process_code_seq(newStat, stat);
    }
 
  // Add the loop indices statements
  if(glOutEffStats != NIL)
    {
      newStat =
        make_block_statement(gen_nconc(CONS(STATEMENT, newStat, NIL),
                                       glOutEffStats));
    }
 
  // Add the toggle initialization statements
  if(glToggleInitStats != NIL)
    {
      newStat =
        make_block_statement(gen_nconc(glToggleInitStats,
                                       CONS(STATEMENT, newStat, NIL)));
    }
 
  // Free some global variables
  hash_table_free(gHtCurNewInd);
  hash_table_free(gLoopToOpt);
  hash_table_free(gLoopToOuterInd);
 
  return newStat;
}