#include "all.h"

Include dependency graph for myintrinsics.c:

Data Structures
struct	IoElementDescriptor
	{{ banner More...

struct	IntrinsicEffectDescriptor
	the following data structure describes an intrinsic function: its name and the function to apply on a call to this intrinsic to get the effects of the call More...

Typedefs
typedef struct IoElementDescriptor	IoElementDescriptor
	{{ banner More...

Functions
list	comp_regions_of_intrinsic (entity e, list args, transformer context)
	}} More...

list	proper_comp_regions_of_intrinsic (entity e, list args, transformer context)
	}} More...

list	no_write_comp_regions (entity __attribute__((unused)) e, list args, transformer context)
	}} More...

list	affect_comp_regions (entity __attribute__((unused)) e, list args, transformer context)
	}} More...

static IoElementDescriptor *	SearchIoElement (char s, char i) const
	}} More...

list	io_comp_regions (entity e, list args, transformer context)
	}} More...

list	comp_regions_of_ioelem (expression exp, tag act, transformer context)
	}} More...

list	comp_regions_of_iolist (list exprs, tag act, transformer context)
	}} More...

list	comp_regions_of_implied_do (expression exp, tag act, transformer context)
	}} More...

Variables
static IoElementDescriptor	IoElementDescriptorUndefined

static IoElementDescriptor	IoElementDescriptorTable []

static IntrinsicEffectDescriptor	IntrinsicDescriptorTable []

Typedef Documentation

◆ IoElementDescriptor

typedef struct IoElementDescriptor IoElementDescriptor

{{ banner

package regions : Alexis Platonoff, 22 Aout 1990

This File contains the main functions that compute the regions of a call to an intrinsic function : "+", "COS", etc... }} {{ data structures for handling descriptors the following data structure indicates whether an io element generates a read regions or a write region. the kind of region depends on the instruction type: for instance, access generates a read region if used within an open statement, and a write region when used inside an inquire statement

Function Documentation

◆ affect_comp_regions()

list affect_comp_regions	(	entity __attribute__((unused))	e,
		list	args,
		transformer	context
	)

}}

