This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[gcc-in-cxx] FYI: fix scoping problems


I'm checking this in on the gcc-in-cxx branch.

g++ was giving various errors due to scoping issues.  The fix in all
these cases is to move the definition of a struct or enum to the top
level.  This patch looks much bigger than it is -- really it is just
rearranging some definitions and then reindenting them.

Tom

ChangeLog:
2008-10-05  Tom Tromey  <tromey@redhat.com>

	* cgraph.h (struct inline_summary): Move to top level.
	(cgraph_local_info): Update.
	* target.h (struct asm_out): Move to top level.
	(struct asm_int_op): Likewise.
	(struct sched): Likewise.
	(struct vectorize): Likewise.
	(struct calls): Likewise.
	(struct c): Likewise.
	(struct cxx): Likewise.
	(struct emutls): Likewise.
	(struct target_option_hooks): Likewise.
	(struct gcc_target): Update.
	* matrix-reorg.c (struct free_info): Move to top level.
	(struct matrix_info): Update.
	* tree-eh.c (struct goto_queue_node): Move to top level.
	(struct leh_tf_state): Update.
	* sched-int.h (struct deps_reg): Move to top level.
	(enum post_call_value): Likewise.  Give name.
	(struct deps): Update.
	* cse.c (struct branch_path): Move to top level.
	(struct cse_basic_block_data): Update.

Index: cgraph.h
===================================================================
--- cgraph.h	(revision 140884)
+++ cgraph.h	(working copy)
@@ -48,19 +48,22 @@
 
 extern const char * const cgraph_availability_names[];
 
