util.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "c_parser_private.h"
#include "c_syntax.h"
#include "text-util.h"
#include "prettyprint.h"
#include "cyacc.h"
#include "resources.h"
#include "database.h"
#include "misc.h"
#include "properties.h"

Include dependency graph for util.c:

Go to the source code of this file.

Macros
#define	FILE_LOCAL_USER_DEFINED_TYPES_P   (true)

Functions
void	c_parser_user_warning_alist (const char *pips_func, const char *pips_file, const int pips_line, const char *format, va_list *args)
	Compared to pips_user_warning(), the name of the calling function is lost, which does not help maintenance but generates more user-friendly messages. More...
void	c_parser_user_warning_func (const char *pips_func, const char *pips_file, const int pips_line, const char *format,...)
static void	set_current_dummy_parameter_number (int n)
void	reset_current_dummy_parameter_number ()
static int	get_current_dummy_parameter_number (void)
entity	get_top_level_entity ()
void	MakeTopLevelEntity ()
void	init_c_areas ()
	In C we have 4 areas. More...
entity	make_C_constant_entity (string name, tag bt, size_t size)
void	init_c_implicit_variables (entity m)
entity	get_current_compilation_unit_entity ()
void	MakeCurrentCompilationUnitEntity (const char *name)
	A compilation unit is also considered as a module. More...
void	ResetCurrentCompilationUnitEntity (bool is_compilation_unit_parser)
expression	MakeFunctionExpression (expression e, list le)
	e is now owned by returned expression and must not be used any longer More...
expression	MemberDerivedIdentifierToExpression (type t, string m)
expression	MemberIdentifierToExpression (expression e, string m)
expression	IdentifierToExpression (string s)
expression	MakeArrayExpression (expression exp, list lexp)
	FI: this function is called for a bracketed comma expression. More...
entity	FindEntityFromLocalName (string name)
entity	FindOrCreateEntityFromLocalNameAndPrefix (string name, string prefix, bool is_external)
entity	FindOrCreateEntityFromLocalNameAndPrefixAndScope (string name, string prefix, string scope, bool is_external)
entity	FindEntityFromLocalNameAndPrefixAndScope (string name, string prefix, string scope)
	The parameter "scope" is potentially destroyed. More...
entity	FindEntityFromLocalNameAndPrefix (string name, string prefix)
entity	CreateEntityFromLocalNameAndPrefix (string name, string prefix, bool is_external)
bool	CheckExternList ()
void	c_parser_put_new_typedef (const char *name)
	Store named type for the lexical analyzer, which has to decide if a character string is the name of a type or the name of a variable. More...
void	put_new_typedef (const char *name)
	This function is used by libraries "step"* and "task_parallelization". More...
entity	FindOrCreateCurrentEntity (string name, stack ContextStack __attribute__((__unused__)), stack FormalStack, stack FunctionStack, bool is_external)
	This function finds or creates the current entity. More...
void	UpdateParenEntity (entity e, list lq)
dimension	MakeDimension (list le, list ql)
type	UpdateFinalPointer (type pt, type t)
void	UpdatePointerEntity (entity e, type pt, list lq)
void	UpdateArrayEntity (entity e, list lq, list le)
entity	RenameFunctionEntity (entity oe)
	Rename function oe if necessary. More...
void	UpdateFunctionEntity (entity oe, list la)
	The parser has found out that an entity is a function and partially sets its type. More...
type	UpdateType (type t1, type t2)
	This function replaces the undefined field in t1 by t2. More...
static bool	referencenodeclfilter (reference r)
static bool	callnodeclfilter (call c)
static void	nodecl_p (entity __attribute__((unused)) module, statement stat)
void	CCompilationUnitMemoryAllocations (entity module, bool first_p)
	This function allocates the memory to the Current Compilation Unit. More...
void	CCompilationUnitMemoryAllocation (entity module)
void	CCompilationUnitMemoryReallocation (entity module)
void	CModuleMemoryAllocation (entity module)
	This function is for MemoryAllocation for Module of C programs. More...
void	UseDummyArguments (entity f)
	If f has regular formal parameters, destroy them. More...
void	UseFormalArguments (entity f)
	If f has dummy formal parameters, replace them by standard formal parameters. More...
void	RemoveDummyArguments (entity f, list refs)
	To chase formals in type declarations. More...
void	SubstituteDummyParameters (entity f, list el)
void	CreateReturnEntity (entity f)
	If necessary, create the return entity, which is a hidden variable used in PIPS internal representation to carry the value returned by a function. More...
void	UpdateEntity2 (entity f, stack FormalStack __attribute__((__unused__)), stack OffsetStack __attribute__((__unused__)))
	A subset of UpdateEntity, used when the function entity is already more defined because the return type is implicit. More...
void	UpdateEntity (entity e, stack ContextStack, stack FormalStack, stack FunctionStack, stack OffsetStack, bool is_external, bool is_declaration)
	Update the entity with final type, storage and initial value; and also (sometimes?) declare it at the module level. More...
void	UpdateEntities (list le, stack ContextStack, stack FormalStack, stack FunctionStack, stack OffsetStack, bool is_external, bool is_declaration)
static entity	CleanUpEntity (entity e)
	if returned entity != original entity, e must be freed, otherwise an invalid entity is still tabulated More...
void	CleanUpEntities (list le)
void	UpdateAbstractEntity (entity e, stack ContextStack)
void	RemoveFromExterns (entity e)
void	AddToExterns (entity e, entity mod)
void	AddToDeclarations (entity e, entity mod)
	FI: check the difference with AddEntityToDeclarations() More...
void	UpdateDerivedEntity (list ld, entity e, stack ContextStack)
list	TakeDerivedEntities (list le)
void	UpdateDerivedEntities (list ld, list le, stack ContextStack)
void	InitializeEnumMemberValues (list lem)
entity	MakeDerivedEntity (string name, list members, bool is_external, int i)
storage	MakeStorageRam (entity v, bool is_external, bool is_static)
	The storage part should not be called twice when reparsing compilation unit. More...
string	CreateMemberScope (string derived, bool is_external)
value	MakeEnumeratorInitialValue (list enum_list, int counter)
int	ComputeAreaOffset (entity a, entity v)
list	MakeParameterList (list l1, list l2, stack FunctionStack)
parameter	FindParameterEntity (string s, int offset, list l)
void	AddToCalledModules (entity e)
void	NStackPop (stack s, int n)
	Pop n times the stack s. More...
void	StackPop (stack OffsetStack)
	The OffsetStack is poped n times, where n is the number of formal arguments of the actual function. More...
void	StackPush (stack OffsetStack)
	The OffsetStack is pushed incrementally. More...
void	set_entity_initial (entity v, expression nie)
	Be careful if the initial value has already been set. More...
bool	check_declaration_uniqueness_p (statement s)
	This is designed for standard C functions, not for compilation units. More...
list	insert_qualifier (list ql, qualifier nq)
	if qualifier "nq" does not already belong to qualifier list "ql", add it in front of the list. More...
void	reset_preprocessor_line_analysis (void)
int	analyze_preprocessor_line (string line, int C_line_number)
	Analyze information about user line number provided by the C preprocessor and by PIPS file splitter and return the C line number in the source file. More...

Variables
static int	current_dummy_parameter_number =0
	The data structure to tackle the memory allocation problem due to reparsing of compilation unit. More...
static bool	declarationerror_p
static bool	buffer_initialized_p = false

Macro Definition Documentation

FILE_LOCAL_USER_DEFINED_TYPES_P

#define FILE_LOCAL_USER_DEFINED_TYPES_P   (true)

Function Documentation

AddToCalledModules()

void AddToCalledModules

(

entity

e

)

Definition at line 3413 of file util.c.

{
  if (!intrinsic_entity_p(e))
    {
      bool already_here = false;
      //string n = top_level_entity_p(e)?entity_local_name(e):entity_name(e);
      const char* n = entity_local_name(e);
      MAP(STRING,s,
      {
        if (strcmp(n, s) == 0)
          {
            already_here = true;
            break;
          }
      }, CalledModules);
 
      if (! already_here)
        {
          pips_debug(2, "Adding %s to list of called modules\n", n);
          CalledModules = CONS(STRING, strdup(n), CalledModules);
        }
    }
}

References CalledModules, CONS, entity_local_name(), intrinsic_entity_p(), MAP, pips_debug, strdup(), and STRING.

Referenced by MakeFunctionExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToDeclarations()

void AddToDeclarations	(	entity	e,
		entity	mod
	)

FI: check the difference with AddEntityToDeclarations()

Here, the declared entity is added to the module declarations only.

Parameters

mod

od

Definition at line 2924 of file util.c.

{
  list dl = code_declarations(value_code(entity_initial(mod)));
 
  if (!gen_in_list_p(e,dl))
    {
      pips_debug(5,"Add entity \"%s\" (\"%s\") to module %s\n",
                 entity_user_name(e),
                 entity_name(e),
                 entity_user_name(mod));
      code_declarations(value_code(entity_initial(mod)))
        = gen_nconc(code_declarations(value_code(entity_initial(mod))),
                    CONS(ENTITY,e,NIL));
    }
}

References code_declarations, CONS, ENTITY, entity_initial, entity_name, entity_user_name(), gen_in_list_p(), gen_nconc(), NIL, pips_debug, and value_code.

Referenced by CreateReturnEntity(), MakeFunctionExpression(), MakeParameterList(), and UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToExterns()

void AddToExterns	(	entity	e,
		entity	mod
	)

Parameters

mod

od

Definition at line 2898 of file util.c.

{
  // the entity e can be extern variable and extern functions
  list le = code_externs(value_code(entity_initial(mod)));
 
  pips_assert("le is an entity list", entity_list_p(le));
 
  if(!gen_in_list_p(e, le))
  {
    pips_debug(5,"Add entity %s to extern declaration %s \n",
               entity_user_name(e), entity_user_name(mod));
    pips_assert("e is an entity", entity_domain_number(e)==entity_domain);
    pips_assert("mod is an entity", entity_domain_number(mod)==entity_domain);
    code_externs(value_code(entity_initial(mod)))
      = gen_nconc(code_externs(value_code(entity_initial(mod))),
                  CONS(ENTITY,e,NIL));
 
    le = code_externs(value_code(entity_initial(mod)));
    pips_assert("le is an entity list", entity_list_p(le));
  }
}

References code_externs, CONS, ENTITY, entity_domain, entity_domain_number, entity_initial, entity_list_p(), entity_user_name(), gen_in_list_p(), gen_nconc(), NIL, pips_assert, pips_debug, and value_code.

Referenced by FindOrCreateCurrentEntity(), and UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

analyze_preprocessor_line()

int analyze_preprocessor_line	(	string	line,
		int	C_line_number
	)

Analyze information about user line number provided by the C preprocessor and by PIPS file splitter and return the C line number in the source file.

We do not have specs and must evolve with C preprocessors such as cpp.

We assume that information about the lines in the included files is only provided for compilation unit.

We assume that information about user line in a module is always related to the user source file, and that the first line has been generated by PIPS file splitter with syntax "x nnn", with no information about the user source file name.

See examples line00.c, line01.c, line02.c and line03.c. And do not forget cominc02 for the compilation unit case. And missing01.c for synthesized code.

More examples needed for include lines placed within a function body, with C code or preprocessor definitions: line04 and line05.

the C preprocessors, such as cpp, and PIPS file splitter provide line information in pragmas which are not line pragmas.

Not too sure about C source code generated by PIPS by passes initializer, clone, outlining, inlinging...

strstr(line, "#line")==line &&

Not to sure about this case

The next lines have been imported from an included file. Ignore information about include files, preserve the current C_line_number.

Not to sure about this case: internal error?

Parameters

line	ine
C_line_number	_line_number

Definition at line 3617 of file util.c.

{
  // In compilation units, ignore information about include files
  // Could be used so size "buffer", but not "init_buffer"
  // int s = strlen(line);
  char buffer[1024];
  static char init_buffer[1024];
 
  pips_debug(9,"Pragma-like comment %s\n",line);
 
  /* the C preprocessors, such as cpp, and PIPS file splitter provide
   * line information in pragmas which are not #line pragmas.
   *
   * Not too sure about C source code generated by PIPS by passes
   * initializer, clone, outlining, inlinging...
   */
 
  if(/* strstr(line, "#line")==line && */ strlen(line)>=4) {
    int initial_C_line_number = -1;
    int items = sscanf(line+1, "%d %s", &initial_C_line_number, buffer);
    if(items==2) { 
      // if(C_line_number==UNDEFINED_C_LINE_NUMBER) {
      //if(C_line_number==FIRST_C_LINE_NUMBER) {
      // Local files are named either "./foo.c" or "foo.c"
      int skip = 0;
      if(buffer[1]=='.' && buffer[2]=='/') {
        skip = 2;
        buffer[2] = '"';
      }
      if(!buffer_initialized_p) {
        //if(strstr(buffer, ".h"))
        //fprintf(stderr, "Abnormal file name %s\n", buffer);
        buffer_initialized_p = true;
        C_line_number = initial_C_line_number;
        C_line_increment = 1;
        (void) strcpy(init_buffer, buffer+skip);
      }
      else if(same_string_p((string) (buffer+skip), (string) init_buffer)) {
        C_line_increment = 1;
        if(!compilation_unit_parser_is_running_p
              && C_line_number>initial_C_line_number) {
          int d = C_line_number-initial_C_line_number;
          remove_LFs_from_C_comment(d);
          C_line_number = initial_C_line_number;
        }
        else {
          /* Not to sure about this case */
          C_line_number = initial_C_line_number;
        }
      }
      else {
        /* The next lines have been imported from an included file.
         * Ignore information about include files, preserve the
         * current C_line_number.
         */
        C_line_increment = 0;
      }
    }
    else if(items==1) {
        /* Not to sure about this case: internal error? */
        C_line_number = initial_C_line_number;
    }
    else {
      // items==0
      pips_user_warning("No line number after a #: \"%s\".\n", line);
      CParserError("Ill. formated # pragma.\n");
    }
  }
  return C_line_number;
}

References buffer, buffer_initialized_p, C_line_increment, C_line_number, compilation_unit_parser_is_running_p, CParserError(), line, pips_debug, pips_user_warning, remove_LFs_from_C_comment(), and same_string_p.

Here is the call graph for this function:

c_parser_put_new_typedef()

void c_parser_put_new_typedef

(

const char *

name

)

Store named type for the lexical analyzer, which has to decide if a character string is the name of a type or the name of a variable.

See is_c_parser_keyword_typedef() in clex.l

Parameters

name

ame

Definition at line 1060 of file util.c.

{
  string s = get_c_parser_current_scope();
  string sname = string_undefined;
  if(same_string_p(s, ""))
    sname = strdup(name);
  else
    sname = strdup(concatenate(name,"%", s, NULL));
  hash_put(keyword_typedef_table, sname,(void *) TK_NAMED_TYPE);
  pips_debug(5, "Add typedef name %s to hash table\n",sname);
}

References concatenate(), get_c_parser_current_scope(), hash_put(), keyword_typedef_table, pips_debug, same_string_p, strdup(), string_undefined, and TK_NAMED_TYPE.

Referenced by FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

c_parser_user_warning_alist()

void c_parser_user_warning_alist	(	const char *	pips_func,
		const char *	pips_file,
		const int	pips_line,
		const char *	format,
		va_list *	args
	)

Compared to pips_user_warning(), the name of the calling function is lost, which does not help maintenance but generates more user-friendly messages.

util.c

Parser warning on C code synthesized by PIPS

Parameters

pips_func	ips_func
pips_file	ips_file
pips_line	ips_line
format	ormat
args	rgs

Definition at line 60 of file util.c.

{
  if (get_bool_property("NO_USER_WARNING"))
    return;
 
  // First and current line number in PIPS preprocessed file (ifn)
  string ifn = get_c_parser_current_input_file_name();
  int fln = get_previous_c_lineno();
  int uln = c_lineno;
  string ifn_src = safe_get_line_interval(ifn, fln, uln);
 
  // Previous and current line numbers, in user input file (uifn)
  // ??? string_undefined for pips generated code?
  string uifn =  get_c_parser_current_user_input_file_name();
  int pln = get_previous_C_line_number();
  int cln = get_current_C_line_number();
 
  // Do not print more than 10 lines: the beginning of the user
  // input C file may be full of includes and comments all
  // considered related to the first declaration.
  pips_assert("consistent line numbers", 1 <= pln && pln <= cln);
  if (pln < cln-9)
    pln = cln-9;
 
  string uifn_src = safe_get_line_interval(uifn, pln, cln);
 
  string more;
 
  asprintf(&more,
           "Source code after preprocessing:\n%s"
           "Input source code, before preprocessing:\n%s",
           ifn_src, uifn_src);
 
  pips_log_alist(warning_log,
                 get_pips_current_pass_name(), get_pips_current_module(),
                 (const string) pips_func, (const string) pips_file, pips_line,
                 NULL, uifn, pln, cln,
                 NULL, more, (const string) format, args);
 
  free(more);
 
  // else???
  /* Parser warning on C code synthesized by PIPS */
  // pips_internal_error("Some synthesized code raises a "
  // "C parser warning.\n");
}

References asprintf, c_lineno, free(), get_bool_property(), get_c_parser_current_input_file_name(), get_c_parser_current_user_input_file_name(), get_current_C_line_number(), get_pips_current_module(), get_pips_current_pass_name(), get_previous_C_line_number(), get_previous_c_lineno(), pips_assert, pips_log_alist(), safe_get_line_interval(), and warning_log.

Referenced by c_parser_user_warning_func().

Here is the call graph for this function:

Here is the caller graph for this function:

c_parser_user_warning_func()

void c_parser_user_warning_func	(	const char *	pips_func,
		const char *	pips_file,
		const int	pips_line,
		const char *	format,
			...
	)

Parameters

pips_func	ips_func
pips_file	ips_file
pips_line	ips_line
format	ormat

Definition at line 112 of file util.c.

{
  va_list args;
  va_start(args, format);
  c_parser_user_warning_alist(pips_func, pips_file, pips_line, format, &args);
  va_end(args);
}

References c_parser_user_warning_alist().

Here is the call graph for this function:

callnodeclfilter()

static bool callnodeclfilter ( call  c )

static

Here, there is no known dummy parameter entity... unless we build a default dummy parameter, using unique names such as v1, v2, v3,..

Definition at line 1822 of file util.c.

{
  entity e = call_function(c);
  if(value_code_p(entity_initial(e))) {
    if(!(gen_in_list_p(e, entity_declarations(get_current_module_entity()))
         || gen_in_list_p(e, entity_declarations(get_current_compilation_unit_entity()))))
      {
        // Implicit declaration of an external function: returns an int
        // Compute arguments type from call c
        type ot = entity_type(e);
        // Too bad we assume the old type is no good
        type rt = make_type(is_type_variable,
                            make_variable(make_basic(is_basic_int, (void *) DEFAULT_INTEGER_TYPE_SIZE),
                                          NIL,
                                          NIL));
        list ptl = NIL;
        list args = call_arguments(c);
        list carg = list_undefined;
        type ft = type_undefined;
 
        for(carg=args; !ENDP(carg); POP (carg)) {
          expression ce = EXPRESSION(CAR(carg));
          type ct = expression_to_user_type(ce);
          /* Here, there is no known dummy parameter entity... unless
             we build a default dummy parameter, using unique names such as v1, v2, v3,.. */
          parameter cp = make_parameter(ct, make_mode_value(), make_dummy_unknown());
 
          ptl = gen_nconc(ptl, CONS(PARAMETER, cp, NIL));
        }
        ft = make_type(is_type_functional, make_functional(ptl, rt));
 
        free_type(ot);
        entity_type(e) = ft;
 
        entity_declarations(get_current_module_entity()) =
          gen_nconc(entity_declarations(get_current_module_entity()), CONS(ENTITY, e, NIL));
        c_parser_user_warning("\n\nNo declaration of function %s in module %s\n"
                          "Implicit declaration added\n",
                          entity_user_name(e), get_current_module_name());
      }
  }
 
  return true;
}

References c_parser_user_warning, call_arguments, call_function, CAR, CONS, cp, DEFAULT_INTEGER_TYPE_SIZE, ENDP, ENTITY, entity_declarations, entity_initial, entity_type, entity_user_name(), EXPRESSION, expression_to_user_type(), free_type(), gen_in_list_p(), gen_nconc(), get_current_compilation_unit_entity(), get_current_module_entity(), get_current_module_name(), is_basic_int, is_type_functional, is_type_variable, list_undefined, make_basic(), make_dummy_unknown(), make_functional(), make_mode_value(), make_parameter(), make_type(), make_variable(), NIL, PARAMETER, POP, type_undefined, and value_code_p.

Referenced by nodecl_p().

Here is the call graph for this function:

Here is the caller graph for this function:

CCompilationUnitMemoryAllocation()

void CCompilationUnitMemoryAllocation

(

entity

module

)

Parameters

module

odule

Definition at line 1967 of file util.c.

{
  CCompilationUnitMemoryAllocations(module, true);
}

References CCompilationUnitMemoryAllocations(), and module.

Referenced by ResetCurrentCompilationUnitEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

CCompilationUnitMemoryAllocations()

void CCompilationUnitMemoryAllocations	(	entity	module,
		bool	first_p
	)

This function allocates the memory to the Current Compilation Unit.

Check that all variables used or defined are declared

Allocate variables

We are in trouble

check the type of variable here to avoid conflicting declarations

The C parser is no longer active when this warning is emitted. It is not possible to rely on its line numbers.

No way to know if a pointer is initialized or not

This may happen with variables such as "__morecore" which is a functional pointer to a malloc like function and which is declared in a header file.

It may or not be an error, depending on conflicting initializations or not. It seems better to leave this for gcc or clang to decide before running PIPS.

Do not modify the initial allocation

Do not allocate the memory for external variables: Set the offset of ram -2 which signifies UNKNOWN offset

Parameters

module	odule
first_p	irst_p

Definition at line 1881 of file util.c.