{{ affect_comp_regions ==============================================================================

Definition at line 332 of file myintrinsics.c.

 {
     list le = NIL;
  
     expression lhs = EXPRESSION(CAR(args));
     syntax s = expression_syntax(lhs);
  
     expression rhs = EXPRESSION(CAR(CDR(args)));
  
     debug(5, "affect_comp_regions", "begin\n");
  
     if (! syntax_reference_p(s))
             pips_internal_error("not a reference");
  
  
     le = comp_regions_of_write(syntax_reference(s), context);
  
     le = CompRegionsExactUnion(le, comp_regions_of_expression(rhs, context), 
                           effects_same_action_p);
  
     debug(5, "affect_comp_regions", "end\n");
  
     return(le);
 }

References CAR, CDR, comp_regions_of_expression(), comp_regions_of_write(), CompRegionsExactUnion(), debug(), effects_same_action_p(), EXPRESSION, expression_syntax, NIL, pips_internal_error, syntax_reference, and syntax_reference_p.

Here is the call graph for this function:

◆ comp_regions_of_implied_do()

list comp_regions_of_implied_do	(	expression	exp,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_implied_do an implied do is a call to an intrinsic function named IMPLIED-DO; its first argument is the loop index, the second one is a range, and the remaining ones are expressions to be written or references to be read, or another implied_do (BA).

loop index

range

regions of implied do index it is must_written but may read because the implied loop might execute no iteration.

the loop index is must-written

Read effects are masked by the first write to the implied-do loop variable

regions of implied-loop bounds and increment

the preconditions of the current statement don't include those induced by the implied_do, because they are local to the statement. But we need them to properly calculate the regions. the solution is to add to the current context the preconditions due to the current implied_do (think of nested implied_do). the regions are calculated, and projected along the index. BA, September 27, 1993.

on a un autre implied_do imbrique'

indices are removed from regions because this is a loop

Parameters

exp	xp
act	ct
context	ontext

Definition at line 544 of file myintrinsics.c.

 {
     list le, lep, lr, args;
     transformer local_context;
     expression arg1, arg2; 
     entity index;
     range r;
     reference ref;
  
     pips_assert("comp_regions_of_implied_do", expression_implied_do_p(exp));
  
     debug(5, "comp_regions_of_implied_do", "begin\n");
  
     args = call_arguments(syntax_call(expression_syntax(exp)));
     arg1 = EXPRESSION(CAR(args));       /* loop index */
     arg2 = EXPRESSION(CAR(CDR(args)));  /* range */
     
     pips_assert("comp_regions_of_implied_do", 
                 syntax_reference_p(expression_syntax(arg1)));
  
     pips_assert("comp_regions_of_implied_do", 
                 syntax_range_p(expression_syntax(arg2)));
  
  
     index = reference_variable(syntax_reference(expression_syntax(arg1)));
     ref = make_reference(index, NIL);
  
     r = syntax_range(expression_syntax(arg2));
  
     /* regions of implied do index 
      * it is must_written but may read because the implied loop 
      * might execute no iteration. 
      */
  
     le = comp_regions_of_write(ref, context); /* the loop index is must-written */
     /* Read effects are masked by the first write to the implied-do loop variable */
         
     /* regions of implied-loop bounds and increment */
     le = CompRegionsExactUnion(comp_regions_of_expression(arg2,context), le, 
                           effects_same_action_p);
  
  
     /* the preconditions of the current statement don't include those
      * induced by the implied_do, because they are local to the statement.
      * But we need them to properly calculate the regions.
      * the solution is to add to the current context the preconditions 
      * due to the current implied_do (think of nested implied_do).
      * the regions are calculated, and projected along the index.
      * BA, September 27, 1993.
      */
  
     local_context = transformer_dup(context);
     local_context = add_index_range_conditions(local_context, index, r, 
                                                transformer_undefined);
     transformer_arguments(local_context) = 
         arguments_add_entity(transformer_arguments(local_context), 
                              entity_to_new_value(index)); 
  
     ifdebug(7) {
         debug(7, "comp_regions_of_implied_do", "local context : \n%s\n", 
               precondition_to_string(local_context));
     }
  
     MAP(EXPRESSION, expr, 
         { 
             syntax s = expression_syntax(expr);
             
             if (syntax_reference_p(s))
                 if (act == is_action_write) 
                     lep = comp_regions_of_write(syntax_reference(s),local_context);
                 else
                     lep = comp_regions_of_expression(expr, local_context);
             else
                 /* on a un autre implied_do imbrique' */
                 lep = comp_regions_of_implied_do(expr, act, local_context);
             
             
             /* indices are removed from regions because this is a loop */
             lr = NIL;
             MAP(REGION, reg,
                 {            
                     if (region_entity(reg) != index)
                         lr =  region_add_to_regions(reg,lr);
                     else
                     {
                         debug(5, "comp_regions_of_implied_do", "index removed");
                         region_free(reg);
                     }
                 }, lep);
             gen_free_list(lep);
             le = CompRegionsExactUnion(le, lr, effects_same_action_p);
             
         }, CDR(CDR(args)));
     
     ifdebug(7) {
         debug(7, "comp_regions_of_implied_do", "regions before projection :\n");
         print_regions(le);
         fprintf(stderr, "\n");
     }
     
     project_regions_along_loop_index(le, 
                                      entity_to_new_value(index), 
                                      r);
  
     ifdebug(6) {
         debug(6, "comp_regions_of_implied_do", "regions after projection :\n");
         print_regions(le);
         fprintf(stderr, "\n");
     }
  
  
     transformer_free(local_context);
     local_context = transformer_undefined;
     
     debug(5, "comp_regions_of_implied_do", "end\n");
  
     return(le);
 }

References add_index_range_conditions(), arguments_add_entity(), call_arguments, CAR, CDR, comp_regions_of_expression(), comp_regions_of_implied_do(), comp_regions_of_write(), CompRegionsExactUnion(), debug(), effects_same_action_p(), entity_to_new_value(), exp, EXPRESSION, expression_implied_do_p(), expression_syntax, fprintf(), gen_free_list(), ifdebug, is_action_write, make_reference(), MAP, NIL, pips_assert, precondition_to_string(), print_regions(), project_regions_along_loop_index(), ref, reference_variable, REGION, region_add_to_regions(), region_entity, region_free(), syntax_call, syntax_range, syntax_range_p, syntax_reference, syntax_reference_p, transformer_arguments, transformer_dup(), transformer_free(), and transformer_undefined.

Referenced by comp_regions_of_implied_do(), and comp_regions_of_iolist().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comp_regions_of_intrinsic()

list comp_regions_of_intrinsic	(	entity	e,
		list	args,
		transformer	context
	)

}}

myintrinsics.c

{{ comp_regions_of_intrinsic list comp_regions_of_intrinsic(entity e, list args, transformer context) input : a intrinsic function name, the list or arguments, and the calling context. output : the corresponding list of regions. modifies : nothing. comment :

Parameters

args	rgs
context	ontext

Definition at line 270 of file myintrinsics.c.

 {
     return (proper_comp_regions_of_intrinsic(e, args, context));
 }

References proper_comp_regions_of_intrinsic().

Referenced by comp_regions_of_call().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comp_regions_of_ioelem()

list comp_regions_of_ioelem	(	expression	exp,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_io_element ==============================================================================

Parameters

exp	xp
act	ct
context	ontext

Definition at line 461 of file myintrinsics.c.

 {   
     list lr;
  
     debug(5, "comp_regions_of_io_elem", "begin\n");
     if (act == is_action_write) {
         syntax s = expression_syntax(exp);
  
         debug(6, "comp_regions_of_io_elem", "is_action_write\n");
         pips_assert("comp_regions_of_ioelem", syntax_reference_p(s));
  
         lr = comp_regions_of_write(syntax_reference(s), context);
     }
     else {  
         debug(6, "comp_regions_of_io_elem", "is_action_read\n");  
         lr = comp_regions_of_expression(exp, context);
     }   
  
     debug(5, "comp_regions_of_elem", "end\n");
  
     return(lr);
 }

References comp_regions_of_expression(), comp_regions_of_write(), debug(), exp, expression_syntax, is_action_write, pips_assert, syntax_reference, and syntax_reference_p.

Referenced by io_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comp_regions_of_iolist()

list comp_regions_of_iolist	(	list	exprs,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_io_list ==============================================================================

There is a bug with effects of io list

READ *,N,(T(I),I=1,N)

there is write effect on N but for the io list, we don't have this effect !

Cause : there is no loop for the list exprs !!! /NN:2000/

Parameters

exprs	xprs
act	ct
context	ontext

Definition at line 489 of file myintrinsics.c.

 {
   list le = NIL;
   debug(5, "comp_regions_of_io_list", "begin\n");
   while (!ENDP(exprs))
     {
       expression exp = EXPRESSION(CAR(exprs));
       list lep = NIL;
         
       /* There is a bug with effects of io list  
        
          READ *,N,(T(I),I=1,N)
  
          there is write effect on N but for the io list, 
          we don't have this effect !
        
          Cause : there is no loop for the list exprs !!! /NN:2000/ */
  
       if (expression_implied_do_p(exp)) {
         lep = comp_regions_of_implied_do(exp, act, context);
       }
       else {
         if (act == is_action_write) {
           syntax s = expression_syntax(exp);
  
           debug(6, "comp_regions_of_io_list", "is_action_write");
           pips_assert("comp_regions_of_iolist", syntax_reference_p(s));
           lep = comp_regions_of_write(syntax_reference(s), context);
         }
         else {  
           debug(6, "comp_regions_of_io_elem", "is_action_read");
           lep = comp_regions_of_expression(exp, context);
         }
       }
       
       le = CompRegionsExactUnion(le, lep, effects_same_action_p);
       
       exprs = CDR(exprs);
     }
  
   debug(5, "comp_regions_of_io_list", "end\n");
  
   return(le);
 }

References CAR, CDR, comp_regions_of_expression(), comp_regions_of_implied_do(), comp_regions_of_write(), CompRegionsExactUnion(), debug(), effects_same_action_p(), ENDP, exp, EXPRESSION, expression_implied_do_p(), expression_syntax, is_action_write, NIL, pips_assert, syntax_reference, and syntax_reference_p.

Referenced by io_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ io_comp_regions()

list io_comp_regions	(	entity	e,
		list	args,
		transformer	context
	)

}}

{{ io_comp_regions

regions effects on logical units - taken from effects/io.c

We simulate actions on files by read/write actions to a static integer array GO: It is necessary to do a read and and write action to the array, because it updates the file-pointer so it reads it and then writes it ...

Parameters

args	rgs
context	ontext

Definition at line 378 of file myintrinsics.c.

 {
     list le = NIL, pc, lep;
  
     debug(5, "io_comp_regions", "begin\n");
  
     for (pc = args; pc != NIL; pc = CDR(pc)) {
         IoElementDescriptor *p;
         entity ci;
         syntax s = expression_syntax(EXPRESSION(CAR(pc)));
  
         pips_assert("io_comp_regions", syntax_call_p(s));
  
         ci = call_function(syntax_call(s));
         p = SearchIoElement(entity_local_name(e), entity_local_name(ci));
  
         pc = CDR(pc);
  
         if (strcmp(p->IoElementName, "IOLIST=") == 0) {
             lep = comp_regions_of_iolist(pc, p->ReadOrWrite, context);
         }
         else {
             lep = comp_regions_of_ioelem(EXPRESSION(CAR(pc)), 
                                     p->ReadOrWrite, context);
         }
  
         if (p->MayOrMust == is_approximation_may) 
         {
             MAP(REGION, reg, 
             {
                 approximation_tag(effect_approximation(reg)) = 
                     is_approximation_may;
             }, lep);
         }
  
         le = CompRegionsExactUnion(le, lep, effects_same_action_p);
  
         /* regions effects on logical units - taken from effects/io.c */
         if ((get_bool_property ("PRETTYPRINT_IO_EFFECTS")) &&
             (pc != NIL) &&
             (strcmp(p->IoElementName, "UNIT=") == 0))
         {
             /* We simulate actions on files by read/write actions
                to a static integer array 
                GO:
                It is necessary to do a read and and write action to
                the array, because it updates the file-pointer so
                it reads it and then writes it ...*/
             entity private_io_entity;
             reference ref;
             list indices = NIL;
  
             indices = gen_nconc(indices,
                                 CONS(EXPRESSION,
                                      EXPRESSION(CAR(pc)),NIL));
  
             private_io_entity = FindEntity(TOP_LEVEL_MODULE_NAME,
                  IO_EFFECTS_ARRAY_NAME);
  
             pips_assert("regions_effects", private_io_entity != entity_undefined);
  
             ref = make_reference(private_io_entity,indices);
             le = CompRegionsExactUnion(le, 
                                  comp_regions_of_read(ref, context), 
                                  effects_same_action_p);
             le = CompRegionsExactUnion(le, 
                                  comp_regions_of_write(ref, context), 
                                  effects_same_action_p);
             
         }
         
     }
  
     debug(5, "io_comp_regions", "end\n");
  
     return(le);
 }    

References approximation_tag, call_function, CAR, CDR, comp_regions_of_ioelem(), comp_regions_of_iolist(), comp_regions_of_read(), comp_regions_of_write(), CompRegionsExactUnion(), CONS, debug(), effect_approximation, effects_same_action_p(), entity_local_name(), entity_undefined, EXPRESSION, expression_syntax, FindEntity(), gen_nconc(), get_bool_property(), indices, IO_EFFECTS_ARRAY_NAME, IoElementDescriptor::IoElementName, is_approximation_may, make_reference(), MAP, IoElementDescriptor::MayOrMust, NIL, pips_assert, IoElementDescriptor::ReadOrWrite, ref, REGION, SearchIoElement(), syntax_call, syntax_call_p, and TOP_LEVEL_MODULE_NAME.

Here is the call graph for this function:

◆ no_write_comp_regions()

list no_write_comp_regions	(	entity __attribute__((unused))	e,
		list	args,
		transformer	context
	)

}}

{{ no_write_comp_regions ==============================================================================

Definition at line 315 of file myintrinsics.c.

 {
     list lr;
  
     debug(5, "no_write_comp_regions", "begin\n");
     lr = comp_regions_of_expressions(args,context);
     debug(5, "no_write_comp_regions", "end\n");
     return(lr);
 }

References comp_regions_of_expressions(), and debug().

Here is the call graph for this function:

◆ proper_comp_regions_of_intrinsic()

list proper_comp_regions_of_intrinsic	(	entity	e,
		list	args,
		transformer	context
	)

}}

{{ proper_comp_regions_of_intrinsic list proper_comp_regions_of_intrinsic(entity e, list args, transformer context) input : a intrinsic function name, the list or arguments, and the calling context. output : the corresponding list of regions. modifies : nothing. comment :

Parameters

args	rgs
context	ontext

Definition at line 286 of file myintrinsics.c.

 {
     const char* s = entity_local_name(e);
     IntrinsicEffectDescriptor *pid = IntrinsicDescriptorTable;
     list lr;
  
     debug(3, "proper_comp_regions_of_intrinsic", "begin\n");
  
     while (pid->name != NULL) {
         if (strcmp(pid->name, s) == 0) {
                 lr = (*(pid->f))(e, args, context);
                       debug(3, "proper_comp_regions_of_intrinsic", "end\n");
                 return(lr);
             }
  
         pid += 1;
     }
  
     pips_internal_error("unknown intrinsic %s", s);
  
     return(NIL);
 }

References debug(), entity_local_name(), IntrinsicEffectDescriptor::f, IntrinsicDescriptorTable, IntrinsicEffectDescriptor::name, NIL, and pips_internal_error.

Referenced by comp_regions_of_intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SearchIoElement()

static IoElementDescriptor* SearchIoElement	(	char *	s,
		char *	i
	)		const

static

}}

{{ SearchIoElements

Never reaches this point. Only to avoid a warning at compile time. BC.

Definition at line 361 of file myintrinsics.c.

 {
     IoElementDescriptor *p = IoElementDescriptorTable;
  
     while (p->StmtName != NULL) {
         if (strcmp(p->StmtName, s) == 0 && strcmp(p->IoElementName, i) == 0)
                 return(p);
         p += 1;
     }
  
     pips_internal_error("unknown io element %s %s", s, i);
     /* Never reaches this point. Only to avoid a warning at compile time. BC. */
     return(&IoElementDescriptorUndefined);
 }