+struct inline_summary GTY(())
+{
+  /* Estimated stack frame consumption by the function.  */
+  HOST_WIDE_INT estimated_self_stack_size;
+
+  /* Size of the function before inlining.  */
+  int self_insns;
+};
+
 /* Information about the function collected locally.
    Available after function is analyzed.  */
 
 struct cgraph_local_info GTY(())
 {
-  struct inline_summary {
-    /* Estimated stack frame consumption by the function.  */
-    HOST_WIDE_INT estimated_self_stack_size;
+  struct inline_summary inline_summary;
 
-    /* Size of the function before inlining.  */
-    int self_insns;
-  } inline_summary;
-
   /* Set when function function is visible in current compilation unit only
      and its address is never taken.  */
   unsigned local : 1;
Index: target.h
===================================================================
--- target.h	(revision 140884)
+++ target.h	(working copy)
@@ -91,390 +91,597 @@
 /* This is defined in ddg.h .  */
 struct ddg;
 
-struct gcc_target
+/* See 'aligned_op' in struct asm_out.  */
+struct asm_int_op
 {
-  /* Functions that output assembler for the target.  */
-  struct asm_out
-  {
-    /* Opening and closing parentheses for asm expression grouping.  */
-    const char *open_paren, *close_paren;
+  const char *hi;
+  const char *si;
+  const char *di;
+  const char *ti;
+};
 
-    /* Assembler instructions for creating various kinds of integer object.  */
-    const char *byte_op;
-    struct asm_int_op
-    {
-      const char *hi;
-      const char *si;
-      const char *di;
-      const char *ti;
-    } aligned_op, unaligned_op;
+/* Functions that output assembler for the target.  */
+struct asm_out
+{
+  /* Opening and closing parentheses for asm expression grouping.  */
+  const char *open_paren, *close_paren;
 
-    /* Try to output the assembler code for an integer object whose
-       value is given by X.  SIZE is the size of the object in bytes and
-       ALIGNED_P indicates whether it is aligned.  Return true if
-       successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
-       and UNALIGNED_OP are NULL.  */
-    bool (* integer) (rtx x, unsigned int size, int aligned_p);
+  /* Assembler instructions for creating various kinds of integer object.  */
+  const char *byte_op;
+  struct asm_int_op aligned_op, unaligned_op;
 
-    /* Output code that will globalize a label.  */
-    void (* globalize_label) (FILE *, const char *);
+  /* Try to output the assembler code for an integer object whose
+     value is given by X.  SIZE is the size of the object in bytes and
+     ALIGNED_P indicates whether it is aligned.  Return true if
+     successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
+     and UNALIGNED_OP are NULL.  */
+  bool (* integer) (rtx x, unsigned int size, int aligned_p);
 
-    /* Output code that will globalize a declaration.  */
-    void (* globalize_decl_name) (FILE *, tree);
+  /* Output code that will globalize a label.  */
+  void (* globalize_label) (FILE *, const char *);
 
-    /* Output code that will emit a label for unwind info, if this
-       target requires such labels.  Second argument is the decl the
-       unwind info is associated with, third is a boolean: true if
-       this is for exception handling, fourth is a boolean: true if
-       this is only a placeholder for an omitted FDE.  */
-    void (* unwind_label) (FILE *, tree, int, int);
+  /* Output code that will globalize a declaration.  */
+  void (* globalize_decl_name) (FILE *, tree);
 
-    /* Output code that will emit a label to divide up the exception
-       table.  */
-    void (* except_table_label) (FILE *);
+  /* Output code that will emit a label for unwind info, if this
+     target requires such labels.  Second argument is the decl the
+     unwind info is associated with, third is a boolean: true if
+     this is for exception handling, fourth is a boolean: true if
+     this is only a placeholder for an omitted FDE.  */
+  void (* unwind_label) (FILE *, tree, int, int);
 
-    /* Emit any directives required to unwind this instruction.  */
-    void (* unwind_emit) (FILE *, rtx);
+  /* Output code that will emit a label to divide up the exception
+     table.  */
+  void (* except_table_label) (FILE *);
 
-    /* Output an internal label.  */
-    void (* internal_label) (FILE *, const char *, unsigned long);
+  /* Emit any directives required to unwind this instruction.  */
+  void (* unwind_emit) (FILE *, rtx);
 
-    /* Emit a ttype table reference to a typeinfo object.  */
-    bool (* ttype) (rtx);
+  /* Output an internal label.  */
+  void (* internal_label) (FILE *, const char *, unsigned long);
 
-    /* Emit an assembler directive to set visibility for the symbol
-       associated with the tree decl.  */
-    void (* visibility) (tree, int);
+  /* Emit a ttype table reference to a typeinfo object.  */
+  bool (* ttype) (rtx);
 
-    /* Output the assembler code for entry to a function.  */
-    void (* function_prologue) (FILE *, HOST_WIDE_INT);
+  /* Emit an assembler directive to set visibility for the symbol
+     associated with the tree decl.  */
+  void (* visibility) (tree, int);
 
-    /* Output the assembler code for end of prologue.  */
-    void (* function_end_prologue) (FILE *);
+  /* Output the assembler code for entry to a function.  */
+  void (* function_prologue) (FILE *, HOST_WIDE_INT);
 
-    /* Output the assembler code for start of epilogue.  */
-    void (* function_begin_epilogue) (FILE *);
+  /* Output the assembler code for end of prologue.  */
+  void (* function_end_prologue) (FILE *);
 
-    /* Output the assembler code for function exit.  */
-    void (* function_epilogue) (FILE *, HOST_WIDE_INT);
+  /* Output the assembler code for start of epilogue.  */
+  void (* function_begin_epilogue) (FILE *);
 
-    /* Initialize target-specific sections.  */
-    void (* init_sections) (void);
+  /* Output the assembler code for function exit.  */
+  void (* function_epilogue) (FILE *, HOST_WIDE_INT);
 
-    /* Tell assembler to change to section NAME with attributes FLAGS.
-       If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
-       which this section is associated.  */
-    void (* named_section) (const char *name, unsigned int flags, tree decl);
+  /* Initialize target-specific sections.  */
+  void (* init_sections) (void);
 
-    /* Return a mask describing how relocations should be treated when
-       selecting sections.  Bit 1 should be set if global relocations
-       should be placed in a read-write section; bit 0 should be set if
-       local relocations should be placed in a read-write section.  */
-    int (*reloc_rw_mask) (void);
+  /* Tell assembler to change to section NAME with attributes FLAGS.
+     If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
+     which this section is associated.  */
+  void (* named_section) (const char *name, unsigned int flags, tree decl);
 
-    /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
-       is nonzero if runtime relocations must be applied; bit 1 will be
-       set if the runtime relocations require non-local name resolution.
-       ALIGN is the required alignment of the data.  */
-    section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
+  /* Return a mask describing how relocations should be treated when
+     selecting sections.  Bit 1 should be set if global relocations
+     should be placed in a read-write section; bit 0 should be set if
+     local relocations should be placed in a read-write section.  */
+  int (*reloc_rw_mask) (void);
 
-    /* Return a section for X.  MODE is X's mode and ALIGN is its
-       alignment in bits.  */
-    section *(* select_rtx_section) (enum machine_mode, rtx,
-				     unsigned HOST_WIDE_INT);
+  /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
+     is nonzero if runtime relocations must be applied; bit 1 will be
+     set if the runtime relocations require non-local name resolution.
+     ALIGN is the required alignment of the data.  */
+  section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
 
-    /* Select a unique section name for DECL.  RELOC is the same as
-       for SELECT_SECTION.  */
-    void (* unique_section) (tree, int);
+  /* Return a section for X.  MODE is X's mode and ALIGN is its
+     alignment in bits.  */
+  section *(* select_rtx_section) (enum machine_mode, rtx,
+				   unsigned HOST_WIDE_INT);
 
-    /* Return the readonly data section associated with function DECL.  */
-    section *(* function_rodata_section) (tree);
+  /* Select a unique section name for DECL.  RELOC is the same as
+     for SELECT_SECTION.  */
+  void (* unique_section) (tree, int);
 
-    /* Output a constructor for a symbol with a given priority.  */
-    void (* constructor) (rtx, int);
+  /* Return the readonly data section associated with function DECL.  */
+  section *(* function_rodata_section) (tree);
 
-    /* Output a destructor for a symbol with a given priority.  */
-    void (* destructor) (rtx, int);
+  /* Output a constructor for a symbol with a given priority.  */
+  void (* constructor) (rtx, int);
 
-    /* Output the assembler code for a thunk function.  THUNK_DECL is the
-       declaration for the thunk function itself, FUNCTION is the decl for
-       the target function.  DELTA is an immediate constant offset to be
-       added to THIS.  If VCALL_OFFSET is nonzero, the word at
-       *(*this + vcall_offset) should be added to THIS.  */
-    void (* output_mi_thunk) (FILE *file, tree thunk_decl,
-			      HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
-			      tree function_decl);
+  /* Output a destructor for a symbol with a given priority.  */
+  void (* destructor) (rtx, int);
 
-    /* Determine whether output_mi_thunk would succeed.  */
-    /* ??? Ideally, this hook would not exist, and success or failure
-       would be returned from output_mi_thunk directly.  But there's
-       too much undo-able setup involved in invoking output_mi_thunk.
-       Could be fixed by making output_mi_thunk emit rtl instead of
-       text to the output file.  */
-    bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
-				  HOST_WIDE_INT vcall_offset,
-				  const_tree function_decl);
+  /* Output the assembler code for a thunk function.  THUNK_DECL is the
+     declaration for the thunk function itself, FUNCTION is the decl for
+     the target function.  DELTA is an immediate constant offset to be
+     added to THIS.  If VCALL_OFFSET is nonzero, the word at
+     *(*this + vcall_offset) should be added to THIS.  */
+  void (* output_mi_thunk) (FILE *file, tree thunk_decl,
+			    HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
+			    tree function_decl);
 
-    /* Output any boilerplate text needed at the beginning of a
-       translation unit.  */
-    void (*file_start) (void);
+  /* Determine whether output_mi_thunk would succeed.  */
+  /* ??? Ideally, this hook would not exist, and success or failure
+     would be returned from output_mi_thunk directly.  But there's
+     too much undo-able setup involved in invoking output_mi_thunk.
+     Could be fixed by making output_mi_thunk emit rtl instead of
+     text to the output file.  */
+  bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
+				HOST_WIDE_INT vcall_offset,
+				const_tree function_decl);
 
-    /* Output any boilerplate text needed at the end of a
-       translation unit.  */
-    void (*file_end) (void);
+  /* Output any boilerplate text needed at the beginning of a
+     translation unit.  */
+  void (*file_start) (void);
 
-    /* Output an assembler pseudo-op to declare a library function name
-       external.  */
-    void (*external_libcall) (rtx);
+  /* Output any boilerplate text needed at the end of a
+     translation unit.  */
+  void (*file_end) (void);
 
-    /* Output an assembler directive to mark decl live. This instructs
-	linker to not dead code strip this symbol.  */
-    void (*mark_decl_preserved) (const char *);
+  /* Output an assembler pseudo-op to declare a library function name
+     external.  */
+  void (*external_libcall) (rtx);
 
-    /* Output a record of the command line switches that have been passed.  */
-    print_switch_fn_type record_gcc_switches;
-    /* The name of the section that the example ELF implementation of
-       record_gcc_switches will use to store the information.  Target
-       specific versions of record_gcc_switches may or may not use
-       this information.  */
-    const char * record_gcc_switches_section;
+  /* Output an assembler directive to mark decl live. This instructs
+     linker to not dead code strip this symbol.  */
+  void (*mark_decl_preserved) (const char *);
 
-    /* Output the definition of a section anchor.  */
-    void (*output_anchor) (rtx);
+  /* Output a record of the command line switches that have been passed.  */
+  print_switch_fn_type record_gcc_switches;
+  /* The name of the section that the example ELF implementation of
+     record_gcc_switches will use to store the information.  Target
+     specific versions of record_gcc_switches may or may not use
+     this information.  */
+  const char * record_gcc_switches_section;
 
-    /* Output a DTP-relative reference to a TLS symbol.  */
-    void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
+  /* Output the definition of a section anchor.  */
+  void (*output_anchor) (rtx);
 
-  } asm_out;
+  /* Output a DTP-relative reference to a TLS symbol.  */
+  void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
+};
 
