area.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "linear.h"
#include "genC.h"
#include "misc.h"
#include "ri.h"
#include "properties.h"
#include "ri-util.h"
#include "prettyprint.h"

Include dependency graph for area.c:

Go to the source code of this file.

Functions
static bool	comparable_entity_in_list_p (entity common, entity v, list l)
	Functions closely related to the entity class, constructors, predicates,... More...
bool	check_common_inclusion (entity common)
	check whether a common declaration can be simply included, that is it is declared with the same names, orders and types in all instances. More...

Function Documentation

check_common_inclusion()

bool check_common_inclusion

(

entity

common

)

check whether a common declaration can be simply included, that is it is declared with the same names, orders and types in all instances.

area.c

of entity

empty common!

take the first function as the reference for the check.

SAME name, type, offset

Parameters

common

ommon

Definition at line 107 of file area.c.

{
  bool ok = true;
  list /* of entity */ lv, lref;
  entity ref;
  pips_assert("entity is a common", entity_area_p(common));
  lv = area_layout(type_area(entity_type(common)));
 
  if (!lv) return true; /* empty common! */
 
  /* take the first function as the reference for the check. */
  ref = ram_function(storage_ram(entity_storage(ENTITY(CAR(lv)))));
  lref = common_members_of_module(common, ref, false);
 
  /* SAME name, type, offset */
  while (lv && ok)
    {
      entity v = ENTITY(CAR(lv));
      if (ram_function(storage_ram(entity_storage(v)))!=ref)
        ok = comparable_entity_in_list_p(common, v, lref);
      POP(lv);
    }
 
  gen_free_list(lref);
  return ok;
}

References area_layout, CAR, common_members_of_module(), comparable_entity_in_list_p(), ENTITY, entity_area_p(), entity_storage, entity_type, gen_free_list(), ok, pips_assert, POP, ram_function, ref, storage_ram, and type_area.

Referenced by text_area_included().

Here is the call graph for this function:

Here is the caller graph for this function:

comparable_entity_in_list_p()

static bool comparable_entity_in_list_p ( entity  common, entity  v, list  l  )

static

Functions closely related to the entity class, constructors, predicates,...

returns true if l contains an entity with same type, local name and offset.

first find an entity with the same NAME.

same OFFSET?

same TYPE?

SG we cannot rely on same_type_p or type_equal_p because we want a syntactic comparison, there used to be a hack in expression_equal_p to handle this particular case, I prefer to have the hack right here

temporary for CA

Definition at line 46 of file area.c.

{
  entity ref = entity_undefined;
  bool ok, sn, so = false, st = false;
 
  /* first find an entity with the same NAME.
   */
  const char* nv = entity_local_name(v);
  MAP(ENTITY, e,
      {
        if (same_string_p(entity_local_name(e),nv))
          {
            ref = e;
            break;
          }
      },
      l);
 
  ok = sn = !entity_undefined_p(ref);
 
  pips_assert("v storage ram", storage_ram_p(entity_storage(v)));
  if (ok) pips_assert("ref storage ram", storage_ram_p(entity_storage(ref)));
 
  /* same OFFSET?
   */
  if (ok) ok = so = (ram_offset(storage_ram(entity_storage(v))) ==
                     ram_offset(storage_ram(entity_storage(ref))));
 
  /* same TYPE?
   */
  /* SG we cannot rely on same_type_p or type_equal_p because we want a syntactic comparison,
   * there used to be a hack in expression_equal_p to handle this particular case, I prefer to have the hack right here
   */
  if( ok ) {
      if(entity_undefined_p(ref)) ok = st =false;
      else {
          type tv = entity_type(v),
               tref = entity_type(ref);
          ok = st = same_type_name_p(tv,tref);
      }
  }
 
  pips_debug(4, "%s ~ %s? %d: n=%d,o=%d,t=%d\n", entity_name(v),
             entity_undefined_p(ref)? "<undef>": entity_name(ref),
             ok, sn, so, st);
 
  /* temporary for CA
   */
  if (!ok) {
    pips_debug(1, "common /%s/: %s != %s (n=%d,o=%d,t=%d)\n",
               entity_name(common), entity_name(v),
               entity_undefined_p(ref)? "<undef>": entity_name(ref),
               sn, so, st);
  }
 
  return ok;
}

References ENTITY, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined, entity_undefined_p, MAP, ok, pips_assert, pips_debug, ram_offset, ref, same_string_p, same_type_name_p(), storage_ram, and storage_ram_p.

Referenced by check_common_inclusion().

Here is the call graph for this function:

Here is the caller graph for this function: