identification.c

Go to the documentation of this file.

/*
 
  $Id: identification.c 23495 2018-10-24 09:19:47Z 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
#include "safescale.h"
 
 
/**
 
 */
static void search_sequence_containing(statement s, void* a_context)
{
  sequence_searching_context* context = (sequence_searching_context*) a_context;
  instruction i = statement_instruction(s);
  
  if (instruction_tag(i) == is_instruction_sequence) 
  {
    MAP(STATEMENT, s2, {
                         if (s2 == context->searched_statement) 
                         {
                           context->found_sequence_statement = s;
                         }
                       }, sequence_statements(instruction_sequence(i)));
  }
}
 
 
/**
 
*/
static statement sequence_statement_containing(statement root_statement, statement searched_stat)
{
  sequence_searching_context context;
 
  context.searched_statement = searched_stat;
  context.found_sequence_statement = NULL;
 
  gen_context_recurse(root_statement, &context, statement_domain, gen_true2, search_sequence_containing);
 
  return context.found_sequence_statement;
}
 
 
/**
  
 */
static bool statement_is_contained_in_a_sequence_p(statement root_statement, statement searched_stat)
{
  return (sequence_statement_containing(root_statement, searched_stat) != NULL);
}
 
 
/**
   Add in the statement containing comments in the list of statements
 */
static void check_if_statement_contains_comment(statement s, void* a_context)
{
  statement_checking_context* context = (statement_checking_context*) a_context;
  string comments;
 
  if (!statement_with_empty_comment_p(s))
  {    
    comments = statement_comments(s);
    
    if (strstr(comments, context->searched_string) != NULL) 
    {
      context->list_of_statements = CONS(STATEMENT, s, context->list_of_statements);
    }
  }
}
 
 
/**
   Build a list with statements containing comments
 */
static list get_statements_with_comments_containing(string comment_portion, statement stat)
{
  string percent;
  statement_checking_context context;
 
  ifdebug(5)
  {
    pips_debug(5, "Comment portion: %s\n", comment_portion);
    pips_debug(5, "Statement:\n");
    print_statement(stat);
  }
 
  /* Set searched string */
  context.searched_string = strdup(comment_portion);
  percent = strstr(context.searched_string, "%s");
 
  pips_debug(5, "Percent: %s\n", percent);
 
  if (percent == NULL)
    pips_user_error("Malformed statement comment to search. Should be of the form 'BLAH_%%s'\n");
 
  *percent = '\0';
 
  /* Reset and get list of statements */
  context.list_of_statements = NIL;
  
  ifdebug(5) 
  {
    pips_debug(5, "Searching statements with comments: %s\n", context.searched_string);      
    pips_debug(5, "In statement:\n");      
    print_statement(stat);
  }
 
  gen_context_recurse(stat, &context, statement_domain, gen_true2, check_if_statement_contains_comment);
  
  free(context.searched_string);
 
  return context.list_of_statements;  
}
 
 
/**
   Return the identified function name of the externalized portion of code by searching comment matching tag 
 */