{
  list ld = entity_declarations(module);
  entity var = entity_undefined;
 
  pips_debug(8,"MEMORY ALLOCATION BEGINS\n");
 
  /* Check that all variables used or defined are declared */
  nodecl_p(module, ModuleStatement);
 
  /* Allocate variables */
  for(; !ENDP(ld); ld = CDR(ld)) {
    var = ENTITY(CAR(ld));
    if(!place_holder_variable_p(var) && type_variable_p(entity_type(var))) {
      storage s = entity_storage(var);
      type t = entity_type(var);
      type ut = ultimate_type(t);
 
      // Make sure that the ultimate type is variable */
      if(!type_variable_p(ut) && storage_ram_p(s)) {
        /* We are in trouble */
        pips_internal_error("Variable %s has not a variable type",
                            entity_user_name(var));
      }
 
      // Add some preconditions here
      if(storage_ram_p(s)) {
        ram r = storage_ram(s);
        entity a = ram_section(r);
        /* check the type of variable here to avoid conflicting declarations */
        // External variable list: evl
        list evl = code_externs(value_code(entity_initial(module)));
        if(!gen_in_list_p(var, evl)) {
          if(ram_offset(r) != UNDEFINED_RAM_OFFSET
             && ram_offset(r) != UNKNOWN_RAM_OFFSET
             && ram_offset(r) != DYNAMIC_RAM_OFFSET ) {
            if(first_p) {
              /* The C parser is no longer active when this warning is emitted.
               * It is not possible to rely on its line numbers.
               */
              // c_parser_user_warning
              pips_user_warning
                ("Multiple declarations of variable \"%s\" in different files\n",
                 entity_local_name(var));
              if(top_level_entity_p(a)
                 && (value_unknown_p(entity_initial(var))
                     /* No way to know if a pointer is initialized or
                        not */
                     ||value_code_p(entity_initial(var)))) {
                /* This may happen with variables such as
                   "__morecore" which is a functional pointer to a
                   malloc like function and which is declared in a
                   header file. */
                ;
              }
              else {
                // CParserError("Fix your source code!\n");
                /* It may or not be an error, depending on conflicting
                 * initializations or not. It seems better to leave
                 * this for gcc or clang to decide before running
                 * PIPS.
                 */
              }
              /* Do not modify the initial allocation */
              ;
            }
          }
          else {
            ram_offset(r) = area_size(type_area(entity_type(a)));
            add_C_variable_to_area(a,var);
          }
        }
        else {
          /* Do not allocate the memory for external variables:
             Set the offset of ram -2 which signifies UNKNOWN offset
          */
 
          // Check type here to avoid conflict declarations
          if(ram_offset(r) == UNKNOWN_RAM_OFFSET)
            ram_offset(r) = UNDEFINED_RAM_OFFSET;
        }
      }
    }
  }
}

References add_C_variable_to_area(), area_size, CAR, CDR, code_externs, DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_declarations, entity_initial, entity_local_name(), entity_storage, entity_type, entity_undefined, entity_user_name(), gen_in_list_p(), module, ModuleStatement, nodecl_p(), pips_debug, pips_internal_error, pips_user_warning, place_holder_variable_p(), ram_offset, ram_section, storage_ram, storage_ram_p, top_level_entity_p(), type_area, type_variable_p, ultimate_type(), UNDEFINED_RAM_OFFSET, UNKNOWN_RAM_OFFSET, value_code, value_code_p, and value_unknown_p.

Referenced by CCompilationUnitMemoryAllocation(), and CCompilationUnitMemoryReallocation().

Here is the call graph for this function:

Here is the caller graph for this function:

CCompilationUnitMemoryReallocation()

void CCompilationUnitMemoryReallocation

(

entity

module

)

Parameters

module

odule

Definition at line 1972 of file util.c.

{
  CCompilationUnitMemoryAllocations(module, false);
}

References CCompilationUnitMemoryAllocations(), and module.

Referenced by ResetCurrentCompilationUnitEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

check_declaration_uniqueness_p()

bool check_declaration_uniqueness_p

(

statement

s

)

This is designed for standard C functions, not for compilation units.

e must be a function: they can be declared several times

Definition at line 3540 of file util.c.

{
  list dl = statement_declarations(s);
  bool failure_p = false;
 
  FOREACH(ENTITY, e, dl) {
    int n = gen_occurences(e, dl);
    if(n>1) {
      /* e must be a function: they can be declared several times */
      type t = ultimate_type(entity_type(e));
 
      if(!type_functional_p(t)) {
        pips_debug(0, "Entity \"%s\" declared %d times.\n", entity_name(e), n);
        failure_p = true;
      }
    }
  }
  if(failure_p)
    pips_internal_error("Module declarations are not unique");
 
  return !failure_p;
}

References ENTITY, entity_name, entity_type, FOREACH, gen_occurences(), pips_debug, pips_internal_error, statement_declarations, type_functional_p, and ultimate_type().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckExternList()

bool CheckExternList

(

void

)

Definition at line 1025 of file util.c.

{
    entity f = get_current_module_entity();
    if(entity_undefined_p(f))
      pips_debug(5,"Current module is undefined\n");
    else {
      value fv = entity_initial(f);
      pips_debug(5,"Current module is function \"%s\"\n", entity_name(f));
      if(!value_undefined_p(fv)) {
        code fc = value_code(fv);
        if(!code_undefined_p(fc)) {
          list el = code_externs(fc);
          list le = gen_last(el);
          pips_debug(8, "Number of extern variables and functions: %zd\n",
                     gen_length(el));
          if(gen_length(el)>0) {
            pips_debug(8, "Last entity %s in cons %p with car=%p and cdr=%p\n",
                       entity_name(ENTITY(CAR(le))),
                       le,
                       &(le->car),
                       (void *) (le->cdr));
          }
          pips_assert("externs is an entity list", entity_list_p(el));
        }
      }
    }
    return true;
}

References cons::car, CAR, cons::cdr, code_externs, code_undefined_p, ENTITY, entity_initial, entity_list_p(), entity_name, entity_undefined_p, f(), gen_last(), gen_length(), get_current_module_entity(), pips_assert, pips_debug, value_code, and value_undefined_p.

Here is the call graph for this function:

CleanUpEntities()

void CleanUpEntities

(

list

le

)

update entity in module declarations

Update storage area

Update entity in current entity list

Remove entity from potentially removable externs and add it the new entity

Apparently, formal parameters may have been declared for such an entity and PIPS code dumps when the symbol table is written.

See decl62.c and decl63.c

Parameters

le

e

Definition at line 2772 of file util.c.

{
  list ce = list_undefined;
  bool found = false;
 
  for(ce=le; !ENDP(ce); POP(ce)) {
    entity e = ENTITY(CAR(ce));
    entity ne = CleanUpEntity(e);
    if(ne!=e) {
      entity m = get_current_module_entity();
      list d = code_declarations(value_code(entity_initial(m)));
      list de = list_undefined;
      storage s = entity_storage(e);
 
      /* update entity in module declarations */
      found = false;
      for(de=d; !ENDP(de); POP(de)) {
        entity ed = ENTITY(CAR(de));
        if(ed==e) {
          CAR(de).p = (gen_chunk *) ne;
          found = true;
        }
      }
      if(!found)
        pips_internal_error("Entity to be replaced not declared");
 
      /* Update storage area */
      found = false;
      if(storage_ram_p(s)) {
        ram r = storage_ram(s);
        entity a = ram_section(r);
        list ld = area_layout(type_area(entity_type(a)));
        list lde = list_undefined;
 
        for(lde=ld; !ENDP(lde); POP(lde)) {
          entity ed = ENTITY(CAR(lde));
          if(ed==e) {
            found = true;
            CAR(lde).p = (gen_chunk *) ne;
          }
        }
        if(!found)
          pips_internal_error("Entity to be replaced not allocated in its ram area");
      }
      else {
        pips_internal_error("Unexpected storage kind");
      }
 
      /* Update entity in current entity list */
      CAR(ce).p = (gen_chunk *) ne;
 
      /* Remove entity from potentially removable externs and add it
         the new entity */
      gen_remove(&removable_extern_entities, (void *) e);
      removable_extern_entities = CONS(ENTITY, ne, removable_extern_entities);
 
      /* Apparently, formal parameters may have been declared for such
       * an entity and PIPS code dumps when the symbol table is
       * written.
       *
       * See decl62.c and decl63.c
       */
      //free_entity(e);
    }
  }
}

References area_layout, CAR, CleanUpEntity(), code_declarations, CONS, ENDP, ENTITY, entity_initial, entity_storage, entity_type, gen_remove(), get_current_module_entity(), list_undefined, pips_internal_error, POP, ram_section, removable_extern_entities, storage_ram, storage_ram_p, type_area, and value_code.

Here is the call graph for this function:

CleanUpEntity()

static entity CleanUpEntity ( entity  e )

static

if returned entity != original entity, e must be freed, otherwise an invalid entity is still tabulated

The variable name is wrong

Entity e should be removed... but it's pretty dangerous.

let the caller do it

Definition at line 2745 of file util.c.

{
  entity ne = e;
  type et = entity_type(e);
  const char* eln = entity_local_name(e);
 
  if(static_module_name_p(eln) && !type_functional_p(et)) {
    /* The variable name is wrong */
    const char* neln = strstr(eln, FILE_SEP_STRING)+1;
    const char* emn = entity_module_name(e);
 
    ne = FindOrCreateEntity(emn, neln);
 
    entity_type(ne) = copy_type(entity_type(e));
    entity_storage(ne) = copy_storage(entity_storage(e));
    entity_initial(ne) = copy_value(entity_initial(e));
 
    pips_assert("entity has type variable", type_variable_p(et));
    pips_debug(1, "Entity %s should have a functional type\n", entity_name(e));
    pips_debug(1, "New Entity %s created\n", entity_name(ne));
    /* Entity e should be removed... but it's pretty dangerous. */
    /* let the caller do it */
  }
 
  return ne;
}

References copy_storage(), copy_type(), copy_value(), entity_initial, entity_local_name(), entity_module_name(), entity_name, entity_storage, entity_type, FILE_SEP_STRING, FindOrCreateEntity(), pips_assert, pips_debug, static_module_name_p(), type_functional_p, and type_variable_p.

Referenced by CleanUpEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

CModuleMemoryAllocation()

void CModuleMemoryAllocation

(

entity

module

)

This function is for MemoryAllocation for Module of C programs.

Parameters

module

odule

Definition at line 1979 of file util.c.

{
  list ld = entity_declarations(module);
  entity var = entity_undefined;
 
  pips_debug(8,"MEMORY ALLOCATION BEGINS\n");
  nodecl_p(module,ModuleStatement);
  //print_entities(ld);
  for(; !ENDP(ld); ld = CDR(ld))
    {
      var = ENTITY(CAR(ld));
 
      if(!place_holder_variable_p(var) && type_variable_p(entity_type(var)))
        {
          storage s = entity_storage(var);
          if(storage_ram_p(s))
            {
              ram r = storage_ram(s);
              entity a = ram_section(r);
              if(!gen_in_list_p(var, code_externs(value_code(entity_initial(module))))) {
                ram_offset(r) = area_size(type_area(entity_type(a)));
                if(a == StackArea)
                  ram_offset(r) = DYNAMIC_RAM_OFFSET;
                else
                  add_C_variable_to_area(a,var);
              }
              else{
                if(ram_offset(r) == UNKNOWN_RAM_OFFSET)
                ram_offset(r) = UNDEFINED_RAM_OFFSET;
              }
            }
          if(storage_formal_p(s))
            {
              //DO NOTHING
            }
        }
    }
}

References add_C_variable_to_area(), area_size, CAR, CDR, code_externs, DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_declarations, entity_initial, entity_storage, entity_type, entity_undefined, gen_in_list_p(), module, ModuleStatement, nodecl_p(), pips_debug, place_holder_variable_p(), ram_offset, ram_section, StackArea, storage_formal_p, storage_ram, storage_ram_p, type_area, type_variable_p, UNDEFINED_RAM_OFFSET, UNKNOWN_RAM_OFFSET, and value_code.

Referenced by ResetCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeAreaOffset()

int ComputeAreaOffset	(	entity	a,
		entity	v
	)

Update the size and layout of the area aa. This function is called too earlier, we may not have the size of v. To be changed !!!

FI: who wrote this? when should the offsets be computed? how do we deal with scoping?

area_size(aa) = offset + 0;

Definition at line 3324 of file util.c.

{
  type ta = entity_type(a);
  area aa = type_area(ta);
  int offset = area_size(aa);
 
  pips_assert("Not used", false);
 
  /* Update the size and layout of the area aa.
     This function is called too earlier, we may not have the size of v.
     To be changed !!!
 
     FI: who wrote this? when should the offsets be computed? how do we deal with
     scoping?
  */
 
  pips_assert("Type is correctly defined", CSafeSizeOfArray(v)!=0);
 
  /* area_size(aa) = offset + 0; */
  area_size(aa) = offset + CSafeSizeOfArray(v);
  area_layout(aa) = gen_nconc(area_layout(aa), CONS(ENTITY, v, NIL));
  return offset;
}

References area_layout, area_size, CONS, CSafeSizeOfArray(), ENTITY, entity_type, gen_nconc(), NIL, offset, pips_assert, and type_area.

Here is the call graph for this function:

CreateEntityFromLocalNameAndPrefix()

entity CreateEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix,
		bool	is_external
	)

We have to know the context:

• if the entity is declared outside any function, their scope is the CurrentCompilationUnit
• if the entity is declared inside a function, we have to know the CurrentBlock, which is omitted for the moment
• if the function is static, their scope is CurrentCompilationUnit::CurrentModule
• if the function is global, their scope is CurrentModule

The entity is created local to the file. For instance, derived and user-named types. This makes type checking more difficult as types such as FILE * vary from C file to C file, but this is consistent with the C standard and the behavior of production compilers: the same local name can be used for two different types in two different files.

These types are created globally, which makes type checking much easier but forbid homonym types in different files.

Parameters

name	ame
prefix	refix
is_external	s_external

Definition at line 962 of file util.c.

{
 /* We have to know the context:
 
    - if the entity is declared outside any function, their scope is
    the CurrentCompilationUnit
 
    - if the entity is declared inside a function, we have to know
    the CurrentBlock, which is omitted for the moment
 
    - if the function is static, their scope is
    CurrentCompilationUnit#CurrentModule
 
    - if the function is global, their scope is CurrentModule
 */
  entity ent = entity_undefined;
 
  if (is_external) {
    pips_debug(5,"Entity local name is %s with prefix %s\n",name,prefix);
    char *local_name;
    asprintf(&local_name,"%s%s",prefix,name);
    // See TRAC Ticket #787
#define FILE_LOCAL_USER_DEFINED_TYPES_P (true)
    if(FILE_LOCAL_USER_DEFINED_TYPES_P) {
      /* The entity is created local to the file. For instance,
       * derived and user-named types. This makes type checking more
       * difficult as types such as FILE * vary from C file to C file,
       * but this is consistent with the C standard and the behavior
       * of production compilers: the same local name can be used for
       * two different types in two different files. 
       */
      ent = FindOrCreateEntity(compilation_unit_name, local_name);
    }
    else {
      /* These types are created globally, which makes type checking
       * much easier but forbid homonym types in different files.
       */
      ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, local_name);
    }
    free(local_name);
  }
  else {
      string scope = scope_to_block_scope(GetScope());
 
      pips_debug(5,"Entity local name is %s with prefix %s and scope \"%s\"\n",
              name,prefix,scope);
      pips_assert("scope is a block scope", string_block_scope_p(scope));
 
      char * local_name;
      asprintf(&local_name,"%s%s%s",scope,prefix,name);
      if (static_module_p(get_current_module_entity())) {
          ent = FindOrCreateEntity( get_current_module_name(),  local_name);
      }
      else {
          ent = FindOrCreateEntity(get_current_module_name(), local_name);
      }
      free(local_name);
      free(scope);
  }
  pips_debug(5,"Entity global name is %s\n",entity_name(ent));
  return ent;
}

References asprintf, compilation_unit_name, entity_name, entity_undefined, FILE_LOCAL_USER_DEFINED_TYPES_P, FindOrCreateEntity(), free(), get_current_module_entity(), get_current_module_name(), GetScope(), is_external, local_name(), pips_assert, pips_debug, prefix, scope_to_block_scope(), static_module_p(), string_block_scope_p(), and TOP_LEVEL_MODULE_NAME.

Referenced by FindOrCreateCurrentEntity(), FindOrCreateEntityFromLocalNameAndPrefix(), FindOrCreateEntityFromLocalNameAndPrefixAndScope(), and MakeDerivedEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateMemberScope()

string CreateMemberScope	(	string	derived,
		bool	is_external
	)

We have to know the context :

• if the struct/union is declared outside any function, its scope is the CurrentCompilationUnit
• if the struct/union is declared inside a function, we have to know the CurrentBlock, which is omitted for the moment
• if the function is static, its scope is CurrentCompilationUnit!CurrentModule
• if the function is global, its scope is CurrentModule

The name of the struct/union is then added to the field entity name, with the MEMBER_SEP_STRING

ompilation_unit_name,

Parameters

derived	erived
is_external	s_external

Definition at line 3261 of file util.c.

{
  /* We have to know the context :
     - if the struct/union is declared outside any function, its scope is the CurrentCompilationUnit
     - if the struct/union is declared inside a function, we have to know the CurrentBlock,
     which is omitted for the moment
     - if the function is static, its scope is CurrentCompilationUnit!CurrentModule
     - if the function is global, its scope is CurrentModule
 
     The name of the struct/union is then added to the field entity name, with
     the MEMBER_SEP_STRING */
 
  string s = string_undefined;
 
  pips_debug(3,"Struc/union name is %s\n",derived);
 
  if (is_external)
    s = strdup(concatenate(compilation_unit_name, MODULE_SEP_STRING, derived, MEMBER_SEP_STRING, NULL));
  else {
    string scope = scope_to_block_scope(GetScope());
 
    pips_assert("scope is a block scope", string_block_scope_p(scope));
 
    if (static_module_p(get_current_module_entity()))
      s = strdup(concatenate(/*compilation_unit_name,*/
                             get_current_module_name(), MODULE_SEP_STRING,
                             scope, derived, MEMBER_SEP_STRING, NULL));
    else
      s = strdup(concatenate(get_current_module_name(), MODULE_SEP_STRING,
                             scope, derived, MEMBER_SEP_STRING, NULL));
  }
 
  pips_debug(3,"The struct/union member's scope is %s\n",s);
 
  return s;
}

References compilation_unit_name, concatenate(), get_current_module_entity(), get_current_module_name(), GetScope(), is_external, MEMBER_SEP_STRING, MODULE_SEP_STRING, pips_assert, pips_debug, scope_to_block_scope(), static_module_p(), strdup(), string_block_scope_p(), and string_undefined.

Here is the call graph for this function:

CreateReturnEntity()

void CreateReturnEntity

(

entity

f

)

If necessary, create the return entity, which is a hidden variable used in PIPS internal representation to carry the value returned by a function.

c_parser_user_warning() should not be called as it may be some times too late to get significant line numbers.

Create the return value

set the language

Definition at line 2382 of file util.c.

{
  if(type_undefined_p(entity_type(f))) {
    /* c_parser_user_warning() should not be called as it may be some
     * times too late to get significant line numbers.
     */
    c_parser_user_warning("Type of \"%s\" is undefined."
                          " Return value cannot be created.\n",
                          entity_user_name(f));
  }
  else {
    type ft = ultimate_type(entity_type(f));
 
    pips_debug(8, "For module \"%s\"\n", entity_name(f));
 
    if(type_functional_p(ft)) {
      type rt = functional_result(type_functional(ft));
 
      if(type_undefined_p(rt)) {
        c_parser_user_warning("Return type of \"%s\" is undefined."
                              " Return value cannot be created.\n",
                              entity_user_name(f));
      }
      else if(!type_void_p(rt)) {
        /* Create the return value */
        const char* fn = entity_local_name(f);
        entity re = FindOrCreateEntity(fn,fn);
        if(type_undefined_p(entity_type(re))) {
          entity_type(re) = copy_type(rt);
          entity_storage(re) = make_storage_return(f);
          /* set the language */
          entity_initial(re) = make_value_unknown();
          AddToDeclarations(re, f);
        }
      }
    }
    else
      pips_internal_error("This function should only be called with a function entity");
  }
}

References AddToDeclarations(), c_parser_user_warning, copy_type(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_user_name(), f(), FindOrCreateEntity(), functional_result, make_storage_return(), make_value_unknown(), pips_debug, pips_internal_error, type_functional, type_functional_p, type_undefined_p, type_void_p, and ultimate_type().

Referenced by UpdateEntity(), and UpdateEntity2().

Here is the call graph for this function:

Here is the caller graph for this function:

FindEntityFromLocalName()

entity FindEntityFromLocalName

(

string

name

)

Find an entity from its local name. We have to look for all possible prefixes, which are: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX

How about multiple results ? The order of prefixes ?

Is it a static function? It must have been parsed in the compilation unit

Parameters

name

ame

Definition at line 778 of file util.c.

{
  /* Find an entity from its local name.
     We have to look for all possible prefixes, which are:
     blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX
 
     How about multiple results ? The order of prefixes ?  */
 
  entity ent = entity_undefined;
  string prefixes[] = {"",STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX,NULL};
  int i;
  //c_parser_context cpc = GetScope();
  //string scope = scope_to_block_scope(c_parser_context_scope(cpc));
 
  for (i=0; prefixes[i]!=NULL; i++)
    {
      if ((ent = FindEntityFromLocalNameAndPrefix(name,prefixes[i])) != entity_undefined)
        return ent;
    }
 
  if(entity_undefined_p(ent)) {
    /* Is it a static function? It must have been parsed in the compilation unit */
    string sname = strdup(concatenate(compilation_unit_name, name, NULL));
    ent = FindEntity(compilation_unit_name, sname);
    free(sname);
    return ent;
  }
 
  c_parser_user_warning("Cannot find entity %s\n", name);
 
  return entity_undefined;
}

References c_parser_user_warning, compilation_unit_name, concatenate(), entity_undefined, entity_undefined_p, ENUM_PREFIX, FindEntity(), FindEntityFromLocalNameAndPrefix(), free(), prefixes, strdup(), STRUCT_PREFIX, TYPEDEF_PREFIX, and UNION_PREFIX.

Referenced by IdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

FindEntityFromLocalNameAndPrefix()

entity FindEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix
	)

Find an entity from its local name and prefix. We have to look from the most enclosing scope.

Possible name combinations and the looking order:

1. FILE!MODULE:BLOCKPREFIXname or MODULE:BLOCKPREFIXname
2. FILE!MODULE:PREFIXname or MODULE:PREFIXname
3. FILE!:PREFIXname (used to be FILE!PREFIXname)
4. TOP-LEVEL:PREFIXname

with 5 possible prefixes: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX

"!" is FILE_SEP_STRING and ":" is MODULE_SEP_STRING and "`" is BLOCK_SEP_STRING

First, look up the surrounding scopes

Is it a formal parameter not yet converted in the function frame?

Should we change the current dummy parameter number?

Is it a static variable declared in the compilation unit?

we have an issue there : a static function will be declared FILE!MODULE:FILE!name, but a static variable will be declared FILE!MODULE:name so try both ... CleanupEntity has been fixed to remove buggy situations ...

Is it a global variable declared in the compilation unit?

Is it a local type used within a function declaration?

It may be a parser error or a normal behavior when an entity is used before it is defined as, for example, a struct in a typedef: typedef struct foo foo;

CParserError("Variable appears to be undefined\n");

Parameters

name	ame
prefix	refix

Definition at line 877 of file util.c.