-  /* Functions relating to instruction scheduling.  */
-  struct sched
-  {
-    /* Given the current cost, COST, of an insn, INSN, calculate and
-       return a new cost based on its relationship to DEP_INSN through
-       the dependence LINK.  The default is to make no adjustment.  */
-    int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
+/* Functions relating to instruction scheduling.  */
+struct sched
+{
+  /* Given the current cost, COST, of an insn, INSN, calculate and
+     return a new cost based on its relationship to DEP_INSN through
+     the dependence LINK.  The default is to make no adjustment.  */
+  int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
 
-    /* Adjust the priority of an insn as you see fit.  Returns the new
-       priority.  */
-    int (* adjust_priority) (rtx, int);
+  /* Adjust the priority of an insn as you see fit.  Returns the new
+     priority.  */
+  int (* adjust_priority) (rtx, int);
 
-    /* Function which returns the maximum number of insns that can be
-       scheduled in the same machine cycle.  This must be constant
-       over an entire compilation.  The default is 1.  */
-    int (* issue_rate) (void);
+  /* Function which returns the maximum number of insns that can be
+     scheduled in the same machine cycle.  This must be constant
+     over an entire compilation.  The default is 1.  */
+  int (* issue_rate) (void);
 
-    /* Calculate how much this insn affects how many more insns we
-       can emit this cycle.  Default is they all cost the same.  */
-    int (* variable_issue) (FILE *, int, rtx, int);
+  /* Calculate how much this insn affects how many more insns we
+     can emit this cycle.  Default is they all cost the same.  */
+  int (* variable_issue) (FILE *, int, rtx, int);
 
-    /* Initialize machine-dependent scheduling code.  */
-    void (* md_init) (FILE *, int, int);
+  /* Initialize machine-dependent scheduling code.  */
+  void (* md_init) (FILE *, int, int);
 
-    /* Finalize machine-dependent scheduling code.  */
-    void (* md_finish) (FILE *, int);
+  /* Finalize machine-dependent scheduling code.  */
+  void (* md_finish) (FILE *, int);
 
-    /* Initialize machine-dependent function wide scheduling code.  */
-    void (* md_init_global) (FILE *, int, int);
+  /* Initialize machine-dependent function wide scheduling code.  */
+  void (* md_init_global) (FILE *, int, int);
 
-    /* Finalize machine-dependent function wide scheduling code.  */
-    void (* md_finish_global) (FILE *, int);
+  /* Finalize machine-dependent function wide scheduling code.  */
+  void (* md_finish_global) (FILE *, int);
 
-    /* Reorder insns in a machine-dependent fashion, in two different
-       places.  Default does nothing.  */
-    int (* reorder) (FILE *, int, rtx *, int *, int);
-    int (* reorder2) (FILE *, int, rtx *, int *, int);
+  /* Reorder insns in a machine-dependent fashion, in two different
+     places.  Default does nothing.  */
+  int (* reorder) (FILE *, int, rtx *, int *, int);
+  int (* reorder2) (FILE *, int, rtx *, int *, int);
 
-    /* The following member value is a pointer to a function called
-       after evaluation forward dependencies of insns in chain given
-       by two parameter values (head and tail correspondingly).  */
-    void (* dependencies_evaluation_hook) (rtx, rtx);
+  /* The following member value is a pointer to a function called
+     after evaluation forward dependencies of insns in chain given
+     by two parameter values (head and tail correspondingly).  */
+  void (* dependencies_evaluation_hook) (rtx, rtx);
 
-    /* The values of the following four members are pointers to
-       functions used to simplify the automaton descriptions.
-       dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
-       returning insns which are used to change the pipeline hazard
-       recognizer state when the new simulated processor cycle
-       correspondingly starts and finishes.  The function defined by
-       init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
-       to initialize the corresponding insns.  The default values of
-       the members result in not changing the automaton state when
-       the new simulated processor cycle correspondingly starts and
-       finishes.  */
-    void (* init_dfa_pre_cycle_insn) (void);
-    rtx (* dfa_pre_cycle_insn) (void);
-    void (* init_dfa_post_cycle_insn) (void);
-    rtx (* dfa_post_cycle_insn) (void);
+  /* The values of the following four members are pointers to
+     functions used to simplify the automaton descriptions.
+     dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
+     returning insns which are used to change the pipeline hazard
+     recognizer state when the new simulated processor cycle
+     correspondingly starts and finishes.  The function defined by
+     init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
+     to initialize the corresponding insns.  The default values of
+     the members result in not changing the automaton state when
+     the new simulated processor cycle correspondingly starts and
+     finishes.  */
+  void (* init_dfa_pre_cycle_insn) (void);
+  rtx (* dfa_pre_cycle_insn) (void);
+  void (* init_dfa_post_cycle_insn) (void);
+  rtx (* dfa_post_cycle_insn) (void);
 
-    /* The values of the following two members are pointers to
-       functions used to simplify the automaton descriptions.
-       dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
-       immediately before and after cycle is advanced.  */
-    void (* dfa_pre_advance_cycle) (void);
-    void (* dfa_post_advance_cycle) (void);
+  /* The values of the following two members are pointers to
+     functions used to simplify the automaton descriptions.
+     dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
+     immediately before and after cycle is advanced.  */
+  void (* dfa_pre_advance_cycle) (void);
+  void (* dfa_post_advance_cycle) (void);
 
-    /* The following member value is a pointer to a function returning value
-       which defines how many insns in queue `ready' will we try for
-       multi-pass scheduling.  If the member value is nonzero and the
-       function returns positive value, the DFA based scheduler will make
-       multi-pass scheduling for the first cycle.  In other words, we will
-       try to choose ready insn which permits to start maximum number of
-       insns on the same cycle.  */
-    int (* first_cycle_multipass_dfa_lookahead) (void);
+  /* The following member value is a pointer to a function returning value
+     which defines how many insns in queue `ready' will we try for
+     multi-pass scheduling.  If the member value is nonzero and the
+     function returns positive value, the DFA based scheduler will make
+     multi-pass scheduling for the first cycle.  In other words, we will
+     try to choose ready insn which permits to start maximum number of
+     insns on the same cycle.  */
+  int (* first_cycle_multipass_dfa_lookahead) (void);
 
-    /* The following member value is pointer to a function controlling
-       what insns from the ready insn queue will be considered for the
-       multipass insn scheduling.  If the hook returns zero for insn
-       passed as the parameter, the insn will be not chosen to be
-       issued.  */
-    int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
+  /* The following member value is pointer to a function controlling
+     what insns from the ready insn queue will be considered for the
+     multipass insn scheduling.  If the hook returns zero for insn
+     passed as the parameter, the insn will be not chosen to be
+     issued.  */
+  int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
 
-    /* The following member value is pointer to a function called by
-       the insn scheduler before issuing insn passed as the third
-       parameter on given cycle.  If the hook returns nonzero, the
-       insn is not issued on given processors cycle.  Instead of that,
-       the processor cycle is advanced.  If the value passed through
-       the last parameter is zero, the insn ready queue is not sorted
-       on the new cycle start as usually.  The first parameter passes
-       file for debugging output.  The second one passes the scheduler
-       verbose level of the debugging output.  The forth and the fifth
-       parameter values are correspondingly processor cycle on which
-       the previous insn has been issued and the current processor
-       cycle.  */
-    int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
+  /* The following member value is pointer to a function called by
+     the insn scheduler before issuing insn passed as the third
+     parameter on given cycle.  If the hook returns nonzero, the
+     insn is not issued on given processors cycle.  Instead of that,
+     the processor cycle is advanced.  If the value passed through
+     the last parameter is zero, the insn ready queue is not sorted
+     on the new cycle start as usually.  The first parameter passes
+     file for debugging output.  The second one passes the scheduler
+     verbose level of the debugging output.  The forth and the fifth
+     parameter values are correspondingly processor cycle on which
+     the previous insn has been issued and the current processor
+     cycle.  */
+  int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
 
-    /* The following member value is a pointer to a function called by the
-       insn scheduler.  It should return true if there exists a dependence
-       which is considered costly by the target, between the insn
-       DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP).  The first parameter is
-       the dep that represents the dependence between the two insns.  The
-       second argument is the cost of the dependence as estimated by
-       the scheduler.  The last argument is the distance in cycles
-       between the already scheduled insn (first parameter) and the
-       second insn (second parameter).  */
-    bool (* is_costly_dependence) (struct _dep *_dep, int, int);
+  /* The following member value is a pointer to a function called by the
+     insn scheduler.  It should return true if there exists a dependence
+     which is considered costly by the target, between the insn
+     DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP).  The first parameter is
+     the dep that represents the dependence between the two insns.  The
+     second argument is the cost of the dependence as estimated by
+     the scheduler.  The last argument is the distance in cycles
+     between the already scheduled insn (first parameter) and the
+     second insn (second parameter).  */
+  bool (* is_costly_dependence) (struct _dep *_dep, int, int);
 
-    /* Given the current cost, COST, of an insn, INSN, calculate and
-       return a new cost based on its relationship to DEP_INSN through the
-       dependence of type DEP_TYPE.  The default is to make no adjustment.  */
-    int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
+  /* Given the current cost, COST, of an insn, INSN, calculate and
+     return a new cost based on its relationship to DEP_INSN through the
+     dependence of type DEP_TYPE.  The default is to make no adjustment.  */
+  int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
 
-    /* The following member value is a pointer to a function called
-       by the insn scheduler. This hook is called to notify the backend
-       that new instructions were emitted.  */
-    void (* h_i_d_extended) (void);
+  /* The following member value is a pointer to a function called
+     by the insn scheduler. This hook is called to notify the backend
+     that new instructions were emitted.  */
+  void (* h_i_d_extended) (void);
 
-    /* Next 5 functions are for multi-point scheduling.  */
+  /* Next 5 functions are for multi-point scheduling.  */
 
-    /* Allocate memory for scheduler context.  */
-    void *(* alloc_sched_context) (void);
+  /* Allocate memory for scheduler context.  */
+  void *(* alloc_sched_context) (void);
 
-    /* Fills the context from the local machine scheduler context.  */
-    void (* init_sched_context) (void *, bool);
+  /* Fills the context from the local machine scheduler context.  */
+  void (* init_sched_context) (void *, bool);
 
-    /* Sets local machine scheduler context to a saved value.  */
-    void (* set_sched_context) (void *);
+  /* Sets local machine scheduler context to a saved value.  */
+  void (* set_sched_context) (void *);
 
-    /* Clears a scheduler context so it becomes like after init.  */
-    void (* clear_sched_context) (void *);
+  /* Clears a scheduler context so it becomes like after init.  */
+  void (* clear_sched_context) (void *);
 
-    /* Frees the scheduler context.  */
-    void (* free_sched_context) (void *);
+  /* Frees the scheduler context.  */
+  void (* free_sched_context) (void *);
 
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.
-       The first parameter is an instruction, the second parameter is the type
-       of the requested speculation, and the third parameter is a pointer to the
-       speculative pattern of the corresponding type (set if return value == 1).
-       It should return
-       -1, if there is no pattern, that will satisfy the requested speculation
-       type,
-       0, if current pattern satisfies the requested speculation type,
-       1, if pattern of the instruction should be changed to the newly
-       generated one.  */
-    int (* speculate_insn) (rtx, int, rtx *);
+  /* The following member value is a pointer to a function called
+     by the insn scheduler.
+     The first parameter is an instruction, the second parameter is the type
+     of the requested speculation, and the third parameter is a pointer to the
+     speculative pattern of the corresponding type (set if return value == 1).
+     It should return
+     -1, if there is no pattern, that will satisfy the requested speculation
+     type,
+     0, if current pattern satisfies the requested speculation type,
+     1, if pattern of the instruction should be changed to the newly
+     generated one.  */
+  int (* speculate_insn) (rtx, int, rtx *);
 
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.  It should return true if the check instruction
-       passed as the parameter needs a recovery block.  */
-    bool (* needs_block_p) (const_rtx);
+  /* The following member value is a pointer to a function called
+     by the insn scheduler.  It should return true if the check instruction
+     passed as the parameter needs a recovery block.  */
+  bool (* needs_block_p) (const_rtx);
 
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.  It should return a pattern for the check
-       instruction.
-       The first parameter is a speculative instruction, the second parameter
-       is the label of the corresponding recovery block (or null, if it is a
-       simple check).  If the mutation of the check is requested (e.g. from
-       ld.c to chk.a), the third parameter is true - in this case the first
-       parameter is the previous check.  */
-    rtx (* gen_spec_check) (rtx, rtx, bool);
+  /* The following member value is a pointer to a function called
+     by the insn scheduler.  It should return a pattern for the check
+     instruction.
+     The first parameter is a speculative instruction, the second parameter
+     is the label of the corresponding recovery block (or null, if it is a
+     simple check).  If the mutation of the check is requested (e.g. from
+     ld.c to chk.a), the third parameter is true - in this case the first
+     parameter is the previous check.  */
+  rtx (* gen_spec_check) (rtx, rtx, bool);
 
-    /* The following member value is a pointer to a function controlling
-       what insns from the ready insn queue will be considered for the
-       multipass insn scheduling.  If the hook returns zero for the insn
-       passed as the parameter, the insn will not be chosen to be
-       issued.  This hook is used to discard speculative instructions,
-       that stand at the first position of the ready list.  */
-    bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
+  /* The following member value is a pointer to a function controlling
+     what insns from the ready insn queue will be considered for the
+     multipass insn scheduling.  If the hook returns zero for the insn
+     passed as the parameter, the insn will not be chosen to be
+     issued.  This hook is used to discard speculative instructions,
+     that stand at the first position of the ready list.  */
+  bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
 
-    /* The following member value is a pointer to a function that provides
-       information about the speculation capabilities of the target.
-       The parameter is a pointer to spec_info variable.  */
-    void (* set_sched_flags) (struct spec_info_def *);
+  /* The following member value is a pointer to a function that provides
+     information about the speculation capabilities of the target.
+     The parameter is a pointer to spec_info variable.  */
+  void (* set_sched_flags) (struct spec_info_def *);
 
-    /* Return speculation types of the instruction passed as the parameter.  */
-    int (* get_insn_spec_ds) (rtx);
+  /* Return speculation types of the instruction passed as the parameter.  */
+  int (* get_insn_spec_ds) (rtx);
 
-    /* Return speculation types that are checked for the instruction passed as
-       the parameter.  */
-    int (* get_insn_checked_ds) (rtx);
+  /* Return speculation types that are checked for the instruction passed as
+     the parameter.  */
+  int (* get_insn_checked_ds) (rtx);
 
-    /* Return bool if rtx scanning should just skip current layer and
-       advance to the inner rtxes.  */
-    bool (* skip_rtx_p) (const_rtx);
+  /* Return bool if rtx scanning should just skip current layer and
+     advance to the inner rtxes.  */
+  bool (* skip_rtx_p) (const_rtx);
 
-    /* The following member value is a pointer to a function that provides
-       information about the target resource-based lower bound which is
-       used by the swing modulo scheduler.  The parameter is a pointer
-       to ddg variable.  */
-    int (* sms_res_mii) (struct ddg *);
-  } sched;
+  /* The following member value is a pointer to a function that provides
+     information about the target resource-based lower bound which is
+     used by the swing modulo scheduler.  The parameter is a pointer
+     to ddg variable.  */
+  int (* sms_res_mii) (struct ddg *);
+};
 
