Conditional execution is used to mask the call to MakeSimpleIoInst2. More...

Collaboration diagram for Methods dealing with statements:

Modules
	Statement predicate methods
	detects a statement with no special effect...

Functions
void	statement_remove_extensions (statement s)
	That's all folks. More...

void	statement_remove_useless_label (statement s, bool *changed)
	remove the label of a statement if the statement is not unstructured. More...

bool	belong_to_statement (statement stmt, statement s, bool found_p)
	return true if s is enclosed in stmt NL: What is the difference with statement_in_statement_p? More...

entity	find_final_statement_label (statement s)
	Find the label associated with the last statement executed within s. More...

string	comment_sentinel (tag t)
	Start a single line comment. More...

Variables
list	add_statement_declarations_t::statement_to_all_included_declarations

set	add_statement_declarations_t::cache

list	entities_t::lents

set	entities_t::sents

statement	fswl::st
	statement matching condition More...

entity	fswl::key
	used for the condition More...

list	fswp::l

const char *	fswp::begin

statement	sb::searched_statement

bool	sb::found_p

statement	replace_statement_context::old_stat

statement	replace_statement_context::new_stat

bool	replace_statement_context::found_p

Detailed Description

Conditional execution is used to mask the call to MakeSimpleIoInst2.

It is preserved because the current validation suite does not include test cases covering its replacement.

include "syntax.h" // MakeSimpleIoInst2

Function Documentation

◆ belong_to_statement()

bool belong_to_statement	(	statement	stmt,
		statement	s,
		bool	found_p
	)

return true if s is enclosed in stmt NL: What is the difference with statement_in_statement_p?

Parameters

stmt	tmt
found_p	ound_p

Definition at line 4304 of file statement.c.

 {
   if(!found_p){
     if(statement_ordering(s) == statement_ordering(stmt))
       return true;
     else
       {
         instruction inst = statement_instruction(stmt);
         switch(instruction_tag(inst))  {
         case is_instruction_block: {
           bool bs = found_p;
           MAPL( stmt_ptr,
                 {
                     statement local_stmt = STATEMENT(CAR( stmt_ptr ));
                     bs = bs || belong_to_statement(local_stmt, s, found_p);
                 },
                 instruction_block( inst ) );
           return bs;
         }
         case is_instruction_test :{
           test t = instruction_test(inst);
           bool bt = found_p || belong_to_statement(test_true(t), s, found_p);
           return bt || belong_to_statement(test_false(t), s, found_p);
           break;
         }
         case is_instruction_loop : {
           loop l = statement_loop(stmt);
           statement body = loop_body(l);
           return found_p || belong_to_statement(body, s, found_p);
           break;
         }
         case is_instruction_forloop :{
           forloop l = statement_forloop(stmt);
           statement body = forloop_body(l);
           return found_p || belong_to_statement(body, s, found_p);
           break;
         }
         case is_instruction_whileloop : {
           whileloop l = statement_whileloop(stmt);
           statement body = whileloop_body(l);
           return found_p || belong_to_statement(body, s, found_p);
           break;
         }
         case is_instruction_call:
           return found_p || false;
           break;
         default:
           break;
         }
       }
   }
   else return true;
   return found_p;
 }

References belong_to_statement(), CAR, forloop_body, replace_statement_context::found_p, instruction_block, instruction_tag, instruction_test, is_instruction_block, is_instruction_call, is_instruction_forloop, is_instruction_loop, is_instruction_test, is_instruction_whileloop, loop_body, MAPL, STATEMENT, statement_forloop(), statement_instruction, statement_loop(), statement_ordering, statement_whileloop(), test_false, test_true, and whileloop_body.

Referenced by belong_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comment_sentinel()

string comment_sentinel ( tag t )

Start a single line comment.

Returns: a string containing the begin of a comment line, language dependent

Definition at line 4420 of file statement.c.

                                {
   switch(t) {
     case is_language_c: return "//";
     case is_language_fortran: return "C";
     case is_language_fortran95: return "!";
     default: pips_internal_error("language unknown not handled"); return NULL ;
   }
 }