{
  /* Find an entity from its local name and prefix.
     We have to look from the most enclosing scope.
 
     Possible name combinations and the looking order:
 
     1. FILE!MODULE:BLOCK`PREFIXname or MODULE:BLOCK`PREFIXname
     2. FILE!MODULE:PREFIXname or MODULE:PREFIXname
     3. FILE!:PREFIXname (used to be FILE!PREFIXname)
     4. TOP-LEVEL:PREFIXname
 
     with 5 possible prefixes: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX
 
     "!" is FILE_SEP_STRING and ":" is MODULE_SEP_STRING and "`" is BLOCK_SEP_STRING
 */
 
  entity ent = entity_undefined;
  string global_name = string_undefined;
  string scope = scope_to_block_scope(GetScope());
  string ls = strdup(scope);
  string ls_head = ls;
 
  pips_debug(5,"Entity local name is \"%s\" with prefix \"%s\" and scope \"%s\"\n",
             name,prefix,scope);
  pips_assert("Scope is a block scope", string_block_scope_p(scope));
  free(scope);
 
  /* First, look up the surrounding scopes */
  ent = FindEntityFromLocalNameAndPrefixAndScope(name, prefix, ls);
 
  /* Is it a formal parameter not yet converted in the function frame? */
  if(entity_undefined_p(ent)) {
    /* Should we change the current dummy parameter number? */
    string sn = int2a(get_current_dummy_parameter_number());
 
    global_name = (concatenate(DUMMY_PARAMETER_PREFIX,sn,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
    free(sn);
  }
 
  /* Is it a static variable declared in the compilation unit? */
  /* we have an issue there : a static function will be declared  FILE!MODULE:FILE!name,
   * but a static variable will be declared FILE!MODULE:name
   * so try both ... CleanupEntity has been fixed to remove buggy situations ...*/
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(compilation_unit_name,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(compilation_unit_name,MODULE_SEP_STRING,compilation_unit_name,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
 
  /* Is it a global variable declared in the compilation unit? */
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(TOP_LEVEL_MODULE_NAME,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
 
  /* Is it a local type used within a function declaration? */
  if(entity_undefined_p(ent) && strcmp(ls, "")==0 && ScopeStackSize()>=2) {
    string lls = strdup(scope_to_block_scope(GetParentScope()));
    ent = FindEntityFromLocalNameAndPrefixAndScope(name, prefix, lls);
    free(lls);
  }
 
  if(entity_undefined_p(ent)) {
    pips_debug(8, "Cannot find entity with local name \"%s\" with prefix \"%s\" at line %d\n",
               name, prefix, get_current_C_line_number());
    /* It may be a parser error or a normal behavior when an entity is
       used before it is defined as, for example, a struct in a typedef:
       typedef struct foo foo; */
    /* CParserError("Variable appears to be undefined\n"); */
  } else
    pips_debug(5,"Entity global name is %s\n",entity_name(ent));
  //free(global_name);
  free(ls_head);
  return ent;
}

References compilation_unit_name, concatenate(), DUMMY_PARAMETER_PREFIX, entity_domain, entity_name, entity_undefined, entity_undefined_p, FindEntityFromLocalNameAndPrefixAndScope(), free(), gen_find_tabulated(), get_current_C_line_number(), get_current_dummy_parameter_number(), GetParentScope(), GetScope(), int2a(), MODULE_SEP_STRING, pips_assert, pips_debug, prefix, scope_to_block_scope(), ScopeStackSize(), strdup(), string_block_scope_p(), string_undefined, and TOP_LEVEL_MODULE_NAME.

Referenced by FindEntityFromLocalName(), FindOrCreateEntityFromLocalNameAndPrefix(), and FindOrCreateEntityFromLocalNameAndPrefixAndScope().

Here is the call graph for this function:

Here is the caller graph for this function:

FindEntityFromLocalNameAndPrefixAndScope()

entity FindEntityFromLocalNameAndPrefixAndScope	(	string	name,
		string	prefix,
		string	scope
	)

The parameter "scope" is potentially destroyed.

Add block scope case here

ompilation_unit_name,

return values are not C variables... but they are entities.

Parameters

name	ame
prefix	refix
scope	cope

Definition at line 850 of file util.c.

{
  entity ent = entity_undefined;
 
  if (!entity_undefined_p(get_current_module_entity())) {
    string global_name = string_undefined;
    /* Add block scope case here */
    do {
      if (static_module_p(get_current_module_entity()))
        global_name = (concatenate(/*compilation_unit_name,*/
                                         get_current_module_name(),MODULE_SEP_STRING,
                                         scope,prefix,name,NULL));
      else
        global_name = (concatenate(get_current_module_name(),MODULE_SEP_STRING,
                                         scope,prefix,name,NULL));
      ent = gen_find_tabulated(global_name,entity_domain);
      /* return values are not C variables... but they are entities. */
      if(!entity_undefined_p(ent)
         && !storage_undefined_p(entity_storage(ent))
         && storage_return_p(entity_storage(ent))) {
        ent = entity_undefined;
      }
    } while(entity_undefined_p(ent) && (scope = pop_block_scope(scope))!=NULL);
  }
  return ent;
}

References concatenate(), entity_domain, entity_storage, entity_undefined, entity_undefined_p, gen_find_tabulated(), get_current_module_entity(), get_current_module_name(), MODULE_SEP_STRING, pop_block_scope(), prefix, static_module_p(), storage_return_p, storage_undefined_p, and string_undefined.

Referenced by FindEntityFromLocalNameAndPrefix().

Here is the call graph for this function:

Here is the caller graph for this function:

FindOrCreateCurrentEntity()

entity FindOrCreateCurrentEntity	(	string	name,
		stack ContextStack	__attribute__(__unused__),
		stack	FormalStack,
		stack	FunctionStack,
		bool	is_external
	)

This function finds or creates the current entity.

Only entity full name is created, other fields such as type, storage and initial value are undefined.

function is only used for formal variables

Tell the lexer about the new type names : add to keyword_typedef_table. Because of scopes, different types can have the same name...

Prefix for the current struct: use full_scope

Maybe it would have been better to push "external" in the context

&& strstr(scope,TOP_LEVEL_MODULE_NAME) != NULL

This entity is declared in a compilation unit with keyword EXTERN. Add it to the storage of the compilation unit to help code prettyprint unless if has already been declared earlier in the current compilation unit. See C_syntax/global_extern.c

ent has not been declared earlier

A global entity may already have been seen in a previous compilation unit and so it is already typed but still must be declared as extern. See test case C_syntax/declarations.c

The bad news is: function are not yet fully typed when this is executed and their type is "variable", the future result type; hence, they are declared "extern" no matter what... Do we want to clean up the code_externs list later since the extern keyword is useless for functions? No other simple solution found...

FI: The test above may be stronger than the previous one, but I'm pretty conservative when dealing with the parser.

This variable is declared extern within a function body.

Impossible: this is not detected here

This entity may have already been declared external but is redeclared inside the same module. See C_syntax/global_extern.c

Formal parameter for a function declaration or for a function definition or for a pointer to a function or for a functional typedef

It is too early to define formal parameters. Let's start with dummy parameters

scope = NULL, not extern/typedef/struct/union/enum

This is a variable/function declared outside any module's body

If it is a function, we'd like to increase its name. If it's a variable, we'd like not to increase its name with the compilation unit name. But we do not have much information here to make the decision. Let's assume it's a function and postpone to UpdateEntity()

Depending on the type, we should or not introduce a MODULE_SEP_STRING, but the type is still not fully known. Wait for UpdateFunctionEntity().

We may have to remove it from the extern list: C_syntax/global_extern01.c

code_externs(value_code(entity_initial(com_unit))) =

arguments_rm_entity(el, ent);

This is a variable/function declared inside a module's body: add block scope here Attention, the scope of a function declared in module is the module, not global.

The module name is unambiguous because it is used by pipdbm

FI: why is ct not exploited? Because the information is later destroyed. I guess it is related to the type_stack stored in the entity_ initial field.

entity_type(ent) = copy_type(ct);

Definition at line 1088 of file util.c.

{
  entity ent;
  c_parser_context context = GetContext();
  string full_scope = c_parser_context_scope(context);
  string scope = strrchr(full_scope, BLOCK_SEP_CHAR);
  string block_scope = scope_to_block_scope(full_scope);
  type ct = c_parser_context_type(context);
  bool is_typedef = c_parser_context_typedef(context);
  bool is_static = c_parser_context_static(context);
  entity function = entity_undefined;
  bool is_formal;
 
  if(scope!=NULL)
    scope++;
  else {
    scope = full_scope;
  }
 
  if(!string_block_scope_p(block_scope)) {
    pips_assert("block_scope is TOP-LEVEL:", same_string_p(block_scope, "TOP-LEVEL:"));
    free(block_scope);
    block_scope = empty_scope();
  }
 
  if (stack_undefined_p(FormalStack) || stack_empty_p(FormalStack))
    is_formal = false;
  else {
    is_formal= true;
    function = stack_head(FunctionStack);
  }
 
  ifdebug(5) {
    entity f = get_current_module_entity();
    if(entity_undefined_p(f))
      pips_debug(5,"Entity local name \"%s\"\n",name);
    else {
      value fv = entity_initial(f);
      pips_debug(5,"Entity local name \"%s\" in function \"%s\"\n",name, entity_name(f));
      if(!value_undefined_p(fv)) {
        code fc = value_code(fv);
        if(!code_undefined_p(fc)) {
          list el = code_externs(fc);
          pips_assert("externs is an entity list", entity_list_p(el));
        }
      }
    }
    pips_debug(5,"Context %p\n",context);
    if (full_scope != NULL) {
      pips_debug(5,"Current scope: \"%s\"\n",full_scope);
      pips_debug(5,"Local declaration scope: \"%s\"\n",scope);
      pips_debug(5,"Block scope: \"%s\"\n",block_scope);
      pips_assert("block_scope is a block scope", string_block_scope_p(block_scope));
    }
    pips_debug(5,"type %p: %s\n", ct, list_to_string(safe_c_words_entity(ct, NIL)));
    pips_debug(5,"is_typedef: %d\n",is_typedef);
    pips_debug(5,"is_static: %d\n",is_static);
    pips_debug(5,"is_external: %d\n",is_external);
    pips_debug(5,"is_formal: %d\n",is_formal);
    if (is_formal)
      pips_debug(5,"of current function %s\n",entity_user_name(function));
    /* function is only used for formal variables*/
  }
 
  if (is_typedef)
    {
      /* Tell the lexer about the new type names : add to
         keyword_typedef_table. Because of scopes, different types
         can have the same name... */
      c_parser_put_new_typedef(name);
      /*
      hash_put(keyword_typedef_table,strdup(name),(void *) TK_NAMED_TYPE);
      pips_debug(5,"Add typedef name %s to hash table\n",name);
      */
      ent = CreateEntityFromLocalNameAndPrefix(name,TYPEDEF_PREFIX,is_external);
    }
  else
    {
      if (strcmp(scope,"") != 0 && !is_formal)
        {
          /* Prefix for the current struct: use full_scope */
        char * mname = strdup(module_name(full_scope));
        char * tname = name;
        asprintf(&name,"%s%s",local_name(full_scope),name);
        ent = FindOrCreateEntity(mname,name);
        free(mname);free(tname);
          if (is_external
              && !member_entity_p(ent) /* Maybe it would have been
                                          better to push "external" in
                                          the context */
              /* && strstr(scope,TOP_LEVEL_MODULE_NAME) != NULL*/ )
            {
              /* This entity is declared in a compilation unit with
                 keyword EXTERN. Add it to the storage of the
                 compilation unit to help code prettyprint unless if
                 has already been declared earlier in the current
                 compilation unit. See C_syntax/global_extern.c */
              entity com_unit = get_current_compilation_unit_entity();
              code c = value_code(entity_initial(com_unit));
              list el = code_externs(c);
              if(type_undefined_p(entity_type(ent))
                 || intrinsic_entity_p(ent)) {
                /* ent has not been declared earlier */
                //ram_shared(storage_ram(entity_storage(com_unit))) =
                //gen_nconc(ram_shared(storage_ram(entity_storage(com_unit))), CONS(ENTITY,ent,NIL));
                pips_debug(8, "Variable \"%s\" added to external declarations of \"%s\"\n",
                           entity_name(ent), entity_name(com_unit));
                pips_assert("ent is an entity", entity_domain_number(ent)==entity_domain);
                pips_assert("com_unit is an entity", entity_domain_number(com_unit)==entity_domain);
                pips_assert("el is a pure entity list", entity_list_p(el));
                //code_externs(c) = gen_nconc(el,
                //CONS(ENTITY,ent,NIL));
                AddToExterns(ent, com_unit);
                el = code_externs(value_code(entity_initial(com_unit)));
                pips_assert("el is a pure entity list", entity_list_p(el));
              }
              else if(!gen_in_list_p(ent, el)
                      && !type_undefined_p(entity_type(ent))
                      && !type_functional_p(entity_type(ent))) {
                /* A global entity may already have been seen in a
                   previous compilation unit and so it is already
                   typed but still must be declared as extern. See
                   test case C_syntax/declarations.c */
                /* The bad news is: function are not yet fully typed
                   when this is executed and their type is "variable",
                   the future result type; hence, they are declared
                   "extern" no matter what... Do we want to clean up
                   the code_externs list later since the extern
                   keyword is useless for functions? No other simple
                   solution found... */
                /* FI: The test above may be stronger than the previous one,
                   but I'm pretty conservative when dealing with the
                   parser. */
                AddToExterns(ent, com_unit);
              }
            }
          else if(strstr(full_scope,TOP_LEVEL_MODULE_NAME)!=NULL) {
            if(!compilation_unit_entity_p(function=get_current_module_entity()))
              if(type_undefined_p(entity_type(ent))
                 || !type_functional_p(entity_type(ent))) {
                /* This variable is declared extern within a function
                   body. */
                AddToExterns(ent, function);
              }
          }
          else {
            /* Impossible: this is not detected here  */
            /* This entity may have already been declared external but
               is redeclared inside the same module. See
               C_syntax/global_extern.c */
            /*
              entity com_unit = get_current_compilation_unit_entity();
              list el = code_externs(value_code(entity_initial(com_unit)));
              if(entity_is_argument_p(ent, el))
                code_externs(value_code(entity_initial(com_unit))) =
                  arguments_rm_entity(el, ent);
            */
          }
        }
      else
        {
          if (is_formal) {
            /* Formal parameter for a function declaration or for a
               function definition or for a pointer to a function or
               for a functional typedef */
            stack st = get_from_entity_type_stack_table(function);
            type ft = stack_undefined_p(st)? type_undefined : (type)stack_head(st);
 
            if(typedef_entity_p(function)) {
              // To get a unique identifier for each function typedef
              set_current_dummy_parameter_number((_int) ft);
          char * module_name;
          asprintf(&module_name,DUMMY_PARAMETER_PREFIX"%d",get_current_dummy_parameter_number());
 
              ent = FindOrCreateEntity(module_name,name);
              free(module_name);
            }
            else if(!type_undefined_p(ft) && type_variable_p(ft)
                && basic_pointer_p(variable_basic(type_variable(ft)))) {
 
              // To get a unique identifier for each function pointerdeclaration, dummy or not
              set_current_dummy_parameter_number((_int) ft);
          char * module_name;
          asprintf(&module_name,DUMMY_PARAMETER_PREFIX"%d",get_current_dummy_parameter_number());
 
              ent = FindOrCreateEntity(module_name,name);
              free(module_name);
            }
            else {
              /* It is too early to define formal parameters. Let's start with dummy parameters */
              // To get a unique identifier for each function (This
              // may not be sufficient as a function can be declared
              // any number of times with any parameter names)
              set_current_dummy_parameter_number((_int) function);
          char * module_name;
          asprintf(&module_name,DUMMY_PARAMETER_PREFIX"%d",get_current_dummy_parameter_number());
              ent = FindOrCreateEntity(module_name,name);
              free(module_name);
              /*
              if(top_level_entity_p(function))
                ent = find_or_create_entity(strdup(concatenate(entity_user_name(function),
                                                               MODULE_SEP_STRING,name,NULL)));
              else {
                // The function is local to a compilation unit
                // Was this the best possible design?
                string mn = entity_module_name(function);
                string ln = entity_local_name(function);
                ent = find_or_create_entity(strdup(concatenate(mn,ln,
                                                               MODULE_SEP_STRING,name,NULL)));
              }
              */
            }
          }
          else
            {
              /* scope = NULL, not extern/typedef/struct/union/enum  */
              if (is_external)
                {
                  /* This is a variable/function declared outside any module's body*/
            if (is_static) {
                /* If it is a function, we'd like to increase its
                   name. If it's a variable, we'd like not to
                   increase its name with the compilation unit
                   name. But we do not have much information here to
                   make the decision. Let's assume it's a function
                   and postpone to UpdateEntity() */
                /* Depending on the type, we should or not
                   introduce a MODULE_SEP_STRING, but the type is
                   still not fully known. Wait for UpdateFunctionEntity(). */
                char * local_name;
                asprintf(&local_name,"%s%s",compilation_unit_name,name);
                ent = FindOrCreateEntity(compilation_unit_name,local_name);
                free(local_name);
            }
                  else {
                    /* We may have to remove it from the extern list:
                       C_syntax/global_extern01.c */
                    ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,name);
                    entity com_unit = get_current_compilation_unit_entity();
                    list el = code_externs(value_code(entity_initial(com_unit)));
                    if(entity_is_argument_p(ent, el)) {
                      type ent_t = entity_type(ent);
                      if(!type_undefined_p(ent_t) && !type_functional_p(ent_t))
                        /* code_externs(value_code(entity_initial(com_unit))) = */
                        /*   arguments_rm_entity(el, ent); */
                        RemoveFromExterns(ent);
                    }
                  }
                }
              else
                {
                  /* This is a variable/function declared inside a module's body: add block scope here
                     Attention, the scope of a function declared in module is the module, not global.*/
              char * local_name;
              asprintf(&local_name,"%s%s",block_scope,name);
                  if (static_module_p(get_current_module_entity()))
              /* The module name is unambiguous because it is used by pipdbm */
              ent = FindOrCreateEntity(get_current_module_name(),local_name);
          else 
              ent = FindOrCreateEntity(get_current_module_name(),local_name);
          free(local_name);
                  /* FI: why is ct not exploited? Because the
                     information is later destroyed. I guess it is
                     related to the type_stack stored in the entity_
                     initial field. */
                  /* entity_type(ent) = copy_type(ct); */
                }
            }
        }
    }
  pips_debug(5,"Entity global name \"%s\"\n\n",entity_name(ent));
  free(block_scope);
  return ent;
}

References AddToExterns(), asprintf, basic_pointer_p, BLOCK_SEP_CHAR, c_parser_context_scope, c_parser_context_static, c_parser_context_type, c_parser_context_typedef, c_parser_put_new_typedef(), code_externs, code_undefined_p, compilation_unit_entity_p(), compilation_unit_name, CreateEntityFromLocalNameAndPrefix(), DUMMY_PARAMETER_PREFIX, empty_scope(), entity_domain, entity_domain_number, entity_initial, entity_is_argument_p(), entity_list_p(), entity_name, entity_type, entity_undefined, entity_undefined_p, entity_user_name(), f(), FindOrCreateEntity(), FormalStack, free(), FunctionStack, gen_in_list_p(), get_current_compilation_unit_entity(), get_current_dummy_parameter_number(), get_current_module_entity(), get_current_module_name(), get_from_entity_type_stack_table(), GetContext(), ifdebug, intrinsic_entity_p(), is_external, list_to_string(), local_name(), member_entity_p(), module_name(), NIL, pips_assert, pips_debug, RemoveFromExterns(), safe_c_words_entity(), same_string_p, scope_to_block_scope(), set_current_dummy_parameter_number(), stack_empty_p(), stack_head(), stack_undefined_p, static_module_p(), strdup(), string_block_scope_p(), TOP_LEVEL_MODULE_NAME, type_functional_p, type_undefined, type_undefined_p, type_variable, type_variable_p, typedef_entity_p(), TYPEDEF_PREFIX, value_code, value_undefined_p, and variable_basic.

Here is the call graph for this function:

FindOrCreateEntityFromLocalNameAndPrefix()

entity FindOrCreateEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix,
		bool	is_external
	)

Parameters

name	ame
prefix	refix
is_external	s_external

Definition at line 811 of file util.c.

{
  entity e;
 
  if ((e = FindEntityFromLocalNameAndPrefix(name,prefix)) != entity_undefined)
    return e;
  return CreateEntityFromLocalNameAndPrefix(name,prefix,is_external);
}

References CreateEntityFromLocalNameAndPrefix(), entity_undefined, FindEntityFromLocalNameAndPrefix(), is_external, and prefix.

Here is the call graph for this function:

FindOrCreateEntityFromLocalNameAndPrefixAndScope()

entity FindOrCreateEntityFromLocalNameAndPrefixAndScope	(	string	name,
		string	prefix,
		string	scope,
		bool	is_external
	)

The current scope will be automatically added

Parameters

name	ame
prefix	refix
scope	cope
is_external	s_external

Definition at line 820 of file util.c.

{
  entity e = entity_undefined;
  string ls = strdup(scope);
  string ls_head = ls;
 
  pips_assert("Should not be used", false);
 
  pips_assert("scope is a block scope", string_block_scope_p(scope));
 
  do {
    string sname = strdup(concatenate(ls, name, NULL));
    e = FindEntityFromLocalNameAndPrefix(sname,prefix);
    free(sname);
  }
  while(e != entity_undefined && (ls = pop_block_scope(ls)));
 
  if(entity_undefined_p(e)) {
    /* The current scope will be automatically added */
    e = CreateEntityFromLocalNameAndPrefix(name,prefix,is_external);
  }
  free(ls_head);
  pips_debug(8, "Entity returned: \"%s\"\n", entity_name(e));
  return e;
}

References concatenate(), CreateEntityFromLocalNameAndPrefix(), entity_name, entity_undefined, entity_undefined_p, FindEntityFromLocalNameAndPrefix(), free(), is_external, pips_assert, pips_debug, pop_block_scope(), prefix, strdup(), and string_block_scope_p().

Here is the call graph for this function:

FindParameterEntity()

parameter FindParameterEntity	(	string	s,
		int	offset,
		list	l
	)

to be verified in C, when by reference, when by value

Parameters

offset

ffset

Definition at line 3384 of file util.c.

{
  FOREACH(ENTITY,e,l)
  {
    const char* name = entity_user_name(e);
    if (strcmp(name,s)==0)
      {
        type t = entity_type(e);
        mode m = make_mode_value(); /* to be verified in C, when by reference, when by value*/
        /*
          What about the storage of
 
          void AMMPmonitor( vfs,ffs,nfs,op )
          int  (*vfs[])(),(*ffs[])();
          int nfs;
          FILE *op;*/
 
        storage st = entity_storage(e);
        if (storage_formal_p(st))
          {
            formal f = storage_formal(st);
            formal_offset(f) = offset;
          }
        return make_parameter(t,m,make_dummy_identifier(e)); // FI: Could be entity_undefined
      }
  }
  return parameter_undefined;
}

References ENTITY, entity_storage, entity_type, entity_user_name(), f(), FOREACH, formal_offset, make_dummy_identifier(), make_mode_value(), make_parameter(), offset, parameter_undefined, storage_formal, and storage_formal_p.

Referenced by MakeParameterList().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_compilation_unit_entity()

entity get_current_compilation_unit_entity

(

void

)

Definition at line 320 of file util.c.

{
  return FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,compilation_unit_name);
}

References compilation_unit_name, FindOrCreateEntity(), and TOP_LEVEL_MODULE_NAME.

Referenced by callnodeclfilter(), FindOrCreateCurrentEntity(), MakeFunctionExpression(), MakeStorageRam(), and referencenodeclfilter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_dummy_parameter_number()

static int get_current_dummy_parameter_number ( void  )

static

Definition at line 147 of file util.c.

{return current_dummy_parameter_number;}

References current_dummy_parameter_number.

Referenced by FindEntityFromLocalNameAndPrefix(), and FindOrCreateCurrentEntity().

Here is the caller graph for this function:

get_top_level_entity()

entity get_top_level_entity

(

void

)

Definition at line 152 of file util.c.

{
  return FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,TOP_LEVEL_MODULE_NAME);
}

References FindOrCreateEntity(), and TOP_LEVEL_MODULE_NAME.

Referenced by MakeStorageRam(), and step_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

IdentifierToExpression()

expression IdentifierToExpression

(

string

s

)

Could this be non declared variables ?

This identifier has not been passed by the parser. It is probably a function call => try this case now and complete others later. The scope of this function is global

This may be a call or a reference in case a functional pointer is initialized

eturn MakeNullaryCall(ent);

FI: This may happen when a variable is used to initialize another variable within the same declaration statement: see decl29.c. This might not be a general fix as the type could be functional: to be checked. But setting up type earlier would require a huge change in the parser rules. Unless FindOrCreateCurrentEntity() could do a better job? But the information added is later destroyed by the parser.

Generate a call to an enum member

Definition at line 650 of file util.c.

{
  entity ent = FindEntityFromLocalName(s);
  expression exp = expression_undefined;
 
  pips_debug(5,"Identifier is \"%s\" and entity_name is \"\%s\"\n",
             s, safe_entity_name(ent));
 
  if (entity_undefined_p(ent)) {
      /* Could this be non declared variables ?*/
      /* This identifier has not been passed by the parser.
         It is probably a function call => try this case now and complete others later.
         The scope of this function is global */
      pips_debug(5,"Create unparsed global function: %s\n",s);
      ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,s);
      //entity_storage(ent) = make_storage_return(ent);
      entity_storage(ent) = make_storage_rom();
      entity_type(ent) = make_type_functional(make_functional(NIL,make_type_unknown()));
      entity_initial(ent) = make_value(is_value_code,make_code(NIL,strdup(""),make_sequence(NIL),NIL, make_language_c()));
      /* This may be a call or a reference in case a functional pointer is initialized */
      exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),normalized_undefined);
      /*return MakeNullaryCall(ent);*/
    }
  else if(type_undefined_p(entity_type(ent))) {
    /* FI: This may happen when a variable is used to initialize another
       variable within the same declaration statement: see
       decl29.c. This might not be a general fix as the type could be
       functional: to be checked. But setting up type earlier would require a huge
       change in the parser rules. Unless FindOrCreateCurrentEntity()
       could do a better job? But the information added is later
       destroyed by the parser. */
    exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),
                          normalized_undefined);
  }
  else {
    switch (type_tag(entity_type(ent))) {
    case is_type_variable:
    case is_type_functional:
      {
        value iv = entity_initial(ent);
 
        if(!value_undefined_p(iv) && value_symbolic_p(iv))
          /* Generate a call to an enum member */
          exp = make_expression(make_syntax_call(make_call(ent, NIL)), normalized_undefined);
        else
      exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),
                                               normalized_undefined);
 
        break;
      }
    default:
      {
        CParserError("Which kind of expression?\n");
      }
    }
  }
  return exp;
}