-  /* Functions relating to vectorization.  */
-  struct vectorize
-  {
-    /* The following member value is a pointer to a function called
-       by the vectorizer, and return the decl of the target builtin
-       function.  */
-    tree (* builtin_mask_for_load) (void);
+/* Functions relating to vectorization.  */
+struct vectorize
+{
+  /* The following member value is a pointer to a function called
+     by the vectorizer, and return the decl of the target builtin
+     function.  */
+  tree (* builtin_mask_for_load) (void);
 
-    /* Returns a code for builtin that realizes vectorized version of
-       function, or NULL_TREE if not available.  */
-    tree (* builtin_vectorized_function) (unsigned, tree, tree);
+  /* Returns a code for builtin that realizes vectorized version of
+     function, or NULL_TREE if not available.  */
+  tree (* builtin_vectorized_function) (unsigned, tree, tree);
 
-    /* Returns a code for builtin that realizes vectorized version of
-       conversion, or NULL_TREE if not available.  */
-    tree (* builtin_conversion) (unsigned, tree);
+  /* Returns a code for builtin that realizes vectorized version of
+     conversion, or NULL_TREE if not available.  */
+  tree (* builtin_conversion) (unsigned, tree);
 
-    /* Target builtin that implements vector widening multiplication.
-       builtin_mul_widen_eve computes the element-by-element products 
-       for the even elements, and builtin_mul_widen_odd computes the
-       element-by-element products for the odd elements.  */
-    tree (* builtin_mul_widen_even) (tree);
-    tree (* builtin_mul_widen_odd) (tree);
+  /* Target builtin that implements vector widening multiplication.
+     builtin_mul_widen_eve computes the element-by-element products 
+     for the even elements, and builtin_mul_widen_odd computes the
+     element-by-element products for the odd elements.  */
+  tree (* builtin_mul_widen_even) (tree);
+  tree (* builtin_mul_widen_odd) (tree);
 
-    /* Returns the cost to be added to the overheads involved with
-       executing the vectorized version of a loop.  */
-    int (*builtin_vectorization_cost) (bool);
+  /* Returns the cost to be added to the overheads involved with
+     executing the vectorized version of a loop.  */
+  int (*builtin_vectorization_cost) (bool);
 
-    /* Return true if vector alignment is reachable (by peeling N
-       iterations) for the given type.  */
-    bool (* vector_alignment_reachable) (const_tree, bool);
+  /* Return true if vector alignment is reachable (by peeling N
+     iterations) for the given type.  */
+  bool (* vector_alignment_reachable) (const_tree, bool);
 
-    /* Target builtin that implements vector permute.  */
-    tree (* builtin_vec_perm) (tree, tree*);
-} vectorize;
+  /* Target builtin that implements vector permute.  */
+  tree (* builtin_vec_perm) (tree, tree*);
+};
 