References is_language_c, is_language_fortran, is_language_fortran95, and pips_internal_error.

Referenced by loop_test(), and whileloop_test().

Here is the caller graph for this function:

◆ find_final_statement_label()

entity find_final_statement_label ( statement s )

Find the label associated with the last statement executed within s.

If empty blocks are allowed, we've recursed one statement too far.

There cannot be a final statement. The test itself is the final instruction.

Must be the label of the exit node.

fsl should be either a meaningful label or the empty label

Definition at line 4360 of file statement.c.

 {
   entity fsl = entity_undefined;
   instruction i = statement_instruction(s);
   list l = list_undefined;
  
   switch(instruction_tag(i)) {
  
   case is_instruction_block:
     if(!ENDP(l=gen_last(instruction_block(i)))) {
       fsl = statement_label(STATEMENT(CAR(l)));
     }
     else {
       /* If empty blocks are allowed, we've recursed one statement too
          far. */
       pips_internal_error("Useless empty sequence. Unexpected in controlized code.");
     }
     break;
  
   case is_instruction_test:
     /* There cannot be a final statement. The test itself is the final
        instruction. */
     fsl = statement_label(s);
     break;
  
   case is_instruction_loop:
     fsl = find_final_statement_label(loop_body(instruction_loop(i)));
     break;
  
   case is_instruction_goto:
     pips_internal_error("Controlized code should not contain GO TO statements");
     break;
  
   case is_instruction_call:
     fsl = statement_label(s);
     break;
  
   case is_instruction_unstructured:
     /* Must be the label of the exit node. */
     fsl = find_final_statement_label
       (control_statement(unstructured_exit(instruction_unstructured(i))));
     break;
  
   default:
     pips_internal_error("Unknown instruction tag: %d",
                instruction_tag(i));
   }
  
   /* fsl should be either a meaningful label or the empty label */
   if(entity_undefined_p(fsl)) {
     pips_internal_error("Undefined final label");
   }
  
   return fsl;
 }

References CAR, control_statement, ENDP, entity_undefined, entity_undefined_p, find_final_statement_label(), gen_last(), instruction_block, instruction_loop, instruction_tag, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, list_undefined, loop_body, pips_internal_error, STATEMENT, statement_instruction, statement_label, and unstructured_exit.

Referenced by find_final_statement_label(), and full_loop_unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ statement_remove_extensions()

void statement_remove_extensions ( statement s )

That's all folks.

purge a statement from its extensions

Definition at line 4263 of file statement.c.

                                               {
     extensions ext = statement_extensions(s);
     gen_full_free_list(extensions_extension(ext));
     extensions_extension(ext)=NIL;
 }

References extensions_extension, gen_full_free_list(), NIL, and statement_extensions.

Here is the call graph for this function:

◆ statement_remove_useless_label()

void statement_remove_useless_label	(	statement	s,
		bool *	changed
	)

remove the label of a statement if the statement is not unstructured.

labels on fortran loops and Fortran return are also preserved

Parameters

s	statement considered

Parameters

changed hanged

Definition at line 4275 of file statement.c.

 {
   instruction i = statement_instruction(s);
   if (!instruction_unstructured_p(i) &&
       c_module_p(get_current_module_entity()))
   {
     // under pyps, do not remove loop label like this */
     if (!(get_bool_property("PYPS") && instruction_loop_p(i)))
     {
       if (!entity_empty_label_p( statement_label(s)) &&
           !fortran_return_statement_p(s))
       {
         // SG: should free_entity?
         *changed = true;
         statement_label(s) = entity_empty_label();
  
         // OK but guarded by previous test
         if (instruction_loop_p(i))
           loop_label(instruction_loop(i))=entity_empty_label();
         if( instruction_whileloop_p(i) )
           whileloop_label(instruction_whileloop(i))=entity_empty_label();
       }
     }
   }
 }