References CParserError(), entity_initial, entity_storage, entity_type, entity_undefined_p, exp, expression_undefined, FindEntityFromLocalName(), FindOrCreateEntity(), is_type_functional, is_type_variable, is_value_code, make_call(), make_code(), make_expression(), make_functional(), make_language_c(), make_reference(), make_sequence(), make_storage_rom(), make_syntax_call(), make_syntax_reference(), make_type_functional(), make_type_unknown(), make_value(), NIL, normalized_undefined, pips_debug, safe_entity_name(), strdup(), TOP_LEVEL_MODULE_NAME, type_tag, type_undefined_p, value_symbolic_p, and value_undefined_p.

Referenced by MemberDerivedIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

init_c_areas()

void init_c_areas

(

void

)

In C we have 4 areas.

1. globalStaticArea: For the Global Variables, these variables are added into StaticArea.
2. moduleStaticArea: For the Static module variables
3. localStaticArea(SticArea): General Static variables
4. DynamicArea The GlobalStaticArea and ModuleStaticArea are basically static areas but they are not defined globally. It is to be added to the Declarations for C

Create a hidden pointer in the heap area to modelize malloc and free effects and to keep track of the corresponding abstract state.

FI: I use a complex type to avoid seeing this variable in the transformers and preconditions... OK, it's not a clean way to do it. Should we create another area to allocate this abstract heap state?

FI: I keep the code below, because it may turn useful again if context-insensitive address values must be generated.

This is because of the reparsing of the compilation unit The area is set to zero and all the declarations are overrided and the memory is reallocated The area is reset to only when it is called by same compilation unit twice. The code is dangerous hence it is commented. Please have a look

if( get_current_compilation_unit_entity() == get_current_module_entity() && (get_current_compilation_unit_entity() == previouscompilationunit)) area_size(type_area(entity_type(msae))) = 0;

if( get_current_compilation_unit_entity() == get_current_module_entity() && (get_current_compilation_unit_entity() == previouscompilationunit)) area_size(type_area(entity_type(gsae))) = previoussizeofGlobalArea ;

Definition at line 186 of file util.c.

{
  DynamicArea = FindOrCreateEntity(get_current_module_name(), DYNAMIC_AREA_LOCAL_NAME);
  entity_type(DynamicArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(DynamicArea) = make_storage_rom();
  entity_initial(DynamicArea) = make_value_unknown();
  entity_kind(DynamicArea) = ABSTRACT_LOCATION|ENTITY_DYNAMIC_AREA;
  AddEntityToDeclarations(DynamicArea, get_current_module_entity());
 
  StaticArea = FindOrCreateEntity(get_current_module_name(), STATIC_AREA_LOCAL_NAME);
  entity_type(StaticArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(StaticArea) = make_storage_rom();
  entity_initial(StaticArea) = make_value_unknown();
  entity_kind(StaticArea) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(StaticArea, get_current_module_entity());
 
  //HeapArea = FindOrCreateEntity(compilation_unit_name, HEAP_AREA_LOCAL_NAME);
  HeapArea = FindOrCreateEntity(get_current_module_name(), HEAP_AREA_LOCAL_NAME);
  entity_type(HeapArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(HeapArea) = make_storage_rom();
  entity_initial(HeapArea) = make_value_unknown();
  entity_kind(HeapArea) = ABSTRACT_LOCATION|ENTITY_HEAP_AREA;
  AddEntityToDeclarations(HeapArea, get_current_module_entity());
 
  /* Create a hidden pointer in the heap area to modelize malloc and
     free effects and to keep track of the corresponding abstract
     state. */
    /* FI: I use a complex type to avoid seeing this variable in the
       transformers and preconditions... OK, it's not a clean way to
       do it. Should we create another area to allocate this abstract
       heap state? */
  /* FI: I keep the code below, because it may turn useful again if
     context-insensitive address values must be generated. */
  /*
  if(!compilation_unit_entity_p(get_current_module_entity())) {
    make_entity(AddPackageToName(get_current_module_name(),
                                 MALLOC_EFFECTS_NAME),
                make_scalar_complex_type(DEFAULT_COMPLEX_TYPE_SIZE),
 
                Chose a storage... Maybe in MALLOC_EFFECTS_PACKAGE_NAME?
 
                make_storage(is_storage_ram,
                make_ram(entity_undefined, DynamicArea, 0, NIL))
                
                make_storage(is_storage_ram,
                             make_ram(get_current_module_entity(),
                                      HeapArea,
                                      0, NIL)),
                make_value(is_value_unknown, UU));
  }
  */
 
  // Dynamic variables whose size are not known are stored in Stack area
  StackArea = FindOrCreateEntity(get_current_module_name(), STACK_AREA_LOCAL_NAME);
  entity_type(StackArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(StackArea) = make_storage_rom();
  entity_initial(StackArea) = make_value_unknown();
  entity_kind(StackArea) = ABSTRACT_LOCATION|ENTITY_STACK_AREA;
  AddEntityToDeclarations(StackArea, get_current_module_entity());
 
  entity msae = FindOrCreateEntity(compilation_unit_name,  STATIC_AREA_LOCAL_NAME);
  entity_kind(msae) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(msae, get_current_module_entity());
 
  entity gsae = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,  STATIC_AREA_LOCAL_NAME);
  entity_kind(gsae) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(gsae, get_current_module_entity());
 
  /* This is because of the reparsing of the compilation unit
     The area is set to zero and all the declarations are overrided and the memory is reallocated
     The area is reset to only when it is called by same compilation unit twice.
     The code is dangerous hence it is commented. Please have a look
 
     if( get_current_compilation_unit_entity() == get_current_module_entity() &&
     (get_current_compilation_unit_entity() == previouscompilationunit))
     area_size(type_area(entity_type(msae))) = 0;
 
     if( get_current_compilation_unit_entity() == get_current_module_entity() &&
     (get_current_compilation_unit_entity() == previouscompilationunit))
     area_size(type_area(entity_type(gsae))) = previoussizeofGlobalArea ;
  */
}

References ABSTRACT_LOCATION, AddEntityToDeclarations(), compilation_unit_name, DYNAMIC_AREA_LOCAL_NAME, DynamicArea, ENTITY_DYNAMIC_AREA, ENTITY_HEAP_AREA, entity_initial, entity_kind, ENTITY_STACK_AREA, ENTITY_STATIC_AREA, entity_storage, entity_type, FindOrCreateEntity(), get_current_module_entity(), get_current_module_name(), HEAP_AREA_LOCAL_NAME, HeapArea, is_type_area, make_area(), make_storage_rom(), make_type(), make_value_unknown(), NIL, STACK_AREA_LOCAL_NAME, StackArea, STATIC_AREA_LOCAL_NAME, StaticArea, and TOP_LEVEL_MODULE_NAME.

Referenced by MakeCurrentCompilationUnitEntity(), and MakeCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

init_c_implicit_variables()

void init_c_implicit_variables

(

entity

m

)

Function name variable function and FUNCTION

Should be static, but not compatible with FREIA inlining.

It is not clear if the encoding is correct or not. It may also be correct but not supported. This could be checked by computing the preconditions for strings and/or by adding initial values to the symbol table display.

Since the declarations are not added to a statement_declarations field, they are not going to be prettyprinted.

Definition at line 277 of file util.c.

{
  /* Function name variable __function__ and __FUNCTION__ */
  const char * mn = entity_local_name(m);
  string bs = "0`"; // first local scope in a module: should be
                    // returned by a function to stay consistent in
                    // case of change
  string fn1 = strdup(concatenate(bs, IMPLICIT_VARIABLE_NAME_1, NULL));
  string fn2 = strdup(concatenate(bs, IMPLICIT_VARIABLE_NAME_2, NULL));
  entity func_name1 = FindOrCreateEntity(mn, fn1);
  entity func_name2 = FindOrCreateEntity(mn, fn2);
  const char * name = entity_user_name(m);
  string cn = strdup(concatenate("\"", mn, "\"", NULL));
  entity fn = make_C_constant_entity(cn,
                                     is_basic_string,
                                     strlen(name)+1);
  free(cn);
  entity a = DynamicArea; /* Should be static, but not compatible with
                           FREIA inlining. */
 
  entity_type(func_name1) = make_char_array_type(strlen(name)+1);
  entity_storage(func_name1) =
    make_storage_ram(make_ram(m, a, UNKNOWN_RAM_OFFSET, NIL));
  /* It is not clear if the encoding is correct or not. It may also
     be correct but not supported. This could be checked by computing
     the preconditions for strings and/or by adding initial values to
     the symbol table display. */
  entity_initial(func_name1) = make_value_expression(make_call_expression(fn, NIL));
  AddEntityToDeclarations(func_name1, m);
 
  entity_type(func_name2) = make_char_array_type(strlen(name)+1);
  entity_storage(func_name2) =
    make_storage_ram(make_ram(m, a, UNKNOWN_RAM_OFFSET, NIL));
  entity_initial(func_name2) = make_value_expression(make_call_expression(fn, NIL));
  AddEntityToDeclarations(func_name2, m);
  /* Since the declarations are not added to a statement_declarations
     field, they are not going to be prettyprinted. */
 
  free(fn1);
  free(fn2);
}

References AddEntityToDeclarations(), concatenate(), DynamicArea, entity_initial, entity_local_name(), entity_storage, entity_type, entity_user_name(), FindOrCreateEntity(), free(), IMPLICIT_VARIABLE_NAME_1, IMPLICIT_VARIABLE_NAME_2, is_basic_string, make_C_constant_entity(), make_call_expression(), make_char_array_type(), make_ram(), make_storage_ram(), make_value_expression(), NIL, strdup(), and UNKNOWN_RAM_OFFSET.

Referenced by MakeCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeEnumMemberValues()

void InitializeEnumMemberValues

(

list

lem

)

The expression evaluation may have been delayed

Parameters

lem

em

Definition at line 3104 of file util.c.

{
  // enum member with implicit values are not yet fully instantiated
  list cem = list_undefined;
  _int cv = 0;
 
  for(cem = lem; !ENDP(cem); POP(cem)) {
    entity em = ENTITY(CAR(cem));
    value emv = entity_initial(em);
 
    if(value_undefined_p(emv)) {
      entity_initial(em) =
        make_value_symbolic(make_symbolic(int_to_expression(cv),
                                          make_constant(is_constant_int, (void *) cv)));
    }
    else {
      symbolic s = value_symbolic(emv);
      constant c = symbolic_constant(s);
 
      if(expression_undefined_p(symbolic_expression(s))) {
        symbolic_expression(s) = int_to_expression(cv);
        symbolic_constant(s) =  make_constant(is_constant_int, (void *) cv);
      }
      else if(constant_unknown_p(c)) {
      /* The expression evaluation may have been delayed */
        value nv = EvalExpression(symbolic_expression(s));
        if(value_constant_p(nv) && constant_int_p(value_constant(nv)))
          symbolic_constant(s) = value_constant(nv);
      }
      cv = constant_int(symbolic_constant(value_symbolic(emv)));
      pips_assert("The symbolic field is consisten", symbolic_consistent_p(s));
    }
    cv++;
  }
}

References CAR, constant_int, constant_int_p, constant_unknown_p, ENDP, ENTITY, entity_initial, EvalExpression(), expression_undefined_p, int_to_expression(), is_constant_int, list_undefined, make_constant(), make_symbolic(), make_value_symbolic(), pips_assert, POP, symbolic_consistent_p(), symbolic_constant, symbolic_expression, value_constant, value_constant_p, value_symbolic, and value_undefined_p.

Here is the call graph for this function:

insert_qualifier()

list insert_qualifier	(	list	ql,
		qualifier	nq
	)

if qualifier "nq" does not already belong to qualifier list "ql", add it in front of the list.

The list is probably reversed somewhere else... for instance by the parsing grammar rules

FI: either the context was not stacked or it was not used and emptied...

Parameters

ql	l
nq	q

Definition at line 3567 of file util.c.

{
  bool found = false; // FI: Should never be useful...
  list nql = ql;
 
  FOREACH(QUALIFIER, q, ql) {
    if(qualifier_equal_p(q, nq)) {
      /* FI: either the context was not
         stacked or it was not used and
         emptied... */
      c_parser_user_warning("Dupliquate qualifier \"%s\"\n",
                            qualifier_to_string(q));
      found = true;
    }
  }
 
  if(!found)
    //c_parser_context_qualifiers(ycontext) =
    nql = CONS(QUALIFIER, nq, ql);
 
  return nql;
}

References c_parser_user_warning, CONS, FOREACH, QUALIFIER, qualifier_equal_p(), and qualifier_to_string().

Here is the call graph for this function:

make_C_constant_entity()

entity make_C_constant_entity	(	string	name,
		tag	bt,
		size_t	size
	)

Parameters

name	ame
bt	t
size	ize

Definition at line 269 of file util.c.

{
  return make_C_or_Fortran_constant_entity(name, bt, size, false, c_parser_error);
}

References c_parser_error(), and make_C_or_Fortran_constant_entity().

Referenced by init_c_implicit_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeArrayExpression()

expression MakeArrayExpression	(	expression	exp,
		list	lexp
	)

FI: this function is called for a bracketed comma expression.

The two arguments are (should be) reused within the returned expression

There are two cases:

1. Simple array reference, where the first argument is a simple array or pointer name. We create a reference expression (syntax = reference).
2. Complicated subscripting array, where the first argument can be a function call (foo()[]), a structure or union member (str[5].field[7], ... We create a subscripting expression (syntax = subscript).

FI: Memory leak with exp?

FI: we might have preexisting subscript? No, in this context, only one index due to lack of type information?

Parameters

exp	xp
lexp	exp

Definition at line 713 of file util.c.

{
  /* There are two cases:
 
   1. Simple array reference, where the first argument is a simple
   array or pointer name. We create a reference expression (syntax =
   reference).
 
   2. Complicated subscripting array, where the first argument can be
   a function call (foo()[]), a structure or union member
   (str[5].field[7], ... We create a subscripting expression (syntax =
   subscript).
 */
 
  expression e = expression_undefined;
  syntax s = expression_syntax(exp);
  list sl = lexp;
 
  if(!ENDP(CDR(lexp))) {
    expression se = MakeCommaExpression(lexp);
    sl = CONS(EXPRESSION, se, NIL);
  }
 
  switch(syntax_tag(s)) {
  case is_syntax_reference:
    {
      /* FI: Memory leak with exp? */
      reference r = syntax_reference(s);
      entity ent = reference_variable(r);
      list l = reference_indices(r);
      pips_debug(6,"Normal reference expression\n");
      e = reference_to_expression(make_reference(ent,gen_nconc(l,sl)));
      break;
    }
  case is_syntax_call:
  case is_syntax_range:
  case is_syntax_cast:
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
    {
      /* FI: we might have preexisting subscript? No, in this
         context, only one index due to lack of type information? */
      subscript a = make_subscript(exp,sl);
      syntax s = make_syntax_subscript(a);
      pips_debug(6,"Subscripting array expression\n");
      e = make_expression(s,normalized_undefined);
      break;
    }
  default:
    {
      pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
    }
  }
  return e;
}

References CDR, CONS, ENDP, exp, EXPRESSION, expression_syntax, expression_undefined, gen_nconc(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, lexp, make_expression(), make_reference(), make_subscript(), make_syntax_subscript(), MakeCommaExpression(), NIL, normalized_undefined, pips_debug, pips_internal_error, reference_indices, reference_to_expression(), reference_variable, syntax_reference, and syntax_tag.

Here is the call graph for this function:

MakeCurrentCompilationUnitEntity()

void MakeCurrentCompilationUnitEntity

(

const char *

name

)

A compilation unit is also considered as a module.

value v = entity_initial(e);

if(value_code_p(v)) {

code c = value_code(v);

language l = code_language(c);

if(language_unknown_p(l))

code_language(c) = make_language_c();

else if(language_fortran_p(l) || language_fortran95_p(l))

pips_internal_error("A compilation unit should have language \"C".
");

}

else

pips_internal_error("A compilation unit should have value \"code".
");

Parameters

name

ame

Definition at line 328 of file util.c.

{
  entity e = MakeCompilationUnitEntity(name);
  /* value v = entity_initial(e); */
  /* if(value_code_p(v)) { */
  /*   code c = value_code(v); */
  /*   language l = code_language(c); */
  /*   if(language_unknown_p(l)) */
  /*     code_language(c) = make_language_c(); */
  /*   else if(language_fortran_p(l) || language_fortran95_p(l)) */
  /*     pips_internal_error("A compilation unit should have language \"C\".\n"); */
  /* } */
  /* else */
  /*   pips_internal_error("A compilation unit should have value \"code\".\n"); */
 
  pips_debug(4,"Set current module entity for compilation unit %s\n",name);
  set_current_module_entity(e);
  //init_stack_storage_table();
  init_c_areas();
}

References init_c_areas(), MakeCompilationUnitEntity(), pips_debug, and set_current_module_entity().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeDerivedEntity()

entity MakeDerivedEntity	(	string	name,
		list	members,
		bool	is_external,
		int	i
	)

FI: What should the initial value be?

Parameters

name	ame
members	embers
is_external	s_external

Definition at line 3140 of file util.c.

{
  entity ent = entity_undefined;
  switch (i) {
  case is_type_struct:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,STRUCT_PREFIX,is_external);
      entity_type(ent) = make_type_struct(members);
      break;
    }
  case is_type_union:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,UNION_PREFIX,is_external);
      entity_type(ent) = make_type_union(members);
      break;
    }
  case is_type_enum:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,ENUM_PREFIX,is_external);
      entity_type(ent) = make_type_enum(members);
      break;
    }
  }
  entity_storage(ent) = make_storage_rom();
  /* FI: What should the initial value be? */
  if (value_undefined_p(entity_initial(ent)))
    entity_initial(ent) = make_value_unknown();
  AddEntityToDeclarations(ent, get_current_module_entity());
 
  return ent;
}

References AddEntityToDeclarations(), CreateEntityFromLocalNameAndPrefix(), entity_initial, entity_storage, entity_type, entity_undefined, ENUM_PREFIX, get_current_module_entity(), is_external, is_type_enum, is_type_struct, is_type_union, make_storage_rom(), make_type_enum(), make_type_struct(), make_type_union(), make_value_unknown(), STRUCT_PREFIX, UNION_PREFIX, and value_undefined_p.

Here is the call graph for this function:

MakeDimension()

dimension MakeDimension	(	list	le,
		list	ql
	)

Take only the first expression of le, do not know why it can be a list ?

use the integer value

If we do this, we cannot restitute the source code

Build a new expression e' == e-1

Parameters

le	e
ql	l

Definition at line 1389 of file util.c.

{
  dimension d;
  if (le == NIL)
    {
      d = make_dimension(int_to_expression(0),make_unbounded_expression(), NIL);
      pips_debug(5,"Unbounded dimension\n");
    }
  else
    {
      /* Take only the first expression of le, do not know why it can be a list ?*/
      expression e = EXPRESSION(CAR(le));
      intptr_t up;
 
      if (false && expression_integer_value(e,&up))
        /* use the integer value */ /* If we do this, we cannot restitute the source code */
        d = make_dimension(int_to_expression(0), int_to_expression(up-1), NIL);
      else
        /* Build a new expression e' == e-1 */
        d = make_dimension(int_to_expression(0),
                           MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                          e,
                                          int_to_expression(1)),
                           ql);
 
      ifdebug(9)
        {
          pips_debug(5,"Array dimension:");
          print_expression(e);
          pips_debug(8,"Array lower bound:");
          print_expression(dimension_lower(d));
          pips_debug(5,"Array dimension:");
          print_expression(dimension_upper(d));
        }
    }
  return d;
}

