OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

C90 prototype updates.

Browse Source 
From-SVN: r73113
This commit is contained in:
R. Kelley Cook 2003-10-31 01:08:43 +00:00
parent 6587cd2b21
commit 9373164a48
33 changed files with 701 additions and 1092 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,7 @@
2003-10-30 Kelley Cook <kcook@gcc.gnu.org>
* value-prof.c, web.c: Update to C90.
2003-10-30 Eric Christopher <echristo@redhat.com>
* function.c (purge_addressof_1): Add case for REG_RETVAL
@ -16,7 +20,8 @@
* real.c (encode_ieee_extended): Initialize whole array.
* reg-stack.c (move_for_stack_reg0: Use always XFmode.
* i386-modes.def: Change definitions of TFmode and XFmode.
* i386.c (classify_argument): Rename TFmodes to XFmodes; add new TFmode code.
* i386.c (classify_argument): Rename TFmodes to XFmodes; add new TFmode
code.
(construct_container): Allow constructing of TFmode integer containers.
(ix86_return_in_memory): XFmode is not returned in memory.
(init_ext_80387_constants): Always use XFmode.

8
gcc/ada/ChangeLog
View File

@ -1,3 +1,11 @@
2003-10-30 Kelley Cook <kcook@gcc.gnu.org>
* adadecode.c, adaint.c, argv.c, aux-io.c, cal.c, cio.c, cstreams.c,
ctrl_c.c, cuintp.c, decl.c, errno.c, exit.c, expect.c, final.c,
gigi.h, gmem.c, gnatbl.c, init.c, misc.c, mkdir.c, raise.c, socket.c,
sysdep.c, sysdep.c, targtyps.c, tb-alvms.c, tb-alvxw.c, tracebak.c,
trans.c, utils.c, utils2.c: Convert function prototypes to C90.
2003-10-30 Vasiliy Fofanov <fofanov@act-europe.fr>
* 3vtrasym.adb:

26
gcc/ada/adadecode.c
View File

@ -41,9 +41,9 @@
#include "ctype.h"
#include "adadecode.h"
static void add_verbose PARAMS ((const char *, char *));
static int has_prefix PARAMS ((const char *, const char *));
static int has_suffix PARAMS ((const char *, const char *));
static void add_verbose (const char *, char *);
static int has_prefix (const char *, const char *);
static int has_suffix (const char *, const char *);
/* This is a safe version of strcpy that can be used with overlapped
pointers. Does nothing if s2 <= s1. */
@ -55,9 +55,7 @@ static int verbose_info;
/* Add TEXT to end of ADA_NAME, putting a leading " (" or ", ", depending
on VERBOSE_INFO. */
static void add_verbose (text, ada_name)
const char *text;
char *ada_name;
static void add_verbose (const char *text, char *ada_name)
{
strcat (ada_name, verbose_info ? ", " : " (");
strcat (ada_name, text);
@ -68,9 +66,7 @@ static void add_verbose (text, ada_name)
/* Returns 1 if NAME starts with PREFIX. */
static int
has_prefix (name, prefix)
const char *name;
const char *prefix;
has_prefix (const char *name, const char *prefix)
{
return strncmp (name, prefix, strlen (prefix)) == 0;
}
@ -78,9 +74,7 @@ has_prefix (name, prefix)
/* Returns 1 if NAME ends with SUFFIX. */
static int
has_suffix (name, suffix)
const char *name;
const char *suffix;
has_suffix (const char *name, const char *suffix)
{
int nlen = strlen (name);
int slen = strlen (suffix);
@ -147,10 +141,7 @@ ostrcpy (char *s1, char *s2)
x__Oexpon "**" */
void
__gnat_decode (coded_name, ada_name, verbose)
const char *coded_name;
char *ada_name;
int verbose;
__gnat_decode (const char *coded_name, char *ada_name, int verbose)
{
int lib_subprog = 0;
int overloaded = 0;
@ -322,8 +313,7 @@ __gnat_decode (coded_name, ada_name, verbose)
}
char *
ada_demangle (coded_name)
const char *coded_name;
ada_demangle (const char *coded_name)
{
char ada_name[2048];

21
gcc/ada/adaint.c
View File

@ -425,7 +425,7 @@ __gnat_try_lock (char *dir, char *file)
/* Return the maximum file name length. */
int
__gnat_get_maximum_file_name_length ()
__gnat_get_maximum_file_name_length (void)
{
#if defined (MSDOS)
return 8;
@ -442,7 +442,7 @@ __gnat_get_maximum_file_name_length ()
/* Return nonzero if file names are case sensitive. */
int
__gnat_get_file_names_case_sensitive ()
__gnat_get_file_names_case_sensitive (void)
{
#if defined (__EMX__) || defined (MSDOS) || defined (VMS) || defined (WINNT)
return 0;
@ -452,7 +452,7 @@ __gnat_get_file_names_case_sensitive ()
}
char
__gnat_get_default_identifier_character_set ()
__gnat_get_default_identifier_character_set (void)
{
#if defined (__EMX__) || defined (MSDOS)
return 'p';
@ -782,7 +782,7 @@ __gnat_readdir (DIR *dirp, char *buffer)
/* Returns 1 if readdir is thread safe, 0 otherwise. */
int
__gnat_readdir_is_thread_safe ()
__gnat_readdir_is_thread_safe (void)
{
#ifdef HAVE_READDIR_R
return 1;
@ -1270,7 +1270,7 @@ __gnat_set_env_value (char *name, char *value)
key. */
char *
__gnat_get_libraries_from_registry ()
__gnat_get_libraries_from_registry (void)
{
char *result = (char *) "";
@ -2299,13 +2299,13 @@ __gnat_to_canonical_file_list_init
}
char *
__gnat_to_canonical_file_list_next ()
__gnat_to_canonical_file_list_next (void)
{
return (char *) "";
}
void
__gnat_to_canonical_file_list_free ()
__gnat_to_canonical_file_list_free (void)
{
}
@ -2340,7 +2340,7 @@ __gnat_to_host_file_spec (char *filespec)
}
void
__gnat_adjust_os_resource_limits ()
__gnat_adjust_os_resource_limits (void)
{
}
@ -2458,9 +2458,8 @@ extern void __gnat_install_locks (void (*) (void), void (*) (void));
locking subprograms for libgcc_eh. */
void
__gnatlib_install_locks (lock, unlock)
void (*lock) (void) ATTRIBUTE_UNUSED;
void (*unlock) (void) ATTRIBUTE_UNUSED;
__gnatlib_install_locks (void (*lock) (void) ATTRIBUTE_UNUSED,
void (*unlock) (void) ATTRIBUTE_UNUSED)
{
#ifdef IN_RTS
__gnat_install_locks (lock, unlock);

18
gcc/ada/argv.c
View File

@ -71,28 +71,25 @@ const char **gnat_envp = (const char **) 0;
#endif
int
__gnat_arg_count ()
__gnat_arg_count (void)
{
return gnat_argc;
}
int
__gnat_len_arg (arg_num)
int arg_num;
__gnat_len_arg (int arg_num)
{
return strlen (gnat_argv[arg_num]);
}
void
__gnat_fill_arg (a, i)
char *a;
int i;
__gnat_fill_arg ( char *a, int i)
{
strncpy (a, gnat_argv[i], strlen(gnat_argv[i]));
}
int
__gnat_env_count ()
__gnat_env_count (void)
{
int i;
@ -102,16 +99,13 @@ __gnat_env_count ()
}
int
__gnat_len_env (env_num)
int env_num;
__gnat_len_env (int env_num)
{
return strlen (gnat_envp[env_num]);
}
void
__gnat_fill_env (a, i)
char *a;
int i;
__gnat_fill_env (char *a, int i)
{
strncpy (a, gnat_envp[i], strlen (gnat_envp[i]));
}

29
gcc/ada/aux-io.c
View File

@ -43,28 +43,28 @@
/* Function wrappers are needed to access the values from Ada which are
defined as C macros. */
FILE *c_stdin PARAMS ((void));
FILE *c_stdout PARAMS ((void));
FILE *c_stderr PARAMS ((void));
int seek_set_function PARAMS ((void));
int seek_end_function PARAMS ((void));
void *null_function PARAMS ((void));
int c_fileno PARAMS ((FILE *));
FILE *c_stdin (void);
FILE *c_stdout (void);
FILE *c_stderr (void);
int seek_set_function (void);
int seek_end_function (void);
void *null_function (void);
int c_fileno (FILE *);
FILE *
c_stdin ()
c_stdin (void)
{
return stdin;
}
FILE *
c_stdout ()
c_stdout (void)
{
return stdout;
}
FILE *
c_stderr ()
c_stderr (void)
{
return stderr;
}
@ -76,25 +76,24 @@ c_stderr ()
#endif
int
seek_set_function ()
seek_set_function (void)
{
return SEEK_SET;
}
int
seek_end_function ()
seek_end_function (void)
{
return SEEK_END;
}
void *null_function ()
void *null_function (void)
{
return NULL;
}
int
c_fileno (s)
FILE *s;
c_fileno (FILE *s)
{
return fileno (s);
}

2
gcc/ada/cal.c
View File

@ -94,7 +94,7 @@ __gnat_duration_to_timeval (long sec, long usec, struct timeval *t)
what time_t is on the target. */
long
gnat_time ()
gnat_time (void)
{
return time (0);
}

19
gcc/ada/cio.c
View File

@ -52,7 +52,7 @@
#endif
int
get_char ()
get_char (void)
{
#ifdef VMS
return decc$getchar();
@ -62,7 +62,7 @@ get_char ()
}
int
get_int ()
get_int (void)
{
int x;
@ -71,8 +71,7 @@ get_int ()
}
void
put_int (x)
int x;
put_int (int x)
{
/* Use fprintf rather than printf, since the latter is unbuffered
on vxworks */
@ -80,22 +79,19 @@ put_int (x)
}
void
put_int_stderr (x)
int x;
put_int_stderr (int x)
{
fprintf (stderr, "%d", x);
}
void
put_char (c)
int c;
put_char (int c)
{
putchar (c);
}
void
put_char_stderr (c)
int c;
put_char_stderr (int c)
{
fputc (c, stderr);
}
@ -103,8 +99,7 @@ put_char_stderr (c)
#ifdef __vxworks
char *
mktemp (template)
char *template;
mktemp (char *template)
{
return tmpnam (NULL);
}

12
gcc/ada/cstreams.c
View File

@ -76,29 +76,25 @@
#endif
int
__gnat_feof (stream)
FILE *stream;
__gnat_feof (FILE *stream)
{
return (feof (stream));
}
int
__gnat_ferror (stream)
FILE *stream;
__gnat_ferror (FILE *stream)
{
return (ferror (stream));
}
int
__gnat_fileno (stream)
FILE *stream;
__gnat_fileno (FILE *stream)
{
return (fileno (stream));
}
int
__gnat_is_regular_file_fd (fd)
int fd;
__gnat_is_regular_file_fd (int fd)
{
int ret;
struct stat statbuf;

4
gcc/ada/ctrl_c.c
View File

@ -132,7 +132,7 @@ __gnat_install_int_handler (void (*proc) (void))
}
void
__gnat_uninstall_int_handler ()
__gnat_uninstall_int_handler (void)
{
if (sigint_intercepted != NULL)
SetConsoleCtrlHandler (__gnat_int_handler, FALSE);
@ -150,7 +150,7 @@ __gnat_install_int_handler (void (*proc) (void) __attribute__ ((unused)))
}
void
__gnat_uninstall_int_handler ()
__gnat_uninstall_int_handler (void)
{
}
#endif

4
gcc/ada/cuintp.c
View File

@ -57,9 +57,7 @@
resulting node. */
tree
UI_To_gnu (Input, type)
Uint Input;
tree type;
UI_To_gnu (Uint Input, tree type)
{
tree gnu_ret;

251
gcc/ada/decl.c
View File

@ -82,42 +82,34 @@ static struct incomplete
Entity_Id full_type;
} *defer_incomplete_list = 0;
static tree substitution_list PARAMS ((Entity_Id, Entity_Id,
tree, int));
static int allocatable_size_p PARAMS ((tree, int));
static struct attrib *build_attr_list PARAMS ((Entity_Id));
static tree elaborate_expression PARAMS ((Node_Id, Entity_Id, tree,
int, int, int));
static int is_variable_size PARAMS ((tree));
static tree elaborate_expression_1 PARAMS ((Node_Id, Entity_Id, tree,
tree, int, int));
static tree make_packable_type PARAMS ((tree));
static tree maybe_pad_type PARAMS ((tree, tree, unsigned int,
Entity_Id, const char *, int,
int, int));
static tree gnat_to_gnu_field PARAMS ((Entity_Id, tree, int, int));
static void components_to_record PARAMS ((tree, Node_Id, tree, int,
int, tree *, int, int));
static int compare_field_bitpos PARAMS ((const PTR, const PTR));
static Uint annotate_value PARAMS ((tree));
static void annotate_rep PARAMS ((Entity_Id, tree));
static tree compute_field_positions PARAMS ((tree, tree, tree, tree,
unsigned int));
static tree validate_size PARAMS ((Uint, tree, Entity_Id,
enum tree_code, int, int));
static void set_rm_size PARAMS ((Uint, tree, Entity_Id));
static tree make_type_from_size PARAMS ((tree, tree, int));
static unsigned int validate_alignment PARAMS ((Uint, Entity_Id,
unsigned int));
static void check_ok_for_atomic PARAMS ((tree, Entity_Id, int));
static tree substitution_list (Entity_Id, Entity_Id, tree, int);
static int allocatable_size_p (tree, int);
static struct attrib *build_attr_list (Entity_Id);
static tree elaborate_expression (Node_Id, Entity_Id, tree, int, int, int);
static int is_variable_size (tree);
static tree elaborate_expression_1 (Node_Id, Entity_Id, tree, tree, int, int);
static tree make_packable_type (tree);
static tree maybe_pad_type (tree, tree, unsigned int, Entity_Id, const char *,
int, int, int);
static tree gnat_to_gnu_field (Entity_Id, tree, int, int);
static void components_to_record (tree, Node_Id, tree, int, int, tree *,
int, int);
static int compare_field_bitpos (const PTR, const PTR);
static Uint annotate_value (tree);
static void annotate_rep (Entity_Id, tree);
static tree compute_field_positions (tree, tree, tree, tree, unsigned int);
static tree validate_size (Uint, tree, Entity_Id, enum tree_code, int, int);
static void set_rm_size (Uint, tree, Entity_Id);
static tree make_type_from_size (tree, tree, int);
static unsigned int validate_alignment (Uint, Entity_Id, unsigned int);
static void check_ok_for_atomic (tree, Entity_Id, int);
/* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
GCC type corresponding to that entity. GNAT_ENTITY is assumed to
refer to an Ada type. */
tree
gnat_to_gnu_type (gnat_entity)
Entity_Id gnat_entity;
gnat_to_gnu_type (Entity_Id gnat_entity)
{
tree gnu_decl;
@ -146,10 +138,7 @@ gnat_to_gnu_type (gnat_entity)
the code. */
tree
gnat_to_gnu_entity (gnat_entity, gnu_expr, definition)
Entity_Id gnat_entity;
tree gnu_expr;
int definition;
gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
{
tree gnu_entity_id;
tree gnu_type = 0;
@ -4037,8 +4026,7 @@ gnat_to_gnu_entity (gnat_entity, gnu_expr, definition)
be elaborated at the point of its definition, but do nothing else. */
void
elaborate_entity (gnat_entity)
Entity_Id gnat_entity;
elaborate_entity (Entity_Id gnat_entity)
{
switch (Ekind (gnat_entity))
{
@ -4109,8 +4097,7 @@ elaborate_entity (gnat_entity)
any entities on its entity chain similarly. */
void
mark_out_of_scope (gnat_entity)
Entity_Id gnat_entity;
mark_out_of_scope (Entity_Id gnat_entity)
{
Entity_Id gnat_sub_entity;
unsigned int kind = Ekind (gnat_entity);
@ -4153,11 +4140,10 @@ mark_out_of_scope (gnat_entity)
DEFINITION is as in gnat_to_gnu_entity. */
static tree
substitution_list (gnat_subtype, gnat_type, gnu_list, definition)
Entity_Id gnat_subtype;
Entity_Id gnat_type;
tree gnu_list;
int definition;
substitution_list (Entity_Id gnat_subtype,
Entity_Id gnat_type,
tree gnu_list,
int definition)
{
Entity_Id gnat_discrim;
Node_Id gnat_value;
@ -4191,7 +4177,7 @@ static GTY((length ("max_gnat_nodes"))) tree * dummy_node_table;
/* Initialize the above table. */
void
init_dummy_type ()
init_dummy_type (void)
{
Node_Id gnat_node;
@ -4206,8 +4192,7 @@ init_dummy_type ()
/* Make a dummy type corresponding to GNAT_TYPE. */
tree
make_dummy_type (gnat_type)
Entity_Id gnat_type;
make_dummy_type (Entity_Id gnat_type)
{
Entity_Id gnat_underlying;
tree gnu_type;
@ -4253,9 +4238,7 @@ make_dummy_type (gnat_type)
done with a static allocation. */
static int
allocatable_size_p (gnu_size, static_p)
tree gnu_size;
int static_p;
allocatable_size_p (tree gnu_size, int static_p)
{
HOST_WIDE_INT our_size;
@ -4279,8 +4262,7 @@ allocatable_size_p (gnu_size, static_p)
/* Return a list of attributes for GNAT_ENTITY, if any. */
static struct attrib *
build_attr_list (gnat_entity)
Entity_Id gnat_entity;
build_attr_list (Entity_Id gnat_entity)
{
struct attrib *attr_list = 0;
Node_Id gnat_temp;
@ -4352,8 +4334,7 @@ build_attr_list (gnat_entity)
/* Get the unpadded version of a GNAT type. */
tree
get_unpadded_type (gnat_entity)
Entity_Id gnat_entity;
get_unpadded_type (Entity_Id gnat_entity)
{
tree type = gnat_to_gnu_type (gnat_entity);
@ -4366,9 +4347,7 @@ get_unpadded_type (gnat_entity)
/* Called when we need to protect a variable object using a save_expr. */
tree
maybe_variable (gnu_operand, gnat_node)
tree gnu_operand;
Node_Id gnat_node;
maybe_variable (tree gnu_operand, Node_Id gnat_node)
{
if (TREE_CONSTANT (gnu_operand) || TREE_READONLY (gnu_operand)
|| TREE_CODE (gnu_operand) == SAVE_EXPR
@ -4397,14 +4376,12 @@ maybe_variable (gnu_operand, gnat_node)
purposes even if it isn't needed for code generation. */
static tree
elaborate_expression (gnat_expr, gnat_entity, gnu_name, definition,
need_value, need_debug)
Node_Id gnat_expr;
Entity_Id gnat_entity;
tree gnu_name;
int definition;
int need_value;
int need_debug;
elaborate_expression (Node_Id gnat_expr,
Entity_Id gnat_entity,
tree gnu_name,
int definition,
int need_value,
int need_debug)
{
tree gnu_expr;
@ -4439,14 +4416,12 @@ elaborate_expression (gnat_expr, gnat_entity, gnu_name, definition,
/* Similar, but take a GNU expression. */
static tree
elaborate_expression_1 (gnat_expr, gnat_entity, gnu_expr, gnu_name, definition,
need_debug)
Node_Id gnat_expr;
Entity_Id gnat_entity;
tree gnu_expr;
tree gnu_name;
int definition;
int need_debug;
elaborate_expression_1 (Node_Id gnat_expr,
Entity_Id gnat_entity,
tree gnu_expr,
tree gnu_name,
int definition,
int need_debug)
{
tree gnu_decl = 0;
/* Strip any conversions to see if the expression is a readonly variable.
@ -4514,10 +4489,7 @@ elaborate_expression_1 (gnat_expr, gnat_entity, gnu_expr, gnu_name, definition,
position so that it is aligned to ALIGN bits and is SIZE bytes long. */
tree
make_aligning_type (type, align, size)
tree type;
int align;
tree size;
make_aligning_type (tree type, int align, tree size)
{
tree record_type = make_node (RECORD_TYPE);
tree place = build (PLACEHOLDER_EXPR, record_type);
@ -4568,8 +4540,7 @@ make_aligning_type (type, align, size)
return the new type. If not, return the original type. */
static tree
make_packable_type (type)
tree type;
make_packable_type (tree type)
{
tree new_type = make_node (TREE_CODE (type));
tree field_list = NULL_TREE;
@ -4645,16 +4616,14 @@ make_packable_type (type)
type. */
static tree
maybe_pad_type (type, size, align, gnat_entity, name_trailer,
is_user_type, definition, same_rm_size)
tree type;
tree size;
unsigned int align;
Entity_Id gnat_entity;
const char *name_trailer;
int is_user_type;
int definition;
int same_rm_size;
maybe_pad_type (tree type,
tree size,
unsigned int align,
Entity_Id gnat_entity,
const char *name_trailer,
int is_user_type,
int definition,
int same_rm_size)
{
tree orig_size = TYPE_SIZE (type);
tree record;
@ -4830,9 +4799,7 @@ maybe_pad_type (type, size, align, gnat_entity, name_trailer,
the value passed against the list of choices. */
tree
choices_to_gnu (operand, choices)
tree operand;
Node_Id choices;
choices_to_gnu (tree operand, Node_Id choices)
{
Node_Id choice;
Node_Id gnat_temp;
@ -4924,11 +4891,10 @@ choices_to_gnu (operand, choices)
DEFINITION is nonzero if this field is for a record being defined. */
static tree
gnat_to_gnu_field (gnat_field, gnu_record_type, packed, definition)
Entity_Id gnat_field;
tree gnu_record_type;
int packed;
int definition;
gnat_to_gnu_field (Entity_Id gnat_field,
tree gnu_record_type,
int packed,
int definition)
{
tree gnu_field_id = get_entity_name (gnat_field);
tree gnu_field_type = gnat_to_gnu_type (Etype (gnat_field));
@ -5173,8 +5139,7 @@ gnat_to_gnu_field (gnat_field, gnu_record_type, packed, definition)
of variable size or is a record that has a field such a field. */
static int
is_variable_size (type)
tree type;
is_variable_size (tree type)
{
tree field;
@ -5229,16 +5194,14 @@ is_variable_size (type)
fields of the record and then the record type is finished. */
static void
components_to_record (gnu_record_type, component_list, gnu_field_list, packed,
definition, p_gnu_rep_list, cancel_alignment, all_rep)
tree gnu_record_type;
Node_Id component_list;
tree gnu_field_list;
int packed;
int definition;
tree *p_gnu_rep_list;
int cancel_alignment;
int all_rep;
components_to_record (tree gnu_record_type,
Node_Id component_list,
tree gnu_field_list,
int packed,
int definition,
tree *p_gnu_rep_list,
int cancel_alignment,
int all_rep)
{
Node_Id component_decl;
Entity_Id gnat_field;
@ -5502,9 +5465,7 @@ components_to_record (gnu_record_type, component_list, gnu_field_list, packed,
bit positions and ordinals of the two fields. */
static int
compare_field_bitpos (rt1, rt2)
const PTR rt1;
const PTR rt2;
compare_field_bitpos (const PTR rt1, const PTR rt2)
{
tree *t1 = (tree *) rt1;
tree *t2 = (tree *) rt2;
@ -5524,8 +5485,7 @@ compare_field_bitpos (rt1, rt2)
in the GNAT tree. */
static Uint
annotate_value (gnu_size)
tree gnu_size;
annotate_value (tree gnu_size)
{
int len = TREE_CODE_LENGTH (TREE_CODE (gnu_size));
TCode tcode;
@ -5663,9 +5623,7 @@ annotate_value (gnu_size)
used by Gigi. */
static void
annotate_rep (gnat_entity, gnu_type)
Entity_Id gnat_entity;
tree gnu_type;
annotate_rep (Entity_Id gnat_entity, tree gnu_type)
{
tree gnu_list;
tree gnu_entry;
@ -5743,12 +5701,11 @@ annotate_rep (gnat_entity, gnu_type)
so far. */
static tree
compute_field_positions (gnu_type, gnu_list, gnu_pos, gnu_bitpos, offset_align)
tree gnu_type;
tree gnu_list;
tree gnu_pos;
tree gnu_bitpos;
unsigned int offset_align;
compute_field_positions (tree gnu_type,
tree gnu_list,
tree gnu_pos,
tree gnu_bitpos,
unsigned int offset_align)
{
tree gnu_field;
tree gnu_result = gnu_list;
@ -5792,13 +5749,12 @@ compute_field_positions (gnu_type, gnu_list, gnu_pos, gnu_bitpos, offset_align)
it means that a size of zero should be treated as an unspecified size. */
static tree
validate_size (uint_size, gnu_type, gnat_object, kind, component_p, zero_ok)
Uint uint_size;
tree gnu_type;
Entity_Id gnat_object;
enum tree_code kind;
int component_p;
int zero_ok;
validate_size (Uint uint_size,
tree gnu_type,
Entity_Id gnat_object,
enum tree_code kind,
int component_p,
int zero_ok)
{
Node_Id gnat_error_node;
tree type_size
@ -5911,10 +5867,7 @@ validate_size (uint_size, gnu_type, gnat_object, kind, component_p, zero_ok)
routine is only called for types. */
static void
set_rm_size (uint_size, gnu_type, gnat_entity)
Uint uint_size;
tree gnu_type;
Entity_Id gnat_entity;
set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity)
{
/* Only give an error if a Value_Size clause was explicitly given.
Otherwise, we'd be duplicating an error on the Size clause. */
@ -5988,10 +5941,7 @@ set_rm_size (uint_size, gnu_type, gnat_entity)
we are making a biased type. */
static tree
make_type_from_size (type, size_tree, biased_p)
tree type;
tree size_tree;
int biased_p;
make_type_from_size (tree type, tree size_tree, int biased_p)
{
tree new_type;
unsigned HOST_WIDE_INT size;
@ -6061,10 +6011,7 @@ make_type_from_size (type, size_tree, biased_p)
valid, return it. Otherwise, give an error and return ALIGN. */
static unsigned int
validate_alignment (alignment, gnat_entity, align)
Uint alignment;
Entity_Id gnat_entity;
unsigned int align;
validate_alignment (Uint alignment, Entity_Id gnat_entity, unsigned int align)
{
Node_Id gnat_error_node = gnat_entity;
unsigned int new_align;
@ -6109,10 +6056,7 @@ validate_alignment (alignment, gnat_entity, align)
if we require atomic components. */
static void
check_ok_for_atomic (object, gnat_entity, comp_p)
tree object;
Entity_Id gnat_entity;
int comp_p;
check_ok_for_atomic (tree object, Entity_Id gnat_entity, int comp_p)
{
Node_Id gnat_error_point = gnat_entity;
Node_Id gnat_node;
@ -6188,8 +6132,7 @@ check_ok_for_atomic (object, gnat_entity, comp_p)
changed. */
tree
gnat_substitute_in_type (t, f, r)
tree t, f, r;
gnat_substitute_in_type (tree t, tree f, tree r)
{
tree new = t;
tree tem;
@ -6410,8 +6353,7 @@ gnat_substitute_in_type (t, f, r)
needed to represent the object. */
tree
rm_size (gnu_type)
tree gnu_type;
rm_size (tree gnu_type)
{
/* For integer types, this is the precision. For record types, we store
the size explicitly. For other types, this is just the size. */
@ -6440,9 +6382,7 @@ rm_size (gnu_type)
and the specified suffix. */
tree
create_concat_name (gnat_entity, suffix)
Entity_Id gnat_entity;
const char *suffix;
create_concat_name (Entity_Id gnat_entity, const char *suffix)
{
const char *str = (suffix == 0 ? "" : suffix);
String_Template temp = {1, strlen (str)};
@ -6480,8 +6420,7 @@ create_concat_name (gnat_entity, suffix)
Otherwise, return the name. */
tree
get_entity_name (gnat_entity)
Entity_Id gnat_entity;
get_entity_name (Entity_Id gnat_entity)
{
Get_Encoded_Name (gnat_entity);
return get_identifier (Name_Buffer);
@ -6492,9 +6431,7 @@ get_entity_name (gnat_entity)
the name in GNU_ID and SUFFIX. */
tree
concat_id_with_name (gnu_id, suffix)
tree gnu_id;
const char *suffix;
concat_id_with_name (tree gnu_id, const char *suffix)
{
int len = IDENTIFIER_LENGTH (gnu_id);

5
gcc/ada/errno.c
View File

@ -42,14 +42,13 @@
#include <errno.h>
int
__get_errno()
__get_errno(void)
{
return errno;
}
void
__set_errno(err)
int err;
__set_errno(int err)
{
errno = err;
}

3
gcc/ada/exit.c
View File

@ -50,8 +50,7 @@
int gnat_exit_status = 0;
void
__gnat_set_exit_status (i)
int i;
__gnat_set_exit_status (int i)
{
gnat_exit_status = i;
}

8
gcc/ada/expect.c
View File

@ -72,7 +72,7 @@ __gnat_kill (int pid, int sig)
}
int
__gnat_expect_fork ()
__gnat_expect_fork (void)
{
return 0;
}
@ -159,7 +159,7 @@ __gnat_pipe (int *fd)
}
int
__gnat_expect_fork ()
__gnat_expect_fork (void)
{
return -1;
}
@ -299,7 +299,7 @@ __gnat_pipe (int *fd)
}
int
__gnat_expect_fork ()
__gnat_expect_fork (void)
{
return fork ();
}
@ -406,7 +406,7 @@ __gnat_pipe (int *fd)
}
int
__gnat_expect_fork ()
__gnat_expect_fork (void)
{
return -1;
}

2
gcc/ada/final.c
View File

@ -38,6 +38,6 @@ extern void __gnat_finalize (void);
where finalization is required. */
void
__gnat_finalize ()
__gnat_finalize (void)
{
}

5
gcc/ada/gmem.c
View File

@ -75,7 +75,7 @@ convert_addresses (char *addrs[], int n_addr, void *buf, int *len);
*/
static void
gmem_read_backtrace ()
gmem_read_backtrace (void)
{
fread (&cur_tb_len, sizeof (int), 1, gmemfile);
fread (tracebk, sizeof (char *), cur_tb_len, gmemfile);
@ -120,8 +120,7 @@ void __gnat_gmem_a2l_initialize (char *exename)
write an alloc/free information in buf to be processed by gnatmem */
void
__gnat_gmem_read_next (buf)
struct struct_storage_elmt *buf;
__gnat_gmem_read_next (struct struct_storage_elmt *buf)
{
void *addr;
size_t size;

17
gcc/ada/gnatbl.c
View File

@ -72,12 +72,11 @@ char *gcc_B_arg = 0;
static int linkonly = 0;
static void addarg PARAMS ((char *));
static void process_args PARAMS ((int *, char *[]));
static void addarg (char *);
static void process_args (int *, char *[]);
static void
addarg (str)
char *str;
addarg (char *str)
{
int i;
@ -100,9 +99,7 @@ addarg (str)
}
static void
process_args (p_argc, argv)
int *p_argc;
char *argv[];
process_args (int *p_argc, char *argv[])
{
int i, j;
@ -199,12 +196,10 @@ process_args (p_argc, argv)
}
}
}
extern int main PARAMS ((int, char **));
extern int main (int, char **);
int
main (argc, argv)
int argc;
char **argv;
main (int argc, char **argv)
{
int i, j;
int done_an_ali = 0;

220
gcc/ada/init.c
View File

@ -71,28 +71,28 @@ extern struct Exception_Data tasking_error;
extern struct Exception_Data _abort_signal;
#define Lock_Task system__soft_links__lock_task
extern void (*Lock_Task) PARAMS ((void));
extern void (*Lock_Task) (void);
#define Unlock_Task system__soft_links__unlock_task
extern void (*Unlock_Task) PARAMS ((void));
extern void (*Unlock_Task) (void);
#define Get_Machine_State_Addr \
system__soft_links__get_machine_state_addr
extern struct Machine_State *(*Get_Machine_State_Addr) PARAMS ((void));
extern struct Machine_State *(*Get_Machine_State_Addr) (void);
#define Check_Abort_Status \
system__soft_links__check_abort_status
extern int (*Check_Abort_Status) PARAMS ((void));
extern int (*Check_Abort_Status) (void);
#define Raise_From_Signal_Handler \
ada__exceptions__raise_from_signal_handler
extern void Raise_From_Signal_Handler PARAMS ((struct Exception_Data *,
const char *));
extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
#define Propagate_Signal_Exception \
__gnat_propagate_sig_exc
extern void Propagate_Signal_Exception
PARAMS ((struct Machine_State *, struct Exception_Data *, const char *));
extern void Propagate_Signal_Exception (struct Machine_State *,
struct Exception_Data *,
const char *);
/* Copies of global values computed by the binder */
int __gl_main_priority = -1;
@ -134,8 +134,7 @@ char __gnat_get_interrupt_state (int);
's' Interrupt_State pragma set state to System */
char
__gnat_get_interrupt_state (intrup)
int intrup;
__gnat_get_interrupt_state (int intrup)
{
if (intrup >= __gl_num_interrupt_states)
return 'n';
@ -156,30 +155,18 @@ __gnat_get_interrupt_state (intrup)
boundaries like this are not handled correctly in all systems. */
void
__gnat_set_globals (main_priority,
time_slice_val,
wc_encoding,
locking_policy,
queuing_policy,
task_dispatching_policy,
restrictions,
interrupt_states,
num_interrupt_states,
unreserve_all_interrupts,
exception_tracebacks,
zero_cost_exceptions)
int main_priority;
int time_slice_val;
char wc_encoding;
char locking_policy;
char queuing_policy;
char task_dispatching_policy;
char *restrictions;
char *interrupt_states;
int num_interrupt_states;
int unreserve_all_interrupts;
int exception_tracebacks;
int zero_cost_exceptions;
__gnat_set_globals (int main_priority,
int time_slice_val,
char wc_encoding,
char locking_policy,
char queuing_policy,
char task_dispatching_policy,
char *restrictions,
char *interrupt_states,
int num_interrupt_states,
int unreserve_all_interrupts,
int exception_tracebacks,
int zero_cost_exceptions)
{
static int already_called = 0;
@ -288,22 +275,20 @@ __gnat_set_globals (main_priority,
#ifndef _AIXVERSION_430
extern int nanosleep PARAMS ((struct timestruc_t *, struct timestruc_t *));
extern int nanosleep (struct timestruc_t *, struct timestruc_t *);
int
nanosleep (Rqtp, Rmtp)
struct timestruc_t *Rqtp, *Rmtp;
nanosleep (struct timestruc_t *Rqtp, struct timestruc_t *Rmtp)
{
return nsleep (Rqtp, Rmtp);
}
#endif /* _AIXVERSION_430 */
static void __gnat_error_handler PARAMS ((int));
static void __gnat_error_handler (int);
static void
__gnat_error_handler (sig)
int sig;
__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
const char *msg;
@ -335,7 +320,7 @@ __gnat_error_handler (sig)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -363,7 +348,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -380,20 +365,16 @@ __gnat_initialize ()
#include <signal.h>
#include <sys/siginfo.h>
static void __gnat_error_handler PARAMS ((int, siginfo_t *,
struct sigcontext *));
extern char *__gnat_get_code_loc PARAMS ((struct sigcontext *));
extern void __gnat_enter_handler PARAMS ((struct sigcontext *, char *));
extern size_t __gnat_machine_state_length PARAMS ((void));
static void __gnat_error_handler (int, siginfo_t *, struct sigcontext *);
extern char *__gnat_get_code_loc (struct sigcontext *);
extern void __gnat_enter_handler (struct sigcontext *, char *);
extern size_t __gnat_machine_state_length (void);
extern long exc_lookup_gp PARAMS ((char *));
extern void exc_resume PARAMS ((struct sigcontext *));
extern long exc_lookup_gp (char *);
extern void exc_resume (struct sigcontext *);
static void
__gnat_error_handler (sig, sip, context)
int sig;
siginfo_t *sip;
struct sigcontext *context;
__gnat_error_handler (int sig, siginfo_t *sip, struct sigcontext *context)
{
struct Exception_Data *exception;
static int recurse = 0;
@ -463,7 +444,7 @@ __gnat_error_handler (sig, sip, context)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -471,7 +452,7 @@ __gnat_install_handler ()
exceptions. Make sure that the handler isn't interrupted by another
signal that might cause a scheduling event! */
act.sa_handler = (void (*) PARAMS ((int))) __gnat_error_handler;
act.sa_handler = (void (*) (int)) __gnat_error_handler;
act.sa_flags = SA_ONSTACK | SA_RESTART | SA_NODEFER | SA_SIGINFO;
sigemptyset (&act.sa_mask);
@ -491,7 +472,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -500,16 +481,13 @@ __gnat_initialize ()
#define SC_GP 29
char *
__gnat_get_code_loc (context)
struct sigcontext *context;
__gnat_get_code_loc (struct sigcontext *context)
{
return (char *) context->sc_pc;
}
void
__gnat_enter_handler (context, pc)
struct sigcontext *context;
char *pc;
__gnat_enter_handler ( struct sigcontext *context, char *pc)
{
context->sc_pc = (long) pc;
context->sc_regs[SC_GP] = exc_lookup_gp (pc);
@ -517,7 +495,7 @@ __gnat_enter_handler (context, pc)
}
size_t
__gnat_machine_state_length ()
__gnat_machine_state_length (void)
{
return sizeof (struct sigcontext);
}
@ -530,11 +508,10 @@ __gnat_machine_state_length ()
#include <signal.h>
static void __gnat_error_handler PARAMS ((int));
static void __gnat_error_handler (int);
static void
__gnat_error_handler (sig)
int sig;
__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
char *msg;
@ -566,7 +543,7 @@ __gnat_error_handler (sig)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -609,7 +586,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -639,11 +616,10 @@ struct Machine_State
unsigned long edi;
};
static void __gnat_error_handler PARAMS ((int));
static void __gnat_error_handler (int);
static void
__gnat_error_handler (sig)
int sig;
__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
const char *msg;
@ -731,7 +707,7 @@ __gnat_error_handler (sig)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -759,7 +735,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -770,13 +746,12 @@ __gnat_initialize ()
#elif defined (__MINGW32__)
#include <windows.h>
static LONG WINAPI __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
static LONG WINAPI __gnat_error_handler (PEXCEPTION_POINTERS);
/* __gnat_initialize (mingw32). */
static LONG WINAPI
__gnat_error_handler (info)
PEXCEPTION_POINTERS info;
__gnat_error_handler (PEXCEPTION_POINTERS info)
{
static int recurse;
struct Exception_Data *exception;
@ -891,14 +866,14 @@ __gnat_error_handler (info)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
SetUnhandledExceptionFilter (__gnat_error_handler);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
/* Initialize floating-point coprocessor. This call is needed because
@ -921,11 +896,10 @@ __gnat_initialize ()
#include <signal.h>
static void __gnat_error_handler PARAMS ((int));
static void __gnat_error_handler (int);
static void
__gnat_error_handler (sig)
int sig;
__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
char *msg;
@ -956,7 +930,7 @@ __gnat_error_handler (sig)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -982,7 +956,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_init_float ();
}
@ -994,7 +968,7 @@ __gnat_initialize ()
#elif defined (__Lynx__)
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_init_float ();
}
@ -1004,7 +978,7 @@ __gnat_initialize ()
/*********************************/
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
@ -1016,7 +990,7 @@ __gnat_install_handler ()
#elif defined (__EMX__) /* OS/2 dependent initialization */
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -1025,7 +999,7 @@ __gnat_initialize ()
/*********************************/
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
@ -1052,13 +1026,10 @@ struct Machine_State
sigcontext_t context;
};
static void __gnat_error_handler PARAMS ((int, int, sigcontext_t *));
static void __gnat_error_handler (int, int, sigcontext_t *);
static void
__gnat_error_handler (sig, code, sc)
int sig;
int code;
sigcontext_t *sc;
__gnat_error_handler (int sig, int code, sigcontext_t *sc)
{
struct Machine_State *mstate;
struct Exception_Data *exception;
@ -1138,7 +1109,7 @@ __gnat_error_handler (sig, code, sc)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -1169,7 +1140,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -1182,12 +1153,10 @@ __gnat_initialize ()
#include <signal.h>
#include <siginfo.h>
static void __gnat_error_handler PARAMS ((int, siginfo_t *));
static void __gnat_error_handler (int, siginfo_t *);
static void
__gnat_error_handler (sig, sip)
int sig;
siginfo_t *sip;
__gnat_error_handler (int sig, siginfo_t *sip)
{
struct Exception_Data *exception;
static int recurse = 0;
@ -1253,7 +1222,7 @@ __gnat_error_handler (sig, sip)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -1279,7 +1248,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -1291,7 +1260,7 @@ __gnat_initialize ()
/* The prehandler actually gets control first on a condition. It swaps the
stack pointer and calls the handler (__gnat_error_handler). */
extern long __gnat_error_prehandler ();
extern long __gnat_error_prehandler (void);
extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
@ -1329,12 +1298,10 @@ extern struct Exception_Data *Coded_Exception (int);
struct descriptor_s {unsigned short len, mbz; char *adr; };
long __gnat_error_handler PARAMS ((int *, void *));
long __gnat_error_handler (int *, void *);
long
__gnat_error_handler (sigargs, mechargs)
int *sigargs;
void *mechargs;
__gnat_error_handler (int *sigargs, void *mechargs)
{
struct Exception_Data *exception = 0;
char *msg = "";
@ -1470,7 +1437,7 @@ __gnat_error_handler (sigargs, mechargs)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
long prvhnd;
char *c;
@ -1485,7 +1452,7 @@ __gnat_install_handler ()
}
void
__gnat_initialize()
__gnat_initialize(void)
{
}
@ -1508,10 +1475,10 @@ static void __gnat_error_handler (int, int, struct sigcontext *);
/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
on Alpha VxWorks */
extern long getpid PARAMS ((void));
extern long getpid (void);
long
getpid ()
getpid (void)
{
return taskIdSelf ();
}
@ -1519,17 +1486,13 @@ getpid ()
/* This is needed by the GNAT run time to handle Vxworks interrupts */
int
__gnat_inum_to_ivec (num)
int num;
__gnat_inum_to_ivec (int num)
{
return INUM_TO_IVEC (num);
}
static void
__gnat_error_handler (sig, code, sc)
int sig;
int code;
struct sigcontext *sc;
__gnat_error_handler (int sig, int code, struct sigcontext *sc)
{
struct Exception_Data *exception;
sigset_t mask;
@ -1576,7 +1539,7 @@ __gnat_error_handler (sig, code, sc)
}
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
struct sigaction act;
@ -1601,7 +1564,7 @@ __gnat_install_handler ()
#define HAVE_GNAT_INIT_FLOAT
void
__gnat_init_float ()
__gnat_init_float (void)
{
/* Disable overflow/underflow exceptions on the PPC processor, this is needed
to get correct Ada semantic. */
@ -1631,7 +1594,7 @@ __gnat_init_float ()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_init_float ();
@ -1661,8 +1624,7 @@ __gnat_initialize ()
#include <unistd.h>
static void
__gnat_error_handler (sig)
int sig;
__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
const char *msg;
@ -1694,7 +1656,7 @@ __gnat_error_handler (sig)
}
void
__gnat_install_handler()
__gnat_install_handler(void)
{
struct sigaction act;
@ -1714,7 +1676,7 @@ __gnat_install_handler()
}
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_install_handler ();
__gnat_init_float ();
@ -1726,12 +1688,12 @@ __gnat_initialize ()
#elif defined(__rtems__)
extern void __gnat_install_handler ();
extern void __gnat_install_handler (void);
/* For RTEMS, each bsp will provide a custom __gnat_install_handler (). */
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_install_handler ();
}
@ -1742,12 +1704,12 @@ __gnat_initialize ()
#elif defined(__rtems__)
extern void __gnat_install_handler ();
extern void __gnat_install_handler (void);
/* For RTEMS, each bsp will provide a custom __gnat_install_handler (). */
void
__gnat_initialize ()
__gnat_initialize (void)
{
__gnat_install_handler ();
}
@ -1762,7 +1724,7 @@ __gnat_initialize ()
/***************************************/
void
__gnat_initialize ()
__gnat_initialize (void)
{
}
@ -1771,7 +1733,7 @@ __gnat_initialize ()
/********************************************/
void
__gnat_install_handler ()
__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
@ -1792,7 +1754,7 @@ __gnat_install_handler ()
#define HAVE_GNAT_INIT_FLOAT
void
__gnat_init_float ()
__gnat_init_float (void)
{
#if defined (__i386__) || defined (i386)
@ -1809,7 +1771,7 @@ __gnat_init_float ()
/* All targets without a specific __gnat_init_float will use an empty one */
void
__gnat_init_float ()
__gnat_init_float (void)
{
}
#endif

6
gcc/ada/misc.c
View File

@ -359,7 +359,7 @@ gnat_tree_size (enum tree_code code)
/* Perform all the initialization steps that are language-specific. */
static bool
gnat_init ()
gnat_init (void)
{
/* Performs whatever initialization steps needed by the language-dependent
lexical analyzer. */
@ -396,7 +396,7 @@ gnat_finish_incomplete_decl (tree dont_care ATTRIBUTE_UNUSED)
objects. */
void
gnat_compute_largest_alignment ()
gnat_compute_largest_alignment (void)
{
enum machine_mode mode;
@ -413,7 +413,7 @@ gnat_compute_largest_alignment ()
various language dependent hooks. */
void
gnat_init_gcc_eh ()
gnat_init_gcc_eh (void)
{
/* We shouldn't do anything if the No_Exceptions_Handler pragma is set,
though. This could for instance lead to the emission of tables with

3
gcc/ada/mkdir.c
View File

@ -48,8 +48,7 @@
/* This function provides a portable binding to the mkdir function. */
int
__gnat_mkdir (dir_name)
char *dir_name;
__gnat_mkdir (char *dir_name)
{
#if defined (_WIN32) || defined (__vxworks)
return mkdir (dir_name);

105
gcc/ada/raise.c
View File

@ -58,9 +58,7 @@ typedef char bool;
/* We have not yet figured out how to import this directly */
void
_gnat_builtin_longjmp (ptr, flag)
void *ptr;
int flag ATTRIBUTE_UNUSED;
_gnat_builtin_longjmp (void *ptr, int flag ATTRIBUTE_UNUSED)
{
__builtin_longjmp (ptr, 1);
}
@ -72,7 +70,7 @@ _gnat_builtin_longjmp (ptr, flag)
performs any system dependent cleanup required. */
void
__gnat_unhandled_terminate ()
__gnat_unhandled_terminate (void)
{
/* Special termination handling for VMS */
@ -108,10 +106,10 @@ typedef struct _Unwind_Context _Unwind_Context;
typedef struct _Unwind_Exception _Unwind_Exception;
_Unwind_Reason_Code
__gnat_Unwind_RaiseException PARAMS ((_Unwind_Exception *));
__gnat_Unwind_RaiseException (_Unwind_Exception *);
_Unwind_Reason_Code
__gnat_Unwind_ForcedUnwind PARAMS ((_Unwind_Exception *, void *, void *));
__gnat_Unwind_ForcedUnwind (_Unwind_Exception *, void *, void *);
#ifdef IN_RTS /* For eh personality routine */
@ -540,9 +538,7 @@ typedef struct
} region_descriptor;
static void
db_region_for (region, uw_context)
region_descriptor *region;
_Unwind_Context *uw_context;
db_region_for (region_descriptor *region, _Unwind_Context *uw_context)
{
_Unwind_Ptr ip = _Unwind_GetIP (uw_context) - 1;
@ -563,9 +559,7 @@ db_region_for (region, uw_context)
ttype table. */
static const _Unwind_Ptr
get_ttype_entry_for (region, filter)
region_descriptor *region;
long filter;
get_ttype_entry_for (region_descriptor *region, long filter)
{
_Unwind_Ptr ttype_entry;
@ -580,9 +574,8 @@ get_ttype_entry_for (region, filter)
/* Fill out the REGION descriptor for the provided UW_CONTEXT. */
static void
get_region_description_for (uw_context, region)
_Unwind_Context *uw_context;
region_descriptor *region;
get_region_description_for (_Unwind_Context *uw_context,
region_descriptor *region)
{
const unsigned char * p;
_Unwind_Word tmp;
@ -674,9 +667,7 @@ typedef struct
static void
db_action_for (action, uw_context)
action_descriptor *action;
_Unwind_Context *uw_context;
db_action_for (action_descriptor *action, _Unwind_Context *uw_context)
{
_Unwind_Ptr ip = _Unwind_GetIP (uw_context) - 1;
@ -725,10 +716,9 @@ db_action_for (action, uw_context)
#define __builtin_eh_return_data_regno(x) x
static void
get_call_site_action_for (uw_context, region, action)
_Unwind_Context *uw_context;
region_descriptor *region;
action_descriptor *action;
get_call_site_action_for (_Unwind_Context *uw_context,
region_descriptor *region,
action_descriptor *action)
{
_Unwind_Ptr call_site
= _Unwind_GetIP (uw_context) - 1;
@ -786,10 +776,9 @@ get_call_site_action_for (uw_context, region, action)
/* ! __USING_SJLJ_EXCEPTIONS__ */
static void
get_call_site_action_for (uw_context, region, action)
_Unwind_Context *uw_context;
region_descriptor *region;
action_descriptor *action;
get_call_site_action_for (_Unwind_Context *uw_context,
region_descriptor *region,
action_descriptor *action)
{
_Unwind_Ptr ip
= _Unwind_GetIP (uw_context) - 1;
@ -861,11 +850,10 @@ get_call_site_action_for (uw_context, region, action)
UW_CONTEXT in REGION. */
static void
get_action_description_for (uw_context, uw_exception, region, action)
_Unwind_Context *uw_context;
_Unwind_Exception *uw_exception;
region_descriptor *region;
action_descriptor *action;
get_action_description_for (_Unwind_Context *uw_context,
_Unwind_Exception *uw_exception,
region_descriptor *regionr,
action_descriptor *actionr)
{
_GNAT_Exception * gnat_exception = (_GNAT_Exception *) uw_exception;
@ -950,11 +938,10 @@ get_action_description_for (uw_context, uw_exception, region, action)
occured. */
static void
setup_to_install (uw_context, uw_exception, uw_landing_pad, uw_filter)
_Unwind_Context *uw_context;
_Unwind_Exception *uw_exception;
int uw_filter;
_Unwind_Ptr uw_landing_pad;
setup_to_install (_Unwind_Context *uw_context,
_Unwind_Exception *uw_exception,
int uw_filter,
_Unwind_Ptr uw_landing_pad)
{
#ifndef EH_RETURN_DATA_REGNO
/* We should not be called if the appropriate underlying support is not
@ -981,20 +968,18 @@ setup_to_install (uw_context, uw_exception, uw_landing_pad, uw_filter)
/* The following is defined from a-except.adb. Its purpose is to enable
automatic backtraces upon exception raise, as provided through the
GNAT.Traceback facilities. */
extern void __gnat_notify_handled_exception PARAMS ((void));
extern void __gnat_notify_unhandled_exception PARAMS ((void));
extern void __gnat_notify_handled_exception (void);
extern void __gnat_notify_unhandled_exception (void);
/* Below is the eh personality routine per se. We currently assume that only
GNU-Ada exceptions are met. */
_Unwind_Reason_Code
__gnat_eh_personality (uw_version, uw_phases,
uw_exception_class, uw_exception, uw_context)
int uw_version;
_Unwind_Action uw_phases;
_Unwind_Exception_Class uw_exception_class;
_Unwind_Exception *uw_exception;
_Unwind_Context *uw_context;
__gnat_eh_personality (int uw_version,
_Unwind_Action uw_phases,
_Unwind_Exception_Class uw_exception_class,
_Unwind_Exception *uw_exception,
_Unwind_Context *uw_context)
{
_GNAT_Exception * gnat_exception = (_GNAT_Exception *) uw_exception;
@ -1075,8 +1060,7 @@ __gnat_eh_personality (uw_version, uw_phases,
#undef _Unwind_RaiseException
_Unwind_Reason_Code
__gnat_Unwind_RaiseException (e)
_Unwind_Exception *e;
__gnat_Unwind_RaiseException (_Unwind_Exception *e)
{
return _Unwind_SjLj_RaiseException (e);
}
@ -1085,10 +1069,9 @@ __gnat_Unwind_RaiseException (e)
#undef _Unwind_ForcedUnwind
_Unwind_Reason_Code
__gnat_Unwind_ForcedUnwind (e, handler, argument)
_Unwind_Exception *e;
void * handler;
void * argument;
__gnat_Unwind_ForcedUnwind (_Unwind_Exception *e,
void * handler,
void * argument)
{
return _Unwind_SjLj_ForcedUnwind (e, handler, argument);
}
@ -1097,17 +1080,15 @@ __gnat_Unwind_ForcedUnwind (e, handler, argument)
#else /* __USING_SJLJ_EXCEPTIONS__ */
_Unwind_Reason_Code
__gnat_Unwind_RaiseException (e)
_Unwind_Exception *e;
__gnat_Unwind_RaiseException (_Unwind_Exception *e)
{
return _Unwind_RaiseException (e);
}
_Unwind_Reason_Code
__gnat_Unwind_ForcedUnwind (e, handler, argument)
_Unwind_Exception *e;
void * handler;
void * argument;
__gnat_Unwind_ForcedUnwind (_Unwind_Exception *e,
void * handler,
void * argument)
{
return _Unwind_ForcedUnwind (e, handler, argument);
}
@ -1127,18 +1108,16 @@ __gnat_Unwind_ForcedUnwind (e, handler, argument)
functions never to be called. */
_Unwind_Reason_Code
__gnat_Unwind_RaiseException (e)
_Unwind_Exception *e ATTRIBUTE_UNUSED;
__gnat_Unwind_RaiseException (_Unwind_Exception *e ATTRIBUTE_UNUSED)
{
abort ();
}
_Unwind_Reason_Code
__gnat_Unwind_ForcedUnwind (e, handler, argument)
_Unwind_Exception *e ATTRIBUTE_UNUSED;
void * handler ATTRIBUTE_UNUSED;
void * argument ATTRIBUTE_UNUSED;
__gnat_Unwind_ForcedUnwind (_Unwind_Exception *e ATTRIBUTE_UNUSED,
void * handler ATTRIBUTE_UNUSED,
void * argument ATTRIBUTE_UNUSED)
{
abort ();
}

41
gcc/ada/socket.c
View File

@ -66,19 +66,18 @@
#include "raise.h"
extern void __gnat_free_socket_set PARAMS ((fd_set *));
extern void __gnat_last_socket_in_set PARAMS ((fd_set *, int *));
extern void __gnat_get_socket_from_set PARAMS ((fd_set *, int *, int *));
extern void __gnat_insert_socket_in_set PARAMS ((fd_set *, int));
extern int __gnat_is_socket_in_set PARAMS ((fd_set *, int));
extern fd_set *__gnat_new_socket_set PARAMS ((fd_set *));
extern void __gnat_remove_socket_from_set PARAMS ((fd_set *, int));
extern void __gnat_free_socket_set (fd_set *);
extern void __gnat_last_socket_in_set (fd_set *, int *);
extern void __gnat_get_socket_from_set (fd_set *, int *, int *);
extern void __gnat_insert_socket_in_set (fd_set *, int);
extern int __gnat_is_socket_in_set (fd_set *, int);
extern fd_set *__gnat_new_socket_set (fd_set *);
extern void __gnat_remove_socket_from_set (fd_set *, int);
/* Free socket set. */
void
__gnat_free_socket_set (set)
fd_set *set;
__gnat_free_socket_set (fd_set *set)
{
__gnat_free (set);
}
@ -89,9 +88,7 @@ __gnat_free_socket_set (set)
actual largest socket in the socket set. */
void
__gnat_last_socket_in_set (set, last)
fd_set *set;
int *last;
__gnat_last_socket_in_set (fd_set *set, int *last)
{
int s;
int l;
@ -122,10 +119,7 @@ __gnat_last_socket_in_set (set, last)
socket in the socket set. */
void
__gnat_get_socket_from_set (set, last, socket)
fd_set *set;
int *last;
int *socket;
__gnat_get_socket_from_set (fd_set *set, int *last, int *socket)
{
*socket = *last;
FD_CLR (*socket, set);
@ -135,9 +129,7 @@ __gnat_get_socket_from_set (set, last, socket)
/* Insert SOCKET in the socket set SET. */
void
__gnat_insert_socket_in_set (set, socket)
fd_set *set;
int socket;
__gnat_insert_socket_in_set (fd_set *set, int socket)
{
FD_SET (socket, set);
}
@ -145,9 +137,7 @@ __gnat_insert_socket_in_set (set, socket)
/* Check whether a given SOCKET is in the socket set SET. */
int
__gnat_is_socket_in_set (set, socket)
fd_set *set;
int socket;
__gnat_is_socket_in_set (fd_set *set, int socket)
{
return FD_ISSET (socket, set);
}
@ -155,8 +145,7 @@ __gnat_is_socket_in_set (set, socket)
/* Allocate a new socket set and set it as empty. */
fd_set *
__gnat_new_socket_set (set)
fd_set *set;
__gnat_new_socket_set (fd_set *set)
{
fd_set *new;
@ -173,9 +162,7 @@ __gnat_new_socket_set (set)
/* Remove SOCKET from the socket set SET. */
void
__gnat_remove_socket_from_set (set, socket)
fd_set *set;
int socket;
__gnat_remove_socket_from_set (fd_set *set, int socket)
{
FD_CLR (socket, set);
}

106
gcc/ada/sysdep.c
View File

@ -157,15 +157,13 @@ static const char *mode_append_binary_plus = "a+b";
const char __gnat_text_translation_required = 1;
void
__gnat_set_binary_mode (handle)
int handle;
__gnat_set_binary_mode (int handle)
{
_setmode (handle, O_BINARY);
}
void
__gnat_set_text_mode (handle)
int handle;
__gnat_set_text_mode (int handle)
{
_setmode (handle, O_TEXT);
}
@ -178,8 +176,7 @@ __gnat_set_text_mode (handle)
"console". */
char *
__gnat_ttyname (filedes)
int filedes;
__gnat_ttyname (int filedes)
{
if (isatty (filedes))
return "console";
@ -206,22 +203,22 @@ __gnat_ttyname (filedes)
Calling FlushConsoleInputBuffer just after getch() fix the bug under
95/98. */
static void winflush_init PARAMS ((void));
static void winflush_init (void);
static void winflush_95 PARAMS ((void));
static void winflush_95 (void);
static void winflush_nt PARAMS ((void));
static void winflush_nt (void);
/* winflusfunction is set first to the winflushinit function which will check
the OS version 95/98 or NT/2000 */
static void (*winflush_function) PARAMS ((void)) = winflush_init;
static void (*winflush_function) (void) = winflush_init;
/* This function does the runtime check of the OS version and then sets
winflush_function to the appropriate function and then call it. */
static void
winflush_init ()
winflush_init (void)
{
DWORD dwVersion = GetVersion();
@ -234,12 +231,12 @@ winflush_init ()
}
static void winflush_95 ()
static void winflush_95 (void)
{
FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE));
}
static void winflush_nt ()
static void winflush_nt (void)
{
/* Does nothing as there is no problem under NT. */
}
@ -264,22 +261,19 @@ const char __gnat_text_translation_required = 0;
/* These functions do nothing in non-DOS systems. */
void
__gnat_set_binary_mode (handle)
int handle ATTRIBUTE_UNUSED;
__gnat_set_binary_mode (int handle ATTRIBUTE_UNUSED)
{
}
void
__gnat_set_text_mode (handle)
int handle ATTRIBUTE_UNUSED;
__gnat_set_text_mode (int handle ATTRIBUTE_UNUSED)
{
}
char *
__gnat_ttyname (filedes)
int filedes;
__gnat_ttyname (int filedes)
{
#ifndef __vxworks
extern char *ttyname PARAMS ((int));
extern char *ttyname (int);
return ttyname (filedes);
@ -315,18 +309,14 @@ static int initted = 0;
/* Implements the common processing for getc_immediate and
getc_immediate_nowait. */
extern void getc_immediate PARAMS ((FILE *, int *, int *));
extern void getc_immediate_nowait PARAMS ((FILE *, int *, int *, int *));
extern void getc_immediate_common PARAMS ((FILE *, int *, int *,
int *, int));
extern void getc_immediate (FILE *, int *, int *);
extern void getc_immediate_nowait (FILE *, int *, int *, int *);
extern void getc_immediate_common (FILE *, int *, int *, int *, int);
/* Called by Get_Immediate (Foo); */
void
getc_immediate (stream, ch, end_of_file)
FILE *stream;
int *ch;
int *end_of_file;
getc_immediate (FILE *stream, int *ch, int *end_of_file)
{
int avail;
@ -336,11 +326,7 @@ getc_immediate (stream, ch, end_of_file)
/* Called by Get_Immediate (Foo, Available); */
void
getc_immediate_nowait (stream, ch, end_of_file, avail)
FILE *stream;
int *ch;
int *end_of_file;
int *avail;
getc_immediate_nowait (FILE *stream, int *ch, int *end_of_file, int *avail)
{
getc_immediate_common (stream, ch, end_of_file, avail, 0);
}
@ -348,12 +334,11 @@ getc_immediate_nowait (stream, ch, end_of_file, avail)
/* Called by getc_immediate () and getc_immediate_nowait () */
void
getc_immediate_common (stream, ch, end_of_file, avail, waiting)
FILE *stream;
int *ch;
int *end_of_file;
int *avail;
int waiting;
getc_immediate_common (FILE *stream,
int *ch,
int *end_of_file,
int *avail,
int waiting)
{
#if defined (linux) || defined (sun) || defined (sgi) || defined (__EMX__) \
|| (defined (__osf__) && ! defined (__alpha_vxworks)) \
@ -614,31 +599,31 @@ getc_immediate_common (stream, ch, end_of_file, avail, waiting)
will want to import these). We use the same names as the routines used
by AdaMagic for compatibility. */
char *rts_get_hInstance PARAMS ((void));
char *rts_get_hPrevInstance PARAMS ((void));
char *rts_get_lpCommandLine PARAMS ((void));
int rts_get_nShowCmd PARAMS ((void));
char *rts_get_hInstance (void);
char *rts_get_hPrevInstance (void);
char *rts_get_lpCommandLine (void);
int rts_get_nShowCmd (void);
char *
rts_get_hInstance ()
rts_get_hInstance (void)
{
return (char *)GetModuleHandleA (0);
}
char *
rts_get_hPrevInstance ()
rts_get_hPrevInstance (void)
{
return 0;
}
char *
rts_get_lpCommandLine ()
rts_get_lpCommandLine (void)
{
return GetCommandLineA ();
}
int
rts_get_nShowCmd ()
rts_get_nShowCmd (void)
{
return 1;
}
@ -650,10 +635,10 @@ rts_get_nShowCmd ()
#include <time.h>
extern long get_gmtoff PARAMS ((void));
extern long get_gmtoff (void);
long
get_gmtoff ()
get_gmtoff (void)
{
time_t t;
struct tm *ts;
@ -668,22 +653,19 @@ get_gmtoff ()
#if defined (_AIX) || defined (__EMX__)
#define Lock_Task system__soft_links__lock_task
extern void (*Lock_Task) PARAMS ((void));
extern void (*Lock_Task) (void);
#define Unlock_Task system__soft_links__unlock_task
extern void (*Unlock_Task) PARAMS ((void));
extern void (*Unlock_Task) (void);
/* Provide reentrant version of localtime on Aix and OS/2. Note that AiX does
provide localtime_r, but in the library libc_r which doesn't get included
systematically, so we can't use it. */
extern struct tm *__gnat_localtime_r PARAMS ((const time_t *,
struct tm *));
extern struct tm *__gnat_localtime_r (const time_t *, struct tm *);
struct tm *
__gnat_localtime_r (timer, tp)
const time_t *timer;
struct tm *tp;
__gnat_localtime_r (const time_t *timer, struct tm *tp)
{
struct tm *tmp;
@ -703,12 +685,10 @@ __gnat_localtime_r (timer, tp)
spec is required. Only use when ___THREADS_POSIX4ad4__ is defined,
the Lynx convention when building against the legacy API. */
extern struct tm *__gnat_localtime_r PARAMS ((const time_t *, struct tm *));
extern struct tm *__gnat_localtime_r (const time_t *, struct tm *);
struct tm *
__gnat_localtime_r (timer, tp)
const time_t *timer;
struct tm *tp;
__gnat_localtime_r (const time_t *timer, struct tm *tp)
{
localtime_r (tp, timer);
return NULL;
@ -723,12 +703,10 @@ __gnat_localtime_r (timer, tp)
/* All other targets provide a standard localtime_r */
extern struct tm *__gnat_localtime_r PARAMS ((const time_t *, struct tm *));
extern struct tm *__gnat_localtime_r (const time_t *, struct tm *);
struct tm *
__gnat_localtime_r (timer, tp)
const time_t *timer;
struct tm *tp;
__gnat_localtime_r (const time_t *timer, struct tm *tp)
{
return (struct tm *) localtime_r (timer, tp);
}

38
gcc/ada/targtyps.c
View File

@ -69,86 +69,86 @@
to determine the sizes that are used for various C types. */
Pos
get_target_bits_per_unit ()
get_target_bits_per_unit (void)
{
return BITS_PER_UNIT;
}
Pos
get_target_bits_per_word ()
get_target_bits_per_word (void)
{
return BITS_PER_WORD;
}
Pos
get_target_char_size ()
get_target_char_size (void)
{
return CHAR_TYPE_SIZE;
}
Pos
get_target_wchar_t_size ()
get_target_wchar_t_size (void)
{
/* We never want wide chacters less than "short" in Ada. */
return MAX (SHORT_TYPE_SIZE, WCHAR_TYPE_SIZE);
}
Pos
get_target_short_size ()
get_target_short_size (void)
{
return SHORT_TYPE_SIZE;
}
Pos
get_target_int_size ()
get_target_int_size (void)
{
return INT_TYPE_SIZE;
}
Pos
get_target_long_size ()
get_target_long_size (void)
{
return ADA_LONG_TYPE_SIZE;
}
Pos
get_target_long_long_size ()
get_target_long_long_size (void)
{
return LONG_LONG_TYPE_SIZE;
}
Pos
get_target_float_size ()
get_target_float_size (void)
{
return FLOAT_TYPE_SIZE;
}
Pos
get_target_double_size ()
get_target_double_size (void)
{
return DOUBLE_TYPE_SIZE;
}
Pos
get_target_long_double_size ()
get_target_long_double_size (void)
{
return WIDEST_HARDWARE_FP_SIZE;
}
Pos
get_target_pointer_size ()
get_target_pointer_size (void)
{
return POINTER_SIZE;
}
Pos
get_target_maximum_alignment ()
get_target_maximum_alignment (void)
{
return BIGGEST_ALIGNMENT / BITS_PER_UNIT;
}
Boolean
get_target_no_dollar_in_label ()
get_target_no_dollar_in_label (void)
{
#ifdef NO_DOLLAR_IN_LABEL
return 1;
@ -162,31 +162,31 @@ get_target_no_dollar_in_label ()
#endif
Nat
get_float_words_be ()
get_float_words_be (void)
{
return FLOAT_WORDS_BIG_ENDIAN;
}
Nat
get_words_be ()
get_words_be (void)
{
return WORDS_BIG_ENDIAN;
}
Nat
get_bytes_be ()
get_bytes_be (void)
{
return BYTES_BIG_ENDIAN;
}
Nat
get_bits_be ()
get_bits_be (void)
{
return BITS_BIG_ENDIAN;
}
Nat
get_strict_alignment ()
get_strict_alignment (void)
{
return STRICT_ALIGNMENT;
}

11
gcc/ada/tb-alvms.c
View File

@ -207,12 +207,11 @@ typedef struct {
********************/
int
__gnat_backtrace (array, size, exclude_min, exclude_max, skip_frames)
void **array;
int size;
void *exclude_min;
void *exclude_max;
int skip_frames;
__gnat_backtrace (void **array,
int size,
void *exclude_min,
void *exclude_max,
int skip_frames)
{
int cnt;

92
gcc/ada/tb-alvxw.c
View File

@ -39,7 +39,7 @@
#include <limits.h>
#include <string.h>
extern void kerTaskEntry();
extern void kerTaskEntry(void);
/* We still use a number of macros similar to the ones for the generic
__gnat_backtrace implementation. */
@ -259,8 +259,7 @@ struct alloc_chain
struct alloc_chain *trace_alloc_chain;
static void *
trace_alloc (n)
unsigned int n;
trace_alloc (unsigned int n)
{
struct alloc_chain * result = malloc (n + sizeof(struct alloc_chain));
@ -270,7 +269,7 @@ trace_alloc (n)
}
static void
free_trace_alloc ()
free_trace_alloc (void)
{
while (trace_alloc_chain != 0)
{
@ -285,9 +284,7 @@ free_trace_alloc ()
otherwise. */
static int
read_memory_safe4 (addr, dest)
CORE_ADDR addr;
unsigned int *dest;
read_memory_safe4 (CORE_ADDR addr, unsigned int *dest)
{
*dest = *((unsigned int*) addr);
return 0;
@ -297,17 +294,14 @@ read_memory_safe4 (addr, dest)
otherwise. */
static int
read_memory_safe8 (addr, dest)
CORE_ADDR addr;
CORE_ADDR *dest;
read_memory_safe8 (CORE_ADDR addr, CORE_ADDR *dest)
{
*dest = *((CORE_ADDR*) addr);
return 0;
}
static CORE_ADDR
read_register (regno)
int regno;
read_register (int regno)
{
if (regno >= 0 && regno < 31)
return theRegisters[regno];
@ -316,23 +310,20 @@ read_register (regno)
}
static void
frame_saved_regs_zalloc (fi)
struct frame_info *fi;
frame_saved_regs_zalloc (struct frame_info *fi)
{
fi->saved_regs = (CORE_ADDR *) trace_alloc (SIZEOF_FRAME_SAVED_REGS);
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
}
static void *
frame_obstack_alloc (size)
unsigned long size;
frame_obstack_alloc (unsigned long size)
{
return (void *) trace_alloc (size);
}
static int
inside_entry_file (addr)
CORE_ADDR addr;
inside_entry_file (CORE_ADDR addr)
{
if (addr == 0)
return 1;
@ -341,8 +332,7 @@ inside_entry_file (addr)
}
static CORE_ADDR
alpha_saved_pc_after_call (frame)
struct frame_info *frame;
alpha_saved_pc_after_call (struct frame_info *frame)
{
CORE_ADDR pc = frame->pc;
alpha_extra_func_info_t proc_desc;
@ -358,8 +348,7 @@ alpha_saved_pc_after_call (frame)
NULL). */
static void
alpha_find_saved_regs (frame)
struct frame_info *frame;
alpha_find_saved_regs (struct frame_info *frame)
{
int ireg;
CORE_ADDR reg_position;
@ -430,9 +419,7 @@ alpha_find_saved_regs (frame)
}
static CORE_ADDR
read_next_frame_reg (fi, regno)
struct frame_info *fi;
int regno;
read_next_frame_reg (struct frame_info *fi, int regno)
{
CORE_ADDR result;
for (; fi; fi = fi->next)
@ -460,8 +447,7 @@ read_next_frame_reg (fi, regno)
}
static CORE_ADDR
alpha_frame_saved_pc (frame)
struct frame_info *frame;
alpha_frame_saved_pc (struct frame_info *frame)
{
return read_next_frame_reg (frame, frame->pc_reg);
}
@ -472,8 +458,7 @@ static struct alpha_extra_func_info temp_proc_desc;
$zero,($ra),1" on alpha. */
static int
alpha_about_to_return (pc)
CORE_ADDR pc;
alpha_about_to_return (CORE_ADDR pc)
{
int inst;
@ -485,8 +470,7 @@ alpha_about_to_return (pc)
containing address PC. Returns 0 if none detected. */
static CORE_ADDR
heuristic_proc_start (pc)
CORE_ADDR pc;
heuristic_proc_start (CORE_ADDR pc)
{
CORE_ADDR start_pc = pc;
CORE_ADDR fence = start_pc - heuristic_fence_post;
@ -512,11 +496,10 @@ heuristic_proc_start (pc)
}
static alpha_extra_func_info_t
heuristic_proc_desc (start_pc, limit_pc, next_frame, saved_regs_p)
CORE_ADDR start_pc;
CORE_ADDR limit_pc;
struct frame_info *next_frame;
struct frame_saved_regs *saved_regs_p;
heuristic_proc_desc (CORE_ADDR start_pc,
CORE_ADDR limit_pc,
struct frame_info *next_frame,
struct frame_saved_regs *saved_regs_p)
{
CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);
CORE_ADDR cur_pc;
@ -641,10 +624,9 @@ heuristic_proc_desc (start_pc, limit_pc, next_frame, saved_regs_p)
}
static alpha_extra_func_info_t
find_proc_desc (pc, next_frame, saved_regs)
CORE_ADDR pc;
struct frame_info *next_frame;
struct frame_saved_regs *saved_regs;
find_proc_desc (CORE_ADDR pc,
struct frame_info *next_frame,
struct frame_saved_regs *saved_regs)
{
CORE_ADDR startaddr;
@ -660,8 +642,7 @@ find_proc_desc (pc, next_frame, saved_regs)
}
static CORE_ADDR
alpha_frame_chain (frame)
struct frame_info *frame;
alpha_frame_chain (struct frame_info *frame)
{
alpha_extra_func_info_t proc_desc;
CORE_ADDR saved_pc = FRAME_SAVED_PC (frame);
@ -685,8 +666,7 @@ alpha_frame_chain (frame)
}
static void
init_extra_frame_info (frame)
struct frame_info *frame;
init_extra_frame_info (struct frame_info *frame)
{
struct frame_saved_regs temp_saved_regs;
alpha_extra_func_info_t proc_desc =
@ -729,9 +709,7 @@ init_extra_frame_info (frame)
Always returns a non-NULL value. */
static struct frame_info *
create_new_frame (addr, pc)
CORE_ADDR addr;
CORE_ADDR pc;
create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
{
struct frame_info *fi;
@ -754,19 +732,19 @@ create_new_frame (addr, pc)
static CORE_ADDR current_pc;
static void
set_current_pc ()
set_current_pc (void)
{
current_pc = (CORE_ADDR) __builtin_return_address (0);
}
static CORE_ADDR
read_pc ()
read_pc (void)
{
return current_pc;
}
static struct frame_info *
get_current_frame ()
get_current_frame (void)
{
return create_new_frame (0, read_pc ());
}
@ -775,8 +753,7 @@ get_current_frame ()
If FI is the original frame (it has no caller), return 0. */
static struct frame_info *
get_prev_frame (next_frame)
struct frame_info *next_frame;
get_prev_frame (struct frame_info *next_frame)
{
CORE_ADDR address = 0;
struct frame_info *prev;
@ -897,12 +874,11 @@ get_prev_frame (next_frame)
"stq $" #regno ", " #disp "(%0)\n"
int
__gnat_backtrace (array, size, exclude_min, exclude_max, skip_frames)
void **array;
int size;
void *exclude_min;
void *exclude_max;
int skip_frames;
__gnat_backtrace (void **array,
int size,
void *exclude_min,
void *exclude_max,
int skip_frames)
{
struct frame_info* top;
struct frame_info* current;

17
gcc/ada/tracebak.c
View File

@ -58,7 +58,7 @@
#include "system.h"
#endif
extern int __gnat_backtrace PARAMS ((void **, int, void *, void *, int));
extern int __gnat_backtrace (void **, int, void *, void *, int);
/* The point is to provide an implementation of the __gnat_bactrace function
above, called by the default implementation of the System.Traceback
@ -77,10 +77,10 @@ extern int __gnat_backtrace PARAMS ((void **, int, void *, void *, int));
function is still referenced by the default System.Traceback. */
#define Lock_Task system__soft_links__lock_task
extern void (*Lock_Task) PARAMS ((void));
extern void (*Lock_Task) (void);
#define Unlock_Task system__soft_links__unlock_task
extern void (*Unlock_Task) PARAMS ((void));
extern void (*Unlock_Task) (void);
/*-------------------------------------*
*-- Target specific implementations --*
@ -339,12 +339,11 @@ static void forced_callee () {}
#endif
int
__gnat_backtrace (array, size, exclude_min, exclude_max, skip_frames)
void **array;
int size;
void *exclude_min;
void *exclude_max;
int skip_frames;
__gnat_backtrace (void **array,
int size,
void *exclude_min,
void *exclude_max,
int skip_frames)
{
struct layout *current;
void *top_frame;

221
gcc/ada/trans.c
View File

@ -103,24 +103,22 @@ Node_Id error_gnat_node;
a return in some functions. See processing for N_Subprogram_Body. */
static GTY(()) tree gnu_return_label_stack;
static tree tree_transform PARAMS((Node_Id));
static void elaborate_all_entities PARAMS((Node_Id));
static void process_freeze_entity PARAMS((Node_Id));
static void process_inlined_subprograms PARAMS((Node_Id));
static void process_decls PARAMS((List_Id, List_Id, Node_Id,
int, int));
static tree emit_range_check PARAMS((tree, Node_Id));
static tree emit_index_check PARAMS((tree, tree, tree, tree));
static tree emit_check PARAMS((tree, tree, int));
static tree convert_with_check PARAMS((Entity_Id, tree,
int, int, int));
static int addressable_p PARAMS((tree));
static tree assoc_to_constructor PARAMS((Node_Id, tree));
static tree extract_values PARAMS((tree, tree));
static tree pos_to_constructor PARAMS((Node_Id, tree, Entity_Id));
static tree maybe_implicit_deref PARAMS((tree));
static tree gnat_stabilize_reference_1 PARAMS((tree, int));
static int build_unit_elab PARAMS((Entity_Id, int, tree));
static tree tree_transform (Node_Id);
static void elaborate_all_entities (Node_Id);
static void process_freeze_entity (Node_Id);
static void process_inlined_subprograms (Node_Id);
static void process_decls (List_Id, List_Id, Node_Id, int, int);
static tree emit_range_check (tree, Node_Id);
static tree emit_index_check (tree, tree, tree, tree);
static tree emit_check (tree, tree, int);
static tree convert_with_check (Entity_Id, tree, int, int, int);
static int addressable_p (tree);
static tree assoc_to_constructor (Node_Id, tree);
static tree extract_values (tree, tree);
static tree pos_to_constructor (Node_Id, tree, Entity_Id);
static tree maybe_implicit_deref (tree);
static tree gnat_stabilize_reference_1 (tree, int);
static int build_unit_elab (Entity_Id, int, tree);
/* Constants for +0.5 and -0.5 for float-to-integer rounding. */
static REAL_VALUE_TYPE dconstp5;
@ -130,27 +128,23 @@ static REAL_VALUE_TYPE dconstmp5;
structures and then generates code. */
void
gigi (gnat_root, max_gnat_node, number_name, nodes_ptr, next_node_ptr,
prev_node_ptr, elists_ptr, elmts_ptr, strings_ptr, string_chars_ptr,
list_headers_ptr, number_units, file_info_ptr, standard_integer,
standard_long_long_float, standard_exception_type, gigi_operating_mode)
Node_Id gnat_root;
int max_gnat_node;
int number_name;
struct Node *nodes_ptr;
Node_Id *next_node_ptr;
Node_Id *prev_node_ptr;
struct Elist_Header *elists_ptr;
struct Elmt_Item *elmts_ptr;
struct String_Entry *strings_ptr;
Char_Code *string_chars_ptr;
struct List_Header *list_headers_ptr;
Int number_units ATTRIBUTE_UNUSED;
char *file_info_ptr ATTRIBUTE_UNUSED;
Entity_Id standard_integer;
Entity_Id standard_long_long_float;
Entity_Id standard_exception_type;
Int gigi_operating_mode;
gigi (Node_Id gnat_root,
int max_gnat_node,
int number_name,
struct Node *nodes_ptr,
Node_Id *next_node_ptr,
Node_Id *prev_node_ptr,
struct Elist_Header *elists_ptr,
struct Elmt_Item *elmts_ptr,
struct String_Entry *strings_ptr,
Char_Code *string_chars_ptr,
struct List_Header *list_headers_ptr,
Int number_units ATTRIBUTE_UNUSED,
char *file_info_ptr ATTRIBUTE_UNUSED,
Entity_Id standard_integer,
Entity_Id standard_long_long_float,
Entity_Id standard_exception_type,
Int gigi_operating_mode)
{
tree gnu_standard_long_long_float;
tree gnu_standard_exception_type;
@ -233,8 +227,7 @@ gigi (gnat_root, max_gnat_node, number_name, nodes_ptr, next_node_ptr,
part of the tree. */
void
gnat_to_code (gnat_node)
Node_Id gnat_node;
gnat_to_code (Node_Id gnat_node)
{
tree gnu_root;
@ -259,8 +252,7 @@ gnat_to_code (gnat_node)
code. */
tree
gnat_to_gnu (gnat_node)
Node_Id gnat_node;
gnat_to_gnu (Node_Id gnat_node)
{
tree gnu_root;
@ -286,8 +278,7 @@ gnat_to_gnu (gnat_node)
in the above two routines for most purposes. */
static tree
tree_transform (gnat_node)
Node_Id gnat_node;
tree_transform (Node_Id gnat_node)
{
tree gnu_result = error_mark_node; /* Default to no value. */
tree gnu_result_type = void_type_node;
@ -4156,8 +4147,7 @@ tree_transform (gnat_node)
/* GNU_STMT is a statement. We generate code for that statement. */
void
gnat_expand_stmt (gnu_stmt)
tree gnu_stmt;
gnat_expand_stmt (tree gnu_stmt)
{
set_lineno_from_sloc (TREE_SLOC (gnu_stmt), 1);
@ -4193,8 +4183,7 @@ gnat_expand_stmt (gnu_stmt)
information for types in withed units, for ASIS use */
static void
elaborate_all_entities (gnat_node)
Node_Id gnat_node;
elaborate_all_entities (Node_Id gnat_node)
{
Entity_Id gnat_with_clause, gnat_entity;
@ -4260,8 +4249,7 @@ elaborate_all_entities (gnat_node)
/* Do the processing of N_Freeze_Entity, GNAT_NODE. */
static void
process_freeze_entity (gnat_node)
Node_Id gnat_node;
process_freeze_entity (Node_Id gnat_node)
{
Entity_Id gnat_entity = Entity (gnat_node);
tree gnu_old;
@ -4369,8 +4357,7 @@ process_freeze_entity (gnat_node)
N_Compilation_Unit. */
static void
process_inlined_subprograms (gnat_node)
Node_Id gnat_node;
process_inlined_subprograms (Node_Id gnat_node)
{
Entity_Id gnat_entity;
Node_Id gnat_body;
@ -4416,10 +4403,11 @@ process_inlined_subprograms (gnat_node)
correspond to the public and private parts of a package. */
static void
process_decls (gnat_decls, gnat_decls2, gnat_end_list, pass1p, pass2p)
List_Id gnat_decls, gnat_decls2;
Node_Id gnat_end_list;
int pass1p, pass2p;
process_decls (List_Id gnat_decls,
List_Id gnat_decls2,
Node_Id gnat_end_list,
int pass1p,
int pass2p)
{
List_Id gnat_decl_array[2];
Node_Id gnat_decl;
@ -4536,9 +4524,7 @@ process_decls (gnat_decls, gnat_decls2, gnat_end_list, pass1p, pass2p)
which we have to check. */
static tree
emit_range_check (gnu_expr, gnat_range_type)
tree gnu_expr;
Entity_Id gnat_range_type;
emit_range_check (tree gnu_expr, Entity_Id gnat_range_type)
{
tree gnu_range_type = get_unpadded_type (gnat_range_type);
tree gnu_low = TYPE_MIN_VALUE (gnu_range_type);
@ -4588,11 +4574,10 @@ emit_range_check (gnu_expr, gnat_range_type)
subprograms having unconstrained array formal parameters */
static tree
emit_index_check (gnu_array_object, gnu_expr, gnu_low, gnu_high)
tree gnu_array_object;
tree gnu_expr;
tree gnu_low;
tree gnu_high;
emit_index_check (tree gnu_array_object,
tree gnu_expr,
tree gnu_low,
tree gnu_high)
{
tree gnu_expr_check;
@ -4635,10 +4620,7 @@ emit_index_check (gnu_array_object, gnu_expr, gnu_low, gnu_high)
why the exception was raised. */
static tree
emit_check (gnu_cond, gnu_expr, reason)
tree gnu_cond;
tree gnu_expr;
int reason;
emit_check (tree gnu_cond, tree gnu_expr, int reason)
{
tree gnu_call;
tree gnu_result;
@ -4676,12 +4658,11 @@ emit_check (gnu_cond, gnu_expr, reason)
truncation; otherwise round. */
static tree
convert_with_check (gnat_type, gnu_expr, overflow_p, range_p, truncate_p)
Entity_Id gnat_type;
tree gnu_expr;
int overflow_p;
int range_p;
int truncate_p;
convert_with_check (Entity_Id gnat_type,
tree gnu_expr,
int overflow_p,
int range_p,
int truncate_p)
{
tree gnu_type = get_unpadded_type (gnat_type);
tree gnu_in_type = TREE_TYPE (gnu_expr);
@ -4820,8 +4801,7 @@ convert_with_check (gnat_type, gnu_expr, overflow_p, range_p, truncate_p)
cases. */
static int
addressable_p (gnu_expr)
tree gnu_expr;
addressable_p (tree gnu_expr)
{
switch (TREE_CODE (gnu_expr))
{
@ -4883,8 +4863,7 @@ addressable_p (gnu_expr)
make a GCC type for GNAT_ENTITY and set up the correspondance. */
void
process_type (gnat_entity)
Entity_Id gnat_entity;
process_type (Entity_Id gnat_entity)
{
tree gnu_old
= present_gnu_tree (gnat_entity) ? get_gnu_tree (gnat_entity) : 0;
@ -4979,9 +4958,7 @@ process_type (gnat_entity)
Return a CONSTRUCTOR to build the record. */
static tree
assoc_to_constructor (gnat_assoc, gnu_type)
Node_Id gnat_assoc;
tree gnu_type;
assoc_to_constructor (Node_Id gnat_assoc, tree gnu_type)
{
tree gnu_field, gnu_list, gnu_result;
@ -5030,10 +5007,9 @@ assoc_to_constructor (gnat_assoc, gnu_type)
of the array component. It is needed for range checking. */
static tree
pos_to_constructor (gnat_expr, gnu_array_type, gnat_component_type)
Node_Id gnat_expr;
tree gnu_array_type;
Entity_Id gnat_component_type;
pos_to_constructor (Node_Id gnat_expr,
tree gnu_array_type,
Entity_Id gnat_component_type)
{
tree gnu_expr;
tree gnu_expr_list = NULL_TREE;
@ -5074,9 +5050,7 @@ pos_to_constructor (gnat_expr, gnu_array_type, gnat_component_type)
record, make a recursive call to fill it in as well. */
static tree
extract_values (values, record_type)
tree values;
tree record_type;
extract_values (tree values, tree record_type)
{
tree result = NULL_TREE;
tree field, tem;
@ -5123,8 +5097,7 @@ extract_values (values, record_type)
an access object and perform the required dereferences. */
static tree
maybe_implicit_deref (exp)
tree exp;
maybe_implicit_deref (tree exp)
{
/* If the type is a pointer, dereference it. */
@ -5142,8 +5115,7 @@ maybe_implicit_deref (exp)
/* Protect EXP from multiple evaluation. This may make a SAVE_EXPR. */
tree
protect_multiple_eval (exp)
tree exp;
protect_multiple_eval (tree exp)
{
tree type = TREE_TYPE (exp);
@ -5182,9 +5154,7 @@ protect_multiple_eval (exp)
whether to force evaluation of everything. */
tree
gnat_stabilize_reference (ref, force)
tree ref;
int force;
gnat_stabilize_reference (tree ref, int force)
{
register tree type = TREE_TYPE (ref);
register enum tree_code code = TREE_CODE (ref);
@ -5280,9 +5250,7 @@ gnat_stabilize_reference (ref, force)
arg to force a SAVE_EXPR for everything. */
static tree
gnat_stabilize_reference_1 (e, force)
tree e;
int force;
gnat_stabilize_reference_1 (tree e, int force)
{
register enum tree_code code = TREE_CODE (e);
register tree type = TREE_TYPE (e);
@ -5345,10 +5313,7 @@ gnat_stabilize_reference_1 (e, force)
Return 1 if we didn't need an elaboration function, zero otherwise. */
static int
build_unit_elab (gnat_unit, body_p, gnu_elab_list)
Entity_Id gnat_unit;
int body_p;
tree gnu_elab_list;
build_unit_elab (Entity_Id gnat_unit, int body_p, tree gnu_elab_list)
{
tree gnu_decl;
rtx insn;
@ -5429,16 +5394,14 @@ build_unit_elab (gnat_unit, body_p, gnu_elab_list)
return result;
}
extern char *__gnat_to_canonical_file_spec PARAMS ((char *));
extern char *__gnat_to_canonical_file_spec (char *);
/* Determine the input_filename and the input_line from the source location
(Sloc) of GNAT_NODE node. Set the global variable input_filename and
input_line. If WRITE_NOTE_P is true, emit a line number note. */
void
set_lineno (gnat_node, write_note_p)
Node_Id gnat_node;
int write_note_p;
set_lineno (Node_Id gnat_node, int write_note_p)
{
Source_Ptr source_location = Sloc (gnat_node);
@ -5448,9 +5411,7 @@ set_lineno (gnat_node, write_note_p)
/* Likewise, but passed a Sloc. */
void
set_lineno_from_sloc (source_location, write_note_p)
Source_Ptr source_location;
int write_note_p;
set_lineno_from_sloc (Source_Ptr source_location, int write_note_p)
{
/* If node not from source code, ignore. */
if (source_location < 0)
@ -5486,9 +5447,7 @@ set_lineno_from_sloc (source_location, write_note_p)
"&" substitution. */
void
post_error (msg, node)
const char *msg;
Node_Id node;
post_error (const char *msg, Node_Id node)
{
String_Template temp;
Fat_Pointer fp;
@ -5503,10 +5462,7 @@ post_error (msg, node)
is the node to use for the "&" substitution. */
void
post_error_ne (msg, node, ent)
const char *msg;
Node_Id node;
Entity_Id ent;
post_error_ne (const char *msg, Node_Id node, Entity_Id ent)
{
String_Template temp;
Fat_Pointer fp;
@ -5521,11 +5477,7 @@ post_error_ne (msg, node, ent)
to use for the "&" substitution, and N is the number to use for the ^. */
void
post_error_ne_num (msg, node, ent, n)
const char *msg;
Node_Id node;
Entity_Id ent;
int n;
post_error_ne_num (const char *msg, Node_Id node, Entity_Id ent, int n)
{
String_Template temp;
Fat_Pointer fp;
@ -5545,11 +5497,7 @@ post_error_ne_num (msg, node, ent, n)
and the text inside square brackets will be output instead. */
void
post_error_ne_tree (msg, node, ent, t)
const char *msg;
Node_Id node;
Entity_Id ent;
tree t;
post_error_ne_tree (const char *msg, Node_Id node, Entity_Id ent, tree t)
{
char *newmsg = alloca (strlen (msg) + 1);
String_Template temp = {1, 0};
@ -5597,12 +5545,11 @@ post_error_ne_tree (msg, node, ent, t)
integer to write in the message. */
void
post_error_ne_tree_2 (msg, node, ent, t, num)
const char *msg;
Node_Id node;
Entity_Id ent;
tree t;
int num;
post_error_ne_tree_2 (const char *msg,
Node_Id node,
Entity_Id ent,
tree t,
int num)
{
Error_Msg_Uint_2 = UI_From_Int (num);
post_error_ne_tree (msg, node, ent, t);
@ -5611,8 +5558,7 @@ post_error_ne_tree_2 (msg, node, ent, t, num)
/* Set the node for a second '&' in the error message. */
void
set_second_error_entity (e)
Entity_Id e;
set_second_error_entity (Entity_Id e)
{
Error_Msg_Node_2 = e;
}
@ -5621,8 +5567,7 @@ set_second_error_entity (e)
as the relevant node that provides the location info for the error */
void
gigi_abort (code)
int code;
gigi_abort (int code)
{
String_Template temp = {1, 10};
Fat_Pointer fp;
@ -5637,7 +5582,7 @@ gigi_abort (code)
binary and unary operations. */
void
init_code_table ()
init_code_table (void)
{
gnu_codes[N_And_Then] = TRUTH_ANDIF_EXPR;
gnu_codes[N_Or_Else] = TRUTH_ORIF_EXPR;

304
gcc/ada/utils.c
View File

@ -144,22 +144,21 @@ struct language_function GTY(())
int unused;
};
static tree merge_sizes PARAMS ((tree, tree, tree, int, int));
static tree compute_related_constant PARAMS ((tree, tree));
static tree split_plus PARAMS ((tree, tree *));
static int value_zerop PARAMS ((tree));
static tree float_type_for_size PARAMS ((int, enum machine_mode));
static tree convert_to_fat_pointer PARAMS ((tree, tree));
static tree convert_to_thin_pointer PARAMS ((tree, tree));
static tree make_descriptor_field PARAMS ((const char *,tree, tree,
tree));
static int value_factor_p PARAMS ((tree, int));
static int potential_alignment_gap PARAMS ((tree, tree, tree));
static tree merge_sizes (tree, tree, tree, int, int);
static tree compute_related_constant (tree, tree);
static tree split_plus (tree, tree *);
static int value_zerop (tree);
static tree float_type_for_size (int, enum machine_mode);
static tree convert_to_fat_pointer (tree, tree);
static tree convert_to_thin_pointer (tree, tree);
static tree make_descriptor_field (const char *,tree, tree, tree);
static int value_factor_p (tree, int);
static int potential_alignment_gap (tree, tree, tree);
/* Initialize the association of GNAT nodes to GCC trees. */
void
init_gnat_to_gnu ()
init_gnat_to_gnu (void)
{
associate_gnat_to_gnu
= (tree *) ggc_alloc_cleared (max_gnat_nodes * sizeof (tree));
@ -174,10 +173,7 @@ init_gnat_to_gnu ()
If GNU_DECL is zero, a previous association is to be reset. */
void
save_gnu_tree (gnat_entity, gnu_decl, no_check)
Entity_Id gnat_entity;
tree gnu_decl;
int no_check;
save_gnu_tree (Entity_Id gnat_entity, tree gnu_decl, int no_check)
{
/* Check that GNAT_ENTITY is not already defined and that it is being set
to something which is a decl. Raise gigi 401 if not. Usually, this
@ -199,8 +195,7 @@ save_gnu_tree (gnat_entity, gnu_decl, no_check)
be elaborated only once, GNAT_ENTITY is really not an entity. */
tree
get_gnu_tree (gnat_entity)
Entity_Id gnat_entity;
get_gnu_tree (Entity_Id gnat_entity)
{
if (! associate_gnat_to_gnu[gnat_entity - First_Node_Id])
gigi_abort (402);
@ -211,8 +206,7 @@ get_gnu_tree (gnat_entity)
/* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
int
present_gnu_tree (gnat_entity)
Entity_Id gnat_entity;
present_gnu_tree (Entity_Id gnat_entity)
{
return (associate_gnat_to_gnu[gnat_entity - First_Node_Id] != NULL_TREE);
}
@ -221,7 +215,7 @@ present_gnu_tree (gnat_entity)
/* Return non-zero if we are currently in the global binding level. */
int
global_bindings_p ()
global_bindings_p (void)
{
return (force_global != 0 || current_binding_level == global_binding_level
? -1 : 0);
@ -231,7 +225,7 @@ global_bindings_p ()
is in reverse order (it has to be so for back-end compatibility). */
tree
getdecls ()
getdecls (void)
{
return current_binding_level->names;
}
@ -239,7 +233,7 @@ getdecls ()
/* Nonzero if the current level needs to have a BLOCK made. */
int
kept_level_p ()
kept_level_p (void)
{
return (current_binding_level->names != 0);
}
@ -248,8 +242,7 @@ kept_level_p ()
specified for back-end compatibility. */
void
pushlevel (ignore)
int ignore ATTRIBUTE_UNUSED;
pushlevel (int ignore ATTRIBUTE_UNUSED)
{
struct binding_level *newlevel = NULL;
@ -287,10 +280,7 @@ pushlevel (ignore)
them into the BLOCK. */
tree
poplevel (keep, reverse, functionbody)
int keep;
int reverse;
int functionbody;
poplevel (int keep, int reverse, int functionbody)
{
/* Points to a GCC BLOCK tree node. This is the BLOCK node construted for the
binding level that we are about to exit and which is returned by this
@ -396,8 +386,7 @@ poplevel (keep, reverse, functionbody)
to handle the BLOCK node inside the BIND_EXPR. */
void
insert_block (block)
tree block;
insert_block (tree block)
{
TREE_USED (block) = 1;
current_binding_level->blocks
@ -408,8 +397,7 @@ insert_block (block)
(the one we are currently in). */
void
set_block (block)
tree block;
set_block (tree block)
{
current_binding_level->this_block = block;
current_binding_level->names = chainon (current_binding_level->names,
@ -422,8 +410,7 @@ set_block (block)
Returns the ..._DECL node. */
tree
pushdecl (decl)
tree decl;
pushdecl (tree decl)
{
struct binding_level *b;
@ -478,7 +465,7 @@ pushdecl (decl)
front end has been run. */
void
gnat_init_decl_processing ()
gnat_init_decl_processing (void)
{
input_line = 0;
@ -516,8 +503,7 @@ gnat_init_decl_processing ()
in the gcc back-end and initialize the global binding level. */
void
init_gigi_decls (long_long_float_type, exception_type)
tree long_long_float_type, exception_type;
init_gigi_decls (tree long_long_float_type, tree exception_type)
{
tree endlink, decl;
unsigned int i;
@ -708,11 +694,10 @@ init_gigi_decls (long_long_float_type, exception_type)
on this type; it will be done later. */
void
finish_record_type (record_type, fieldlist, has_rep, defer_debug)
tree record_type;
tree fieldlist;
int has_rep;
int defer_debug;
finish_record_type (tree record_type,
tree fieldlist,
int has_rep,
int defer_debug)
{
enum tree_code code = TREE_CODE (record_type);
tree ada_size = bitsize_zero_node;
@ -1030,11 +1015,11 @@ finish_record_type (record_type, fieldlist, has_rep, defer_debug)
We return an expression for the size. */
static tree
merge_sizes (last_size, first_bit, size, special, has_rep)
tree last_size;
tree first_bit, size;
int special;
int has_rep;
merge_sizes (tree last_size,
tree first_bit,
tree size,
int special,
int has_rep)
{
tree type = TREE_TYPE (last_size);
tree new;
@ -1070,8 +1055,7 @@ merge_sizes (last_size, first_bit, size, special, has_rep)
related by the addition of a constant. Return that constant if so. */
static tree
compute_related_constant (op0, op1)
tree op0, op1;
compute_related_constant (tree op0, tree op1)
{
tree op0_var, op1_var;
tree op0_con = split_plus (op0, &op0_var);
@ -1092,9 +1076,7 @@ compute_related_constant (op0, op1)
bitsizetype. */
static tree
split_plus (in, pvar)
tree in;
tree *pvar;
split_plus (tree in, tree *pvar)
{
/* Strip NOPS in order to ease the tree traversal and maximize the
potential for constant or plus/minus discovery. We need to be careful
@ -1137,12 +1119,12 @@ split_plus (in, pvar)
depressed stack pointer. */
tree
create_subprog_type (return_type, param_decl_list, cico_list,
returns_unconstrained, returns_by_ref, returns_with_dsp)
tree return_type;
tree param_decl_list;
tree cico_list;
int returns_unconstrained, returns_by_ref, returns_with_dsp;
create_subprog_type (tree return_type,
tree param_decl_list,
tree cico_list,
int returns_unconstrained,
int returns_by_ref,
int returns_with_dsp)
{
/* A chain of TREE_LIST nodes whose TREE_VALUEs are the data type nodes of
the subprogram formal parameters. This list is generated by traversing the
@ -1186,8 +1168,7 @@ create_subprog_type (return_type, param_decl_list, cico_list,
/* Return a copy of TYPE but safe to modify in any way. */
tree
copy_type (type)
tree type;
copy_type (tree type)
{
tree new = copy_node (type);
@ -1207,9 +1188,7 @@ copy_type (type)
TYPE_INDEX_TYPE is INDEX. */
tree
create_index_type (min, max, index)
tree min, max;
tree index;
create_index_type (tree min, tree max, tree index)
{
/* First build a type for the desired range. */
tree type = build_index_2_type (min, max);
@ -1235,12 +1214,11 @@ create_index_type (min, max, index)
information about this type. */
tree
create_type_decl (type_name, type, attr_list, artificial_p, debug_info_p)
tree type_name;
tree type;
struct attrib *attr_list;
int artificial_p;
int debug_info_p;
create_type_decl (tree type_name,
tree type,
struct attrib *attr_list,
int artificial_p,
int debug_info_p)
{
tree type_decl = build_decl (TYPE_DECL, type_name, type);
enum tree_code code = TREE_CODE (type);
@ -1282,17 +1260,15 @@ create_type_decl (type_name, type, attr_list, artificial_p, debug_info_p)
it indicates whether to always allocate storage to the variable. */
tree
create_var_decl (var_name, asm_name, type, var_init, const_flag, public_flag,
extern_flag, static_flag, attr_list)
tree var_name;
tree asm_name;
tree type;
tree var_init;
int const_flag;
int public_flag;
int extern_flag;
int static_flag;
struct attrib *attr_list;
create_var_decl (tree var_name,
tree asm_name,
tree type,
tree var_init,
int const_flag,
int public_flag,
int extern_flag,
int static_flag,
struct attrib *attr_list)
{
int init_const
= (var_init == 0
@ -1397,14 +1373,13 @@ create_var_decl (var_name, asm_name, type, var_init, const_flag, public_flag,
the address of this field for aliasing purposes. */
tree
create_field_decl (field_name, field_type, record_type, packed, size, pos,
addressable)
tree field_name;
tree field_type;
tree record_type;
int packed;
tree size, pos;
int addressable;
create_field_decl (tree field_name,
tree field_type,
tree record_type,
int packed,
tree size,
tree pos,
int addressable)
{
tree field_decl = build_decl (FIELD_DECL, field_name, field_type);
@ -1515,8 +1490,7 @@ create_field_decl (field_name, field_type, record_type, packed, size, pos,
effects, has the value of zero. */
static int
value_zerop (exp)
tree exp;
value_zerop (tree exp)
{
if (TREE_CODE (exp) == COMPOUND_EXPR)
return value_zerop (TREE_OPERAND (exp, 1));
@ -1530,10 +1504,7 @@ value_zerop (exp)
parameter). */
tree
create_param_decl (param_name, param_type, readonly)
tree param_name;
tree param_type;
int readonly;
create_param_decl (tree param_name, tree param_type, int readonly)
{
tree param_decl = build_decl (PARM_DECL, param_name, param_type);
@ -1570,9 +1541,7 @@ create_param_decl (param_name, param_type, readonly)
/* Given a DECL and ATTR_LIST, process the listed attributes. */
void
process_attributes (decl, attr_list)
tree decl;
struct attrib *attr_list;
process_attributes (tree decl, struct attrib *attr_list)
{
for (; attr_list; attr_list = attr_list->next)
switch (attr_list->type)
@ -1613,9 +1582,7 @@ process_attributes (decl, attr_list)
/* Add some pending elaborations on the list. */
void
add_pending_elaborations (var_decl, var_init)
tree var_decl;
tree var_init;
add_pending_elaborations (tree var_decl, tree var_init)
{
if (var_init != 0)
Check_Elaboration_Code_Allowed (error_gnat_node);
@ -1627,7 +1594,7 @@ add_pending_elaborations (var_decl, var_init)
/* Obtain any pending elaborations and clear the old list. */
tree
get_pending_elaborations ()
get_pending_elaborations (void)
{
/* Each thing added to the list went on the end; we want it on the
beginning. */
@ -1641,9 +1608,7 @@ get_pending_elaborations ()
of 2. */
static int
value_factor_p (value, factor)
tree value;
int factor;
value_factor_p (tree value, int factor)
{
if (host_integerp (value, 1))
return tree_low_cst (value, 1) % factor == 0;
@ -1662,10 +1627,7 @@ value_factor_p (value, factor)
position of CURR_FIELD. It is ignored if null. */
static int
potential_alignment_gap (prev_field, curr_field, offset)
tree prev_field;
tree curr_field;
tree offset;
potential_alignment_gap (tree prev_field, tree curr_field, tree offset)
{
/* If this is the first field of the record, there cannot be any gap */
if (!prev_field)
@ -1707,7 +1669,7 @@ potential_alignment_gap (prev_field, curr_field, offset)
/* Return nonzero if there are pending elaborations. */
int
pending_elaborations_p ()
pending_elaborations_p (void)
{
return TREE_CHAIN (pending_elaborations) != 0;
}
@ -1716,7 +1678,7 @@ pending_elaborations_p ()
one. */
void
push_pending_elaborations ()
push_pending_elaborations (void)
{
struct e_stack *p = (struct e_stack *) ggc_alloc (sizeof (struct e_stack));
@ -1729,7 +1691,7 @@ push_pending_elaborations ()
/* Pop the stack of pending elaborations. */
void
pop_pending_elaborations ()
pop_pending_elaborations (void)
{
struct e_stack *p = elist_stack;
@ -1741,7 +1703,7 @@ pop_pending_elaborations ()
elaborations after that point. */
tree
get_elaboration_location ()
get_elaboration_location (void)
{
return tree_last (pending_elaborations);
}
@ -1750,8 +1712,7 @@ get_elaboration_location ()
list. */
void
insert_elaboration_list (elab)
tree elab;
insert_elaboration_list (tree elab)
{
tree next = TREE_CHAIN (elab);
@ -1766,8 +1727,7 @@ insert_elaboration_list (elab)
/* Returns a LABEL_DECL node for LABEL_NAME. */
tree
create_label_decl (label_name)
tree label_name;
create_label_decl (tree label_name)
{
tree label_decl = build_decl (LABEL_DECL, label_name, void_type_node);
@ -1787,16 +1747,14 @@ create_label_decl (label_name)
appropriate fields in the FUNCTION_DECL. */
tree
create_subprog_decl (subprog_name, asm_name, subprog_type, param_decl_list,
inline_flag, public_flag, extern_flag, attr_list)
tree subprog_name;
tree asm_name;
tree subprog_type;
tree param_decl_list;
int inline_flag;
int public_flag;
int extern_flag;
struct attrib *attr_list;
create_subprog_decl (tree subprog_name,
tree asm_name,
tree subprog_type,
tree param_decl_list,
int inline_flag,
int public_flag,
int extern_flag,
struct attrib *attr_list)
{
tree return_type = TREE_TYPE (subprog_type);
tree subprog_decl = build_decl (FUNCTION_DECL, subprog_name, subprog_type);
@ -1842,8 +1800,7 @@ static int function_nesting_depth;
appearing in the subprogram. */
void
begin_subprog_body (subprog_decl)
tree subprog_decl;
begin_subprog_body (tree subprog_decl)
{
tree param_decl_list;
tree param_decl;
@ -1905,7 +1862,7 @@ begin_subprog_body (subprog_decl)
to assembler language output. */
void
end_subprog_body ()
end_subprog_body (void)
{
tree decl;
tree cico_list;
@ -1979,13 +1936,12 @@ end_subprog_body ()
ATTRS is nonzero, use that for the function attribute list. */
tree
builtin_function (name, type, function_code, class, library_name, attrs)
const char *name;
tree type;
int function_code;
enum built_in_class class;
const char *library_name;
tree attrs;
builtin_function (const char *name,
tree type,
int function_code,
enum built_in_class class,
const char *library_name,
tree attrs)
{
tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
@ -2007,9 +1963,7 @@ builtin_function (name, type, function_code, class, library_name, attrs)
it is a signed type. */
tree
gnat_type_for_size (precision, unsignedp)
unsigned precision;
int unsignedp;
gnat_type_for_size (unsigned precision, int unsignedp)
{
tree t;
char type_name[20];
@ -2038,9 +1992,7 @@ gnat_type_for_size (precision, unsignedp)
/* Likewise for floating-point types. */
static tree
float_type_for_size (precision, mode)
int precision;
enum machine_mode mode;
float_type_for_size (int precision, enum machine_mode mode)
{
tree t;
char type_name[20];
@ -2068,9 +2020,7 @@ float_type_for_size (precision, mode)
an unsigned type; otherwise a signed type is returned. */
tree
gnat_type_for_mode (mode, unsignedp)
enum machine_mode mode;
int unsignedp;
gnat_type_for_mode (enum machine_mode mode, int unsignedp)
{
if (GET_MODE_CLASS (mode) == MODE_FLOAT)
return float_type_for_size (GET_MODE_BITSIZE (mode), mode);
@ -2081,8 +2031,7 @@ gnat_type_for_mode (mode, unsignedp)
/* Return the unsigned version of a TYPE_NODE, a scalar type. */
tree
gnat_unsigned_type (type_node)
tree type_node;
gnat_unsigned_type (tree type_node)
{
tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 1);
@ -2105,8 +2054,7 @@ gnat_unsigned_type (type_node)
/* Return the signed version of a TYPE_NODE, a scalar type. */
tree
gnat_signed_type (type_node)
tree type_node;
gnat_signed_type (tree type_node)
{
tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 0);
@ -2130,9 +2078,7 @@ gnat_signed_type (type_node)
UNSIGNEDP. */
tree
gnat_signed_or_unsigned_type (unsignedp, type)
int unsignedp;
tree type;
gnat_signed_or_unsigned_type (int unsignedp, tree type)
{
if (! INTEGRAL_TYPE_P (type) || TREE_UNSIGNED (type) == unsignedp)
return type;
@ -2145,9 +2091,7 @@ gnat_signed_or_unsigned_type (unsignedp, type)
minimum (if ! MAX_P) possible value of the discriminant. */
tree
max_size (exp, max_p)
tree exp;
int max_p;
max_size (tree exp, int max_p)
{
enum tree_code code = TREE_CODE (exp);
tree type = TREE_TYPE (exp);
@ -2246,10 +2190,7 @@ max_size (exp, max_p)
Return a constructor for the template. */
tree
build_template (template_type, array_type, expr)
tree template_type;
tree array_type;
tree expr;
build_template (tree template_type, tree array_type, tree expr)
{
tree template_elts = NULL_TREE;
tree bound_list = NULL_TREE;
@ -2318,10 +2259,7 @@ build_template (template_type, array_type, expr)
an object of that type and also for the name. */
tree
build_vms_descriptor (type, mech, gnat_entity)
tree type;
Mechanism_Type mech;
Entity_Id gnat_entity;
build_vms_descriptor (tree type, Mechanism_Type mech, Entity_Id gnat_entity)
{
tree record_type = make_node (RECORD_TYPE);
tree field_list = 0;
@ -2606,11 +2544,7 @@ build_vms_descriptor (type, mech, gnat_entity)
/* Utility routine for above code to make a field. */
static tree
make_descriptor_field (name, type, rec_type, initial)
const char *name;
tree type;
tree rec_type;
tree initial;
make_descriptor_field (const char *name, tree type, tree rec_type, tree initial)
{
tree field
= create_field_decl (get_identifier (name), type, rec_type, 0, 0, 0, 0);
@ -2627,10 +2561,7 @@ make_descriptor_field (name, type, rec_type, initial)
as the name of the record. */
tree
build_unc_object_type (template_type, object_type, name)
tree template_type;
tree object_type;
tree name;
build_unc_object_type (tree template_type, tree object_type, tree name)
{
tree type = make_node (RECORD_TYPE);
tree template_field = create_field_decl (get_identifier ("BOUNDS"),
@ -2653,9 +2584,7 @@ build_unc_object_type (template_type, object_type, name)
if NEW is an UNCONSTRAINED_ARRAY_TYPE. */
void
update_pointer_to (old_type, new_type)
tree old_type;
tree new_type;
update_pointer_to (tree old_type, tree new_type)
{
tree ptr = TYPE_POINTER_TO (old_type);
tree ref = TYPE_REFERENCE_TO (old_type);
@ -2792,9 +2721,7 @@ update_pointer_to (old_type, new_type)
pointer. This involves making or finding a template. */
static tree
convert_to_fat_pointer (type, expr)
tree type;
tree expr;
convert_to_fat_pointer (tree type, tree expr)
{
tree template_type = TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (type))));
tree template, template_addr;
@ -2861,9 +2788,7 @@ convert_to_fat_pointer (type, expr)
is not already a fat pointer. */
static tree
convert_to_thin_pointer (type, expr)
tree type;
tree expr;
convert_to_thin_pointer (tree type, tree expr)
{
if (! TYPE_FAT_POINTER_P (TREE_TYPE (expr)))
expr
@ -2886,8 +2811,7 @@ convert_to_thin_pointer (type, expr)
not permitted by the language being compiled. */
tree
convert (type, expr)
tree type, expr;
convert (tree type, tree expr)
{
enum tree_code code = TREE_CODE (type);
tree etype = TREE_TYPE (expr);
@ -3229,9 +3153,7 @@ convert (type, expr)
the address is not bit-aligned. */
tree
remove_conversions (exp, true_address)
tree exp;
int true_address;
remove_conversions (tree exp, int true_address)
{
switch (TREE_CODE (exp))
{
@ -3264,8 +3186,7 @@ remove_conversions (exp, true_address)
likewise return an expression pointing to the underlying array. */
tree
maybe_unconstrained_array (exp)
tree exp;
maybe_unconstrained_array (tree exp)
{
enum tree_code code = TREE_CODE (exp);
tree new;
@ -3327,10 +3248,7 @@ maybe_unconstrained_array (exp)
If NOTRUNC_P is set, truncation operations should be suppressed. */
tree
unchecked_convert (type, expr, notrunc_p)
tree type;
tree expr;
int notrunc_p;
unchecked_convert (tree type, tree expr, int notrunc_p)
{
tree etype = TREE_TYPE (expr);

139
gcc/ada/utils2.c
View File

@ -44,13 +44,12 @@
#include "ada-tree.h"
#include "gigi.h"
static tree find_common_type PARAMS ((tree, tree));
static int contains_save_expr_p PARAMS ((tree));
static tree contains_null_expr PARAMS ((tree));
static tree compare_arrays PARAMS ((tree, tree, tree));
static tree nonbinary_modular_operation PARAMS ((enum tree_code, tree,
tree, tree));
static tree build_simple_component_ref PARAMS ((tree, tree, tree, int));
static tree find_common_type (tree, tree);
static int contains_save_expr_p (tree);
static tree contains_null_expr (tree);
static tree compare_arrays (tree, tree, tree);
static tree nonbinary_modular_operation (enum tree_code, tree, tree, tree);
static tree build_simple_component_ref (tree, tree, tree, int);
/* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical
operation.
@ -68,8 +67,7 @@ static tree build_simple_component_ref PARAMS ((tree, tree, tree, int));
the only possible operands will be things of Boolean type. */
tree
gnat_truthvalue_conversion (expr)
tree expr;
gnat_truthvalue_conversion (tree expr)
{
tree type = TREE_TYPE (expr);
@ -106,8 +104,7 @@ gnat_truthvalue_conversion (expr)
/* Return the base type of TYPE. */
tree
get_base_type (type)
tree type;
get_base_type (tree type)
{
if (TREE_CODE (type) == RECORD_TYPE
&& TYPE_LEFT_JUSTIFIED_MODULAR_P (type))
@ -123,8 +120,7 @@ get_base_type (type)
/* Likewise, but only return types known to the Ada source. */
tree
get_ada_base_type (type)
tree type;
get_ada_base_type (tree type)
{
while (TREE_TYPE (type) != 0
&& (TREE_CODE (type) == INTEGER_TYPE
@ -140,8 +136,7 @@ get_ada_base_type (type)
in bits. If we don't know anything about the alignment, return 0. */
unsigned int
known_alignment (exp)
tree exp;
known_alignment (tree exp)
{
unsigned int this_alignment;
unsigned int lhs, rhs;
@ -221,8 +216,7 @@ known_alignment (exp)
Otherwise return zero. */
static tree
find_common_type (t1, t2)
tree t1, t2;
find_common_type (tree t1, tree t2)
{
/* If either type is non-BLKmode, use it. Note that we know that we will
not have any alignment problems since if we did the non-BLKmode
@ -251,8 +245,7 @@ find_common_type (t1, t2)
of some very general solution. */
static int
contains_save_expr_p (exp)
tree exp;
contains_save_expr_p (tree exp)
{
switch (TREE_CODE (exp))
{
@ -283,8 +276,7 @@ contains_save_expr_p (exp)
that are known to raise Constraint_Error. */
static tree
contains_null_expr (exp)
tree exp;
contains_null_expr (tree exp)
{
tree tem;
@ -339,9 +331,7 @@ contains_null_expr (exp)
length tests in as efficient a manner as possible. */
static tree
compare_arrays (result_type, a1, a2)
tree a1, a2;
tree result_type;
compare_arrays (tree result_type, tree a1, tree a2)
{
tree t1 = TREE_TYPE (a1);
tree t2 = TREE_TYPE (a2);
@ -501,10 +491,10 @@ compare_arrays (result_type, a1, a2)
modulus. */
static tree
nonbinary_modular_operation (op_code, type, lhs, rhs)
enum tree_code op_code;
tree type;
tree lhs, rhs;
nonbinary_modular_operation (enum tree_code op_code,
tree type,
tree lhs,
tree rhs)
{
tree modulus = TYPE_MODULUS (type);
unsigned int needed_precision = tree_floor_log2 (modulus) + 1;
@ -601,11 +591,10 @@ nonbinary_modular_operation (op_code, type, lhs, rhs)
have to do here is validate the work done by SEM and handle subtypes. */
tree
build_binary_op (op_code, result_type, left_operand, right_operand)
enum tree_code op_code;
tree result_type;
tree left_operand;
tree right_operand;
build_binary_op (enum tree_code op_code,
tree result_type,
tree left_operand,
tree right_operand)
{
tree left_type = TREE_TYPE (left_operand);
tree right_type = TREE_TYPE (right_operand);
@ -1094,10 +1083,7 @@ build_binary_op (op_code, result_type, left_operand, right_operand)
/* Similar, but for unary operations. */
tree
build_unary_op (op_code, result_type, operand)
enum tree_code op_code;
tree result_type;
tree operand;
build_unary_op (enum tree_code op_code, tree result_type, tree operand)
{
tree type = TREE_TYPE (operand);
tree base_type = get_base_type (type);
@ -1415,11 +1401,10 @@ build_unary_op (op_code, result_type, operand)
/* Similar, but for COND_EXPR. */
tree
build_cond_expr (result_type, condition_operand, true_operand, false_operand)
tree result_type;
tree condition_operand;
tree true_operand;
tree false_operand;
build_cond_expr (tree result_type,
tree condition_operand,
tree true_operand,
tree false_operand)
{
tree result;
int addr_p = 0;
@ -1470,9 +1455,7 @@ build_cond_expr (result_type, condition_operand, true_operand, false_operand)
the CALL_EXPR. */
tree
build_call_1_expr (fundecl, arg)
tree fundecl;
tree arg;
build_call_1_expr (tree fundecl, tree arg)
{
tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
@ -1488,9 +1471,7 @@ build_call_1_expr (fundecl, arg)
the CALL_EXPR. */
tree
build_call_2_expr (fundecl, arg1, arg2)
tree fundecl;
tree arg1, arg2;
build_call_2_expr (tree fundecl, tree arg1, tree arg2)
{
tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
@ -1507,8 +1488,7 @@ build_call_2_expr (fundecl, arg1, arg2)
/* Likewise to call FUNDECL with no arguments. */
tree
build_call_0_expr (fundecl)
tree fundecl;
build_call_0_expr (tree fundecl)
{
tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
@ -1523,8 +1503,7 @@ build_call_0_expr (fundecl)
name, if requested. MSG says which exception function to call. */
tree
build_call_raise (msg)
int msg;
build_call_raise (int msg)
{
tree fndecl = gnat_raise_decls[msg];
const char *str = discard_file_names ? "" : ref_filename;
@ -1545,9 +1524,7 @@ build_call_raise (msg)
/* Return a CONSTRUCTOR of TYPE whose list is LIST. */
tree
gnat_build_constructor (type, list)
tree type;
tree list;
gnat_build_constructor (tree type, tree list)
{
tree elmt;
int allconstant = (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST);
@ -1616,11 +1593,10 @@ gnat_build_constructor (type, list)
actual record and know how to look for fields in variant parts. */
static tree
build_simple_component_ref (record_variable, component, field, no_fold_p)
tree record_variable;
tree component;
tree field;
int no_fold_p;
build_simple_component_ref (tree record_variable,
tree component,
tree field,
int no_fold_p)
{
tree record_type = TYPE_MAIN_VARIANT (TREE_TYPE (record_variable));
tree ref;
@ -1707,11 +1683,10 @@ build_simple_component_ref (record_variable, component, field, no_fold_p)
reference could not be found. */
tree
build_component_ref (record_variable, component, field, no_fold_p)
tree record_variable;
tree component;
tree field;
int no_fold_p;
build_component_ref (tree record_variable,
tree component,
tree field,
int no_fold_p)
{
tree ref = build_simple_component_ref (record_variable, component, field,
no_fold_p);
@ -1741,14 +1716,12 @@ build_component_ref (record_variable, component, field, no_fold_p)
object dynamically on the stack frame. */
tree
build_call_alloc_dealloc
(gnu_obj, gnu_size, align, gnat_proc, gnat_pool, gnat_node)
tree gnu_obj;
tree gnu_size;
int align;
Entity_Id gnat_proc;
Entity_Id gnat_pool;
Node_Id gnat_node;
build_call_alloc_dealloc (tree gnu_obj,
tree gnu_size,
int align,
Entity_Id gnat_proc,
Entity_Id gnat_pool,
Node_Id gnat_node)
{
tree gnu_align = size_int (align / BITS_PER_UNIT);
@ -1865,13 +1838,12 @@ build_call_alloc_dealloc
the storage pool to use. */
tree
build_allocator (type, init, result_type, gnat_proc, gnat_pool, gnat_node)
tree type;
tree init;
tree result_type;
Entity_Id gnat_proc;
Entity_Id gnat_pool;
Node_Id gnat_node;
build_allocator (tree type,
tree init,
tree result_type,
Entity_Id gnat_proc,
Entity_Id gnat_pool,
Node_Id gnat_node)
{
tree size = TYPE_SIZE_UNIT (type);
tree result;
@ -2030,9 +2002,7 @@ build_allocator (type, init, result_type, gnat_proc, gnat_pool, gnat_node)
GNAT_FORMAL is how we find the descriptor record. */
tree
fill_vms_descriptor (expr, gnat_formal)
tree expr;
Entity_Id gnat_formal;
fill_vms_descriptor (tree expr, Entity_Id gnat_formal)
{
tree record_type = TREE_TYPE (TREE_TYPE (get_gnu_tree (gnat_formal)));
tree field;
@ -2059,8 +2029,7 @@ fill_vms_descriptor (expr, gnat_formal)
should not be allocated in a register. Returns true if successful. */
bool
gnat_mark_addressable (expr_node)
tree expr_node;
gnat_mark_addressable (tree expr_node)
{
while (1)
switch (TREE_CODE (expr_node))

2
gcc/value-prof.c
View File

@ -314,7 +314,7 @@ find_values_to_profile (unsigned *n_values, struct histogram_value **values)
we would have to be very careful here. */
bool
value_profile_transformations ()
value_profile_transformations (void)
{
rtx insn, next;
int changed = false;

47
gcc/web.c
View File

@ -66,22 +66,18 @@ struct web_entry
rtx reg;
};
static struct web_entry *unionfind_root PARAMS ((struct web_entry *));
static void unionfind_union PARAMS ((struct web_entry *,
struct web_entry *));
static void union_defs PARAMS ((struct df *, struct ref *,
struct web_entry *,
struct web_entry *));
static rtx entry_register PARAMS ((struct web_entry *,
struct ref *, char *, char *));
static void replace_ref PARAMS ((struct ref *, rtx));
static int mark_addressof PARAMS ((rtx *, void *));
static struct web_entry *unionfind_root (struct web_entry *);
static void unionfind_union (struct web_entry *, struct web_entry *);
static void union_defs (struct df *, struct ref *, struct web_entry *,
struct web_entry *);
static rtx entry_register (struct web_entry *, struct ref *, char *, char *);
static void replace_ref (struct ref *, rtx);
static int mark_addressof (rtx *, void *);
/* Find the root of unionfind tree (the representative of set). */
static struct web_entry *
unionfind_root (element)
struct web_entry *element;
unionfind_root (struct web_entry *element)
{
struct web_entry *element1 = element, *element2;
@ -99,8 +95,7 @@ unionfind_root (element)
/* Union sets. */
static void
unionfind_union (first, second)
struct web_entry *first, *second;
unionfind_union (struct web_entry *first, struct web_entry *second)
{
first = unionfind_root (first);
second = unionfind_root (second);
@ -113,11 +108,8 @@ unionfind_union (first, second)
register, union them. */
static void
union_defs (df, use, def_entry, use_entry)
struct df *df;
struct ref *use;
struct web_entry *def_entry;
struct web_entry *use_entry;
union_defs (struct df *df, struct ref *use, struct web_entry *def_entry,
struct web_entry *use_entry)
{
rtx insn = DF_REF_INSN (use);
struct df_link *link = DF_REF_CHAIN (use);
@ -179,11 +171,8 @@ union_defs (df, use, def_entry, use_entry)
/* Find the corresponding register for the given entry. */
static rtx
entry_register (entry, ref, used, use_addressof)
struct web_entry *entry;
struct ref *ref;
char *used;
char *use_addressof;
entry_register (struct web_entry *entry, struct ref *ref, char *used,
char *use_addressof)
{
struct web_entry *root;
rtx reg, newreg;
@ -235,9 +224,7 @@ entry_register (entry, ref, used, use_addressof)
/* Replace the reference by REG. */
static void
replace_ref (ref, reg)
struct ref *ref;
rtx reg;
replace_ref (struct ref *ref, rtx reg)
{
rtx oldreg = DF_REF_REAL_REG (ref);
rtx *loc = DF_REF_REAL_LOC (ref);
@ -253,9 +240,7 @@ replace_ref (ref, reg)
/* Mark each pseudo whose address is taken. */
static int
mark_addressof (rtl, data)
rtx *rtl;
void *data;
mark_addressof (rtx *rtl, void *data)
{
if (!*rtl)
return 0;
@ -268,7 +253,7 @@ mark_addressof (rtl, data)
/* Main entry point. */
void
web_main ()
web_main (void)
{
struct df *df;
struct web_entry *def_entry;