+/* Functions relating to calls - argument passing, returns, etc.  */
+struct calls
+{
+  bool (*promote_function_args) (const_tree fntype);
+  bool (*promote_function_return) (const_tree fntype);
+  bool (*promote_prototypes) (const_tree fntype);
+  rtx (*struct_value_rtx) (tree fndecl, int incoming);
+  bool (*return_in_memory) (const_tree type, const_tree fndecl);
+  bool (*return_in_msb) (const_tree type);
+
+  /* Return true if a parameter must be passed by reference.  TYPE may
+     be null if this is a libcall.  CA may be null if this query is
+     from __builtin_va_arg.  */
+  bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+			     const_tree type, bool named_arg);
+
+  rtx (*expand_builtin_saveregs) (void);
+  /* Returns pretend_argument_size.  */
+  void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+				  tree type, int *pretend_arg_size,
+				  int second_time);
+  bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
+  /* Returns true if we should use
+     targetm.calls.setup_incoming_varargs() and/or
+     targetm.calls.strict_argument_naming().  */
+  bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
+
+  /* Given a complex type T, return true if a parameter of type T
+     should be passed as two scalars.  */
+  bool (* split_complex_arg) (const_tree type);
+
+  /* Return true if type T, mode MODE, may not be passed in registers,
+     but must be passed on the stack.  */
+  /* ??? This predicate should be applied strictly after pass-by-reference.
+     Need audit to verify that this is the case.  */
+  bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
+
+  /* Return true if type TYPE, mode MODE, which is passed by reference,
+     should have the object copy generated by the callee rather than
+     the caller.  It is never called for TYPE requiring constructors.  */
+  bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+			  const_tree type, bool named);
+
+  /* Return zero for arguments passed entirely on the stack or entirely
+     in registers.  If passed in both, return the number of bytes passed
+     in registers; the balance is therefore passed on the stack.  */
+  int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+			     tree type, bool named);
+
+  /* Return the diagnostic message string if function without a prototype
+     is not allowed for this 'val' argument; NULL otherwise. */
+  const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
+						  const_tree funcdecl,
+						  const_tree val);
+
+  /* Return an rtx for the return value location of the function
+     specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
+  rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
+			 bool outgoing);
+
+  /* Return an rtx for the argument pointer incoming to the
+     current function.  */
+  rtx (*internal_arg_pointer) (void);
+
+  /* Update the current function stack boundary if needed.  */
+  void (*update_stack_boundary) (void);
+
+  /* Handle stack alignment and return an rtx for Dynamic Realign
+     Argument Pointer if necessary.  */
+  rtx (*get_drap_rtx) (void);
+
+  /* Return true if all function parameters should be spilled to the
+     stack.  */
+  bool (*allocate_stack_slots_for_args) (void);
+    
+};
+
+/* Functions specific to the C family of frontends.  */
+struct c
+{
+  /* Return machine mode for non-standard suffix
+     or VOIDmode if non-standard suffixes are unsupported.  */
+  enum machine_mode (*mode_for_suffix) (char);
+};
+
+/* Functions specific to the C++ frontend.  */
+struct cxx
+{
+  /* Return the integer type used for guard variables.  */
+  tree (*guard_type) (void);
+  /* Return true if only the low bit of the guard should be tested.  */
+  bool (*guard_mask_bit) (void);
+  /* Returns the size of the array cookie for an array of type.  */
+  tree (*get_cookie_size) (tree);
+  /* Returns true if the element size should be stored in the
+     array cookie.  */
+  bool (*cookie_has_size) (void);
+  /* Allows backends to perform additional processing when
+     deciding if a class should be exported or imported.  */
+  int (*import_export_class) (tree, int);
+  /* Returns true if constructors and destructors return "this".  */
+  bool (*cdtor_returns_this) (void);
+  /* Returns true if the key method for a class can be an inline
+     function, so long as it is not declared inline in the class
+     itself.  Returning true is the behavior required by the Itanium
+     C++ ABI.  */
+  bool (*key_method_may_be_inline) (void);
+  /* DECL is a virtual table, virtual table table, typeinfo object,
+     or other similar implicit class data object that will be
+     emitted with external linkage in this translation unit.  No ELF
+     visibility has been explicitly specified.  If the target needs
+     to specify a visibility other than that of the containing class,
+     use this hook to set DECL_VISIBILITY and
+     DECL_VISIBILITY_SPECIFIED.  */
+  void (*determine_class_data_visibility) (tree decl);
+  /* Returns true (the default) if virtual tables and other
+     similar implicit class data objects are always COMDAT if they
+     have external linkage.  If this hook returns false, then
+     class data for classes whose virtual table will be emitted in
+     only one translation unit will not be COMDAT.  */
+  bool (*class_data_always_comdat) (void);
+  /* Returns true (the default) if the RTTI for the basic types,
+     which is always defined in the C++ runtime, should be COMDAT;
+     false if it should not be COMDAT.  */
+  bool (*library_rtti_comdat) (void);
+  /* Returns true if __aeabi_atexit should be used to register static
+     destructors.  */
+  bool (*use_aeabi_atexit) (void);
+  /* Returns true if target may use atexit in the same manner as
+     __cxa_atexit  to register static destructors.  */
+  bool (*use_atexit_for_cxa_atexit) (void);
+  /* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
+     has just been defined.  Use this hook to make adjustments to the
+     class  (eg, tweak visibility or perform any other required
+     target modifications).  */
+  void (*adjust_class_at_definition) (tree type);
+};
+
+/* Functions and data for emulated TLS support.  */
+struct emutls
+{
+  /* Name of the address and common functions.  */
+  const char *get_address;
+  const char *register_common;
+
+  /* Prefixes for proxy variable and template.  */
+  const char *var_section;
+  const char *tmpl_section;
+
+  /* Prefixes for proxy variable and template.  */
+  const char *var_prefix;
+  const char *tmpl_prefix;
+    
+  /* Function to generate field definitions of the proxy variable.  */
+  tree (*var_fields) (tree, tree *);
+
+  /* Function to initialize a proxy variable.  */
+  tree (*var_init) (tree, tree, tree);
+
+  /* Whether we are allowed to alter the usual alignment of the
+     proxy variable.  */
+  bool var_align_fixed;
+
+  /* Whether we can emit debug information for TLS vars.  */
+  bool debug_form_tls_address;
+};
+
+struct target_option_hooks
+{
+  /* Function to validate the attribute((option(...))) strings or NULL.  If
+     the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
+     be filled in in the function decl node.  */
+  bool (*valid_attribute_p) (tree, tree, tree, int);
+
+  /* Function to save any extra target state in the target options
+     structure.  */
+  void (*save) (struct cl_target_option *);
+
+  /* Function to restore any extra target state from the target options
+     structure.  */
+  void (*restore) (struct cl_target_option *);
+
+  /* Function to print any extra target state from the target options
+     structure.  */
+  void (*print) (FILE *, int, struct cl_target_option *);
+
+  /* Function to parse arguments to be validated for #pragma option, and to
+     change the state if the options are valid.  If the first argument is
+     NULL, the second argument specifies the default options to use.  Return
+     true if the options are valid, and set the current state.  */
+  bool (*pragma_parse) (tree, tree);
+
+  /* Function to determine if one function can inline another function.  */
+  bool (*can_inline_p) (tree, tree);
+};
+
+struct gcc_target
+{
+  /* Functions that output assembler for the target.  */
+  struct asm_out asm_out;
+
+  /* Functions relating to instruction scheduling.  */
+  struct sched sched;
+
+  /* Functions relating to vectorization.  */
+  struct vectorize vectorize;
+
   /* The initial value of target_flags.  */
   int default_target_flags;
 
@@ -812,81 +1019,8 @@
   bool (* valid_dllimport_attribute_p) (const_tree decl);
 
   /* Functions relating to calls - argument passing, returns, etc.  */
-  struct calls {
-    bool (*promote_function_args) (const_tree fntype);
-    bool (*promote_function_return) (const_tree fntype);
-    bool (*promote_prototypes) (const_tree fntype);
-    rtx (*struct_value_rtx) (tree fndecl, int incoming);
-    bool (*return_in_memory) (const_tree type, const_tree fndecl);
-    bool (*return_in_msb) (const_tree type);
+  struct calls calls;
 
-    /* Return true if a parameter must be passed by reference.  TYPE may
-       be null if this is a libcall.  CA may be null if this query is
-       from __builtin_va_arg.  */
-    bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			       const_tree type, bool named_arg);
-
-    rtx (*expand_builtin_saveregs) (void);
-    /* Returns pretend_argument_size.  */
-    void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-				    tree type, int *pretend_arg_size,
-				    int second_time);
-    bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
-    /* Returns true if we should use
-       targetm.calls.setup_incoming_varargs() and/or
-       targetm.calls.strict_argument_naming().  */
-    bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
-
-    /* Given a complex type T, return true if a parameter of type T
-       should be passed as two scalars.  */
-    bool (* split_complex_arg) (const_tree type);
-
-    /* Return true if type T, mode MODE, may not be passed in registers,
-       but must be passed on the stack.  */
-    /* ??? This predicate should be applied strictly after pass-by-reference.
-       Need audit to verify that this is the case.  */
-    bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
-
-    /* Return true if type TYPE, mode MODE, which is passed by reference,
-       should have the object copy generated by the callee rather than
-       the caller.  It is never called for TYPE requiring constructors.  */
-    bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			    const_tree type, bool named);
-
-    /* Return zero for arguments passed entirely on the stack or entirely
-       in registers.  If passed in both, return the number of bytes passed
-       in registers; the balance is therefore passed on the stack.  */
-    int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			       tree type, bool named);
-
-    /* Return the diagnostic message string if function without a prototype
-       is not allowed for this 'val' argument; NULL otherwise. */
-    const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
-					     	    const_tree funcdecl,
-						    const_tree val);
-
-    /* Return an rtx for the return value location of the function
-       specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
-    rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
-			   bool outgoing);
-
-    /* Return an rtx for the argument pointer incoming to the
-       current function.  */
-    rtx (*internal_arg_pointer) (void);
-
-    /* Update the current function stack boundary if needed.  */
-    void (*update_stack_boundary) (void);
-
-    /* Handle stack alignment and return an rtx for Dynamic Realign
-       Argument Pointer if necessary.  */
-    rtx (*get_drap_rtx) (void);
-
-    /* Return true if all function parameters should be spilled to the
-       stack.  */
-    bool (*allocate_stack_slots_for_args) (void);
-    
-  } calls;
-
   /* Return the diagnostic message string if conversion from FROMTYPE
      to TOTYPE is not allowed, NULL otherwise.  */
   const char *(*invalid_conversion) (const_tree fromtype, const_tree totype);