References CAR, CreateIntrinsic(), dimension_lower, dimension_upper, EXPRESSION, expression_integer_value(), ifdebug, int_to_expression(), intptr_t, make_dimension(), make_unbounded_expression(), MakeBinaryCall(), MINUS_C_OPERATOR_NAME, NIL, pips_debug, and print_expression().

Referenced by UpdateArrayEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeEnumeratorInitialValue()

value MakeEnumeratorInitialValue	(	list	enum_list,
		int	counter
	)

The initial value = 0 if this is the first member in the enumerator list else, it is equal to : intial_value(predecessor) + 1

Find the predecessor of the counter-th member

Parameters

enum_list	num_list
counter	ounter

Definition at line 3299 of file util.c.

{
  /* The initial value = 0 if this is the first member in the enumerator list
     else, it is equal to : intial_value(predecessor) + 1 */
  value v = value_undefined;
  if (counter == 1)
    v = make_value_constant(make_constant_int(0));
  else
    {
      /* Find the predecessor of the counter-th member */
      entity pre = ENTITY(gen_nth(counter-1, enum_list));
      value vp = entity_initial(pre);
      if (value_constant_p(vp))
        {
          constant c = value_constant(vp);
          if (constant_int_p(c))
            {
              int i = constant_int(c);
              v = make_value_constant(make_constant_int(i+1));
            }
        }
    }
  return v;
}

References constant_int, constant_int_p, ENTITY, entity_initial, gen_nth(), make_constant_int(), make_value_constant(), value_constant, value_constant_p, and value_undefined.

Here is the call graph for this function:

MakeFunctionExpression()

expression MakeFunctionExpression	(	expression	e,
		list	le
	)

e is now owned by returned expression and must not be used any longer

There are 2 cases:

1. The first argument corresponds to a function name (an entity).

   In this case, we create a normal call expression and the corresponding entity is added to the list of callees.

2. The first argument can be any expression denoting a called function (a pointer to a function,... such as (*ctx->Driver.RenderString)() in the benchmark mesa in SPEC2000). In this case, we create a function application expression.

Must be a pointer to a function

Undeclared functions return int by default

This cannot be checked unless bootstrap typing is improved for varargs intrinsics, mostly IOs.

Parameters

le

e

Definition at line 368 of file util.c.

{
  /* There are 2 cases:
 
     1. The first argument corresponds to a function name (an entity).
 
        In this case, we create a normal call expression and the
        corresponding entity is added to the list of callees.
 
     2. The first argument can be any expression denoting a called
        function (a pointer to a function,... such as
        (*ctx->Driver.RenderString)() in the benchmark mesa in
        SPEC2000).  In this case, we create a function application
        expression.
  */
  expression exp = expression_undefined;
  syntax s = expression_syntax(e);
  switch (syntax_tag(s))
    {
    case is_syntax_reference:
      {
        entity ent = reference_variable(syntax_reference(s));
    free_expression(e);
        entity cf = get_current_module_entity();
 
        ifdebug(8) {
          pips_debug(8, "Call to \"\%s\" with %zd argument(s)\n",
                     entity_name(ent), gen_length(le));
          print_expressions(le);
        }
 
        if(!intrinsic_entity_p(ent)) {
          entity cu = get_current_compilation_unit_entity();
          list cudl = code_declarations(value_code(entity_initial(cu)));
          type ut = ultimate_type(entity_type(ent));
 
          if(type_functional_p(ut))
            AddToCalledModules(ent);
          else {
            /* Must be a pointer to a function */
            const char * eun = entity_user_name(ent);
            c_parser_user_warning("Call to an unknown function via function pointer \"\%s\"\n",
                              eun);
          }
 
          if(!gen_in_list_p(ent, cudl)) {
            /* Undeclared functions return int by default */
            type ft = entity_type(ent);
            functional f = type_functional(ft);
 
            pips_assert("function's type is ultimately functional or pointer to functional",
                        call_compatible_type_p(ft));
            f = type_functional(ft);
            if(type_functional_p(ft) && type_unknown_p(functional_result(f)))
              functional_result(f) = MakeIntegerResult();
            AddToDeclarations(ent, cf);
          }
        }
        pips_debug(6,"Normal function or intrinsics call\n");
    (void)check_C_function_type(ent,le);
        exp = make_call_expression(ent,le);
        /* This cannot be checked unless bootstrap typing is improved
           for varargs intrinsics, mostly IOs. */
        /*
        if(!ok) {
          c_parser_user_warning("Actual arguments do not fit the declared formal "
                            "arguments of function \"%s\"\n",
                            entity_user_name(ent));
          CParserError("Type mismatch\n");
          }
        */
        break;
      }
    case is_syntax_call:
      {
        application a = make_application(e,le);
        pips_debug(6,"Application function call\n");
        exp = make_expression(make_syntax_application(a),normalized_undefined);
        break;
      }
    case is_syntax_range:
    case is_syntax_cast:
    case is_syntax_sizeofexpression:
    case is_syntax_subscript:
    case is_syntax_application:
      CParserError("This is not a functional expression\n");
      break;
    default:
      {
        pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
      }
    }
  return exp;
}

References AddToCalledModules(), AddToDeclarations(), c_parser_user_warning, call_compatible_type_p(), check_C_function_type(), code_declarations, CParserError(), entity_initial, entity_name, entity_type, entity_user_name(), exp, expression_syntax, expression_undefined, f(), free_expression(), functional_result, gen_in_list_p(), gen_length(), get_current_compilation_unit_entity(), get_current_module_entity(), ifdebug, intrinsic_entity_p(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, make_application(), make_call_expression(), make_expression(), make_syntax_application(), MakeIntegerResult(), normalized_undefined, pips_assert, pips_debug, pips_internal_error, print_expressions(), reference_variable, syntax_reference, syntax_tag, type_functional, type_functional_p, type_unknown_p, ultimate_type(), and value_code.

Here is the call graph for this function:

MakeParameterList()

list MakeParameterList	(	list	l1,
		list	l2,
		stack	FunctionStack
	)

l1 is a list of parameter names and it represents the exact order in the parameter list l2 is a list of entities with their type, storage,... and the order can be different from l1 In addition, l2 can be incomplete wrt l1, so other entities must be created from l1, with default type : scalar integer variable.

We create the list of parameters with the order of l1, and the parameter type and mode are retrieved from l2.

Since the offset of formal argument in l2 can be false, we have to update it here by using l1

s is not declared in l2, create the corresponding entity/ formal variable and add it to the declaration list, because it cannot be added with par_def in l2

Parameters

l1	1
l2	2
FunctionStack	unctionStack

Definition at line 3348 of file util.c.

{
  /* l1 is a list of parameter names and it represents the exact order in the parameter list
     l2 is a list of entities with their type, storage,... and the order can be different from l1
     In addition, l2 can be incomplete wrt l1, so other entities must be created from l1, with
     default type : scalar integer variable.
 
     We create the list of parameters with the order of l1, and the parameter type and mode 
     are retrieved from l2.
 
     Since the offset of formal argument in l2 can be false, we have to update it here by using l1 */
  list l = NIL;
  int offset = 1;
  entity function = stack_head(FunctionStack);
  FOREACH(STRING, s,l1)
  {
    parameter p = FindParameterEntity(s,offset,l2);
    if (parameter_undefined_p(p))
      {
        /* s is not declared in l2, create the corresponding entity/ formal variable
         and add it to the declaration list, because it cannot be added with par_def in l2*/
        entity ent = FindOrCreateEntity(entity_user_name(function),s);
        variable v = make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL);
        entity_type(ent) = make_type_variable(v);
        entity_storage(ent) = make_storage_formal(make_formal(function,offset));
        AddToDeclarations(ent,function);
        p = make_parameter(entity_type(ent),
                           make_mode_value(),
                           make_dummy_identifier(ent)); // FI: could be unknown?
      }
    l = gen_nconc(l,CONS(PARAMETER,p,NIL));
    offset++;
  }
  return l;
}

References AddToDeclarations(), CONS, DEFAULT_INTEGER_TYPE_SIZE, entity_storage, entity_type, entity_user_name(), FindOrCreateEntity(), FindParameterEntity(), FOREACH, FunctionStack, gen_nconc(), make_basic_int(), make_dummy_identifier(), make_formal(), make_mode_value(), make_parameter(), make_storage_formal(), make_type_variable(), make_variable(), NIL, offset, PARAMETER, parameter_undefined_p, stack_head(), and STRING.

Here is the call graph for this function:

MakeStorageRam()

storage MakeStorageRam	(	entity	v,
		bool	is_external,
		bool	is_static
	)

The storage part should not be called twice when reparsing compilation unit.

We assume that double declarations are dealt with someone else

ComputeAreaOffset(StaticArea,e)

he offset must be recomputed lately, when we know for sure the size of the variables

This must be a variable, not a function/typedef/struct/union/enum. The variable is declared outside any function, and hence is global

ComputeAreaOffset(get_top_level_entity(),e)

the offset must be recomputed lately, when we know for sure the size of the variable

Global variable can be declared in many different file

ADD BLOCK SCOPE

ComputeAreaOffset(StaticArea,e)

he offset must be recomputed lately, when we know for sure the size of the variable

ComputeAreaOffset(DynamicArea,e)

the offset must be recomputed lately, when we know for sure the size of the variable

Parameters

is_external	s_external
is_static	s_static

Definition at line 3177 of file util.c.

{
  ram r = ram_undefined;
  area lsa = type_area(entity_type(StaticArea));
  area dsa = type_area(entity_type(DynamicArea));
  entity moduleStaticArea = FindOrCreateEntity(compilation_unit_name,  STATIC_AREA_LOCAL_NAME);
  area msa = type_area(entity_type(moduleStaticArea));
  entity globalStaticArea = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,  STATIC_AREA_LOCAL_NAME);
  area gsa = type_area(entity_type(globalStaticArea));
  area stack = type_area(entity_type(StackArea));
  //area heap = type_area (entity_type(HeapArea));
  //entity m = get_current_module_entity();
 
  pips_assert("RAM Storage is used only for variables", type_variable_p(entity_type(v)));
 
  if (is_external)
    {
      if (is_static)
        {
          r = make_ram(get_current_compilation_unit_entity(),
                       moduleStaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(StaticArea,e) */,
                       NIL);
 
          /*the offset must be recomputed lately, when we know for
            sure the size of the variables */
          if(get_current_compilation_unit_entity() != get_current_module_entity()
             || !gen_in_list_p(v,area_layout(msa)))
            area_layout(msa) = gen_nconc(area_layout(msa), CONS(ENTITY, v, NIL));
        }
      else
        {
          /* This must be a variable, not a function/typedef/struct/union/enum.
             The variable is declared outside any function, and hence is global*/
 
          r = make_ram(get_top_level_entity(),
                       globalStaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(get_top_level_entity(),e) */,
                       NIL);
          /* the offset must be recomputed lately, when we know for
             sure the size of the variable */
          /* Global variable can be declared in many different file */
          if(!gen_in_list_p(v,area_layout(gsa)))
            area_layout(gsa) = gen_nconc(area_layout(gsa), CONS(ENTITY, v, NIL));
        }
    }
  else
    {
      /* ADD BLOCK SCOPE */
      if (is_static)
        {
          r = make_ram(get_current_module_entity(),
                       StaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(StaticArea,e) */,
                       NIL);
          /*the offset must be recomputed lately, when we know for
            sure the size of the variable */
          area_layout(lsa) = gen_nconc(area_layout(lsa), CONS(ENTITY, v, NIL));
        }
      else
        {
          int s = 0;
          if(!SizeOfArray(v, &s))
            {
              r = make_ram(get_current_module_entity(),
                           StackArea,
                           DYNAMIC_RAM_OFFSET,
                           NIL);
              area_layout(stack) = gen_nconc(area_layout(stack), CONS(ENTITY, v, NIL));
            }
          else {
            r = make_ram(get_current_module_entity(),
                         DynamicArea,
                         UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(DynamicArea,e) */,
                         NIL);
            /* the offset must be recomputed lately, when we know for
               sure the size of the variable */
            area_layout(dsa) = gen_nconc(area_layout(dsa), CONS(ENTITY, v, NIL));
          }
        }
    }
  return make_storage_ram(r);
}

References area_layout, compilation_unit_name, CONS, DYNAMIC_RAM_OFFSET, DynamicArea, ENTITY, entity_type, FindOrCreateEntity(), gen_in_list_p(), gen_nconc(), get_current_compilation_unit_entity(), get_current_module_entity(), get_top_level_entity(), is_external, make_ram(), make_storage_ram(), NIL, pips_assert, ram_undefined, SizeOfArray(), StackArea, STATIC_AREA_LOCAL_NAME, StaticArea, TOP_LEVEL_MODULE_NAME, type_area, type_variable_p, and UNKNOWN_RAM_OFFSET.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeTopLevelEntity()

void MakeTopLevelEntity

(

void

)

To be economic, group this top-level entity to it areas

FI: this is not convenient if top-level:top-level is a module. All global variables should be declared there. I need also to generate stubs for global variables... Do I? Yes, because the points-to information is computed bottom-up.

Definition at line 157 of file util.c.

{
  /* To be economic, group this top-level entity to it areas*/
  /* FI: this is not convenient if top-level:top-level is a
     module. All global variables should be declared there. I need
     also to generate stubs for global variables... Do I? Yes, because
     the points-to information is computed bottom-up. */
  entity e = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,TOP_LEVEL_MODULE_NAME);
  entity_storage(e) = make_storage_rom();
  //entity_type(e) = make_type(is_type_area, make_area(0, NIL));
  entity_type(e) =
    make_type_functional(make_functional(NIL, make_type_void(NIL)));
  //entity_initial(e) = make_value_unknown();
  code c = make_code(NIL, strdup(""), make_sequence(NIL),
                     NIL, make_language_c());
  entity_initial(e) = make_value_code(c);
}

References entity_initial, entity_storage, entity_type, FindOrCreateEntity(), make_code(), make_functional(), make_language_c(), make_sequence(), make_storage_rom(), make_type_functional(), make_type_void(), make_value_code(), NIL, strdup(), and TOP_LEVEL_MODULE_NAME.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

MemberDerivedIdentifierToExpression()

expression MemberDerivedIdentifierToExpression	(	type	t,
		string	m
	)

Definition at line 463 of file util.c.

{
  if (type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      pips_debug(6,"Basic tag is %d\n",basic_tag(b));
      switch (basic_tag(b)) {
      case is_basic_pointer:
        {
          type tp = basic_pointer(b);
          return MemberDerivedIdentifierToExpression(tp,m);
        }
      case is_basic_typedef:
        {
          entity te = basic_typedef(b);
          type tp = entity_type(te);
          return MemberDerivedIdentifierToExpression(tp,m);
        }
      case is_basic_derived:
        {
          entity de = basic_derived(b);
          const char * name = entity_user_name(de);
      string id = strdup(concatenate(name,MEMBER_SEP_STRING,m,NULL));
          expression exp = IdentifierToExpression(id);
      free(id);
      return exp;
        }
      default:
        break;
      }
    }
  CParserError("Cannot find the field identifier from current type\n");
  return expression_undefined;
}

References basic_derived, basic_pointer, basic_tag, basic_typedef, concatenate(), CParserError(), entity_type, entity_user_name(), exp, expression_undefined, free(), IdentifierToExpression(), is_basic_derived, is_basic_pointer, is_basic_typedef, MEMBER_SEP_STRING, MemberDerivedIdentifierToExpression(), pips_debug, strdup(), type_variable, type_variable_p, and variable_basic.

Referenced by MemberDerivedIdentifierToExpression(), and MemberIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

MemberIdentifierToExpression()

expression MemberIdentifierToExpression	(	expression	e,
		string	m
	)

Find the name of struct/union of m from the type of expression e

The first expression must be a pointer

standard integer arithmetic: why bother? why take the CDR?

FI: seems too simple. No need to remember if you sarted with "." or "->"?

Let use the second argument

More types of call must be taken into account: typedef and pointer to functions

User defined call and intrinsics not processed above

A call must have occured somewhere...

An apply must have occured somewhere...

expression exp = subscript_array(syntax_subscript(s));

pips_debug(6,"Subscripting array expression\n");

return MemberIdentifierToExpression(exp, m);

Definition at line 498 of file util.c.

