#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "misc.h"
#include "ri-util.h"

Include dependency graph for clean.c:

Functions
static void	set_current_function (entity function)

static bool	local_entity_of_current_function_p (entity e)

void	GenericCleanEntities (list el, entity function, bool fortran_p)
	Useful when the user edit a source file and parse it again or when a program transformation is performed by prettyprinting and reparsing. More...

void	GenericCleanLocalEntities (entity function, bool fortran_p)

void	CleanLocalEntities (entity function)
	Fortran version. More...

void	CCleanLocalEntities (entity function)
	C language version. More...

void	RemoveLocalEntities (entity function)
	Useful for ParserError()? More...

Variables
static entity	current_function = entity_undefined

static const char *	current_function_local_name = NULL

Function Documentation

◆ CCleanLocalEntities()

void CCleanLocalEntities ( entity function )

C language version.

Parameters

function unction

Definition at line 146 of file clean.c.

 {
   GenericCleanLocalEntities(function, false);
 }

References GenericCleanLocalEntities().

Referenced by MakeCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CleanLocalEntities()

void CleanLocalEntities ( entity function )

Fortran version.

Parameters

function unction

Definition at line 140 of file clean.c.

 {
   GenericCleanLocalEntities(function, true);
 }

References GenericCleanLocalEntities().

Referenced by AbortEntries(), c_parser_error(), MakeCurrentFunction(), and ParserError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenericCleanEntities()

void GenericCleanEntities	(	list	el,
		entity	function,
		bool	fortran_p
	)

Useful when the user edit a source file and parse it again or when a program transformation is performed by prettyprinting and reparsing.

clean.c

FI: A memory leak is better than a dangling pointer?

My explanation: CleanLocalEntities is called by MakeCurrentFunction when the begin_inst rule is reduced; by that time, the module entity and its formal parameters have already been parsed and allocated... but they are not yet fully initialized; thus the gen_full_free is a killer while the undefinitions are ok.

en_full_free_list(function_local_entities);

In C, parameter typing may have already occured and the return entity may be already defined. They must be preserved.

free_type(entity_type(e));

free_storage(entity_storage(e));

free_value(entity_initial(e));

In C, the entity must be removed from the declarations and from the symbol table

Parameters

el	l
function	unction
fortran_p	ortran_p

Definition at line 63 of file clean.c.

 {
   /* FI: A memory leak is better than a dangling pointer? */
   /* My explanation: CleanLocalEntities is called by MakeCurrentFunction when
    * the begin_inst rule is reduced; by that time, the module entity and its
    * formal parameters have already been parsed and allocated... but they
    * are not yet fully initialized; thus the gen_full_free is a killer while
    * the undefinitions are ok.
    */
   /*gen_full_free_list(function_local_entities);*/
  
   list pe = list_undefined;
  
   for(pe=el; !ENDP(pe); POP(pe)) {
     entity e = ENTITY(CAR(pe));
     storage s = entity_storage(e);
  
     pips_debug(8, "Clean up %s?\n", entity_local_name(e));
  
     if(!storage_undefined_p(s) && storage_ram_p(s)) {
       entity sec = ram_section(storage_ram(s));
       type t = entity_type(sec);
       if(!type_undefined_p(t)) {
           pips_assert("t is an area", type_area_p(t));
           gen_remove(&(area_layout(type_area(t))),e);
       }
     }
  
     /* In C, parameter typing may have already occured and the return
        entity may be already defined. They must be preserved. */
     if(fortran_p
        || (!storage_undefined_p(entity_storage(e))
            && !storage_formal_p(entity_storage(e))
            && !storage_return_p(entity_storage(e)))) {
       pips_debug(8, "Clean up %s? YES\n", entity_local_name(e));
       if(!type_undefined_p(entity_type(e))) {
         /* free_type(entity_type(e)); */
         entity_type(e) = type_undefined;
       }
       if(!storage_undefined_p(entity_storage(e))) {
         /* free_storage(entity_storage(e)); */
         entity_storage(e) = storage_undefined;
       }
       if(!value_undefined_p(entity_initial(e))) {
         /* free_value(entity_initial(e)); */
         entity_initial(e) = value_undefined;
       }
       if(!fortran_p) {
         /* In C, the entity must be removed from the declarations and
            from the symbol table */
         gen_remove(&(code_declarations(value_code(entity_initial(function)))),e);
         free_entity(e);
       }
     }
     else {
       pips_debug(8, "Clean up %s? NO\n", entity_local_name(e));
     }
   }
 }

References area_layout, CAR, code_declarations, ENDP, ENTITY, entity_initial, entity_local_name(), entity_storage, entity_type, free_entity(), gen_remove(), list_undefined, pips_assert, pips_debug, POP, ram_section, storage_formal_p, storage_ram, storage_ram_p, storage_return_p, storage_undefined, storage_undefined_p, type_area, type_area_p, type_undefined, type_undefined_p, value_code, value_undefined, and value_undefined_p.

Referenced by clean_up_points_to_stubs(), and GenericCleanLocalEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenericCleanLocalEntities()

void GenericCleanLocalEntities	(	entity	function,
		bool	fortran_p
	)

Parameters

function	unction
fortran_p	ortran_p

Definition at line 123 of file clean.c.

 {
   list function_local_entities = NIL;
   //list pe = NIL;
  
   set_current_function(function);
  
   function_local_entities =
     gen_filter_tabulated(local_entity_of_current_function_p, 
                          entity_domain);
  
   GenericCleanEntities(function_local_entities, function, fortran_p);
  
   gen_free_list(function_local_entities);
 }

References entity_domain, gen_filter_tabulated(), gen_free_list(), GenericCleanEntities(), local_entity_of_current_function_p(), NIL, and set_current_function().

Referenced by CCleanLocalEntities(), and CleanLocalEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ local_entity_of_current_function_p()

static bool local_entity_of_current_function_p ( entity e )

static

Definition at line 53 of file clean.c.

 {
     return(same_string_p(entity_module_name(e), current_function_local_name));
 }

References current_function_local_name, entity_module_name(), and same_string_p.

Referenced by GenericCleanLocalEntities(), and RemoveLocalEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveLocalEntities()

void RemoveLocalEntities ( entity function )

Useful for ParserError()?

FI: dangling pointers? Some variables may be referenced in area_layouts of global common entities!

gen_full_free_list(function_local_entities);

A gen_multi_recurse would be required but it's hard to be at the list level to remove the elements?!?

Parameters

function unction

Definition at line 152 of file clean.c.

 {
  
     set_current_function(function);
  
 #if 0
     list function_local_entities =
         gen_filter_tabulated(local_entity_of_current_function_p, 
                              entity_domain);
 #endif
  
     /* FI: dangling pointers? Some variables may be referenced in area_layouts of
        global common entities! */
     /* gen_full_free_list(function_local_entities); */
     /* A gen_multi_recurse would be required but it's hard to be at the
        list level to remove the elements?!? */
     pips_assert("implemented", false);
 }

References entity_domain, gen_filter_tabulated(), local_entity_of_current_function_p(), pips_assert, and set_current_function().

Here is the call graph for this function:

◆ set_current_function()

static void set_current_function ( entity function )

static

Definition at line 42 of file clean.c.

 {
     pips_assert("set_current_function", top_level_entity_p(function)
                 || compilation_unit_p(entity_module_name(function)));
     current_function = function;
     current_function_local_name = module_local_name(function);
 }