@@ -918,120 +1052,16 @@
   bool (* hard_regno_scratch_ok) (unsigned int regno);
 
   /* Functions specific to the C family of frontends.  */
-  struct c {
-    /* Return machine mode for non-standard suffix
-       or VOIDmode if non-standard suffixes are unsupported.  */
-    enum machine_mode (*mode_for_suffix) (char);
-  } c;
+  struct c c;
 
   /* Functions specific to the C++ frontend.  */
-  struct cxx {
-    /* Return the integer type used for guard variables.  */
-    tree (*guard_type) (void);
-    /* Return true if only the low bit of the guard should be tested.  */
-    bool (*guard_mask_bit) (void);
-    /* Returns the size of the array cookie for an array of type.  */
-    tree (*get_cookie_size) (tree);
-    /* Returns true if the element size should be stored in the
-       array cookie.  */
-    bool (*cookie_has_size) (void);
-    /* Allows backends to perform additional processing when
-       deciding if a class should be exported or imported.  */
-    int (*import_export_class) (tree, int);
-    /* Returns true if constructors and destructors return "this".  */
-    bool (*cdtor_returns_this) (void);
-    /* Returns true if the key method for a class can be an inline
-       function, so long as it is not declared inline in the class
-       itself.  Returning true is the behavior required by the Itanium
-       C++ ABI.  */
-    bool (*key_method_may_be_inline) (void);
-    /* DECL is a virtual table, virtual table table, typeinfo object,
-       or other similar implicit class data object that will be
-       emitted with external linkage in this translation unit.  No ELF
-       visibility has been explicitly specified.  If the target needs
-       to specify a visibility other than that of the containing class,
-       use this hook to set DECL_VISIBILITY and
-       DECL_VISIBILITY_SPECIFIED.  */
-    void (*determine_class_data_visibility) (tree decl);
-    /* Returns true (the default) if virtual tables and other
-       similar implicit class data objects are always COMDAT if they
-       have external linkage.  If this hook returns false, then
-       class data for classes whose virtual table will be emitted in
-       only one translation unit will not be COMDAT.  */
-    bool (*class_data_always_comdat) (void);
-    /* Returns true (the default) if the RTTI for the basic types,
-       which is always defined in the C++ runtime, should be COMDAT;
-       false if it should not be COMDAT.  */
-    bool (*library_rtti_comdat) (void);
-    /* Returns true if __aeabi_atexit should be used to register static
-       destructors.  */
-    bool (*use_aeabi_atexit) (void);
-    /* Returns true if target may use atexit in the same manner as
-    __cxa_atexit  to register static destructors.  */
-    bool (*use_atexit_for_cxa_atexit) (void);
-    /* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
-       has just been defined.  Use this hook to make adjustments to the
-       class  (eg, tweak visibility or perform any other required
-       target modifications).  */
-    void (*adjust_class_at_definition) (tree type);
-  } cxx;
+  struct cxx cxx;
 
   /* Functions and data for emulated TLS support.  */