{
  /* Find the name of struct/union of m from the type of expression e*/
 
  syntax s = expression_syntax(e);
  ifdebug(6)
    {
      pips_debug(6,"Find the struct/union of \"%s\" from expression:\n",m);
      print_expression(e);
    }
  switch (syntax_tag(s))
    {
    case is_syntax_call:
      {
        call c = syntax_call(s);
        entity f = call_function(c);
        pips_debug(6,"Called operator is \"%s\"\n",entity_name(f));
        if(ENTITY_PLUS_C_P(f))
          {
            expression e1 = EXPRESSION(CAR(call_arguments(c)));
            expression e2 = EXPRESSION(CAR(CDR(call_arguments(c))));
            expression exp = expression_undefined;
            basic b1 = basic_of_expression(e1);
            basic b2 = basic_of_expression(e2);
 
            if(basic_pointer_p(b1) && (basic_int_p(b2)||basic_bit_p(b2)))
              exp = e1;
            else if(basic_pointer_p(b2) && (basic_int_p(b1)||basic_bit_p(b1)))
              exp = e2;
            else
              CParserError("Pointer arithmetic error, incompatible types");
            free_basic(b1);
            free_basic(b2);
 
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_POST_INCREMENT_P(f) || ENTITY_POST_DECREMENT_P(f)
           || ENTITY_PRE_INCREMENT_P(f) || ENTITY_PRE_DECREMENT_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_MINUS_C_P(f))
          {
            /* The first expression must be a pointer */
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_PLUS_P(f))
          {
            /* standard integer arithmetic: why bother? why take the CDR? */
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_FIELD_P(f) || ENTITY_POINT_TO_P(f))
          {
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_DEREFERENCING_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        /* FI: seems too simple. No need to remember if you sarted with "." or "->"? */
        else if (ENTITY_ADDRESS_OF_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_ASSIGN_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_CONDITIONAL_P(f))
          {
            /* Let use the second argument */
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        /* More types of call must be taken into account: typedef and
           pointer to functions */
        else if (true || type_functional_p(entity_type(f)))
          {
            /* User defined call and intrinsics not processed above */
            type ft = call_to_functional_type(c, true);
            type t = functional_result(type_functional(ft));
            if(overloaded_type_p(t))
              pips_internal_error("Unresolved expression type\n");
            return MemberDerivedIdentifierToExpression(t,m);
          }
        break;
      }
    case is_syntax_reference:
      {
        entity ent = reference_variable(syntax_reference(s));
        type t = ultimate_type(entity_type(ent));
        pips_debug(6,"Reference expression\n");
 
        if(type_functional_p(t)) {
          /* A call must have occured somewhere... */
          type rt = ultimate_type(functional_result(type_functional(t)));
          return MemberDerivedIdentifierToExpression(rt,m);
        }
        else if(type_variable_p(t) && basic_pointer_p(variable_basic(type_variable(t)))) {
          type pt = ultimate_type(basic_pointer(variable_basic(type_variable(t))));
 
          if(type_functional_p(pt)) {
            /* An apply must have occured somewhere... */
            type rt = ultimate_type(functional_result(type_functional(pt)));
            return MemberDerivedIdentifierToExpression(rt,m);
          }
          else
            return MemberDerivedIdentifierToExpression(t,m);
        }
        else
          return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_cast:
      {
        type t = cast_type(syntax_cast(s));
        pips_debug(6,"Cast expression\n");
        return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_range:
      break;
    case is_syntax_sizeofexpression:
      break;
    case is_syntax_subscript:
      {
        /* expression exp = subscript_array(syntax_subscript(s)); */
        /* pips_debug(6,"Subscripting array expression\n"); */
        /* return MemberIdentifierToExpression(exp, m); */
        type t = expression_to_type(e);
        return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_application:
      {
        expression fe = application_function(syntax_application(s));
        return MemberIdentifierToExpression(fe, m);
        break;
      }
    default:
      {
        pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
      }
    }
  CParserError("Cannot find the field identifier from current expression\n");
  return expression_undefined;
}

References application_function, b1, b2, basic_bit_p, basic_int_p, basic_of_expression(), basic_pointer, basic_pointer_p, call_arguments, call_function, call_to_functional_type(), CAR, cast_type, CDR, CParserError(), ENTITY_ADDRESS_OF_P, ENTITY_ASSIGN_P, ENTITY_CONDITIONAL_P, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, ENTITY_MINUS_C_P, entity_name, ENTITY_PLUS_C_P, ENTITY_PLUS_P, ENTITY_POINT_TO_P, ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_DECREMENT_P, ENTITY_PRE_INCREMENT_P, entity_type, exp, EXPRESSION, expression_syntax, expression_to_type(), expression_undefined, f(), free_basic(), functional_result, ifdebug, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, MemberDerivedIdentifierToExpression(), MemberIdentifierToExpression(), overloaded_type_p(), pips_debug, pips_internal_error, print_expression(), reference_variable, syntax_application, syntax_call, syntax_cast, syntax_reference, syntax_tag, type_functional, type_functional_p, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by MemberIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

nodecl_p()

static void nodecl_p ( entity __attribute__((unused))  module, statement  stat  )

static

Definition at line 1868 of file util.c.

{
  declarationerror_p = false;
  gen_multi_recurse(stat, reference_domain,referencenodeclfilter,gen_null,
                    call_domain,callnodeclfilter,gen_null, NULL);
 
  if(declarationerror_p)
    CParserError("Illegal Input\n");
}

References call_domain, callnodeclfilter(), CParserError(), declarationerror_p, gen_multi_recurse(), gen_null(), reference_domain, and referencenodeclfilter().

Referenced by CCompilationUnitMemoryAllocations(), and CModuleMemoryAllocation().

Here is the call graph for this function:

Here is the caller graph for this function:

NStackPop()

void NStackPop	(	stack	s,
		int	n
	)

Pop n times the stack s.

Definition at line 3442 of file util.c.

{
  while (n-->0)
    gen_free(stack_pop(s));
}

References gen_free(), and stack_pop().

Referenced by StackPop().

Here is the call graph for this function:

Here is the caller graph for this function:

put_new_typedef()

void put_new_typedef

(

const char *

name

)

This function is used by libraries "step"* and "task_parallelization".

FI: I have no idea why it works although the keyword_typedef_table should not be initialized... It could not be made static, because it might be used by any file in the c_syntax library.

Parameters

name

ame

Definition at line 1078 of file util.c.

{
  hash_put(keyword_typedef_table,strdup(name),(void *) TK_NAMED_TYPE);
  pips_debug(5,"Add typedef name %s to hash table\n",name);
}

References hash_put(), keyword_typedef_table, pips_debug, strdup(), and TK_NAMED_TYPE.

Referenced by cast_STEP_ARG(), mpi_initialize(), mpi_type_mpi_comm(), mpi_type_mpi_request(), and mpi_type_mpi_status().

Here is the call graph for this function:

Here is the caller graph for this function:

referencenodeclfilter()

static bool referencenodeclfilter ( reference  r )

static

There can be a reference to variable of storage return when a function pointer is assigned a function

FI: this may be a bad decision choice to confuse a function and its return value. It might be better to keep storage "rom" systematically for functions and to restore this test.

Definition at line 1790 of file util.c.

{
  entity e = reference_variable(r);
  entity m = get_current_module_entity();
  entity cu = get_current_compilation_unit_entity();
 
  if(variable_entity_p(e)) {
    if(!(gen_in_list_p(e, entity_declarations(m))
         || gen_in_list_p(e, entity_declarations(cu))))
      {
        declarationerror_p = true;
        user_log("\n\nNo declaration of variable \"%s\" (\"%s\") in module \"%s\'\n",
                 entity_local_name(e),entity_name(e),get_current_module_name());
      }
  }
  /* There can be a reference to variable of storage return when a
     function pointer is assigned a function */
  /* FI: this may be a bad decision choice to confuse a function and
     its return value. It might be better to keep storage "rom"
     systematically for functions and to restore this test. */
  /*
  //  if(storage_return_p(entity_storage(e))){
  //  declarationerror_p = true;
  //  user_log("\n\nNo declaration of variable \"%s\" (\"%s\") in module \"%s\"\n",
  //         entity_user_name(e),entity_name(e),get_current_module_name());
  }
  */
 
  return true;
}

References declarationerror_p, entity_declarations, entity_local_name(), entity_name, gen_in_list_p(), get_current_compilation_unit_entity(), get_current_module_entity(), get_current_module_name(), reference_variable, user_log(), and variable_entity_p().

Referenced by nodecl_p().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveDummyArguments()

void RemoveDummyArguments	(	entity	f,
		list	refs
	)

To chase formals in type declarations.

If f has dummy formal parameters, replace them by standard formal parameters

make a list of formal dummy parameters

Since the compilation order is not known, the standard formal parameters may already exist and they should not be removed.

Update the "dummy" field of the "parameter" data structure

This special case could be ignored and handled like the next one to avoid cut-and-past and/or the definition of a new function.

no dummy naming information available as in foo(int);

FI: just in case?

Remore the dummy formals from f's declaration list (and from the symbol table?) but keep all pointers towards them in the declarations as in "void foo(n,a[n])"

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

No, there may be occurences due to dependent types.

Parameters

refs

efs

Definition at line 2224 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv) && !value_intrinsic_p(fv)) {
    code fc = value_code(fv);
    list dl = code_declarations(fc);
    list cd = list_undefined;
    list formals = NIL;
    type ft = entity_type(f);
    list fp = functional_parameters(type_functional(ft));
    list cformals = list_undefined;
    list cfp = list_undefined;
    int nformals=-1;
    int nfp = gen_length(fp);
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal dummy parameters */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal dummy parameter: \"%s\"\n", entity_name(v));
        /* Since the compilation order is not known, the standard
           formal parameters may already exist and they should not be
           removed. */
        if(dummy_parameter_entity_p(v))
          formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
      }
    }
    nformals = gen_length(formals);
 
    /* Update the "dummy" field of the "parameter" data structure */
 
    if(nformals==nfp) {
      /* This special case could be ignored and handled like the next
         one to avoid cut-and-past and/or the definition of a new
         function. */
      for(cformals=formals, cfp = fp; !ENDP(cfp); POP(cformals), POP(cfp)) {
        parameter p = PARAMETER(CAR(cfp));
        entity ep = ENTITY(CAR(cformals));
          dummy d = parameter_dummy(p);
 
          if(dummy_identifier_p(d)) {
            entity oep = dummy_identifier(d);
 
            MAP(REFERENCE, r, {
              entity v = reference_variable(r);
 
              if(v==oep) {
                pips_debug(8, "Reference to \"\%s\" now refers \"\%s\"\n",
                           entity_name(oep), entity_name(ep));
                reference_variable(r) = ep;
              }
            }, refs);
          }
 
        update_dummy_parameter(p, ep);
      }
    }
    else if(nformals>0) {
      int i = -1;
      for(cfp=fp, i= 1;!ENDP(cfp); POP(cfp), i++) {
        entity ep = find_ith_parameter(f,i);
        if(!entity_undefined_p(ep)) {
          parameter p = PARAMETER(CAR(cfp));
          dummy d = parameter_dummy(p);
 
          if(dummy_identifier_p(d)) {
            entity oep = dummy_identifier(d);
 
            MAP(REFERENCE, r, {
              entity v = reference_variable(r);
 
              if(v==oep) {
                pips_debug(8, "Reference to \"\%s\" now refers \"\%s\"\n",
                           entity_name(oep), entity_name(ep));
                reference_variable(r) = ep;
              }
            }, refs);
          }
 
          update_dummy_parameter(p, ep);
        }
      }
    }
    else {
      /* no dummy naming information available as in foo(int); */
      ;
    }
 
    if(true) {
 
      /* FI: just in case? */
      remove_entity_type_stacks(formals);
 
      /* Remore the dummy formals from f's declaration list (and from
         the symbol table?) but keep all pointers towards them in the
         declarations as in "void foo(n,a[n])" */
      for(cd = formals; !ENDP(cd); POP(cd)) {
        entity p = ENTITY(CAR(cd));
        //type pt = entity_type(p);
        //storage ps = entity_storage(p);
        //formal pfs = storage_formal(ps);
 
        pips_debug(8, "Formal dummy parameter \"%s\" is removed from declarations\n",
                   entity_name(p));
 
        //clean_up_dummy_parameter_type(pt, formals);
        gen_remove(&code_declarations(fc), (void *) p);
 
        /* FI: The storage might point to another dummy argument
           (although it should not) */
        //formal_function(pfs) = entity_undefined;
        /* Let's hope there are no other pointers towards dummy formal parameters */
        /* No, there may be occurences due to dependent types. */
        //free_entity(p);
      }
    }
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, dummy_identifier, dummy_identifier_p, dummy_parameter_entity_p(), ENDP, ENTITY, entity_formal_p(), entity_initial, entity_name, entity_type, entity_undefined_p, f(), find_ith_parameter(), functional_parameters, gen_free_list(), gen_length(), gen_nconc(), gen_remove(), list_undefined, MAP, NIL, PARAMETER, parameter_dummy, pips_assert, pips_debug, POP, REFERENCE, reference_variable, remove_entity_type_stacks(), type_functional, type_functional_p, typedef_entity_p(), update_dummy_parameter(), value_code, value_code_p, value_intrinsic_p, and value_undefined_p.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveFromExterns()

void RemoveFromExterns

(

entity

e

)

This may happen when functional arguments are dealt with

Definition at line 2884 of file util.c.

{
  entity f = get_current_module_entity();
  if(!entity_undefined_p(f)) {
    code fc = value_code(entity_initial(f));
 
    gen_remove(&code_externs(fc), (void *) e);
  }
  else {
    /* This may happen when functional arguments are dealt with */
    c_parser_user_warning("The C parser should not execute this call.\n");
  }
}

References c_parser_user_warning, code_externs, entity_initial, entity_undefined_p, f(), gen_remove(), get_current_module_entity(), and value_code.

Referenced by actual_c_parser(), and FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

RenameFunctionEntity()

entity RenameFunctionEntity

(

entity

oe

)

Rename function oe if necessary.

The function name may be wrong because not enough information was available when it was created by FindOrCreateCurrentEntity().

oe must be a function and not a pointer to a function

oe should be added to the declarations of the current block

A C function or intrinsics name should include no scope information. But a functional typedef should.

In fact, we'd like to know if it is found before we create it...

FI I do not understand how formal parameters could be declared before

We assume oe is not already part of a declaration list since its formal parameters have been taken care of

Parameters

oe

e

Definition at line 1556 of file util.c.

{
  entity ne = oe;
  string oen = entity_name(oe);
  const char* oeln = entity_local_name(oe);
  string sn = local_name_to_scope(oeln);
  //type oet = entity_type(oe);
 
  /* A C function or intrinsics name should include no scope
     information. But a functional typedef should. */
  if(!typedef_entity_p(oe) && !empty_string_p(sn)) {
    if(strchr(oen, MODULE_SEP)!=NULL) {
      //string mn = entity_module_name(ne);
      const char * ln = entity_user_name(ne);
      value voe = entity_initial(oe);
      stack s = get_from_entity_type_stack_table(oe);
      stack ns = stack_copy(s);
 
      /* In fact, we'd like to know if it is found before we create it... */
      ne = FindEntity(TOP_LEVEL_MODULE_NAME, ln);
      if(entity_undefined_p(ne)) {
        ne = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, ln );
        entity_type(ne) = copy_type(entity_type(oe));
        entity_storage(ne) = copy_storage(entity_storage(oe));
        /* FI I do not understand how formal parameters could be declared before */
        if(value_undefined_p(voe) || value_unknown_p(voe))
          entity_initial(ne) = make_value(is_value_code,
                                          make_code(NIL,strdup(""), make_sequence(NIL),NIL, make_language_c()));
        else {
          list dl = list_undefined;
          entity_initial(ne) = copy_value(entity_initial(oe));
 
          dl = code_declarations(value_code(entity_initial(ne)));
          FOREACH(ENTITY, v, dl) {
            storage s = entity_storage(v);
            if(storage_formal_p(s)) {
              formal fs = storage_formal(s);
              formal_function(fs) = ne;
            }
          }
        }
        put_to_entity_type_stack_table(ne, ns);
      }
 
      pips_debug(1, "entity %s renamed %s\n", entity_name(oe), entity_name(ne));
 
      /* We assume oe is not already part of a declaration list since
         its formal parameters have been taken care of */
      gen_clear_tabulated_element((gen_chunkp)oe);
    }
  }
  free(sn);
  return ne;
}

References code_declarations, copy_storage(), copy_type(), copy_value(), empty_string_p(), ENTITY, entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined_p, entity_user_name(), FindEntity(), FindOrCreateEntity(), FOREACH, formal_function, free(), gen_clear_tabulated_element(), get_from_entity_type_stack_table(), is_value_code, list_undefined, local_name_to_scope(), make_code(), make_language_c(), make_sequence(), make_value(), MODULE_SEP, NIL, pips_debug, put_to_entity_type_stack_table(), stack_copy(), storage_formal, storage_formal_p, strdup(), TOP_LEVEL_MODULE_NAME, typedef_entity_p(), value_code, value_undefined_p, and value_unknown_p.

Here is the call graph for this function:

reset_current_dummy_parameter_number()

void reset_current_dummy_parameter_number

(

void

)

Definition at line 144 of file util.c.

{current_dummy_parameter_number=0;}

References current_dummy_parameter_number.

Referenced by actual_c_parser(), and c_parser_error().

Here is the caller graph for this function:

reset_preprocessor_line_analysis()

void reset_preprocessor_line_analysis

(

void

)

Definition at line 3592 of file util.c.

{
  buffer_initialized_p = false;
}

References buffer_initialized_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

ResetCurrentCompilationUnitEntity()

void ResetCurrentCompilationUnitEntity

(

bool

is_compilation_unit_parser

)

Let's redo the memory allocation for variables whose name has changed:-(

reset_entity_type_stack_table();

Parameters

is_compilation_unit_parser

s_compilation_unit_parser

Definition at line 349 of file util.c.

{
  /* Let's redo the memory allocation for variables whose name has changed:-(*/
  if(is_compilation_unit_parser)
    CCompilationUnitMemoryAllocation(get_current_module_entity());
  else
    CCompilationUnitMemoryReallocation(get_current_module_entity());
 
  /* reset_entity_type_stack_table(); */
  if (get_bool_property("PARSER_DUMP_SYMBOL_TABLE"))
    fprint_C_environment(stderr, get_current_module_entity());
  pips_debug(4,"Reset current module entity for compilation unit \"%s\"\n",
             get_current_module_name());
  reset_current_module_entity();
}

References CCompilationUnitMemoryAllocation(), CCompilationUnitMemoryReallocation(), fprint_C_environment(), get_bool_property(), get_current_module_entity(), get_current_module_name(), pips_debug, and reset_current_module_entity().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_dummy_parameter_number()

static void set_current_dummy_parameter_number ( int  n )

static

Definition at line 139 of file util.c.

{current_dummy_parameter_number=n+get_declaration_counter();}

References current_dummy_parameter_number, and get_declaration_counter().

Referenced by FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

set_entity_initial()

void set_entity_initial	(	entity	v,
		expression	nie
	)

Be careful if the initial value has already been set.

Detect double definitions when possible

Take care of the special case of pointers to functions.

The compilation unit has already been scanned once for declarations. Double definitions are no surprise...

Generate initializations for pointers to functions and arrays of pointers to functions

A pointer to a function already has value code as initial value. We may not even know yet it's a pointer...

Parameters

nie

ie

Definition at line 3469 of file util.c.

{
  value oiv = entity_initial(v);
 
  if(!value_undefined_p(oiv) && value_unknown_p(oiv)) {
    free_value(oiv);
    entity_initial(v) = value_undefined;
    oiv = value_undefined;
  }
 
  if(!value_undefined_p(oiv)) {
    if(compilation_unit_p(get_current_module_name())) {
      /* The compilation unit has already
         been scanned once for
         declarations. Double definitions
         are no surprise...*/
      if(value_code_p(oiv)) {
      /* Generate initializations for pointers to functions and arrays
         of pointers to functions */
        code c = value_code(oiv);
        statement s = make_expression_statement(nie);
 
        code_initializations(c) = make_sequence(CONS(STATEMENT, s, NIL));
      }
    }
    else {
      type vt = entity_type(v);
      type uvt = type_undefined_p(vt)? type_undefined
        : ultimate_type(entity_type(v));
      if(!type_undefined_p(uvt) &&
         ((pointer_type_p(uvt) &&
           type_functional_p(basic_pointer(variable_basic(type_variable(uvt)))))
          || type_functional_p(uvt)) ) {
        /* A pointer to a function already has value code as initial
           value. We may not even know yet it's a pointer... */
        code c = value_code(oiv);
        statement s = make_expression_statement(nie);
 
        code_initializations(c) = make_sequence(CONS(STATEMENT, s, NIL));
        //c_parser_user_warning("The initialization of a function pointer is lost\n");
      }
      else {
        c_parser_user_warning(
          "double definition of initial"
          " value for variable \"%s\"", entity_name(v));
 
        // FI: I am not sure it so good to put any junk in any format in the
        // Warning file.  FC: Indeed:-)
 
        string initv = expression_to_string(nie);
        string currv;
        if(value_expression_p(oiv))
          currv = expression_to_string(value_expression(oiv));
        else
          asprintf(&currv, "value tag: %d", value_tag(entity_initial(v)));
 
        pips_user_warning("New initial value expression:\n%s"
                          "Current initial value:\n%s",
                          initv, currv);
        free(initv);
        free(currv);
        pips_internal_error("Scoping might be the reason.");
      }
    }
  }
 
  if(value_undefined_p(entity_initial(v)))
    entity_initial(v) = make_value_expression(nie);
}

References asprintf, basic_pointer, c_parser_user_warning, code_initializations, compilation_unit_p(), CONS, entity_initial, entity_name, entity_type, expression_to_string(), free(), free_value(), get_current_module_name(), make_expression_statement(), make_sequence(), make_value_expression(), NIL, pips_internal_error, pips_user_warning, pointer_type_p(), STATEMENT, type_functional_p, type_undefined, type_undefined_p, type_variable, ultimate_type(), value_code, value_code_p, value_expression, value_expression_p, value_tag, value_undefined, value_undefined_p, value_unknown_p, and variable_basic.

Referenced by freia_is_transpose_call().

Here is the call graph for this function:

Here is the caller graph for this function:

StackPop()

void StackPop

(

stack

OffsetStack

)

The OffsetStack is poped n times, where n is the number of formal arguments of the actual function.

Parameters

OffsetStack

ffsetStack

Definition at line 3450 of file util.c.

{
  int n = basic_int((basic) stack_head(OffsetStack));
  NStackPop(OffsetStack,n);
}

References basic_int, NStackPop(), OffsetStack, and stack_head().

Here is the call graph for this function:

StackPush()

void StackPush

(

stack

OffsetStack

)

The OffsetStack is pushed incrementally.

Parameters

OffsetStack

ffsetStack

Definition at line 3457 of file util.c.

{
  int i = basic_int((basic) stack_head(OffsetStack));
  stack_push((char *) make_basic_int(i+1),OffsetStack);
}

References basic_int, make_basic_int(), OffsetStack, stack_head(), and stack_push().

Here is the call graph for this function:

SubstituteDummyParameters()

void SubstituteDummyParameters	(	entity	f,
		list	el
	)

The copy could be avoided by substituting v->s with nv->s

Store type information. Might be useless.

Inherit any attribute you can

Parameters

el

l

Definition at line 2351 of file util.c.

{
  for(list cel=el; !ENDP(cel); POP(cel)) {
    entity v = ENTITY(CAR(cel));
    if(dummy_parameter_entity_p(v)) {
      const char* mn = entity_local_name(f);
      const char * ln = entity_user_name(v);
      entity nv = FindOrCreateEntity(mn, ln);
      stack s = get_from_entity_type_stack_table(v);
      /* The copy could be avoided by substituting v->s with nv->s */
      stack ns = stack_copy(s);
      ENTITY_(CAR(cel)) = nv;
 
      /* Store type information. Might be useless. */
      put_to_entity_type_stack_table(nv, ns);
      remove_entity_type_stack(v);
 
      /* Inherit any attribute you can */
      if(!type_undefined_p(entity_type(v)))
        entity_type(nv) = copy_type(entity_type(v));
      if(!value_undefined_p(entity_initial(v)))
        entity_initial(nv) = copy_value(entity_initial(v));
      if(!storage_undefined_p(entity_storage(v)))
        entity_storage(nv) = copy_storage(entity_storage(v));
    }
  }
}

References CAR, copy_storage(), copy_type(), copy_value(), dummy_parameter_entity_p(), ENDP, ENTITY, ENTITY_, entity_initial, entity_local_name(), entity_storage, entity_type, entity_user_name(), f(), FindOrCreateEntity(), get_from_entity_type_stack_table(), POP, put_to_entity_type_stack_table(), remove_entity_type_stack(), stack_copy(), storage_undefined_p, type_undefined_p, and value_undefined_p.

Here is the call graph for this function:

TakeDerivedEntities()

list TakeDerivedEntities

(

list

le

)

To simplify debugging

The list is stored there at line 2087 of cyacc.y (5 August 2009)

e->type==entity_domain

lres = gen_nconc(lres,ltmp);

The ltmp lists seem to be somehow shared as shown in ngspice/main.tpips. The previous implementation of the current function generated cyclic lists. The new implementation is incompatible with a proper memory management.

I do not understand what's done in c_syntax/cyacc.y. The trace obtained from C_syntax/ngspice01.c shows that the same derived entities appear several times when dummy structs and unions are embedded as in ngspice01.c

Parameters

le

e

Definition at line 3020 of file util.c.

{
  list lres = NIL;
 
  if(!ENDP(le)) { /* To simplify debugging */
 
    pips_debug(8, "Begin\n");
 
    ifdebug(8) {
      pips_debug(8, "Input entity list: ");
      print_entities(le);
      fprintf(stderr, "\n");
    }
 
    FOREACH (ENTITY, e, le) {
      /* The list is stored there at line 2087 of cyacc.y (5 August
         2009) */
      //list ltmp = (list) entity_initial(e);
      list sltmp = (list) entity_initial(e);
      if(!ENDP(sltmp)) {
        // pips_assert("sltmp has only one element", gen_length(sltmp)==1);
        // statement stmp = STATEMENT(CAR(sltmp));
        // list ltmp = statement_declarations(stmp);
        list ltmp = sltmp;
 
        //pips_assert("sltmp is a continue statement list",
        // continue_statements_p(sltmp));
        pips_assert("e is an entity",
                    check_entity(e) /* e->_type_==entity_domain*/ );
        pips_debug(8, "entity e: %s (%p)\n", entity_name(e), e);
 
        if (ltmp != NIL) {
          /* lres = gen_nconc(lres,ltmp);*/
          FOREACH(ENTITY, de, ltmp) {
 
            pips_assert("de is an entity", de->_type_==entity_domain);
            pips_debug(8, "entity de: %s (%p)\n", entity_name(de), de);
 
            if(!gen_in_list_p(de, lres)) {
              lres = gen_nconc(lres, CONS(ENTITY, de, NIL));
            }
          }
        }
      }
      /* The ltmp lists seem to be somehow shared as shown in
       * ngspice/main.tpips. The previous implementation of the
       * current function generated cyclic lists. The new
       * implementation is incompatible with a proper memory
       * management.
       *
       * I do not understand what's done in c_syntax/cyacc.y. The
       * trace obtained from C_syntax/ngspice01.c shows that the same
       * derived entities appear several times when dummy structs and
       * unions are embedded as in ngspice01.c
       */
      //gen_free_list(ltmp);
      entity_initial(e) = value_undefined;
    }
    pips_assert ("an acyclic list is generated", !gen_list_cyclic_p (lres));
 
    ifdebug(8) {
      pips_debug(8, "Output entity list: ");
      if(ENDP(lres)) {
        fprintf(stderr, "NIL\n");
      }
      else {
        print_entities(lres);
        fprintf(stderr, "\n");
      }
    }
 
    pips_debug(8, "End\n");
  }
 
  return lres;
}

References check_entity(), CONS, ENDP, ENTITY, entity_domain, entity_initial, entity_name, FOREACH, fprintf(), gen_in_list_p(), gen_list_cyclic_p(), gen_nconc(), ifdebug, NIL, pips_assert, pips_debug, print_entities(), and value_undefined.

Here is the call graph for this function:

UpdateAbstractEntity()

