From 91d231cb917f53b4cd34dec24227863e95fceb6f Mon Sep 17 00:00:00 2001 From: Joseph Myers Date: Fri, 21 Sep 2001 02:27:06 +0100 Subject: Table-driven attributes. * c-decl.c, config/alpha/alpha.c, config/arc/arc.c, config/arm/arm.c, config/arm/pe.c, config/avr/avr.c, config/avr/avr.h, config/d30v/d30v.h, config/fr30/fr30.h, config/h8300/h8300.c, config/i386/cygwin.h, config/i386/winnt.c, config/m32r/m32r.c, config/mcore/mcore.c, config/sh/sh.c, config/stormy16/stormy16.h, config/v850/v850.c, doc/c-tree.texi, doc/tm.texi, ggc-common.c, integrate.c, print-tree.c, tree.c, tree.h: Rename DECL_MACHINE_ATTRIBUTES to DECL_ATTRIBUTES. * tree.h (struct tree_decl): Change machine_attributes to attributes. * doc/c-tree.texi: Document that all attributes are now attached to decls and types. * c-common.c (add_attribute, attrtab, attrtab_idx, default_valid_lang_attribute, valid_lang_attribute): Remove. (attribute_tables, attributes_initialized, c_common_attribute_table, default_lang_attribute_table): New variables. (handle_packed_attribute, handle_nocommon_attribute, handle_common_attribute, handle_noreturn_attribute, handle_unused_attribute, handle_const_attribute, handle_transparent_union_attribute, handle_constructor_attribute, handle_destructor_attribute, handle_mode_attribute, handle_section_attribute, handle_aligned_attribute, handle_weak_attribute, handle_alias_attribute, handle_no_instrument_function_attribute, handle_no_check_memory_usage_attribute, handle_malloc_attribute, handle_no_limit_stack_attribute, handle_pure_attribute): New functions. (init_attributes, decl_attributes): Rewrite to implement table-driven attributes. * c-common.h (enum attribute_flags): Move to tree.h. * c-format.c (decl_handle_format_attribute, decl_handle_format_arg_attribute): Rename to handle_format_attribute and handle_format_arg_attribute. Update for table-driven attributes. * c-common.h (decl_handle_format_attribute, decl_handle_format_arg_attribute): Remove prototypes. (handle_format_attribute, handle_format_arg_attribute): Add prototypes. * c-decl.c (grokdeclarator): Handle attributes nested inside declarators. * c-parse.in (setattrs, maybe_setattrs): Remove. (maybe_type_quals_setattrs): Rename to maybe_type_quals_attrs. Update to handle nested attributes properly. (maybe_resetattrs, after_type_declarator, parm_declarator_nostarttypename, notype_declarator, absdcl1_noea, absdcl1_ea, direct_absdcl1): Update to handle nested attributes properly. (make_pointer_declarator): Update to handle nested attributes properly. * doc/extend.texi: Update documentation of limits of attributes syntax. Warn about problems with attribute semantics in C++. * target.h (struct target): Remove valid_decl_attribute and valid_type_attribute. Add attribute_table and function_attribute_inlinable_p. * target-def.h (TARGET_VALID_DECL_ATTRIBUTE, TARGET_VALID_TYPE_ATTRIBUTE): Remove. (TARGET_ATTRIBUTE_TABLE, TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P): Add. (TARGET_INITIALIZER): Update. * integrate.c (FUNCTION_ATTRIBUTE_INLINABLE_P): Remove default definition. (function_attribute_inlinable_p): New function. Check for the presence of any machine attributes before using targetm.function_attribute_inlinable_p. (function_cannot_inline_p): Update. * Makefile.in (integrate.o): Update dependencies. * doc/tm.texi: Update documentation of target attributes and example definition of TARGET_VALID_TYPE_ATTRIBUTE. * tree.c (default_valid_attribute_p, valid_machine_attribute): Remove. (default_target_attribute_table, default_function_attribute_inlinable_p): New. (lookup_attribute): Update comment to clarify handling of multiple attributes with the same name. (merge_attributes, attribute_list_contained): Allow multiple attributes with the same name but different arguments to appear in the same attribute list. * tree.h (default_valid_attribute_p): Remove prototype. (struct attribute_spec): New. (default_target_attribute_table): Declare. (enum attribute_flags): Move from c-common.h. Add ATTR_FLAG_TYPE_IN_PLACE. (default_function_attribute_inlinable_p): Declare. * config/alpha/alpha.c (vms_valid_decl_attribute_p): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (vms_attribute_table): New. * config/arc/arc.c (arc_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (arc_attribute_table, arc_handle_interrupt_attribute): New. * config/arm/arm.c (arm_valid_type_attribute_p, arm_valid_decl_attribute_p, arm_pe_valid_decl_attribute_p): Remove. (TARGET_VALID_TYPE_ATTRIBUTE, TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (arm_attribute_table, arm_handle_fndecl_attribute, arm_handle_isr_attribute): New. * config/avr/avr.c (avr_valid_type_attribute, avr_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE, TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (avr_attribute_table, avr_handle_progmem_attribute, avr_handle_fndecl_attribute): New. * config/c4x/c4x.c (c4x_valid_type_attribute_p): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (c4x_attribute_table, c4x_handle_fntype_attribute): New. * config/h8300/h8300.c (h8300_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (h8300_attribute_table, h8300_handle_fndecl_attribute, h8300_handle_eightbit_data_attribute, h8300_handle_tiny_data_attribute): New. * config/i386/i386-protos.h (ix86_valid_type_attribute_p, i386_pe_valid_decl_attribute_p, i386_pe_valid_type_attribute_p): Remove prototypes. (ix86_handle_dll_attribute, ix86_handle_shared_attribute): New declarations. * config/i386/i386.c (ix86_valid_type_attribute_p: Remove. (TARGET_VALID_TYPE_ATTRIBUTE, TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (ix86_attribute_table, ix86_handle_cdecl_attribute, ix86_handle_regparm_attribute): New. * config/i386/winnt.c (i386_pe_valid_decl_attribute_p, i386_pe_valid_type_attribute_p): Remove. (ix86_handle_dll_attribute, ix86_handle_shared_attribute): New. * config/ia64/ia64.c (ia64_valid_type_attribute): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (ia64_attribute_table): New. * config/m32r/m32r.c (m32r_valid_decl_attribute, interrupt_ident1, interrupt_ident2, model_ident1, model_ident2): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (init_idents): Update. (m32r_attribute_table, m32r_handle_model_attribute): New. * config/m68hc11/m68hc11.c (m68hc11_valid_type_attribute_p): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (m68hc11_attribute_table, m68hc11_handle_fntype_attribute): New. * config/mcore/mcore.c (mcore_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (mcore_attribute_table, mcore_handle_naked_attribute): New. * config/ns32k/ns32k.c (ns32k_valid_type_attribute_p): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (ns32k_attribute_table, ns32k_handle_fntype_attribute): New. * config/rs6000/rs6000.c (rs6000_valid_type_attribute_p): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (rs6000_attribute_table, rs6000_handle_longcall_attribute): New. * config/sh/sh.c (sh_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (sh_attribute_table, sh_handle_interrupt_handler_attribute, sh_handle_sp_switch_attribute, sh_handle_trap_exit_attribute): New. * config/stormy16/stormy16.c (stormy16_valid_type_attribute): Remove. (TARGET_VALID_TYPE_ATTRIBUTE): Don't define (TARGET_ATTRIBUTE_TABLE): Define. (stormy16_attribute_table, stormy16_handle_interrupt_attribute): New. * config/v850/v850.c (v850_valid_decl_attribute): Remove. (TARGET_VALID_DECL_ATTRIBUTE): Don't define. (TARGET_ATTRIBUTE_TABLE): Define. (v850_attribute_table, v850_handle_interrupt_attribute, v850_handle_data_area_attribute): New. * config/v850/v850-c.c (mark_current_function_as_interrupt): Return void. Call decl_attributes instead of valid_machine_attribute. cp: Table-driven attributes. * decl.c: Rename DECL_MACHINE_ATTRIBUTES to DECL_ATTRIBUTES. * decl2.c (cplus_decl_attributes): Only take one attributes parameter. * cp-tree.c (cplus_decl_attributes): Update prototype. * class.c (finish_struct), decl.c (start_decl, start_function), decl2.c (grokfield), friend.c (do_friend), parse.y (parse_bitfield): Update calls to cplus_decl_attributes. * decl.c (grokdeclarator): Take a pointer to a single ordinary attribute list. * decl.h (grokdeclarator): Update prototype. * decl2.c (grokfield): Take a single ordinary attribute list. * friend.c (do_friend): Likewise. * decl.c (shadow_tag, groktypename, start_decl, start_handler_parms, grokdeclarator, grokparms, start_function, start_method), decl2.c (grokfield, grokbitfield, grokoptypename), parse.y (parse_field, parse_bitfield, component_decl_1), pt.c (process_template_parm, do_decl_instantiation): Pass single ordinary attribute lists around. * decl.c (grokdeclarator): Correct handling of nested attributes. Revert the patch 1998-10-18 Jason Merrill * decl.c (grokdeclarator): Embedded attrs bind to the right, not the left. . * cp-tree.h (cp_valid_lang_attribute): Remove declaration (cp_attribute_table): Declare. * decl.c (valid_lang_attribute): Don't define. (lang_attribute_table): Define. (init_decl_processing): Initialize lang_attribute_table instead of valid_lang_attribute. * tree.c (cp_valid_lang_attribute): Remove. (handle_java_interface_attribute, handle_com_interface_attribute, handle_init_priority_attribute): New functions. (cp_attribute_table): New array. * decl2.c (import_export_class): Don't use targetm.valid_type_attribute. testsuite: Table-driven attributes. * g++.dg/ext/attrib1.C: New test. From-SVN: r45718 --- gcc/doc/c-tree.texi | 13 ++-- gcc/doc/extend.texi | 43 ++++++++++--- gcc/doc/tm.texi | 170 +++++++++++++++++++++++++++------------------------- 3 files changed, 127 insertions(+), 99 deletions(-) (limited to 'gcc/doc') diff --git a/gcc/doc/c-tree.texi b/gcc/doc/c-tree.texi index 9d9c25d..350c9bc 100644 --- a/gcc/doc/c-tree.texi +++ b/gcc/doc/c-tree.texi @@ -1658,14 +1658,11 @@ to the same declaration or type, or @code{NULL_TREE} if there are no further attributes in the list. Attributes may be attached to declarations and to types; these -attributes may be accessed with the following macros. At present only -machine-dependent attributes are stored in this way (other attributes -cause changes to the declaration or type or to other internal compiler -data structures, but are not themselves stored along with the -declaration or type), but in future all attributes may be stored like -this. - -@deftypefn {Tree Macro} tree DECL_MACHINE_ATTRIBUTES (tree @var{decl}) +attributes may be accessed with the following macros. All attributes +are stored in this way, and many also cause other changes to the +declaration or type or to other internal compiler data structures. + +@deftypefn {Tree Macro} tree DECL_ATTRIBUTES (tree @var{decl}) This macro returns the attributes on the declaration @var{decl}. @end deftypefn diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 0834496..ea60b57 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -2449,6 +2449,14 @@ language. Some details may vary for C++ and Objective-C@. Because of infelicities in the grammar for attributes, some forms described here may not be successfully parsed in all cases. +There are some problems with the semantics of attributes in C++. For +example, there are no manglings for attributes, although they may affect +code generation, so problems may arise when attributed types are used in +conjunction with templates or overloading. Similarly, @code{typeid} +does not distinguish between types with different attributes. Support +for attributes in C++ may be restricted in future to attributes on +declarations only, but not on nested declarators. + @xref{Function Attributes}, for details of the semantics of attributes applying to functions. @xref{Variable Attributes}, for details of the semantics of attributes applying to variables. @xref{Type Attributes}, @@ -2520,9 +2528,8 @@ defined is not complete until after the attribute specifiers. Otherwise, an attribute specifier appears as part of a declaration, counting declarations of unnamed parameters and type names, and relates to that declaration (which may be nested in another declaration, for -example in the case of a parameter declaration). In future, attribute -specifiers in some places may however apply to a particular declarator -within a declaration instead; these cases are noted below. Where an +example in the case of a parameter declaration), or to a particular declarator +within a declaration. Where an attribute specifier is applied to a parameter declared as a function or an array, it should apply to the function or array rather than the pointer to which the parameter is implicitly converted, but this is not @@ -2597,11 +2604,11 @@ ignored. An attribute specifier list may appear at the start of a nested declarator. At present, there are some limitations in this usage: the -attributes apply to the identifier declared, rather than to a specific -declarator. When attribute specifiers follow the @code{*} of a pointer +attributes correctly apply to the declarator, but for most individual +attributes the semantics this implies are not implemented. +When attribute specifiers follow the @code{*} of a pointer declarator, they may be mixed with any type qualifiers present. -The following describes intended future -semantics which make this syntax more useful only. It will make the +The following describes the formal semantics of this syntax. It will make the most sense if you are familiar with the formal specification of declarators in the ISO C standard. @@ -2642,8 +2649,26 @@ char *__attribute__((aligned(8))) *f; @noindent specifies the type ``pointer to 8-byte-aligned pointer to @code{char}''. -Note again that this describes intended future semantics, not current -implementation. +Note again that this does not work with most attributes; for example, +the usage of @samp{aligned} and @samp{noreturn} attributes given above +is not yet supported. + +For compatibility with existing code written for compiler versions that +did not implement attributes on nested declarators, some laxity is +allowed in the placing of attributes. If an attribute that only applies +to types is applied to a declaration, it will be treated as applying to +the type of that declaration. If an attribute that only applies to +declarations is applied to the type of a declaration, it will be treated +as applying to that declaration; and, for compatibility with code +placing the attributes immediately before the identifier declared, such +an attribute applied to a function return type will be treated as +applying to the function type, and such an attribute applied to an array +element type will be treated as applying to the array type. If an +attribute that only applies to function types is applied to a +pointer-to-function type, it will be treated as applying to the pointer +target type; if such an attribute is applied to a function return type +that is not a pointer-to-function type, it will be treated as applying +to the function type. @node Function Prototypes @section Prototypes and Old-Style Function Definitions diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 71e4cd9..721e161 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -48,6 +48,7 @@ through the macros defined in the @file{.h} file. * Debugging Info:: Defining the format of debugging output. * Cross-compilation:: Handling floating point for cross-compilers. * Mode Switching:: Insertion of mode-switching instructions. +* Target Attributes:: Defining target-specific uses of @code{__attribute__}. * Misc:: Everything else. @end menu @@ -70,8 +71,8 @@ macros for which the default definition is inappropriate. For example: /* @r{Initialize the GCC target structure.} */ -#undef TARGET_VALID_TYPE_ATTRIBUTE -#define TARGET_VALID_TYPE_ATTRIBUTE @var{machine}_valid_type_attribute_p +#undef TARGET_COMP_TYPE_ATTRIBUTES +#define TARGET_COMP_TYPE_ATTRIBUTES @var{machine}_comp_type_attributes struct gcc_target targetm = TARGET_INITIALIZER; @end smallexample @@ -2528,7 +2529,7 @@ This describes the stack layout and calling conventions. * Caller Saves:: * Function Entry:: * Profiling:: -* Inlining and Tail Calls:: +* Tail Calls:: @end menu @node Frame Layout @@ -3222,7 +3223,7 @@ after the function returns. @var{fundecl} is a C variable whose value is a tree node that describes the function in question. Normally it is a node of type @code{FUNCTION_DECL} that describes the declaration of the function. -From this you can obtain the @code{DECL_MACHINE_ATTRIBUTES} of the function. +From this you can obtain the @code{DECL_ATTRIBUTES} of the function. @var{funtype} is a C variable whose value is a tree node that describes the function in question. Normally it is a node of type @@ -4204,18 +4205,11 @@ profiling when the frame pointer is omitted. @end table -@node Inlining and Tail Calls -@subsection Permitting inlining and tail calls -@cindex inlining +@node Tail Calls +@subsection Permitting tail calls +@cindex tail calls @table @code -@findex FUNCTION_ATTRIBUTE_INLINABLE_P -@item FUNCTION_ATTRIBUTE_INLINABLE_P (@var{decl}) -A C expression that evaluates to true if it is ok to inline @var{decl} -into the current function, despite its having target-specific -attributes. By default, if a function has a target specific attribute -attached to it, it will not be inlined. - @findex FUNCTION_OK_FOR_SIBCALL @item FUNCTION_OK_FOR_SIBCALL (@var{decl}) A C expression that evaluates to true if it is ok to perform a sibling @@ -8031,6 +8025,85 @@ Generate one or more insns to set @var{entity} to @var{mode}. the insn(s) are to be inserted. @end table +@node Target Attributes +@section Defining target-specific uses of @code{__attribute__} +@cindex target attributes +@cindex machine attributes +@cindex attributes, target-specific + +Target-specific attributes may be defined for functions, data and types. +These are described using the following target hooks; they also need to +be documented in @file{extend.texi}. + +@deftypevr {Target Hook} {const struct attribute_spec *} TARGET_ATTRIBUTE_TABLE +If defined, this target hook points to an array of @samp{struct +attribute_spec} (defined in @file{tree.h}) specifying the machine +specific attributes for this target and some of the restrictions on the +entities to which these attributes are applied and the arguments they +take. +@end deftypevr + +@deftypefn {Target Hook} int TARGET_COMP_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2}) +If defined, this target hook is a function which returns zero if the attributes on +@var{type1} and @var{type2} are incompatible, one if they are compatible, +and two if they are nearly compatible (which causes a warning to be +generated). If this is not defined, machine-specific attributes are +supposed always to be compatible. +@end deftypefn + +@deftypefn {Target Hook} void TARGET_SET_DEFAULT_TYPE_ATTRIBUTES (tree @var{type}) +If defined, this target hook is a function which assigns default attributes to +newly defined @var{type}. +@end deftypefn + +@deftypefn {Target Hook} tree TARGET_MERGE_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2}) +Define this target hook if the merging of type attributes needs special +handling. If defined, the result is a list of the combined +@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed +that @code{comptypes} has already been called and returned 1. This +function may call @code{merge_attributes} to handle machine-independent +merging. +@end deftypefn + +@deftypefn {Target Hook} tree TARGET_MERGE_DECL_ATTRIBUTES (tree @var{olddecl}, tree @var{newdecl}) +Define this target hook if the merging of decl attributes needs special +handling. If defined, the result is a list of the combined +@code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}. +@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of +when this is needed are when one attribute overrides another, or when an +attribute is nullified by a subsequent definition. This function may +call @code{merge_attributes} to handle machine-independent merging. + +@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES +If the only target-specific handling you require is @samp{dllimport} for +Windows targets, you should define the macro +@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES}. This links in a function +called @code{merge_dllimport_decl_attributes} which can then be defined +as the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. This is done +in @file{i386/cygwin.h} and @file{i386/i386.c}, for example. +@end deftypefn + +@deftypefn {Target Hook} void TARGET_INSERT_ATTRIBUTES (tree @var{node}, tree *@var{attr_ptr}) +Define this target hook if you want to be able to add attributes to a decl +when it is being created. This is normally useful for back ends which +wish to implement a pragma by using the attributes which correspond to +the pragma's effect. The @var{node} argument is the decl which is being +created. The @var{attr_ptr} argument is a pointer to the attribute list +for this decl. The list itself should not be modified, since it may be +shared with other decls, but attributes may be chained on the head of +the list and @code{*@var{attr_ptr}} modified to point to the new +attributes, or a copy of the list may be made if further changes are +needed. +@end deftypefn + +@deftypefn {Target Hook} bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (tree @var{fndecl}) +@cindex inlining +This target hook returns @code{true} if it is ok to inline @var{fndecl} +into the current function, despite its having target-specific +attributes, @code{false} otherwise. By default, if a function has a +target specific attribute attached to it, it will not be inlined. +@end deftypefn + @node Misc @section Miscellaneous Parameters @cindex parameters, miscellaneous @@ -8404,7 +8477,7 @@ other compilers for the same target. In general, we discourage definition of target-specific pragmas for GCC@. If the pragma can be implemented by attributes then you should consider -defining @samp{INSERT_ATTRIBUTES} as well. +defining the target hook @samp{TARGET_INSERT_ATTRIBUTES} as well. Preprocessor macros that appear on pragma lines are not expanded. All @samp{#pragma} directives that do not match any registered pragma are @@ -8484,74 +8557,7 @@ pack value of zero resets the behaviour to the default. Successive invocations of this pragma cause the previous values to be stacked, so that invocations of @samp{#pragma pack(pop)} will return to the previous value. -@end table - -@deftypefn {Target Hook} int TARGET_VALID_DECL_ATTRIBUTE (tree @var{decl}, tree @var{attributes}, tree @var{identifier}, tree @var{args}) -If defined, this target hook is a function which returns nonzero if @var{identifier} with -arguments @var{args} is a valid machine specific attribute for @var{decl}. -The attributes in @var{attributes} have previously been assigned to @var{decl}. -@end deftypefn - -@deftypefn {Target Hook} int TARGET_VALID_TYPE_ATTRIBUTE (tree @var{type}, tree @var{attributes}, tree @var{identifier}, tree @var{args}) -If defined, this target hook is a function which returns nonzero if @var{identifier} with -arguments @var{args} is a valid machine specific attribute for @var{type}. -The attributes in @var{attributes} have previously been assigned to @var{type}. -@end deftypefn - -@deftypefn {Target Hook} int TARGET_COMP_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2}) -If defined, this target hook is a function which returns zero if the attributes on -@var{type1} and @var{type2} are incompatible, one if they are compatible, -and two if they are nearly compatible (which causes a warning to be -generated). If this is not defined, machine-specific attributes are -supposed always to be compatible. -@end deftypefn - -@deftypefn {Target Hook} void TARGET_SET_DEFAULT_TYPE_ATTRIBUTES (tree @var{type}) -If defined, this target hook is a function which assigns default attributes to -newly defined @var{type}. -@end deftypefn -@deftypefn {Target Hook} tree TARGET_MERGE_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2}) -Define this target hook if the merging of type attributes needs special -handling. If defined, the result is a list of the combined -@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed -that @code{comptypes} has already been called and returned 1. This -function may call @code{merge_attributes} to handle machine-independent -merging. -@end deftypefn - -@deftypefn {Target Hook} tree TARGET_MERGE_DECL_ATTRIBUTES (tree @var{olddecl}, tree @var{newdecl}) -Define this target hook if the merging of decl attributes needs special -handling. If defined, the result is a list of the combined -@code{DECL_MACHINE_ATTRIBUTES} of @var{olddecl} and @var{newdecl}. -@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of -when this is needed are when one attribute overrides another, or when an -attribute is nullified by a subsequent definition. This function may -call @code{merge_attributes} to handle machine-independent merging. - -@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES -If the only target-specific handling you require is @samp{dllimport} for -Windows targets, you should define the macro -@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES}. This links in a function -called @code{merge_dllimport_decl_attributes} which can then be defined -as the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. This is done -in @file{i386/cygwin.h} and @file{i386/i386.c}, for example. -@end deftypefn - -@deftypefn {Target Hook} void TARGET_INSERT_ATTRIBUTES (tree @var{node}, tree *@var{attr_ptr}) -Define this target hook if you want to be able to add attributes to a decl -when it is being created. This is normally useful for back ends which -wish to implement a pragma by using the attributes which correspond to -the pragma's effect. The @var{node} argument is the decl which is being -created. The @var{attr_ptr} argument is a pointer to the attribute list -for this decl. The list itself should not be modified, since it may be -shared with other decls, but attributes may be chained on the head of -the list and @code{*@var{attr_ptr}} modified to point to the new -attributes, or a copy of the list may be made if further changes are -needed. -@end deftypefn - -@table @code @findex DOLLARS_IN_IDENTIFIERS @item DOLLARS_IN_IDENTIFIERS Define this macro to control use of the character @samp{$} in identifier -- cgit v1.1