-  struct emutls {
-    /* Name of the address and common functions.  */
-    const char *get_address;
-    const char *register_common;
+  struct emutls emutls;
 
-    /* Prefixes for proxy variable and template.  */
-    const char *var_section;
-    const char *tmpl_section;
+  struct target_option_hooks target_option;
 
-    /* Prefixes for proxy variable and template.  */
-    const char *var_prefix;
-    const char *tmpl_prefix;
-    
-    /* Function to generate field definitions of the proxy variable.  */
-    tree (*var_fields) (tree, tree *);
-
-    /* Function to initialize a proxy variable.  */
-    tree (*var_init) (tree, tree, tree);
-
-    /* Whether we are allowed to alter the usual alignment of the
-       proxy variable.  */
-    bool var_align_fixed;
-
-    /* Whether we can emit debug information for TLS vars.  */
-    bool debug_form_tls_address;
-  } emutls;  
-
-  struct target_option_hooks {
-    /* Function to validate the attribute((option(...))) strings or NULL.  If
-       the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
-       be filled in in the function decl node.  */
-    bool (*valid_attribute_p) (tree, tree, tree, int);
-
-    /* Function to save any extra target state in the target options
-       structure.  */
-    void (*save) (struct cl_target_option *);
-
-    /* Function to restore any extra target state from the target options
-       structure.  */
-    void (*restore) (struct cl_target_option *);
-
-    /* Function to print any extra target state from the target options
-       structure.  */
-    void (*print) (FILE *, int, struct cl_target_option *);
-
-    /* Function to parse arguments to be validated for #pragma option, and to
-       change the state if the options are valid.  If the first argument is
-       NULL, the second argument specifies the default options to use.  Return
-       true if the options are valid, and set the current state.  */
-    bool (*pragma_parse) (tree, tree);
-
-    /* Function to determine if one function can inline another function.  */
-    bool (*can_inline_p) (tree, tree);
-  } target_option;
-
   /* For targets that need to mark extra registers as live on entry to
      the function, they should define this target hook and set their
      bits in the bitmap passed in. */  