void UpdateAbstractEntity	(	entity	e,
		stack	ContextStack
	)

Update the entity with final type, storage

tc must have variable type, add lq to its qualifiers

lse const void, void is not of type variable, store const where ????????? CParserError("Entity has qualifier but no type or is not variable type in the context?\n");

Use the type stack in entity_storage to create the final type for the entity

Parameters

ContextStack

ontextStack

Definition at line 2842 of file util.c.

{
  /* Update the entity with final type, storage */
 
  //stack s = (stack) entity_storage(e);
  stack s = get_from_entity_type_stack_table(e);
  type t = entity_type(e);
  c_parser_context context = stack_head(ContextStack);
  type tc = c_parser_context_type(context);
  type t1,t2;
  list lq = c_parser_context_qualifiers(context);
 
  pips_debug(3,"Update abstract entity %s\n",entity_name(e));
 
  if (lq != NIL)
    {
      /* tc must have variable type, add lq to its qualifiers */
      if (!type_undefined_p(tc) && type_variable_p(tc))
        variable_qualifiers(type_variable(tc)) = lq;
      /*else
        const void, void is not of type variable, store const where ?????????
        CParserError("Entity has qualifier but no type or is not variable type in the context?\n");*/
    }
 
  /************************* TYPE PART *******************************************/
 
  /* Use the type stack in entity_storage to create the final type for the entity*/
  t2 = UpdateType(t,tc);
 
  while (stack_size(s) > 1)
    {
      t1 = stack_pop(s);
      t2 = UpdateType(t1,t2);
    }
  entity_type(e) = t2;
 
  /************************* STORAGE PART *******************************************/
 
  entity_storage(e) = storage_undefined;
}

References c_parser_context_qualifiers, c_parser_context_type, ContextStack, entity_name, entity_storage, entity_type, get_from_entity_type_stack_table(), NIL, pips_debug, stack_head(), stack_pop(), stack_size(), storage_undefined, tc, type_undefined_p, type_variable, type_variable_p, UpdateType(), and variable_qualifiers.

Here is the call graph for this function:

UpdateArrayEntity()

void UpdateArrayEntity	(	entity	e,
		list	lq,
		list	le
	)

lq is for what ? e or le ????: lq should be for le

Parameters

lq	q
le	e

Definition at line 1514 of file util.c.

{
  type t = entity_type(e);
  pips_debug(3,"Update array entity %s\n",entity_name(e));
 
  /* lq is for what ? e or le ????: lq should be for le*/
  if (type_undefined_p(t))
    {
      pips_debug(3,"First array dimension\n");
      entity_type(e) =
        make_type_variable(make_variable(basic_undefined,
                                         CONS(DIMENSION,MakeDimension(le, lq),NIL),
                                         NIL));
    }
  else
    {
      pips_debug(3,"Next array dimension\n");
      if (type_variable_p(t))
        {
          variable v = type_variable(t);
          variable_qualifiers(v) = gen_nconc(variable_qualifiers(v),lq);
          variable_dimensions(v) =
            gen_nconc(variable_dimensions(v),
                      CONS(DIMENSION, MakeDimension(le, lq), NIL));
        }
      else
        {
          CParserError("Dimension for not variable type\n");
        }
    }
}

References basic_undefined, CONS, CParserError(), DIMENSION, entity_name, entity_type, gen_nconc(), make_type_variable(), make_variable(), MakeDimension(), NIL, pips_debug, type_undefined_p, type_variable, type_variable_p, variable_dimensions, and variable_qualifiers.

Here is the call graph for this function:

UpdateDerivedEntities()

void UpdateDerivedEntities	(	list	ld,
		list	le,
		stack	ContextStack
	)

Parameters

ld	d
le	e
ContextStack	ontextStack

Definition at line 3097 of file util.c.

{
  FOREACH (ENTITY, e, le) {
    UpdateDerivedEntity(ld,e,ContextStack);
  }
}

References ContextStack, ENTITY, FOREACH, and UpdateDerivedEntity().

Here is the call graph for this function:

UpdateDerivedEntity()

void UpdateDerivedEntity	(	list	ld,
		entity	e,
		stack	ContextStack
	)

Update the derived entity with final type and rom storage. If the entity has bit type, do not need to update its type

what about context qualifiers ?

What do we do for functional types for instance?

FI: I assume the qualifiers are carried by the result

What do we do for functional types for instance?

Although it should be popped from the stack, the current context seems to be used later in case of typedef, such as seen in decl24.c

Temporally put the list of struct/union entities defined in decl_psec_list to initial value of ent

Parameters

ld	d
ContextStack	ontextStack

Definition at line 2942 of file util.c.

{
  /* Update the derived entity with final type and rom storage.
     If the entity has bit type, do not need to update its type*/
  type t = entity_type(e);
  pips_debug(3,"Update derived entity %s\n",entity_name(e));
  if (!bit_type_p(t))
    {
      //stack s = (stack) entity_storage(e);
      stack s = get_from_entity_type_stack_table(e);
      c_parser_context context = stack_head(ContextStack);
      type tc = c_parser_context_type(context);
      type t1,t2;
      list ql = c_parser_context_qualifiers(context);
 
      /* what about context qualifiers ? */
      t2 = UpdateType(t,tc);
 
      while (stack_size(s) > 1)
        {
          t1 = stack_pop(s);
          t2 = UpdateType(t1,t2);
        }
      entity_type(e) = t2;
 
      if(!ENDP(ql)) {
        if(type_void_p(t2)) {
          type_void(t2) = ql;
        }
        else if(type_variable_p(t2)) {
          if(pointer_type_p(t2)) {
            // The qualifiers must be stored on the effective pointed type
            // type pt = type_to_final_pointed_type(t2);
            // type pt = type_to_pointed_type(t2);
            type pt = basic_pointer(variable_basic(type_variable(t2)));
            if(type_void_p(pt))
              type_void(pt) = ql;
            else if(type_variable_p(pt)) {
              // If pt is a typedef, the typedef is altered...
              variable_qualifiers(type_variable(pt)) = ql;
              //variable_qualifiers(type_variable(t2)) = ql;
            }
            else if(type_functional_p(pt)) {
              /* What do we do for functional types for instance? */
              /* FI: I assume the qualifiers are carried by the
                 result */
              functional f = type_functional(pt);
              type rt = functional_result(f);
              if(type_variable_p(rt))
          variable_qualifiers(type_variable(rt)) = ql;
              else
          pips_internal_error("???");
            }
            else {/* What do we do for functional types for instance? */
              // FI: I assume the qualifiers are carried by the result
              pips_internal_error("???");
            }
          }
          else {
            variable_qualifiers(type_variable(t2)) = ql;
          }
        }
        else
          pips_internal_error("unexpected type");
        /* Although it should be popped from the stack, the current
           context seems to be used later in case of typedef, such as
           seen in decl24.c */
        c_parser_context_qualifiers(context) = NIL;
      }
    }
  entity_storage(e) = make_storage_rom();
 
  /* Temporally put the list of struct/union entities defined in
     decl_psec_list to initial value of ent */
  entity_initial(e) = (value) ld;
 
}

References basic_pointer, bit_type_p(), c_parser_context_qualifiers, c_parser_context_type, ContextStack, ENDP, entity_initial, entity_name, entity_storage, entity_type, f(), functional_result, get_from_entity_type_stack_table(), make_storage_rom(), NIL, pips_debug, pips_internal_error, pointer_type_p(), stack_head(), stack_pop(), stack_size(), tc, type_functional, type_functional_p, type_variable, type_variable_p, type_void, type_void_p, UpdateType(), variable_basic, and variable_qualifiers.

Referenced by UpdateDerivedEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEntities()

void UpdateEntities	(	list	le,
		stack	ContextStack,
		stack	FormalStack,
		stack	FunctionStack,
		stack	OffsetStack,
		bool	is_external,
		bool	is_declaration
	)

Parameters

le	e
ContextStack	ontextStack
FormalStack	ormalStack
FunctionStack	unctionStack
OffsetStack	ffsetStack
is_external	s_external
is_declaration	s_declaration

Definition at line 2733 of file util.c.

{
  FOREACH(ENTITY, e, le) {
    if(!derived_entity_p(e))
      UpdateEntity(e,ContextStack,FormalStack,FunctionStack,OffsetStack,
                   is_external,is_declaration);
  }
}

References ContextStack, derived_entity_p(), ENTITY, FOREACH, FormalStack, FunctionStack, is_external, OffsetStack, and UpdateEntity().

Here is the call graph for this function:

UpdateEntity()

void UpdateEntity	(	entity	e,
		stack	ContextStack,
		stack	FormalStack,
		stack	FunctionStack,
		stack	OffsetStack,
		bool	is_external,
		bool	is_declaration
	)

Update the entity with final type, storage and initial value; and also (sometimes?) declare it at the module level.

Replace dummy arguments by formal arguments for functions

Generate the return variables for functions returning a result

And probably much more...

If e is an intrinsics, nothing should be done, unless you are in the compilation unit: but the intrinsic type has already been put aside in the type stack linked to the entity and destroyed

tc must have variable type, add lq to its qualifiers

lse const void, void is not of type variable, store const where ????????? CParserError("Entity has qualifier but no type or is not variable type in the context?\n");

Use the type stack in entity_storage to create the final type for the entity

The default type is int, or a function returning an int

FI: it might be a good idea to use the type "unknown" or a future type "default" to improve the prettyprinting by not adding implicit "int" declarations.

The default type is int

FI: This elseif branch is apparently useless because the probleme must be dealt with later in the parser

The default return type is int

FI: no longer true, I believe "this field is always pre-defined. It is temporarilly used to store a type. See cyacc.y rule direct-decl:"

FI: Intrinsic do not have formal named parameters in PIPS RI, however such parameters can be named in intrinsic declarations. Problem with Validation/C_syntax/memcof.c

|| type_variable_p(entity_type(function))

Storage does also matter for typedef (and function pointer)

How to access the information about the function type?

FI: This branch should never be executed

The entities for the type_variable is added to the current module and the declarations

It is too early to use extern_entity_p()

Keyword EXTERN has just been encountered

Yes, but this may have been already recognized in FindOrCreateCurrentEntity() and this may not imply the declaration as extern is another declaration of e has already been encountered.

To avoid multiple declarations

Too late to check that the first declaration did not include an initialization

The function should also added to the declarations

We are defining the current module entity

Test case C_syntax/function_name_conflict01.c

Unfortunately, an intrinsics cannot be redefined, just like a user function or subroutine after editing because intrinsics are not handled like user functions or subroutines. They are not added to the called_modules list of other modules, unless the redefining module is parsed FIRST. There is not mechanism in PIPS to control the parsing order.

Be careful if standard arguments are needed: replace the dummy parameters

FI: intrinsic may need to be processed here if they use dynamic typing, a.k.a. dependent types but they do not have a code value!

They cannot be removed in general because they may appear in declarations as in foo(int n, double a[n])

FI: I do not know if refs contains copies of references or just pointer to them

If e is a function pointer, check the storage of its formal parameters

Parameters

ContextStack	ontextStack
FormalStack	ormalStack
FunctionStack	unctionStack
OffsetStack	ffsetStack
is_external	s_external
is_declaration	s_declaration

Definition at line 2473 of file util.c.

{
  //stack s = (stack) entity_storage(e);
  stack s = get_from_entity_type_stack_table(e);
  type t = entity_type(e);
  c_parser_context context = stack_head(ContextStack);
  type tc = c_parser_context_type(context);
  type t1,t2;
  list lq = c_parser_context_qualifiers(context);
 
  pips_debug(3,"Update entity begins for \"%s\" with context %p\n", entity_name(e), context);
 
  /* If e is an intrinsics, nothing should be done, unless you are in
     the compilation unit: but the intrinsic type has already been
     put aside in the type stack linked to the entity and destroyed */
  if(false && intrinsic_entity_p(e) && !compilation_unit_p(get_current_module_name()))
    return;
 
  if (lq != NIL)
    {
      /* tc must have variable type, add lq to its qualifiers */
      if (!type_undefined_p(tc) && type_variable_p(tc))
        variable_qualifiers(type_variable(tc)) = lq;
      else if(type_void_p(tc))
        type_void(tc) = lq;
      /*else
        const void, void is not of type variable, store const where ?????????
        CParserError("Entity has qualifier but no type or is not variable type in the context?\n");*/
      c_parser_context_qualifiers(context) = NIL;
    }
 
  /************************* TYPE PART *******************************************/
 
  /* Use the type stack in entity_storage to create the final type for the entity*/
  //pips_assert("context type tc is defined", !type_undefined_p(tc));
  t2 = UpdateType(t,tc);
 
  if(t2!=t) {
    if(!stack_undefined_p(s)) {
      while (stack_size(s) > 1)
        {
          t1 = stack_pop(s);
          t2 = UpdateType(t1,t2);
        }
      if(type_undefined_p(t2)) {
        /* The default type is int, or a function returning an int */
        t2 = make_scalar_integer_type(DEFAULT_INTEGER_TYPE_SIZE);
      }
    }
    entity_type(e) = t2;
  }
 
  /* FI: it might be a good idea to use the type "unknown" or a
     future type "default" to improve the prettyprinting by not
     adding implicit "int" declarations. */
  if(type_undefined_p(entity_type(e))) {
    /* The default type is int */
    entity_type(e) =
      make_type_variable(make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL));
  }
  /* FI: This elseif  branch is apparently useless because the
     probleme must be dealt with later in the parser */
  else if(type_functional_p(entity_type(e))) {
    functional f = type_functional(entity_type(e));
    type rt = functional_result(f);
    if(type_undefined_p(rt)) {
      /* The default return type is int */
      functional_result(f) =
        make_type_variable(make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL));
    }
  }
  pips_assert("the entity type is defined", !type_undefined_p(entity_type(e)));
 
  /************************* STORAGE PART *******************************************/
 
  /* FI: no longer true, I believe "this field is always
     pre-defined. It is temporarilly used to store a type. See cyacc.y
     rule direct-decl:" */
 
 
  if (!storage_undefined_p(c_parser_context_storage(context))) {
    pips_debug(3,"Current storage context is %d\n",
               storage_tag(c_parser_context_storage(context)));
    entity_storage(e) = c_parser_context_storage(context);
    if(typedef_entity_p(e)) {
      AddToDeclarations(e,get_current_module_entity());
    }
  }
  else if (!stack_undefined_p(FormalStack) && (FormalStack != NULL)
           && !stack_empty_p(FormalStack)) {
    entity function = stack_head(FunctionStack);
    int offset = basic_int((basic) stack_head(OffsetStack));
    pips_debug(3,"Create formal variable %s for function %s with offset %d\n",
               entity_name(e),entity_name(function),offset);
    if(!value_intrinsic_p(entity_initial(function))) {
      /* FI: Intrinsic do not have formal named parameters in PIPS
         RI, however such parameters can be named in intrinsic
         declarations. Problem with Validation/C_syntax/memcof.c */
      AddToDeclarations(e,function);
    }
    if(dummy_parameter_entity_p(e)) {
      if(typedef_entity_p(function) /* || type_variable_p(entity_type(function)) */)
        /* Storage does also matter for typedef (and function pointer) */
        /* How to access the information about the function type? */
        entity_storage(e) = make_storage_rom();
      else
        entity_storage(e) = make_storage_formal(make_formal(function,offset));
    }
    else
      /* FI: This branch should never be executed */
      entity_storage(e) = make_storage_formal(make_formal(function,offset));
  }
  else if(type_variable_p(ultimate_type(entity_type(e)))) {
    /* The entities for the type_variable is added to the
       current module and the declarations*/
    entity function = get_current_module_entity();
 
    /* It is too early to use extern_entity_p() */
    //if(extern_entity_p(function, e))
    if(strstr(entity_name(e),TOP_LEVEL_MODULE_NAME) != NULL)
      if(!empty_scope_p(c_parser_context_scope(context))) {
        /* Keyword EXTERN has just been encountered */
        /* Yes,  but this may have been already recognized in
           FindOrCreateCurrentEntity() and this may not imply the
           declaration as extern is another declaration of e has
           already been encountered. */
        type et = ultimate_type(entity_type(e));
        if(type_functional_p(et))
          AddToExterns(e,function);
      }
 
    /* To avoid multiple declarations */
    list el = code_externs(value_code(entity_initial(function)));
    list dl = code_declarations(value_code(entity_initial(function)));
    if(!gen_in_list_p(e, el) && gen_in_list_p(e, dl)) {
      if(compilation_unit_entity_p(function)) {
        /* Too late to check that the first declaration did not
           include an initialization */
        c_parser_user_warning("Multiple declarations of variable \"%s\".\n",
                              entity_local_name(e));
      }
      else {
        user_log("Multiple declarations of variable \"%s\" in file\"%s\".\n",
                 entity_local_name(e), get_c_parser_current_input_file_name());
        CParserError("Illegal Input");
      }
    }
 
    AddToDeclarations(e,function);
 
    // Check here if already stored the value
    if(storage_undefined_p(entity_storage(e)))
      entity_storage(e) =
        MakeStorageRam(e,is_external,c_parser_context_static(context));
  }
  else if (type_functional_p(ultimate_type(entity_type(e)))){
    /* The function should also added to the declarations */
    if(!entity_undefined_p(get_current_module_entity()))
      AddToDeclarations(e, get_current_module_entity());
    else if(!intrinsic_entity_p(e)) {
      /* We are defining the current module entity */
      CreateReturnEntity(e);
    }
    else {
      /* Test case C_syntax/function_name_conflict01.c */
      c_parser_user_warning("Intrinsic %s redefined.\n"
                        "This is not supported by PIPS. Please rename \"%s\"\n",
                        entity_local_name(e), entity_local_name(e));
      /* Unfortunately, an intrinsics cannot be redefined, just like a user function
       * or subroutine after editing because intrinsics are not handled like
       * user functions or subroutines. They are not added to the called_modules
       * list of other modules, unless the redefining module is parsed FIRST.
       * There is not mechanism in PIPS to control the parsing order.
       */
      CParserError("Name conflict between a "
                   "function and an intrinsic\n");
    }
    entity_storage(e) = make_storage_rom();
  }
  else
    pips_assert("not implemented yet", false);
 
 
  /************************* INITIAL VALUE PART ****************************************/
  if(value_undefined_p(entity_initial(e))) {
    entity_initial(e) = make_value_unknown();
    //type t = entity_type(e);
    //type ut = ultimate_type(t);
    //if(type_functional(ut) && !typedef_entity_p(e))
    //  entity_initial(e) = make_value_code(make_code(NIL, strdup(""),make_sequence(NIL),NIL, make_language_c()));
    //else
    //  entity_initial(e) = make_value_unknown();
  }
 
  /* Be careful if standard arguments are needed: replace the dummy parameters */
  if(true || !is_declaration) {
    type t = entity_type(e);
    /* FI: intrinsic may need to be processed here if they use dynamic
       typing, a.k.a. dependent types but they do not have a code
       value!*/
    if(type_functional_p(t) && !typedef_entity_p(e) && !intrinsic_entity_p(e)) {
      if(is_declaration) {
        /* They cannot be removed in general because they may appear
           in declarations as in foo(int n, double a[n]) */
        value ev = entity_initial(e);
        code ec = value_code(ev);
        list cmdl = code_declarations(ec);
        list refs =  extract_references_from_declarations(cmdl);
 
        RemoveDummyArguments(e, refs);
 
          /* FI: I do not know if refs contains copies of references or just pointer to them */
        gen_free_list(refs);
      }
      else
        UseFormalArguments(e);
    }
  }
 
  /* If e is a function pointer, check the storage of its formal parameters */
  if(pointer_type_p(entity_type(e))) {
    type pt = basic_pointer(variable_basic(type_variable(entity_type(e))));
    if(type_functional_p(pt)) {
      code c = value_code(entity_initial(e));
 
      pips_assert("Although it's a pointer to a function, it has code...",
                  value_code_p(entity_initial(e)));
 
      if(code_undefined_p(c))
        pips_internal_error("Well, the code field is not defined yet...");
      else {
        list dl = code_declarations(c);
        list cl = list_undefined;
 
        for(cl=dl; !ENDP(cl); POP(cl)) {
          entity pe = ENTITY(CAR(cl));
 
          if(formal_parameter_p(pe)) {
            storage ps = entity_storage(pe);
 
            pips_debug(8, "Change storage from \"formal\" to \"rom\" for entity \"%s\"\n",
                       entity_name(pe));
            free_storage(ps);
            entity_storage(pe) = make_storage_rom();
          }
        }
      }
    }
  }
 
  pips_debug(3,"Update entity ends for \"%s\" with type \"%s\" and storage \"%s\"\n",
             entity_name(e),
             list_to_string(safe_c_words_entity(entity_type(e), NIL)),
             storage_to_string(entity_storage(e)));
 
  pips_assert("Current entity is consistent",entity_consistent_p(e));
}