static string get_function_name_by_searching_tag(statement stat, string tag) 
{
  string comments = NULL;
  string searched_string;
  string comment_portion = strdup(tag);
  char* function_name = NULL;
  char* next_line;
  instruction i = statement_instruction(stat);
  
  pips_debug(5, "BEGIN get_function_name_by_searching_tag [%s] on \n", tag);
 
  ifdebug(5) 
  {
    print_statement(stat);
  }
 
  if (instruction_tag(i) == is_instruction_sequence) 
  {
    stat = STATEMENT(gen_nth(0, sequence_statements(instruction_sequence(i))));
  }
  
  if (!statement_with_empty_comment_p(stat)) 
  {
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok(comments, "\n");
  
    if (next_line != NULL) 
    {
      do 
      {
        string first_occurence = strstr(next_line, searched_string);
 
        if (first_occurence != NULL) 
        {
          function_name = malloc(256);
          sscanf(first_occurence, comment_portion, function_name);
          pips_debug(5, "Found function: [%s]\n", function_name);
        }
 
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
  }
 
  free(comment_portion);
  if (comments)
    free(comments);
 
  pips_debug(5, "END get_function_name_by_searching_tag [%s] on \n", tag);
 
  return function_name;
}
 
 
/**
   
 */
static void clean_statement_from_tags(string comment_portion, statement stat) 
{
  if (!statement_with_empty_comment_p(stat)) 
  {
    string new_comments = NULL;
 
    string searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    string comments = strdup(statement_comments(stat));
    char * next_line = strtok(comments, "\n");
 
    if (next_line != NULL) 
    {
      do 
      {
        if (strstr(next_line, searched_string) == NULL) 
        {
          if (new_comments != NULL) 
          {
            new_comments = strdup(concatenate(new_comments, next_line, "\n", NULL));
          }
          else 
          {
            new_comments = strdup(concatenate("", next_line, "\n", NULL));
          }
        }
 
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
    
    if (new_comments != NULL) 
    {
      statement_comments(stat) = new_comments;
    }
    else 
    {
      statement_comments(stat) = empty_comments;
      free(new_comments);
    }
    free(searched_string);
    free(comments);
  }
}
 
 
/**
   Remove begin tag for a given statement and function
 */
static void remove_begin_tag(statement stat, string function_name) 
{
  char* removed_tag = malloc(256);
 
  sprintf(removed_tag, EXTERNALIZED_CODE_PRAGMA_BEGIN, function_name);
  pips_debug(2, "REMOVE %s from\n", removed_tag);
  print_statement(stat);
  clean_statement_from_tags(removed_tag, stat);
}
 
 
/**
   Remove end tag for given statement and function
 */
static void remove_end_tag(statement stat, string function_name) 
{
  char* removed_tag = malloc(256);
 
  sprintf(removed_tag, EXTERNALIZED_CODE_PRAGMA_END, function_name);
  pips_debug(2, "REMOVE %s from\n", removed_tag);
  print_statement(stat);
  clean_statement_from_tags(removed_tag, stat);
}
 
 
/**
   Transform a statement in a sequence statement with a single statement which is the embedded statement that will be distributed 
 */
static statement isolate_code_portion(statement begin_tag_statement, statement end_tag_statement, statement sequence_statement) 
{
  instruction i = statement_instruction(sequence_statement);
  list seq_stats = sequence_statements(instruction_sequence(i));
  list new_seq_stats = NIL;
  list isolated_seq_stats = NIL;
  bool statement_to_isolate = false;
  int nb_of_statements_to_isolate = 0;
  string function_name = get_function_name_by_searching_tag(begin_tag_statement, EXTERNALIZED_CODE_PRAGMA_BEGIN);
 
  pips_assert("sequence_statement is a sequence", instruction_tag(i) == is_instruction_sequence);
  pips_assert("function_name is not NULL", function_name != NULL);
 
  /* Count the number of statements to isolate in a single statement */
  MAP(STATEMENT, s, {
                      if ((statement_to_isolate && (s != end_tag_statement)) || ((!statement_to_isolate) && (s == begin_tag_statement))) 
                      {
                        nb_of_statements_to_isolate++;
                        isolated_seq_stats = CONS(STATEMENT, s, isolated_seq_stats);
                      }
 
                      if (statement_to_isolate && (s == end_tag_statement)) 
                      {
                        statement_to_isolate = false;
                      }
 
                      if ((!statement_to_isolate) && (s == begin_tag_statement)) 
                      {
                        statement_to_isolate = true;
                      }    
                    }, seq_stats);
 
  remove_begin_tag(begin_tag_statement, function_name);
  remove_end_tag(end_tag_statement, function_name);
 
  /* Insert an analyzed tag */
  {
    char *new_tag = malloc(256);
 
    sprintf(new_tag, strdup(concatenate("\n", EXTERNALIZED_CODE_PRAGMA_ANALYZED_PREFIX_TOP, EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, "\n", NULL)), function_name, nb_of_statements_to_isolate);
    insert_comments_to_statement(begin_tag_statement, new_tag);
  }
 
  pips_debug(5, "Found %d statement to isolate\n", nb_of_statements_to_isolate);      
 
  if (nb_of_statements_to_isolate > 1) 
  {
    /* Build a new isolated sequence statement */    
    sequence new_sequence = make_sequence(gen_nreverse(isolated_seq_stats));
    instruction sequence_instruction = make_instruction(is_instruction_sequence, new_sequence);
    statement returned_statement = make_statement (entity_empty_label(),
                                                   statement_number(sequence_statement),
                                                   statement_ordering(sequence_statement),
                                                   empty_comments,
                                                   sequence_instruction,
                                                   NIL,
                                                   NULL,
                                                   statement_extensions (sequence_statement), make_synchronization_none());
    bool isolated_seq_stats_is_inserted = false;
    
    /* Build a new sequence containing isolated sequence statement */
    MAP(STATEMENT, s, {
                        if ((statement_to_isolate && (s != end_tag_statement)) || ((!statement_to_isolate) && (s == begin_tag_statement))) 
                        {
                          if (!isolated_seq_stats_is_inserted) 
                          {
                            new_seq_stats = CONS(STATEMENT, returned_statement, new_seq_stats);
                            isolated_seq_stats_is_inserted = true;
                          }
                        }
                        else 
                        {
                          new_seq_stats = CONS(STATEMENT, s, new_seq_stats);
                        }
 
                        if (statement_to_isolate && (s == end_tag_statement)) 
                        {
                          statement_to_isolate = false;
                        }
 
                        if ((!statement_to_isolate) && (s == begin_tag_statement)) 
                        {
                          statement_to_isolate = true;
                        }
                      }, seq_stats); 
 
    /* Rebuild the sequence in the good order */
    sequence_statements(instruction_sequence(i)) = gen_nreverse(new_seq_stats);
 
    ifdebug(5) 
    {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(returned_statement);
    }
 
    return returned_statement;
  }
  else if (nb_of_statements_to_isolate == 1) 
  {
    /* Nothing to do, the code is already isolated ! */
    ifdebug(5) 
    {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(begin_tag_statement);
    }
 
    return begin_tag_statement;
  }
  else 
  {
    pips_user_warning("Malformed externalized code portion identified. No operation to do. Ignored.\n");
    return NULL;
  }
}
 
 
/**
   Return a list of statements that are marked for externalization
 */
static list identify_statements_to_distribute(statement module_stat) 
{
  list statements_containing_begin_tag;
  list statements_contained_in_a_sequence = NIL;
  list statements_to_distribute = NIL;
  
  /* Restructure code to avoid imbricated sequences if some portions are found to allow more than one INIT */
  simple_restructure_statement(module_stat);
 
  /* Identify statements containing a begin tag */
  statements_containing_begin_tag = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN, module_stat); 
  
  /* Check all statements are contained in a sequence */
  MAP(STATEMENT, s, {
                      ifdebug(5) 
                      {
                        pips_debug(5, "Potential externalizable statement:\n");
                        print_statement(s);
                      }
 
                      if (statement_is_contained_in_a_sequence_p(module_stat,s)) 
                      {
                        statements_contained_in_a_sequence = CONS(STATEMENT, s, statements_contained_in_a_sequence);
                      }
                      else 
                      {
                        pips_user_warning("Malformed externalized code portion identified. Ignored.\n");
                      }
                    }, statements_containing_begin_tag);
  
  /* */
  MAP(STATEMENT, s, {
                      statement sequence_statement;
                      string function_name;
                      list potential_end_statement = NIL;
 
                      sequence_statement = sequence_statement_containing(module_stat, s);
 
                      pips_debug(5, "Potential externalizable statement contained in a sequence \n");
                      print_statement(s);
 
                      function_name = get_function_name_by_searching_tag(s, EXTERNALIZED_CODE_PRAGMA_BEGIN);
 
                      if (function_name != NULL) 
                      {
                        pips_debug(5, "Name: [%s] \n", function_name);
 
                        potential_end_statement = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_END, sequence_statement);
 
                      if (gen_length(potential_end_statement) == 1) 
                      {
                        statement begin_tag_statement = s;
                        statement end_tag_statement = STATEMENT(gen_nth(0, potential_end_statement));
                        statement container_of_end_tag_statement = sequence_statement_containing(sequence_statement, end_tag_statement);
 
                        if (container_of_end_tag_statement == sequence_statement) 
                        {
                          statement externalized_code = isolate_code_portion(begin_tag_statement, end_tag_statement, sequence_statement);
 
                          statements_to_distribute = CONS(STATEMENT, externalized_code, statements_to_distribute);
                        }
                        else 
                        {
                          pips_user_warning("Malformed externalized code portion identified [%s]. End tag found at a bad place!!!. Ignored.\n", function_name);
                        }
                      }
                      else 
                      {
                        pips_user_warning("Malformed externalized code portion identified [%s]. %d end tags found!!!. Ignored.\n", function_name, gen_length(potential_end_statement));
                      }
                    }
                    else 
                    {
                      pips_user_warning("Malformed externalized code portion identified [Unnamed]!!!. Ignored.\n");
                    }
                  }, statements_contained_in_a_sequence);
 
  return statements_to_distribute;
}
        
                                      
/**
   Main phase for block code detection
*/   
bool safescale_distributor_init(const char* module_name)
{
  /* Get the resources */
  statement stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  
 
  set_current_module_statement(stat);
  set_current_module_entity(module_name_to_entity(module_name));
 
  debug_on("SAFESCALE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Doi the job */
  pips_debug(2, "BEGIN of SAFESCALE_DISTRIBUTOR_INIT\n");
  identify_statements_to_distribute(stat);
  pips_debug(2, "END of SAFESCALE_DISTRIBUTOR_INIT\n");
 
  pips_assert("Statement structure is consistent after SAFESCALE_DISTRIBUTOR_INIT", gen_consistent_p((gen_chunk*) stat));             
  pips_assert("Statement is consistent after SAFESCALE_DISTRIBUTOR_INIT", statement_consistent_p(stat));
 
  /* Reorder the module because new statements have been added */  
  module_reorder(stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(stat));
  
  /* Update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  
  debug_off();
  
  return true;
}