Index: cse.c
===================================================================
--- cse.c	(revision 140884)
+++ cse.c	(working copy)
@@ -1,6 +1,6 @@
 /* Common subexpression elimination for GNU compiler.
    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
-   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
    Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -517,6 +517,12 @@
 static int constant_pool_entries_cost;
 static int constant_pool_entries_regcost;
 
+struct branch_path
+{
+  /* The basic block for this path entry.  */
+  basic_block bb;
+};
+
 /* This data describes a block that will be processed by
    cse_extended_basic_block.  */
 
@@ -527,11 +533,7 @@
   /* Size of current branch path, if any.  */
   int path_size;
   /* Current path, indicating which basic_blocks will be processed.  */
-  struct branch_path
-    {
-      /* The basic block for this path entry.  */
-      basic_block bb;
-    } *path;
+  struct branch_path *path;
 };
 
 
Index: matrix-reorg.c
===================================================================
--- matrix-reorg.c	(revision 140884)
+++ matrix-reorg.c	(working copy)
@@ -245,6 +245,13 @@
 DEF_VEC_P (access_site_info_p);
 DEF_VEC_ALLOC_P (access_site_info_p, heap);
 
+/* See 'free_stmts' in struct matrix_info.  */
+struct free_info
+{
+  gimple stmt;
+  tree func;
+};
+
 /* Information about matrix to flatten.  */
 struct matrix_info
 {
@@ -277,11 +284,7 @@
   tree allocation_function_decl;
 
   /* The calls to free for each level of indirection.  */
-  struct free_info
-  {
-    gimple stmt;
-    tree func;
-  } *free_stmts;
+  struct free_info *free_stmts;
 
   /* An array which holds for each dimension its size. where
      dimension 0 is the outer most (one that contains all the others).
Index: tree-eh.c
===================================================================
--- tree-eh.c	(revision 140884)
+++ tree-eh.c	(working copy)
@@ -360,6 +360,18 @@
   struct leh_tf_state *tf;
 };
 
+/* See 'goto_queue' in struct leh_tf_state.  */
+struct goto_queue_node
+{
+  treemple stmt;
+  gimple_seq repl_stmt;
+  gimple cont_stmt;
+  int index;
+  /* this is used when index >= 0 to indicate that stmt is a label(as
+     opposed to a goto stmt) */
+  int is_label;
+};
+
 struct leh_tf_state
 {
   /* Pointer to the GIMPLE_TRY_FINALLY node under discussion.  The
@@ -386,15 +398,7 @@
      REPL_STMT is the sequence used to replace the goto/return statement.
      CONT_STMT is used to store the statement that allows the return/goto to
      jump to the original destination. */
-  struct goto_queue_node {
-    treemple stmt;
-    gimple_seq repl_stmt;
-    gimple cont_stmt;
-    int index;
-    /* this is used when index >= 0 to indicate that stmt is a label(as
-       opposed to a goto stmt) */
-    int is_label;
-  } *goto_queue;
+  struct goto_queue_node *goto_queue;
   size_t goto_queue_size;
   size_t goto_queue_active;
 
Index: sched-int.h
===================================================================
--- sched-int.h	(revision 140884)
+++ sched-int.h	(working copy)
@@ -1,7 +1,7 @@
 /* Instruction scheduling pass.  This file contains definitions used
    internally in the scheduler.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   2001, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -425,6 +425,25 @@
   TRUE_BARRIER
 };
 
+/* See 'reg_last' in struct deps.  */
+struct deps_reg
+{
+  rtx uses;
+  rtx sets;
+  rtx clobbers;
+  int uses_length;
+  int clobbers_length;
+};
+
+/* Used to keep post-call pseudo/hard reg movements together with
+   the call.  */
+enum post_call_value
+{
+  not_post_call,
+  post_call,
+  post_call_initial
+};
+
 /* Describe state of dependencies used during sched_analyze phase.  */
 struct deps
 {
@@ -488,7 +507,7 @@
 
   /* Used to keep post-call pseudo/hard reg movements together with
      the call.  */
-  enum { not_post_call, post_call, post_call_initial } in_post_call_group_p;
+  enum post_call_value in_post_call_group_p;
 
   /* The maximum register number for the following arrays.  Before reload
      this is max_reg_num; after reload it is FIRST_PSEUDO_REGISTER.  */
@@ -498,14 +517,7 @@
      N within the current basic block; or zero, if there is no
      such insn.  Needed for new registers which may be introduced
      by splitting insns.  */
-  struct deps_reg
-    {
-      rtx uses;
-      rtx sets;
-      rtx clobbers;
-      int uses_length;
-      int clobbers_length;
-    } *reg_last;
+  struct deps_reg *reg_last;
 
   /* Element N is set for each register that has any nonzero element
      in reg_last[N].{uses,sets,clobbers}.  */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]