References AddToDeclarations(), AddToExterns(), basic_int, basic_pointer, c_parser_context_qualifiers, c_parser_context_scope, c_parser_context_static, c_parser_context_storage, c_parser_context_type, c_parser_user_warning, CAR, code_declarations, code_externs, code_undefined_p, compilation_unit_entity_p(), compilation_unit_p(), ContextStack, CParserError(), CreateReturnEntity(), DEFAULT_INTEGER_TYPE_SIZE, dummy_parameter_entity_p(), empty_scope_p(), ENDP, ENTITY, entity_consistent_p(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined_p, extract_references_from_declarations(), f(), formal_parameter_p(), FormalStack, free_storage(), functional_result, FunctionStack, gen_free_list(), gen_in_list_p(), get_c_parser_current_input_file_name(), get_current_module_entity(), get_current_module_name(), get_from_entity_type_stack_table(), intrinsic_entity_p(), is_external, list_to_string(), list_undefined, make_basic_int(), make_formal(), make_scalar_integer_type(), make_storage_formal(), make_storage_rom(), make_type_variable(), make_value_unknown(), make_variable(), MakeStorageRam(), NIL, offset, OffsetStack, pips_assert, pips_debug, pips_internal_error, pointer_type_p(), POP, RemoveDummyArguments(), safe_c_words_entity(), stack_empty_p(), stack_head(), stack_pop(), stack_size(), stack_undefined_p, storage_tag, storage_to_string(), storage_undefined_p, tc, TOP_LEVEL_MODULE_NAME, type_functional, type_functional_p, type_undefined_p, type_variable, type_variable_p, type_void, type_void_p, typedef_entity_p(), ultimate_type(), UpdateType(), UseFormalArguments(), user_log(), value_code, value_code_p, value_intrinsic_p, value_undefined_p, variable_basic, and variable_qualifiers.

Referenced by UpdateEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEntity2()

void UpdateEntity2	(	entity	f,
		stack FormalStack	__attribute__(__unused__),
		stack OffsetStack	__attribute__(__unused__)
	)

A subset of UpdateEntity, used when the function entity is already more defined because the return type is implicit.

See call site cyacc.y

The return value is created when needed.

The dummy parameters are used to create the formal parameters.

Definition at line 2431 of file util.c.

{
  type ft = ultimate_type(entity_type(f));
  list dl = code_declarations(value_code(entity_initial(f)));
  list cl = list_undefined;
  int rank = 1; // formal parameter offset
 
  pips_assert("f has a functional type", type_functional_p(ft));
 
  CreateReturnEntity(f);
 
  for(cl = dl; !ENDP(cl); POP(cl)) {
    entity v = ENTITY(CAR(cl));
    if(dummy_parameter_entity_p(v)) {
      const char * ln = entity_user_name(v);
      const char* mn = entity_local_name(f);
      entity fp = FindEntity(mn, ln);
      if(entity_undefined_p(fp)) {
        fp = FindOrCreateEntity(mn, ln);
        entity_type(fp) = copy_type(entity_type(v));
        entity_initial(fp) = make_value_unknown();
        entity_storage(fp) = make_storage_formal(make_formal(f, rank));
        rank++;
        ENTITY_(CAR(cl)) = fp; // substitute v by fp in the declaration list
      }
    }
  }
 
}

References CAR, code_declarations, copy_type(), CreateReturnEntity(), dummy_parameter_entity_p(), ENDP, ENTITY, ENTITY_, entity_initial, entity_local_name(), entity_storage, entity_type, entity_undefined_p, entity_user_name(), f(), FindEntity(), FindOrCreateEntity(), list_undefined, make_formal(), make_storage_formal(), make_value_unknown(), pips_assert, POP, rank, type_functional_p, ultimate_type(), and value_code.

Here is the call graph for this function:

UpdateFinalPointer()

type UpdateFinalPointer	(	type	pt,
		type	t
	)

This function replaces the type pointed by the pointer pt (this can be a pointer of pointer,... so we have to go until the last one) by the type t

Parameters

pt

t

Definition at line 1427 of file util.c.

{
  /* This function replaces the type pointed by the pointer pt
     (this can be a pointer of pointer,... so we have to go until the last one)
     by the type t*/
  pips_debug(3,"Update final pointer type %d and %d\n", type_tag(pt), type_tag(t));
  if (type_variable_p(pt) && basic_pointer_p(variable_basic(type_variable(pt))))
    {
      type ppt = basic_pointer(variable_basic(type_variable(pt)));
      if (type_undefined_p(ppt))
        return make_type_variable(make_variable(make_basic_pointer(t),NIL,variable_qualifiers(type_variable(pt))));
      return UpdateFinalPointer(ppt,t);
    }
  CParserError("pt is not a pointer\n");
  return type_undefined;
}

References basic_pointer, basic_pointer_p, CParserError(), make_basic_pointer(), make_type_variable(), make_variable(), NIL, pips_debug, type_tag, type_undefined, type_undefined_p, type_variable, type_variable_p, UpdateFinalPointer(), variable_basic, and variable_qualifiers.

Referenced by UpdateFinalPointer().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFunctionEntity()

void UpdateFunctionEntity	(	entity	oe,
		list	la
	)

The parser has found out that an entity is a function and partially sets its type.

The function may also be an intrinsics and be already fully defined.

If oe is an intrinsics, nothing should be done if we are compiling a function that redeclares intrinsics, because they are usually badly or at least only partly redeclared.

However, il should be updated if it's declared in a compilation unit as the header files may contain more up-to-date information than bootstrap. Or if its type has already been placed in the type stack and been undefined in the entity.

Note that a user function might have the same name as a C intrinsic. Then we are in trouble.

Is oe's name compatible with a function name? Well oe might be a pointer...

FI: We used never to bump into this case...

Parameters

oe	e
la	a

Definition at line 1614 of file util.c.

{
  type t = entity_type(oe);
  //string oeln = entity_local_name(oe);
  //string sn = local_name_to_scope(oeln);
  //entity ne = oe;
 
  pips_debug(3,"Update function entity \"%s\"\n",entity_name(oe));
 
  ifdebug(8) {
    pips_debug(8, "with type list la: ");
    if(ENDP(la)) {
      (void) fprintf(stderr, "empty list");
    }
    MAP(PARAMETER, at, {
      (void) fprintf(stderr, "%s, ", list_to_string(safe_c_words_entity(parameter_type(at), NIL)));
    }, la);
      (void) fprintf(stderr, "\n");
  }
 
  /* If oe is an intrinsics, nothing should be done if we are
     compiling a function that redeclares intrinsics, because they are
     usually badly or at least only partly redeclared.
 
     However, il should be updated if it's declared in a compilation unit
     as the header files may contain more up-to-date information than
     bootstrap. Or if its type has already been placed in the type
     stack and been undefined in the entity.
 
     Note that a user function might have the same name as a C
     intrinsic. Then we are in trouble.
  */
  if(intrinsic_entity_p(oe)
     && (!entity_undefined_p(get_current_module_entity())
         && !compilation_unit_p(get_current_module_name()))
     && !type_undefined_p(entity_type(oe)))
    return;
 
  /* Is oe's name compatible with a function name? Well oe might be a
     pointer... */
  // pips_assert("A function name does not include a scope", empty_string_p(sn));
 
  if (type_undefined_p(t))
    entity_type(oe) = make_type_functional(make_functional(la,type_undefined));
  else if(type_functional_p(t)) {
    /* FI: We used never to bump into this case... */
    functional f = type_functional(t);
    functional_parameters(f) = la;
  }
  else {
    pips_internal_error("What should be done here?");
    CParserError("This entity must have undefined type\n");
  }
 
  pips_debug(3,"Update function entity \"%s\" with type \"\%s\"\n",
             entity_name(oe),
             list_to_string(safe_c_words_entity(entity_type(oe), NIL)));
}

References compilation_unit_p(), CParserError(), ENDP, entity_name, entity_type, entity_undefined_p, f(), fprintf(), functional_parameters, get_current_module_entity(), get_current_module_name(), ifdebug, intrinsic_entity_p(), list_to_string(), make_functional(), make_type_functional(), MAP, NIL, PARAMETER, parameter_type, pips_debug, pips_internal_error, safe_c_words_entity(), type_functional, type_functional_p, type_undefined, and type_undefined_p.

Here is the call graph for this function:

UpdateParenEntity()

void UpdateParenEntity	(	entity	e,
		list	lq
	)

Parameters

lq

q

Definition at line 1368 of file util.c.

{
  type t = entity_type(e);
  pips_debug(3,"Update entity in parentheses \"%s\" with type \"%s\"\n",
             entity_name(e), safe_type_to_string(entity_type(e)));
  if (lq != NIL) {
    if (type_undefined_p(t))
      t = make_type_variable(make_variable(basic_undefined,list_undefined,lq));
    else {
      if (type_variable_p(t)) {
        variable v = type_variable(t);
        variable_qualifiers(v) = gen_nconc(variable_qualifiers(v),lq);
      }
      else {
        CParserError("Attributes for not variable type\n");
      }
    }
  }
}

References basic_undefined, CParserError(), entity_name, entity_type, gen_nconc(), list_undefined, make_type_variable(), make_variable(), NIL, pips_debug, safe_type_to_string(), type_undefined_p, type_variable, type_variable_p, and variable_qualifiers.

Here is the call graph for this function:

UpdatePointerEntity()

void UpdatePointerEntity	(	entity	e,
		type	pt,
		list	lq
	)

Make e an array of pointers whose type is this of pt

Make e a function returns a pointer

Parameters

pt	t
lq	q

Definition at line 1444 of file util.c.

{
  type t = entity_type(e);
  ifdebug(3) {
    list pdl = NIL;
    pips_debug(3,"Update pointer entity %s with type pt=\"%s\"\n",
               entity_name(e), list_to_string(c_words_entity(pt, NIL, &pdl)));
    gen_free_list(pdl);
  }
  if (type_undefined_p(t))
    {
      pips_debug(3,"Undefined entity type\n");
      entity_type(e) = pt;
      /*
      if(type_undefined_p(pt)) {
        type npt = make_type(is_type_variable,
                             make_variable(make_basic(is_basic_pointer, type_undefined),
                                           NIL, NIL));
        entity_type(e) = npt;
      }
      else if(type_variable_p(pt) && basic_pointer_p(variable_basic(type_variable(pt))))
        entity_type(e) = pt;
      else {
        type npt = make_type(is_type_variable,
                             make_variable(make_basic(is_basic_pointer, pt),
                                           NIL, NIL));
        entity_type(e) = npt;
      }
      */
 
      variable_qualifiers(type_variable(entity_type(e))) = gen_nconc(variable_qualifiers(type_variable(entity_type(e))),lq);
    }
  else
    {
      switch (type_tag(t)) {
      case is_type_variable:
        {
          /* Make e an array of pointers whose type is this of pt */
          variable v = type_variable(t);
          pips_debug(3,"Array of pointers\n");
          entity_type(e) = make_type_variable(make_variable(variable_basic(type_variable(pt)),
                                                            variable_dimensions(v),
                                                            gen_nconc(variable_qualifiers(v),lq)));
          break;
        }
      case is_type_functional:
        {
          /* Make e a function returns a pointer */
          functional f = type_functional(t);
          pips_debug(3,"Function returns a pointer \n");
          entity_type(e) =
            make_type_functional(make_functional(functional_parameters(f),pt));
          break;
        }
      default:
        {
          CParserError("Entity is neither an array of pointers nor a pointer to a function?\n");
        }
      }
    }
  ifdebug(3) {
    list pdl = NIL;
    pips_debug(3,"Ends with type \"%s\" for entity %s\n",
               list_to_string(c_words_entity(entity_type(e), NIL, &pdl)),
               entity_name(e));
    gen_free_list(pdl);
  }
 
}

References c_words_entity(), CParserError(), entity_name, entity_type, f(), functional_parameters, gen_free_list(), gen_nconc(), ifdebug, is_type_functional, is_type_variable, list_to_string(), make_functional(), make_type_functional(), make_type_variable(), make_variable(), NIL, pips_debug, type_functional, type_tag, type_undefined_p, type_variable, variable_basic, variable_dimensions, and variable_qualifiers.

Here is the call graph for this function:

UpdateType()

type UpdateType	(	type	t1,
		type	t2
	)

This function replaces the undefined field in t1 by t2.

If t1 is an array type and the basic of t1 is undefined, it is replaced by the basic of t2.

If t1 is a pointer type, if the pointed type is undefined it is replaced by t2.

If t1 is a functional type, if the result type of t1 is undefined, it is replaced by t2.

If t1 is a void type, then either t2 also is a void type or an error is raised.

The function is recursive.

FI: This function used to create sharing between t1 and t2, which creates problems when t2 is later freed. t1 may be updated and returned or a new type may be created.

This may happen when a type is implicitly declared as in "extern m[3];"

We used to use type_unknown when the type was implicit, but type_unknown does not let us store dimension information. We need here a new kind of basic, basic unknown or basic implicit. This would let us be more respectful of the source code, but requires a modification of the internal representation. It is mostly a prettyprint issue. See ticket

Basic pointer

t1 is already fully defined

Redundant update

Could be a pips internal error...

Parameters

t1	1
t2	2

Definition at line 1693 of file util.c.

{
  if (type_undefined_p(t1)) {
    if(!type_undefined_p(t2))
      return copy_type(t2);
    else
      return t2;
  }
 
  if(type_undefined_p(t2)) {
    /* This may happen when a type is implicitly declared as in
       "extern m[3];" */
    /* We used to use type_unknown when the type was implicit, but
       type_unknown does not let us store dimension information. We
       need here a new kind of basic, basic unknown or basic
       implicit. This would let us be more respectful of the source
       code, but requires a modification of the internal
       representation. It is mostly a prettyprint issue. See ticket
       225. */
    t2 = make_scalar_integer_type(DEFAULT_INTEGER_TYPE_SIZE);
  }
 
  switch (type_tag(t1))
    {
    case is_type_variable:
      {
        variable v = type_variable(t1);
        if (basic_undefined_p(variable_basic(v)))
          {
            pips_assert("type t2 is defined", !type_undefined_p(t2));
            if (type_variable_p(t2))
              return make_type_variable(make_variable(copy_basic(variable_basic(type_variable(t2))),
                                                      variable_dimensions(v),
                                                      gen_nconc(variable_qualifiers(v),
                                                                gen_full_copy_list(variable_qualifiers(type_variable(t2))))));
            CParserError("t1 is a variable type but not t2\n");
          }
        else
          {
            /* Basic pointer */
            if (basic_pointer_p(variable_basic(v)))
              {
                type pt = basic_pointer(variable_basic(v));
                return make_type_variable(make_variable(make_basic_pointer(UpdateType(pt,t2)),
                                                        variable_dimensions(v),
                                                        variable_qualifiers(v)));
              }
            else {
              /* t1 is already fully defined */
              if(type_equal_p(t1,t2))
                return t2;
              else if(overloaded_type_p(t1))
                return t2;
              else
                CParserError("This basic has an undefined field?\n");
            }
          }
        break;
      }
    case is_type_functional:
      {
        functional f = type_functional(t1);
        if (type_undefined_p(functional_result(f)))
          {
              type nt = type_undefined;
            if (type_undefined_p(t2))
              nt = make_type_unknown();
            else
              nt = copy_type(t2);
            return make_type_functional(make_functional(functional_parameters(f),nt));
          }
        return make_type_functional(make_functional(functional_parameters(f),UpdateType(functional_result(f),t2)));
      }
    case is_type_void:
      {
        if(type_void_p(t2)) {
          /* Redundant update */
          ;
        }
        else {
          /* Could be a pips internal error... */
          CParserError("void type to be updated by a non void type...\n");
        }
        return t1;
      }
    default:
      {
        CParserError("t1 has which kind of type?\n");
      }
    }
  return type_undefined;
}

References basic_pointer, basic_pointer_p, basic_undefined_p, copy_basic(), copy_type(), CParserError(), DEFAULT_INTEGER_TYPE_SIZE, f(), functional_parameters, functional_result, gen_full_copy_list(), gen_nconc(), is_type_functional, is_type_variable, is_type_void, make_basic_pointer(), make_functional(), make_scalar_integer_type(), make_type_functional(), make_type_unknown(), make_type_variable(), make_variable(), overloaded_type_p(), pips_assert, type_equal_p(), type_functional, type_tag, type_undefined, type_undefined_p, type_variable, type_variable_p, type_void_p, UpdateType(), variable_basic, variable_dimensions, and variable_qualifiers.

Referenced by UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), and UpdateType().

Here is the call graph for this function:

Here is the caller graph for this function:

UseDummyArguments()

void UseDummyArguments

(

entity

f

)

If f has regular formal parameters, destroy them.

make a list of formal parameters

Remove the formals from f's declaration list and from the symbol table

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

Definition at line 2019 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv)) {
    code fc = value_code(fv);
    list dl = code_declarations(fc);
    list cd = list_undefined;
    list formals = NIL;
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal parameters */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal parameter: \"%s\"\n", entity_name(v));
        formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
      }
    }
 
    /* Remove the formals from f's declaration list and from the
       symbol table */
    for(cd = formals; !ENDP(cd); POP(cd)) {
      entity p = ENTITY(CAR(cd));
      storage ps = entity_storage(p);
      formal pfs = storage_formal(ps);
 
      gen_remove(&code_declarations(fc), (void *) p);
      /* FI: The storage might point to another dummy argument
         (although it should not) */
      formal_function(pfs) = entity_undefined;
      /* Let's hope there are no other pointers towards dummy formal parameters */
      //free_entity(p);
    }
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, ENDP, ENTITY, entity_formal_p(), entity_initial, entity_name, entity_storage, entity_type, entity_undefined, f(), formal_function, gen_free_list(), gen_nconc(), gen_remove(), list_undefined, NIL, pips_assert, pips_debug, POP, storage_formal, type_functional_p, typedef_entity_p(), value_code, value_code_p, and value_undefined_p.

Here is the call graph for this function:

UseFormalArguments()

void UseFormalArguments

(

entity

f

)

If f has dummy formal parameters, replace them by standard formal parameters.

make a list of formal dumy parameters; depending on the kind of function declaration, dummy formal parameters are used (new C function declaration style), or not (old C function declaration style).

FI: Maybe, it would be better to unify the use of summy formal parameter in the parser?

Is it a local function or global function?

mn = strdup(concatenate(entity_module_name(f),entity_local_name(f), NULL));

Remore the dummy formals from f's declaration list (and from the symbol table?) and replace them by equivalent regular formal parameters

Substitute p by new_p in the declaration references for cases such as "foo(n, double a[n])"

This only works if the refs list points to the actual references and not to copies...

sg: this test used to be if e == p, but it missed some cases because reference_variable may have been generated incorectly before using a TOP_LEVEL variable instead of the dummy

A substitution could be performed instead...

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

Check substitution in formal parameter declarations

FI: just in case?

Do not free the dummy formal parameter variable as they are preserved in the dummy field for accurate prettyprinting

Definition at line 2063 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv)) {
    code fc = value_code(fv);
    list dl = module_all_declarations(f);
    list cd = list_undefined;
    list formals = NIL;
    string mn = string_undefined;
    // This is a minimal list of references. We need all references.
    //list refs1 =  extract_references_from_declarations(dl);
    list refs =  declaration_supporting_references(dl);
 
    ifdebug(8) {
      int l2 = gen_length(refs);
 
      pips_debug(8, "refs (%d elements):\n", l2);
      print_references(refs);
    }
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal dumy parameters; depending on the kind of
       function declaration, dummy formal parameters are used (new C
       function declaration style), or not (old C function declaration
       style).
 
       FI: Maybe, it would be better to unify the use of summy formal
       parameter in the parser?
    */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal parameter: \"%s\"\n", entity_name(v));
        if(dummy_parameter_entity_p(v))
          formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
        //pips_assert("v is a dummy parameter", dummy_parameter_entity_p(v));
      }
    }
 
    /* Is it a local function or global function? */
    if(top_level_entity_p(f))
      mn = strdup(entity_user_name(f));
    else
      /* mn = strdup(concatenate(entity_module_name(f),entity_local_name(f), NULL)); */
      mn = strdup(entity_local_name(f));
 
    /* Remore the dummy formals from f's declaration list (and from the
       symbol table?) and replace them by equivalent regular formal parameters */
    for(cd = formals; !ENDP(cd); POP(cd)) {
      entity p = ENTITY(CAR(cd));
      const char * pn = entity_user_name(p);
      entity new_p = entity_undefined;
      //storage ps = entity_storage(p);
      //formal pfs = storage_formal(ps);
 
      if(!stack_undefined_p(get_from_entity_type_stack_table(p))) {
        new_p = FindOrCreateEntity(mn, pn );
        entity_storage(new_p) = copy_storage(entity_storage(p));
        entity_type(new_p) = copy_type(entity_type(p));
        entity_initial(new_p) = copy_value(entity_initial(p));
        pips_debug(8, "Formal dummy parameter \"%s\" is replaced "
                   "by standard formal parameter \"%s\"\n",
                   entity_name(p), entity_name(new_p));
 
        /* Substitute p by new_p in the declaration references for cases
           such as "foo(n, double a[n])" */
        /* This only works if the refs list points to the actual
           references and not to copies... */
        FOREACH(REFERENCE, r, refs){
            entity e = reference_variable(r);
 
        /* sg: this test used to be if e == p, but it missed some cases
         * because reference_variable may have been generated incorectly before
         * using a TOP_LEVEL variable instead of the dummy */
            if(same_entity_lname_p(e,p)) { 
              reference_variable(r) = new_p;
              pips_debug(8, "reference %p to \"%s\" changed into reference to \"\%s\"\n",
                         r, entity_name(p), entity_name(new_p));
            }
        }
 
        /* A substitution could be performed instead...*/
        gen_remove(&code_declarations(fc), (void *) p);
        code_declarations(fc) = gen_nconc(code_declarations(fc), CONS(ENTITY, new_p,NIL));
 
        /* FI: The storage might point to another dummy argument
           (although it should not) */
        //formal_function(pfs) = entity_undefined;
        /* Let's hope there are no other pointers towards dummy formal parameters */
        //free_entity(p); // FI: we may use them in the type data structures in spite of the MAP on refs?
      }
    }
    gen_free_list(dl);
 
    ifdebug(1) {
      dl = module_all_declarations(f);
      /* Check substitution in formal parameter declarations */
      ifdebug(8) {
          pips_debug(8, "list of declared variables:\n");
          print_entities(dl);
          (void) fprintf(stderr, "\n");
      }
      refs =  declaration_supporting_references(dl);
      MAP(REFERENCE, r, {
          entity v = reference_variable(r);
          if(dummy_parameter_entity_p(v)) {
            pips_debug(8, "Substitution failed for reference %p and variable \"%s\"\n",
                       r, entity_name(v));
            pips_internal_error("Failed substitution");
          }
        }, refs);
      gen_free_list(dl);
    }
 
    /* FI: just in case? */
    remove_entity_type_stacks(formals);
 
    /* Do not free the dummy formal parameter variable as they are
       preserved in the dummy field for accurate prettyprinting */
    /*
    MAP(ENTITY, df, {
      free_entity(df);
    }, formals);
    */
 
    free(mn);
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, copy_storage(), copy_type(), copy_value(), declaration_supporting_references(), dummy_parameter_entity_p(), ENDP, ENTITY, entity_formal_p(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined, entity_user_name(), f(), FindOrCreateEntity(), FOREACH, fprintf(), free(), gen_free_list(), gen_length(), gen_nconc(), gen_remove(), get_from_entity_type_stack_table(), ifdebug, list_undefined, MAP, module_all_declarations(), NIL, pips_assert, pips_debug, pips_internal_error, POP, print_entities(), print_references(), REFERENCE, reference_variable, remove_entity_type_stacks(), same_entity_lname_p(), stack_undefined_p, strdup(), string_undefined, top_level_entity_p(), type_functional_p, typedef_entity_p(), value_code, value_code_p, and value_undefined_p.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

buffer_initialized_p

bool buffer_initialized_p = false

static

Definition at line 3590 of file util.c.

Referenced by analyze_preprocessor_line(), and reset_preprocessor_line_analysis().

current_dummy_parameter_number

int current_dummy_parameter_number =0

static

The data structure to tackle the memory allocation problem due to reparsing of compilation unit.

static int previoussizeofGlobalArea; entity previouscompunit; To keep track of the current dummy parameter naming. A function can be redeclared and it is difficult to make a difference between "void foo(int u, int u);", which not in the standard, and "void foo(int u); void foo(int u); which is fine"

Definition at line 137 of file util.c.

Referenced by get_current_dummy_parameter_number(), reset_current_dummy_parameter_number(), and set_current_dummy_parameter_number().

declarationerror_p

bool declarationerror_p

static

Definition at line 1788 of file util.c.

Referenced by nodecl_p(), and referencenodeclfilter().