* gengtype.c (create_option): New function.
* gengtype.h: Prototype it.
* gengtype-yacc.y (stringseq): New rule.
(option): Use create_option. Add new bare ID production. Use
stringseq, not STRING directly.
* alias.c, bitmap.c, c-decl.c, cgraph.h, cpplib.h, cselib.h
* dwarf2out.c, emit-rtl.c, function.h, lists.c, tree.h
* varray.h, config/alpha/alpha.c, cp/name-lookup.c, cp/parser.c
* f/com.c, java/builtins.c, java/expr.c, java/jcf.h, java/parse.h:
Use new shorter form of GTY markers.
* doc/gty.texi: Rewrite.
From-SVN: r80091
+2004-03-30 Zack Weinberg <zack@codesourcery.com>
+
+ * gengtype.c (create_option): New function.
+ * gengtype.h: Prototype it.
+ * gengtype-yacc.y (stringseq): New rule.
+ (option): Use create_option. Add new bare ID production. Use
+ stringseq, not STRING directly.
+
+ * alias.c, bitmap.c, c-decl.c, cgraph.h, cpplib.h, cselib.h
+ * dwarf2out.c, emit-rtl.c, function.h, lists.c, tree.h
+ * varray.h, config/alpha/alpha.c:
+ Use new shorter form of GTY markers.
+
+ * doc/gty.texi: Rewrite.
+
2004-03-30 Andrew Pinski <pinskia@physics.uc.edu>
* config/darwin.c (machopic_function_base_name):
2004-03-30 Hartmut Penner <hpenner@de.ibm.com>
- * config/rs6000/rs6000.c (output_vec_const_move):
- Find all cases of EASY_VECTOR_15_ADD_SELF.
- (easy_vector_constant_add_self): Accept
- all vector constant loadable by vsplt* and vadd*.
+ * config/rs6000/rs6000.c (output_vec_const_move):
+ Find all cases of EASY_VECTOR_15_ADD_SELF.
+ (easy_vector_constant_add_self): Accept
+ all vector constant loadable by vsplt* and vadd*.
(easy_vector_same): Use easy_vector_splat_const.
(easy_vector_const): Use easy_vector_splat_const.
- (easy_vector_splat_const): New function.
+ (easy_vector_splat_const): New function.
(gen_easy_vector_constant_add_self): New function.
-
+
* config/rs6000/rs6000-protos.c (gen_easy_vector_constant_add_self):
New prototype.
- * config/rs6000/altivec.md (movv4si splitter): Change to
+ * config/rs6000/altivec.md (movv4si splitter): Change to
emit move insn with halfed vector constant.
(*movv8hi splitter): Likewise.
(*movv16qi splitter): Likewise.
-
+
2004-03-30 Hartmut Penner <hpenner@de.ibm.com>
- PR 11591
- * config/rs6000/rs6000.c (rs6000_legitimate_address):
+ PR 11591
+ * config/rs6000/rs6000.c (rs6000_legitimate_address):
Allow any offset to argument pointer in no-strict case.
2004-03-30 Jan Hubicka <jh@suse.cz>
/* We preserve the copy of old array around to avoid amount of garbage
produced. About 8% of garbage produced were attributed to this
array. */
-static GTY((deletable (""))) varray_type old_reg_base_value;
+static GTY((deletable)) varray_type old_reg_base_value;
/* Static hunks of RTL used by the aliasing code; these are initialized
once per function to avoid unnecessary RTL allocations. */
/* Global data */
bitmap_element bitmap_zero_bits; /* An element of all zero bits. */
static bitmap_element *bitmap_free; /* Freelist of bitmap elements. */
-static GTY((deletable (""))) bitmap_element *bitmap_ggc_free;
+static GTY((deletable)) bitmap_element *bitmap_ggc_free;
static void bitmap_elem_to_freelist (bitmap, bitmap_element *);
static void bitmap_element_free (bitmap, bitmap_element *);
/* A chain of c_scope structures awaiting reuse. */
-static GTY((deletable (""))) struct c_scope *scope_freelist;
+static GTY((deletable)) struct c_scope *scope_freelist;
/* A chain of c_binding structures awaiting reuse. */
-static GTY((deletable (""))) struct c_binding *binding_freelist;
+static GTY((deletable)) struct c_binding *binding_freelist;
/* Append VAR to LIST in scope SCOPE. */
#define SCOPE_LIST_APPEND(scope, list, decl) do { \
struct cgraph_node *next_nested;
/* Pointer to the next function in cgraph_nodes_queue. */
struct cgraph_node *next_needed;
- PTR GTY ((skip (""))) aux;
+ PTR GTY ((skip)) aux;
struct cgraph_local_info local;
struct cgraph_global_info global;
struct xfloating_op GTY(())
{
const enum rtx_code code;
- const char *const GTY((skip(""))) osf_func;
- const char *const GTY((skip(""))) vms_func;
+ const char *const GTY((skip)) osf_func;
+ const char *const GTY((skip)) vms_func;
rtx libcall;
};
+2004-03-30 Zack Weinberg <zack@codesourcery.com>
+
+ * name-lookup.c, parser.c: Use new shorter form of GTY markers.
+
2004-03-29 Zack Weinberg <zack@codesourcery.com>
* error.c (dump_function_name): If T's DECL_LANG_SPECIFIC
/* A free list of "binding_entry"s awaiting for re-use. */
-static GTY((deletable(""))) binding_entry free_binding_entry = NULL;
+static GTY((deletable)) binding_entry free_binding_entry = NULL;
/* Create a binding_entry object for (NAME, TYPE). */
/* A free list of "cxx_binding"s, connected by their PREVIOUS. */
-static GTY((deletable (""))) cxx_binding *free_bindings;
+static GTY((deletable)) cxx_binding *free_bindings;
/* Zero out a cxx_binding pointed to by B. */
#define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))
/* A chain of binding_level structures awaiting reuse. */
-static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
+static GTY((deletable)) struct cp_binding_level *free_binding_level;
/* Create a new KIND scope and make it the top of the active scopes stack.
ENTITY is the scope of the associated C++ entity (namespace, class,
/* The memory allocated for the buffer. Never NULL. */
cp_token * GTY ((length ("(%h.buffer_end - %h.buffer)"))) buffer;
/* A pointer just past the end of the memory allocated for the buffer. */
- cp_token * GTY ((skip (""))) buffer_end;
+ cp_token * GTY ((skip)) buffer_end;
/* The first valid token in the buffer, or NULL if none. */
- cp_token * GTY ((skip (""))) first_token;
+ cp_token * GTY ((skip)) first_token;
/* The next available token. If NEXT_TOKEN is NULL, then there are
no more available tokens. */
- cp_token * GTY ((skip (""))) next_token;
+ cp_token * GTY ((skip)) next_token;
/* A pointer just past the last available token. If FIRST_TOKEN is
NULL, however, there are no available tokens, and then this
location is simply the place in which the next token read will be
placed. If LAST_TOKEN == FIRST_TOKEN, then the buffer is full.
When the LAST_TOKEN == BUFFER, then the last token is at the
highest memory address in the BUFFER. */
- cp_token * GTY ((skip (""))) last_token;
+ cp_token * GTY ((skip)) last_token;
/* A stack indicating positions at which cp_lexer_save_tokens was
called. The top entry is the most recent position at which we
/* Class variables. */
-static GTY((deletable (""))) cp_parser_context* cp_parser_context_free_list;
+static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
/* Constructors and destructors. */
union _cpp_hashnode_value
{
/* If a macro. */
- cpp_macro * GTY((skip (""))) macro;
+ cpp_macro * GTY((skip)) macro;
/* Answers to an assertion. */
- struct answer * GTY ((skip (""))) answers;
+ struct answer * GTY ((skip)) answers;
/* Code for a builtin macro. */
enum builtin_type GTY ((tag ("1"))) builtin;
/* Macro argument index. */
/* A VALUE rtx that points back to this structure. */
rtx GTY ((tag ("1"))) val_rtx;
/* Used to keep a list of free cselib_val structures. */
- struct cselib_val_struct * GTY ((skip (""))) next_free;
+ struct cselib_val_struct * GTY ((skip)) next_free;
} GTY ((desc ("1"))) u;
/* All rtl expressions that hold this value at the current time during a
source code and using this information to perform garbage collection and
implement precompiled headers.
-A full C parser would be too overcomplicated for this task, so a limited
+A full C parser would be too complicated for this task, so a limited
subset of C is interpreted and special markers are used to determine
-what parts of the source to look at. The parser can also detect
-simple typedefs of the form @code{typedef struct ID1 *ID2;} and
-@code{typedef int ID3;}, and these don't need to be specially marked.
-
-The two forms that do need to be marked are:
-@verbatim
-struct ID1 GTY(([options]))
-{
- [fields]
-};
-
-typedef struct ID2 GTY(([options]))
-{
- [fields]
-} ID3;
-@end verbatim
-
-@menu
-* GTY Options:: What goes inside a @code{GTY(())}.
-* GGC Roots:: Making global variables GGC roots.
-* Files:: How the generated files work.
-@end menu
-
-@node GTY Options
-@section The Inside of a @code{GTY(())}
+what parts of the source to look at. All @code{struct} and
+@code{union} declarations that define data structures that are
+allocated under control of the garbage collector must be marked. All
+global variables that hold pointers to garbage-collected memory must
+also be marked. Finally, all global variables that need to be saved
+and restored by a precompiled header must be marked. (The precompiled
+header mechanism can only save static variables if they're scalar.
+Complex data structures must be allocated in garbage-collected memory
+to be saved in a precompiled header.)
+
+The full format of a marker is
+@smallexample
+GTY (([@var{option}] [(@var{param})], [@var{option}] [(@var{param})] @dots{}))
+@end smallexample
+@noindent
+but in most cases no options are needed. The outer double parentheses
+are still necessary, though: @code{GTY(())}. Markers can appear:
-Sometimes the C code is not enough to fully describe the type structure.
-Extra information can be provided by using more @code{GTY} markers.
-These markers can be placed:
@itemize @bullet
@item
In a structure definition, before the open brace;
In a structure field definition, before the name of the field.
@end itemize
-The format of a marker is
-@verbatim
-GTY (([name] ([param]), [name] ([param]) ...))
-@end verbatim
-The parameter is either a string or a type name.
+Here are some examples of marking simple data structures and globals.
+
+@smallexample
+struct @var{tag} GTY(())
+@{
+ @var{fields}@dots{}
+@};
+
+typedef struct @var{tag} GTY(())
+@{
+ @var{fields}@dots{}
+@} *@var{typename};
+
+static GTY(()) struct @var{tag} *@var{list}; /* @r{points to GC memory} */
+static GTY(()) int @var{counter}; /* @r{save counter in a PCH} */
+@end smallexample
+
+The parser understands simple typedefs such as
+@code{typedef struct @var{tag} *@var{name};} and
+@code{typedef int @var{name};}.
+These don't need to be marked.
+
+@menu
+* GTY Options:: What goes inside a @code{GTY(())}.
+* GGC Roots:: Making global variables GGC roots.
+* Files:: How the generated files work.
+@end menu
+
+@node GTY Options
+@section The Inside of a @code{GTY(())}
+
+Sometimes the C code is not enough to fully describe the type
+structure. Extra information can be provided with @code{GTY} options
+and additional markers. Some options take a parameter, which may be
+either a string or a type name, depending on the parameter. If an
+option takes no parameter, it is acceptable either to omit the
+parameter entirely, or to provide an empty string as a parameter. For
+example, @code{@w{GTY ((skip))}} and @code{@w{GTY ((skip ("")))}} are
+equivalent.
-When the parameter is a string, often it is a fragment of C code. Three
-special escapes may be available:
+When the parameter is a string, often it is a fragment of C code. Four
+special escapes may be used in these strings, to refer to pieces of
+the data structure being marked:
@cindex % in GTY option
@table @code
@item %h
-This expands to an expression that evaluates to the current structure.
+The current structure.
@item %1
-This expands to an expression that evaluates to the structure that
-immediately contains the current structure.
+The structure that immediately contains the current structure.
@item %0
-This expands to an expression that evaluates to the outermost structure
-that contains the current structure.
+The outermost structure that contains the current structure.
@item %a
-This expands to the string of the form @code{[i1][i2]...} that indexes
-the array item currently being marked. For instance, if the field
-being marked is @code{foo}, then @code{%1.foo%a} is the same as @code{%h}.
+A partial expression of the form @code{[i1][i2]...} that indexes
+the array item currently being marked.
@end table
+For instance, suppose that you have a structure of the form
+@smallexample
+struct A @{
+ ...
+@};
+struct B @{
+ struct A foo[12];
+@};
+@end smallexample
+@noindent
+and @code{b} is a variable of type @code{struct B}. When marking
+@samp{b.foo[11]}, @code{%h} would expand to @samp{b.foo[11]},
+@code{%0} and @code{%1} would both expand to @samp{b}, and @code{%a}
+would expand to @samp{[11]}.
+
+As in ordinary C, adjacent strings will be concatenated; this is
+helpful when you have a complicated expression.
+@smallexample
+@group
+GTY ((chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE"
+ " ? TYPE_NEXT_VARIANT (&%h.generic)"
+ " : TREE_CHAIN (&%h.generic)")))
+@end group
+@end smallexample
+
The available options are:
@table @code
@findex length
-@item length
+@item length ("@var{expression}")
There are two places the type machinery will need to be explicitly told
the length of an array. The first case is when a structure ends in a
variable-length array, like this:
-@verbatim
-struct rtvec_def GTY(()) {
- int num_elem; /* number of elements */
+@smallexample
+struct rtvec_def GTY(()) @{
+ int num_elem; /* @r{number of elements} */
rtx GTY ((length ("%h.num_elem"))) elem[1];
-};
-@end verbatim
+@};
+@end smallexample
+
In this case, the @code{length} option is used to override the specified
array length (which should usually be @code{1}). The parameter of the
option is a fragment of C code that calculates the length.
@findex desc
@findex tag
@findex default
-@item desc
-@itemx tag
+@item desc ("@var{expression}")
+@itemx tag ("@var{constant}")
@itemx default
The type machinery needs to be told which field of a @code{union} is
In the @code{desc} option, the ``current structure'' is the union that
it discriminates. Use @code{%1} to mean the structure containing it.
-(There are no escapes available to the @code{tag} option, since it's
-supposed to be a constant.)
+There are no escapes available to the @code{tag} option, since it is a
+constant.
For example,
@smallexample
@findex param_is
@findex use_param
-@item param_is
+@item param_is (@var{type})
@itemx use_param
Sometimes it's convenient to define some data structure to work on
@code{use_param} says where in the generic data structure that type
should be put.
-For instance, to have a @code{htab_t} that points to trees, one should write
-@verbatim
+For instance, to have a @code{htab_t} that points to trees, one would
+write the definition of @code{htab_t} like this:
+@smallexample
+typedef struct GTY(()) @{
+ @dots{}
+ void ** GTY ((use_param, @dots{})) entries;
+ @dots{}
+@} htab_t;
+@end smallexample
+and then declare variables like this:
+@smallexample
htab_t GTY ((param_is (union tree_node))) ict;
-@end verbatim
+@end smallexample
@findex param@var{n}_is
@findex use_param@var{n}
-@item param@var{n}_is
+@item param@var{n}_is (@var{type})
@itemx use_param@var{n}
In more complicated cases, the data structure might need to work on
to keep a list of free structures around for re-use.
@findex if_marked
-@item if_marked
+@item if_marked ("@var{expression}")
Suppose you want some kinds of object to be unique, and so you put them
in a hash table. If garbage collection marks the hash table, these
@findex chain_next
@findex chain_prev
-@item chain_next
-@itemx chain_prev
+@item chain_next ("@var{expression}")
+@itemx chain_prev ("@var{expression}")
It's helpful for the type machinery to know if objects are often
chained together in long lists; this lets it generate code that uses
less stack space by iterating along the list instead of recursing down
it. @code{chain_next} is an expression for the next item in the list,
-@code{chain_prev} is an expression for the previous item. The
-machinery requires that taking the next item of the previous item
-gives the original item.
+@code{chain_prev} is an expression for the previous item. For singly
+linked lists, use only @code{chain_next}; for doubly linked lists, use
+both. The machinery requires that taking the next item of the
+previous item gives the original item.
@findex reorder
-@item reorder
+@item reorder ("@var{function name}")
Some data structures depend on the relative ordering of pointers. If
-the type machinery needs to change that ordering, it will call the
-function referenced by the @code{reorder} option, before changing the
-pointers in the object that's pointed to by the field the option
-applies to. The function must be of the type @code{void ()(void *,
-void *, gt_pointer_operator, void *)}. The second parameter is the
-pointed-to object; the third parameter is a routine that, given a
-pointer, can update it to its new value. The fourth parameter is a
-cookie to be passed to the third parameter. The first parameter is
-the structure that contains the object, or the object itself if it is
-a structure.
-
-No data structure may depend on the absolute value of pointers. Even
-relying on relative orderings and using @code{reorder} functions can
-be expensive. It is better to depend on properties of the data, like
-an ID number or the hash of a string instead.
+the precompiled header machinery needs to change that ordering, it
+will call the function referenced by the @code{reorder} option, before
+changing the pointers in the object that's pointed to by the field the
+option applies to. The function must take four arguments, with the
+signature @samp{@w{void *, void *, gt_pointer_operator, void *}}.
+The first parameter is a pointer to the structure that contains the
+object being updated, or the object itself if there is no containing
+structure. The second parameter is a cookie that should be ignored.
+The third parameter is a routine that, given a pointer, will update it
+to its correct new value. The fourth parameter is a cookie that must
+be passed to the second parameter.
+
+PCH cannot handle data structures that depend on the absolute values
+of pointers. @code{reorder} functions can be expensive. When
+possible, it is better to depend on properties of the data, like an ID
+number or the hash of a string instead.
@findex special
-@item special
-
-The @code{special} option is used for those bizarre cases that are just
-too hard to deal with otherwise. Don't use it for new code.
+@item special ("@var{name}")
+The @code{special} option is used to mark types that have to be dealt
+with by special case machinery. The parameter is the name of the
+special case. See @file{gengtype.c} for further details. Avoid
+adding new special cases unless there is no other alternative.
@end table
@node GGC Roots
@cindex marking roots
In addition to keeping track of types, the type machinery also locates
-the global variables that the garbage collector starts at. There are
-two syntaxes it accepts to indicate a root:
+the global variables (@dfn{roots}) that the garbage collector starts
+at. Roots must be declared using one of the following syntaxes:
-@enumerate
+@itemize @bullet
@item
-@verb{|extern GTY (([options])) [type] ID;|}
+@code{extern GTY(([@var{options}])) @var{type} @var{name};}
@item
-@verb{|static GTY (([options])) [type] ID;|}
-@end enumerate
-
-These are the only syntaxes that are accepted. In particular, if you
-want to mark a variable that is only declared as
-@verbatim
-int ID;
-@end verbatim
-or similar, you should either make it @code{static} or you should create
-a @code{extern} declaration in a header file somewhere.
+@code{static GTY(([@var{options}])) @var{type} @var{name};}
+@end itemize
+@noindent
+The syntax
+@itemize @bullet
+@item
+@code{GTY(([@var{options}])) @var{type} @var{name};}
+@end itemize
+@noindent
+is @emph{not} accepted. There should be an @code{extern} declaration
+of such a variable in a header somewhere---mark that, not the
+definition. Or, if the variable is only used in one file, make it
+@code{static}.
@node Files
@section Source Files Containing Type Information
@cindex generated files
@cindex files, generated
-Whenever you add @code{GTY} markers to a new source file, there are three
-things you need to do:
+Whenever you add @code{GTY} markers to a source file that previously
+had none, or create a new source file containing @code{GTY} markers,
+there are three things you need to do:
@enumerate
@item
You need to add the file to the list of source files the type
-machinery scans. There are three cases:
+machinery scans. There are four cases:
@enumerate a
@item
the appropriate port's entries in @file{config.gcc}.
@item
-For files shared by all front ends, this is done by adding the
-filename to the @code{GTFILES} variable in @file{Makefile.in}.
+For files shared by all front ends, add the filename to the
+@code{GTFILES} variable in @file{Makefile.in}.
@item
-For any other file used by a front end, this is done by adding the
-filename to the @code{gtfiles} variable defined in
+For files that are part of one front end, add the filename to the
+@code{gtfiles} variable defined in the appropriate
@file{config-lang.in}. For C, the file is @file{c-config-lang.in}.
-This list should include all files that have GTY macros in them that
-are used in that front end, other than those defined in the previous
-list items. For example, it is common for front end writers to use
-@file{c-common.c} and other files from the C front end, and these
-should be included in the @file{gtfiles} variable for such front ends.
+@item
+For files that are part of some but not all front ends, add the
+filename to the @code{gtfiles} variable of @emph{all} the front ends
+that use it.
@end enumerate
@item
unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
- HOST_WIDE_INT GTY ((default (""))) val_int;
+ HOST_WIDE_INT GTY ((default)) val_int;
unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
}
\f
/* Space for free sequence stack entries. */
-static GTY ((deletable (""))) struct sequence_stack *free_sequence_stack;
+static GTY ((deletable)) struct sequence_stack *free_sequence_stack;
/* Begin emitting insns to a sequence which can be packaged in an
RTL_EXPR. If this sequence will contain something that might cause
return new;
}
-static GTY((deletable(""))) rtx hard_reg_clobbers [NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
+static GTY((deletable)) rtx hard_reg_clobbers [NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
rtx
gen_hard_reg_clobber (enum machine_mode mode, unsigned int regno)
{
+2004-03-30 Zack Weinberg <zack@codesourcery.com>
+
+ * com.c: Use new shorter form of GTY markers.
+
2004-03-21 Joseph S. Myers <jsm@polyomino.org.uk>
* g77.texi: Update link to "G++ and GCC".
ftp://alpha.gnu.org/gnu/g77/projects/.
(Trouble): Remove obsolete paragraph including a broken link to
ftp://alpha.gnu.org/g77.plan.
-
+
* invoke.texi (Overall Options): Remove broken reference to
rat7.uue (which was of dubious copyright status anyways).
* root.texi (www-burley): Fix URL.
-
+
2004-02-29 Roger Sayle <roger@eyesopen.com>
* parse.c (ffe_parse_file): Handle the case that main_input_filename
2004-01-30 Kelley Cook <kcook@gcc.gnu.org>
- * Make-lang.in (doc/g77.dvi): Use $(abs_docdir).
+ * Make-lang.in (doc/g77.dvi): Use $(abs_docdir).
2004-01-28 Ian Lance Taylor <ian@wasabisystems.com>
/* A chain of binding_level structures awaiting reuse. */
-static GTY((deletable (""))) struct f_binding_level *free_binding_level;
+static GTY((deletable)) struct f_binding_level *free_binding_level;
/* The outermost binding level, for names of file scope.
This is created when the compiler is started and exists
/* For md files. */
/* tm.h can use this to store whatever it likes. */
- struct machine_function * GTY ((maybe_undef (""))) machine;
+ struct machine_function * GTY ((maybe_undef)) machine;
/* The largest alignment of slot allocated on the stack. */
int stack_alignment_needed;
/* Preferred alignment of the end of stack frame. */
%type <p> struct_fields yacc_ids yacc_typematch
%type <t> type lasttype
%type <o> optionsopt options option optionseq optionseqopt
-%type <s> type_option
+%type <s> type_option stringseq
%%
{ $$ = $1; }
;
-option: type_option '(' type ')'
- {
- options_p o = xmalloc (sizeof (*o));
- o->name = $1;
- o->info = adjust_field_type ($3, NULL);
- $$ = o;
- }
- | ID '(' STRING ')'
- {
- options_p o = xmalloc (sizeof (*o));
- o->name = $1;
- o->info = (void *)$3;
- $$ = o;
- }
- ;
+option: ID
+ { $$ = create_option ($1, (void *)""); }
+ | ID '(' stringseq ')'
+ { $$ = create_option ($1, (void *)$3); }
+ | type_option '(' type ')'
+ { $$ = create_option ($1, adjust_field_type ($3, NULL)); }
optionseq: option
{
optionseqopt: { $$ = NULL; }
| optionseq { $$ = $1; }
;
+
+stringseq: STRING
+ { $$ = $1; }
+ | stringseq STRING
+ {
+ size_t l1 = strlen ($1);
+ size_t l2 = strlen ($2);
+ char *s = xrealloc ((char *)$1, l1 + l2 + 1);
+ memcpy (s + l1, $2, l2 + 1);
+ free ((void *)$2);
+ $$ = s;
+ }
%%
return v;
}
+/* Return an options structure with name NAME and info INFO. */
+options_p
+create_option (const char *name, void *info)
+{
+ options_p o = xmalloc (sizeof (*o));
+ o->name = name;
+ o->info = info;
+ return o;
+}
+
/* Add a variable named S of type T with options O defined at POS,
to `variables'. */
extern type_p create_scalar_type (const char *name, size_t name_len);
extern type_p create_pointer (type_p t);
extern type_p create_array (type_p t, const char *len);
+extern options_p create_option (const char *name, void *info);
extern type_p adjust_field_type (type_p, options_p);
extern void note_variable (const char *s, type_p t, options_p o,
struct fileloc *pos);
+2004-03-30 Zack Weinberg <zack@codesourcery.com>
+
+ * builtins.c, expr.c, jcf.h, parse.h: Use new shorter
+ form of GTY markers.
+
2004-03-25 Marcus Meissner <meissner@suse.de>
PR java/14689:
* lang.c (java_handle_option): Handle new options.
* parse.y (build_incomplete_class_ref): Handle class$ in an inner
class in an interface - create helper class nested in outer interface.
- (build_assertion): Short-circuit if enable_assertions is false.
+ (build_assertion): Short-circuit if enable_assertions is false.
2004-03-18 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
!METHOD_INVISIBLE (iface_method).
* class.c (layout_class_methods): Check for CLASS_INTERFACE as
well as CLASS_ABSTRACT.
-
+
2004-02-25 Per Bothner <per@bothner.com>
* parse.y (build_assertion): If we're in an inner class, create the
2004-01-30 Kelley Cook <kcook@gcc.gnu.org>
- * Make-lang.in (doc/gcj.dvi): Use $(abs_docdir).
+ * Make-lang.in (doc/gcj.dvi): Use $(abs_docdir).
2004-01-28 Andrew Pinski <pinskia@physics.uc.edu>
* Make-lang.in: Replace $(docdir) with doc.
(java.info, java.srcinfo, java.man, java.srcman): New rules.
(java.install-man): Revamp rule.
-
+
2004-01-20 Kelley Cook <kcook@gcc.gnu.org>
- * Make-lang.in (JAVA_INSTALL_NAME, JAVA_TARGET_INSTALL_NAME,
- GCJH_TARGET_INSTALL_NAME): Define via a immediate $(shell)
+ * Make-lang.in (JAVA_INSTALL_NAME, JAVA_TARGET_INSTALL_NAME,
+ GCJH_TARGET_INSTALL_NAME): Define via a immediate $(shell)
instead of deferred backquote.
2004-01-16 Andrew Pinski <pinskia@physics.uc.edu>
using indirect dis[atch.
(java_decl_ok_for_sibcall): Use output_class, not current_class.
(java_get_callee_fndecl): Use class local atable.
- * jcf-parse.c
+ * jcf-parse.c
(always_initialize_class_p): Decl moved to java-tree.h.
(HANDLE_CLASS_INFO): Set output_class.
(read_class): Likewise.
Make otable, atable, and ctable class local rather than global.
(emit_catch_table): Make otable, atable, and ctable class local
rather than global.
-
+
2003-12-25 Andrew Pinski <pinskia@physics.uc.edu>
* parse.y (catch_clause_parameter): Fix typo.
PR java/13404
- * parse.y: (catch_clause_parameter): Return early if $3, aka
+ * parse.y: (catch_clause_parameter): Return early if $3, aka
formal_parameter, is null.
2003-12-20 Kazu Hirata <kazu@cs.umass.edu>
{
union string_or_tree GTY ((desc ("1"))) class_name;
union string_or_tree GTY ((desc ("1"))) method_name;
- builtin_creator_function * GTY((skip (""))) creator;
+ builtin_creator_function * GTY((skip)) creator;
enum built_in_function builtin_code;
};
static GTY(()) tree quick_stack;
/* A free-list of unused permanent TREE_LIST nodes. */
-static GTY((deletable (""))) tree tree_list_free_list;
+static GTY((deletable)) tree tree_list_free_list;
/* The stack pointer of the Java virtual machine.
This does include the size of the quick_stack. */
/* JCF encapsulates the state of reading a Java Class File. */
typedef struct JCF GTY(()) {
- unsigned char * GTY ((skip (""))) buffer;
- unsigned char * GTY ((skip (""))) buffer_end;
- unsigned char * GTY ((skip (""))) read_ptr;
- unsigned char * GTY ((skip (""))) read_end;
+ unsigned char * GTY ((skip)) buffer;
+ unsigned char * GTY ((skip)) buffer_end;
+ unsigned char * GTY ((skip)) read_ptr;
+ unsigned char * GTY ((skip)) read_end;
int java_source : 1;
int right_zip : 1;
int finished : 1;
jcf_filbuf_t filbuf;
- PTR GTY ((skip (""))) read_state;
+ PTR GTY ((skip)) read_state;
const char *filename;
const char *classname;
/* Directory entry where it was found. */
- struct ZipDirectory * GTY ((skip (""))) zipd;
+ struct ZipDirectory * GTY ((skip)) zipd;
JCF_u2 access_flags;
JCF_u2 this_class;
JCF_u2 super_class;
const char *filename; /* Current filename */
struct parser_ctxt *next;
- java_lexer * GTY((skip (""))) lexer; /* Current lexer state */
+ java_lexer * GTY((skip)) lexer; /* Current lexer state */
char marker_begining; /* Marker. Should be a sub-struct */
- struct java_line * GTY ((skip (""))) p_line; /* Previous line */
- struct java_line * GTY ((skip (""))) c_line; /* Current line */
+ struct java_line * GTY ((skip)) p_line; /* Previous line */
+ struct java_line * GTY ((skip)) c_line; /* Current line */
java_lc elc; /* Error's line column info */
int ccb_indent; /* Keep track of {} indent, lexer */
int first_ccb_indent1; /* First { at ident level 1 */
int parser_ccb_indent; /* Keep track of {} indent, parser */
int osb_depth; /* Current depth of [ in an expression */
int osb_limit; /* Limit of this depth */
- int * GTY ((skip (""))) osb_number; /* Keep track of ['s */
+ int * GTY ((skip)) osb_number; /* Keep track of ['s */
int lineno; /* Current lineno */
char marker_end; /* End marker. Should be a sub-struct */
/* These two lists won't survive file traversal */
tree class_list; /* List of classes in a CU */
- jdeplist * GTY((skip (""))) classd_list; /* Classe dependencies in a CU */
+ jdeplist * GTY((skip)) classd_list; /* Classe dependencies in a CU */
tree current_parsed_class; /* Class currently parsed */
tree current_parsed_class_un; /* Curr. parsed class unqualified name */
/* Functions for maintaining cache-able lists of EXPR_LIST and INSN_LISTs. */
/* An INSN_LIST containing all INSN_LISTs allocated but currently unused. */
-static GTY ((deletable (""))) rtx unused_insn_list;
+static GTY ((deletable)) rtx unused_insn_list;
/* An EXPR_LIST containing all EXPR_LISTs allocated but currently unused. */
-static GTY ((deletable (""))) rtx unused_expr_list;
+static GTY ((deletable)) rtx unused_expr_list;
/* This function will free an entire list of either EXPR_LIST or INSN_LIST
unsigned int align : 24;
unsigned int off_align : 8;
} a;
- } GTY ((skip (""))) u1;
+ } GTY ((skip)) u1;
tree size_unit;
tree name;
tag ("VARRAY_DATA_HINT"))) hint[1];
unsigned HOST_WIDE_INT GTY ((length ("%0.num_elements"),
tag ("VARRAY_DATA_UHINT"))) uhint[1];
- PTR GTY ((length ("%0.num_elements"), use_param (""),
+ PTR GTY ((length ("%0.num_elements"), use_param,
tag ("VARRAY_DATA_GENERIC"))) generic[1];
char *GTY ((length ("%0.num_elements"),
tag ("VARRAY_DATA_CPTR"))) cptr[1];
tag ("VARRAY_DATA_TREE"))) tree[1];
struct bitmap_head_def *GTY ((length ("%0.num_elements"),
tag ("VARRAY_DATA_BITMAP"))) bitmap[1];
- struct reg_info_def *GTY ((length ("%0.num_elements"), skip (""),
+ struct reg_info_def *GTY ((length ("%0.num_elements"), skip,
tag ("VARRAY_DATA_REG"))) reg[1];
struct const_equiv_data GTY ((length ("%0.num_elements"),
tag ("VARRAY_DATA_CONST_EQUIV"))) const_equiv[1];
- struct basic_block_def *GTY ((length ("%0.num_elements"), skip (""),
+ struct basic_block_def *GTY ((length ("%0.num_elements"), skip,
tag ("VARRAY_DATA_BB"))) bb[1];
struct elt_list *GTY ((length ("%0.num_elements"),
tag ("VARRAY_DATA_TE"))) te[1];
projects / gcc.git / commitdiff