diff mbox

RFA: remove tm.h include from function.h

Message ID 20101125211500.9w4za3yf40swgw8o-nzlynne@webmail.spamcop.net
State New
Headers show

Commit Message

Joern Rennecke Nov. 26, 2010, 2:15 a.m. UTC 
This patch removes the tm.h include from function.h
The target dependent stuff from x_rtl is moved to the new struct  
variable x_tm_rtl.
Some files have been exposed clandestinely using tm.h without including it
directly.
I generate a new header file, tm-holdover.h, for BITS_PER_UNIT.
This can be used instead of tm.h if all other macros from tm.h are gone
in a source file.

With the patches for PR46500 and PR46623,
bootstrapped on i686-pc-linux-gnu, and cross-tested for:
alpha-linux-gnu hppa-linux-gnu mips-elf sh-elf arc-elf ia64-elf  
mmix-knuth-mmixware sparc-elf arm-eabi iq2000-elf mn10300-elf spu-elf  
avr-elf lm32-elf moxie-elf v850-elf bfin-elf m32c-elf pdp11-aout  
vax-linux-gnu cris-elf m32r-elf picochip-elf xstormy16-elf crx-elf  
m68hc11-elf ppc-elf xtensa-elf fr30-elf m68k-elf rx-elf frv-elf  
mcore-elf s390-linux-gnu h8300-elf mep-elf score-elf microblaze-elf ,

then back-ported to current trunk and re-bootstrapped & regtested
for i686-pc-linux-gnu.
2010-11-26  Joern Rennecke  <amylaar@spamcop.net>

	PR middle-end/46495
gcc/java:
	* class.c: Move include up tm.h before tree.h, and update comment.
	* decl.c: Include tm.h .
	* jcf-parse.c: Likewise.
	* Make-lang.in (java/jcf-parse.o): Depend on $(TM_H)
gcc:
	* tree-emutls.c: Include tm-holdover.h .
	* tree-affine.c: Likewise.
	* expr.c (expand_expr_real_1): Use ctmrtl.
	* function.c (free_after_compilation, assign_parms): Likewise.
	* ira.c (compute_regs_asm_clobbered): Likewise.
	(ira_setup_eliminable_regset): Likewise.
	* function.h: Don't include tm.h .
	Make include of hard-reg-set.h dependent on GCC_TM_H .
	(struct incoming_args): Remove info member.
	(struct rtl_data): Remove asm_clobbers member.
	[GCC_TM_H]: (struct rtl_tm_data): New struct tag.
	(x_tm_rtl): Declare.
	(ctmrtl): Define.
	[!GCC_TM_H] (pass_by_reference, reference_callee_copied): Don't declare.
	* emit-rtl.c (x_tm_rtl): Define.
	* ipa-prop.c: Include tm.h .
	* Makefile.in (tree-affine.o): Depend on tm-holdover.h .
	(tree-emutls.o): Likewise.
	(tm-holdover.h, s-holdover): New rules.
	* config/alpha/alpha.c (NUM_ARGS): Use ctmrtl.
	* config/frv/frv.c (frv_expand_builtin_va_start): Likewise.
	* config/s390/s390.c (s390_register_info): Likewise.
	(s390_build_builtin_va_list, s390_va_start): Likewise.
	* config/spu/spu.c (spu_build_builtin_va_list): Likewise.
	* config/sparc/sparc.c (sparc_builtin_saveregs): Likewise.
	* config/i386/i386.c (ix86_va_start): Likewise.
	* config/sh/sh.c (calc_live_regs, sh_expand_prologue): Likewise.
	(sh_expand_epilogue, sh_builtin_saveregs, sh_va_start): Likewise.
	(initial_elimination_offset, sh_allocate_initial_value): Likewise.
	(sh_allocate_initial_value, sh_function_ok_for_sibcall): Likewise.
	* config/sh/sh.md (return, return_i, shcompact_return_tramp): Likewise.
	(shcompact_return_tramp_i): Likewise.
	* config/avr/avr.c (avr_frame_pointer_required_): Likewise.
	* config/xtensa/xtensa.c (xtensa_builtin_saveregs): Likewise.
	(xtensa_va_start, order_regs_for_local_alloc): Likewise.
	* config/stormy16/stormy16.c (xstormy16_expand_builtin_va_start):
	Likewise.
	* config/m68hc11/m68hc11.c (expand_prologue): Likewise.
	* config/iq2000/iq2000.c (iq2000_va_start): Likewise.
	* config/ia64/ia64.c (ia64_expand_prologue): Likewise.
	* config/rs6000/rs6000.c (rs6000_va_start): Likewise.
	(compute_vrsave_mask): Likewise.
	* config/arc/arc.c (arc_va_start): Likewise.
	* config/arm/arm.c (thumb_find_work_register): Likewise.
	* config/mips/mips.c (mips_va_start): Likewise.
	(mips16_build_function_stub, mips_output_function_prologue): Likewise.
	* config/mmix/mmix.c (mmix_reorg): Likewise.
gcc/fortran:
	* f95-lang.c: Include tm.h before tree.h .

Comments

Joseph Myers Nov. 26, 2010, 2:49 a.m. UTC | #1 
On Thu, 25 Nov 2010, Joern Rennecke wrote:

> I generate a new header file, tm-holdover.h, for BITS_PER_UNIT.

Creating the file through grep is a really ugly way of doing things.

There's a case for having multiple tm.h variants for different uses.  For 
example, completing the toplevel libgcc transition will involve some 
headers in libgcc/config for those cases where target macros really are 
appropriate rather than built-in macros and functions and other similar 
approaches.  And when the driver starts to use a target structure, the 
macros filling in that structure will probably continue to go in headers 
(given that they tend to depend on both target OS and target architecture, 
unlike many macros in the core compiler) but it would be good to have a 
separation of those relevant to the driver from those relevant to the rest 
of the compiler - a driver/config/ tree, say.  (This is certainly 
nontrivial; many specs depend on other macros defined in tm.h.)

But doing things through grep isn't reliable (macros may be conditionally 
defined or defined over more than one line) and doesn't achieve logical 
separation of the different areas of compiler configuration.  If there is 
a set of macros you believe are appropriately defined for files in the 
compiler that should not use other macros, work out a logical way to tell 
whether a macro is in that class, then create a separate set of 
configuration headers for them in the source tree.

Such changes should *definitely* not be mixed in with any other patch like 
you have done here.  Regarding the main aim of the present patch, my only 
comment is that splitting up function.h into two separate headers would 
seem cleaner than making what it declares depend on what headers have been 
included first - but at least for CUMULATIVE_ARGS it would be better to 
remove all variables and fields of that type from target-independent code, 
instead using a target-independent type and having targets responsible in 
some way for allocating and deallocating values of that type.
Joern Rennecke Nov. 26, 2010, 4 a.m. UTC | #2 
Quoting "Joseph S. Myers" <joseph@codesourcery.com>:

> On Thu, 25 Nov 2010, Joern Rennecke wrote:
>
>> I generate a new header file, tm-holdover.h, for BITS_PER_UNIT.
>
> Creating the file through grep is a really ugly way of doing things.

I think it is practically superior to including tm.h in a C file and then
emitting BITS_PER_UNIT with a printf.  Consider the case when you have
#define BITS_PER_UNIT (TARGET_64BIT ? 1 : 32)

Then if the generator file compiles at all it would emit a constant;
OTOH the grep statement does the right thing.
We could use a more sophisticated solution with assigning a string - to
be interpreted as a C expression in config,gcc, or by actually parsing
all the include files.
But considering that the few targets the define BITS_PER_UNIT define it
as 8, that would seem over-engineering to me.

> There's a case for having multiple tm.h variants for different uses.  For
> example, completing the toplevel libgcc transition will involve some
> headers in libgcc/config for those cases where target macros really are
> appropriate rather than built-in macros and functions and other similar
> approaches.

Would that then be macros that would be available to user programs via
an installed header file?
Or are you talking about ways to identify the build time or other
circumstances of building the package?
Otherwise, I'm at a loss why the libgcc should be able to do things that
user code couldn't do.

> And when the driver starts to use a target structure, the
> macros filling in that structure will probably continue to go in headers
> (given that they tend to depend on both target OS and target architecture,
> unlike many macros in the core compiler) but it would be good to have a
> separation of those relevant to the driver from those relevant to the rest
> of the compiler - a driver/config/ tree, say.  (This is certainly
> nontrivial; many specs depend on other macros defined in tm.h.)

> But doing things through grep isn't reliable (macros may be conditionally
> defined or defined over more than one line)

If the macro goes over more than one line, that is an indicator that it
should be considered if it would be better made into a hook.
Certainly BITS_PER_UNIT is quite far from that.

> and doesn't achieve logical separation of the different areas of  
> compiler configuration.  If there is
> a set of macros you believe are appropriately defined for files in the
> compiler that should not use other macros, work out a logical way to tell
> whether a macro is in that class,

It wasn't my idea to leave BITS_PER_UNIT exposed to the entirety of the
compiler, it was Richard Guenther's.

What I'm saying is that I can make a multi-target compiler for an interesting
subset of possible configurations work with BITS_PER_UNIT as a macro.
Also, target-agnostic frontend / tree-optimizer plugins would still be
useful because so many target share the same constant value of BITS_PER_UNIT.
But having the frontends include tm.h for the purpose of getting
BITS_PER_UNIT makes it pretty much impossible to tell if there are any
other target macros in use there.  Witness the include in java/class.c
that continued to claim to be there for the sake of gcc_obstack_init,
even though that macro was long since moved to coretypes.h; java/class.c
hade become dependent in the meantime on tm.h in a multitude of other ways.

So, if Richard Guenter and anybody else wo thinks that frontends and tree
optimizers should continue to use target macros, could list those putatively
inalienable macros, we can then discuss if we will be able to gain any real
benefits from our target hooks if these macros remain.

 From a practical use standpoint, the impact of macros in different files
is actually different for the different uses.  I.e. for frontend plugins,
you'd care only about the frontend files, but very much about these.
For a multi-target compiler that targets a heterogenous system with a uniform
API, for most part, the front-ends don't actually matter, because they
define the semantics of the program in the context of the API.  But all the
tree-optimizers than can be re-run after outlining / autoparallelization
have to be able to optimize for the different targets.

> then create a separate set of
> configuration headers for them in the source tree.

I was kinda hoping we could stop at BITS_PER_UNIT...

> Such changes should *definitely* not be mixed in with any other patch like
> you have done here.

So what do you propose to do instead?  Including tm.h in more source files?

Or having this work block till we have made a census of all macros and
decided which to put where, and implemented a mechanism to effect any
agreed moving of macros?

>  Regarding the main aim of the present patch, my only
> comment is that splitting up function.h into two separate headers would
> seem cleaner than making what it declares depend on what headers have been
> included first -

Yes, I could do that.  All the targets $(out_file)s would have to include
this, though.  name it something like function-implementation.h and
$(FUNCTION_IMPLEMENTATION_H) ?

> but at least for CUMULATIVE_ARGS it would be better to
> remove all variables and fields of that type from target-independent code,

I consider calls.c and function.c target-dependent, but I'm not sure if
you do too.  Could you clarify?

> instead using a target-independent type and having targets responsible in
> some way for allocating and deallocating values of that type.

AFAICT the meaning of this statement becomes either approval or rejection of
the basic premise of my patch depending on how the above question is answered.
Joseph Myers Nov. 26, 2010, 3:22 p.m. UTC | #3 
On Thu, 25 Nov 2010, Joern Rennecke wrote:

> > There's a case for having multiple tm.h variants for different uses.  For
> > example, completing the toplevel libgcc transition will involve some
> > headers in libgcc/config for those cases where target macros really are
> > appropriate rather than built-in macros and functions and other similar
> > approaches.
> 
> Would that then be macros that would be available to user programs via
> an installed header file?

No.

> Or are you talking about ways to identify the build time or other
> circumstances of building the package?
> Otherwise, I'm at a loss why the libgcc should be able to do things that
> user code couldn't do.

I am talking about making configuration in $target/$multilib/libgcc/ 
entirely independent of that in gcc/ - thus, having libgcc not use any 
configuration information derived from building or configuring the gcc/ 
directory.  This has several advantages, including much cleaner ways for 
libgcc configuration variables to depend on the multilib (so different 
multilibs can built different source files into libgcc), and the 
possibility of building libgcc separately from building the compiler 
proper.

It ought to be possible to change the set of multilibs after the compiler 
is built, but building libgcc with an installed compiler isn't readily 
possible at present.

It also ought to be possible, when bootstrapping a cross compiler and 
associated libc, to build and install the compiler just once with all 
relevant features enabled, then iterate on the alternate sequence of GCC 
library and libc builds, rather than needing to do multiple rebuilds of 
the whole compiler.  (At present, building for a GNU/Linux target, you 
need to build a minimal compiler with static libgcc in order to configure 
glibc and install its headers and crt*.o and build a dummy libc.so, which 
in turn are needed to build the second compiler with shared libgcc, which 
in turn allows you actually to do a full glibc build, which in turn is 
needed to build non-C runtime libraries from GCC.)

Certain macros used in libgcc, such as DECLARE_LIBRARY_RENAMES in 
particular, seem to be clear cases for use of target macros - but the 
headers containing those macros should be under the libgcc directory, and 
selected by configure code in that directory.  See 
<http://gcc.gnu.org/wiki/Top-Level_Libgcc_Migration> for some lists 
classifying some of the target macros used in libgcc.

Furthermore, I would like to see source files in GCC including headers 
defining macros and declaring types and functions only where those macros, 
types and functions are (a) appropriate to use in the relevant source 
files and (b) actually available in all programs into which the resulting 
objects are linked.

Regarding (b), code built for the target should not include anything 
involving the "tree" type at all.  Nor should code built for the driver 
(or collect2, gcov etc.) because the "tree" interfaces aren't available 
there.  You should never get a link error from accidental use of an 
interface not available in the GCC program you are linking without first 
getting an error or warning about an undeclared function.  As I see it, 
there should be some common infrastructure, usable everywhere and linked 
into all GCC programs (and using a cut-down coretypes.h not mentioning any 
irrelevant types, and not using tm.h or target hooks of any kind at all); 
further code shared by the driver and the compilers proper but not other 
programs (this includes option handling); and the code for the core 
compilers; these could use subdirectories to make the separation clearer 
if desired.

Regarding (a), as well as containing definitions for different programs 
tm.h contains definitions appropriate for different places.  There are 
target-specific macros such as TARGET_64BIT, which should only ever be 
used within code in config/ (including the .md files, and insn-*.c 
generated from them).  And there are the macros that are actually intended 
to be used directly in code outside config/ - BITS_PER_UNIT is one of 
those.  Because definitions of the latter macros may use the former 
macros, splitting these into separate headers is tricky, but I think the 
aim eventually should be to eliminate the latter case completely.

I discussed further advantages of splitting up tm.h (by where the 
different macros are used) in 
<http://gcc.gnu.org/ml/gcc/2010-10/msg00294.html>.

> > then create a separate set of
> > configuration headers for them in the source tree.
> 
> I was kinda hoping we could stop at BITS_PER_UNIT...

If you want to stop at BITS_PER_UNIT, do not go extracting definitions 
with grep.  Have config.gcc define tm_bits_per_unit_file like it defines 
tm_file - all existing targets might use "8bit-unit.h" as the definition.  
Create tm-bits-per-unit.h based on the tm_bits_per_unit_file definition, 
and have tm.h include tm-bits-per-unit.h.  (Plus all the usual dependency 
updates.)  That would certainly be better than your patch in terms of 
removing dependencies - direct or indirect - of source files on the full 
set of tm.h headers.

> > Such changes should *definitely* not be mixed in with any other patch like
> > you have done here.
> 
> So what do you propose to do instead?  Including tm.h in more source files?

See contribute.html:

    Don't mix together changes made for different reasons. Send them 
    individually. Ideally, each change you send should be impossible to 
    subdivide into parts that we might want to consider separately, 
    because each of its parts gets its motivation from the other parts.

This patch could be divided into *at least* three parts.

(i) The parts adding explicit tm.h includes, or comments on such includes, 
to files using target macros.  Those should be reasonably uncontroversial.

(ii) Creation of tm-bits-per-unit.h, and replacing selected tm.h includes 
with includes of the new header.

(iii) The actual function.h changes, though as noted I think they are 
following the wrong approach.

> > but at least for CUMULATIVE_ARGS it would be better to
> > remove all variables and fields of that type from target-independent code,
> 
> I consider calls.c and function.c target-dependent, but I'm not sure if
> you do too.  Could you clarify?

I consider everything in gcc/, outside of gcc/config/ to be 
target-independent, except maybe for a few misplaced files such as 
mips-tdump.c and mips-tfile.c.

> > instead using a target-independent type and having targets responsible in
> > some way for allocating and deallocating values of that type.
> 
> AFAICT the meaning of this statement becomes either approval or rejection of
> the basic premise of my patch depending on how the above question is answered.

I don't think target-independent files should use types whose definitions 
depend on the target.  The more substantial the target dependence, the 
more desirable that target-independent files should not use the type.

When a target-independent file is being compiled, the target-specific 
definition of CUMULATIVE_ARGS should not be visible to the host compiler 
at all.  Where a target-independent file needs to use a datastructure 
involving such target-dependent data, it should do so through a 
target-independent type.  The code under config/ should then do the 
necessary base-to-derived-class dynamic casts.  The fact that there exists 
a type called CUMULATIVE_ARGS in each back end would then become a 
historical coincidence rather than an actual requirement that back ends 
make any use of such a type name in future.

I consider your patch 
<http://gcc.gnu.org/ml/gcc-patches/2010-11/msg01994.html> to be a 
reasonable start towards implementing such an approach for CUMULATIVE_ARGS 
- but to complete it, get_cumulative_args and pack_cumulative_args should 
move into each target's code, all instances of CUMULATIVE_ARGS outside 
config/ should go away and additional interfaces should be added to 
initialize a cumulative_args_t for a target (which would involve 
allocating the target-specific storage) and to finish using it 
(deallocating storage, though this probably isn't important).

HARD_REG_SET could be trickier (more likely to involve performance cost if 
you abstract it away everywhere) but you could at least replace it with a 
void * pointer in function.h and use inline functions defined elsewhere to 
convert to/from the actual HARD_REG_SET type.
diff mbox

Patch

Index: java/class.c
===================================================================
--- java/class.c	(revision 167152)
+++ java/class.c	(working copy)
@@ -27,6 +27,7 @@  the Free Software Foundation; either ver
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm.h"       /* FIXME: For TARGET_PTRMEMFUNC_VBIT_LOCATION / BITS_PER_UNIT / TARGET_VTABLE_USES_DESCRIPTORS / POINTER_SIZE / TARGET_USE_JCR_SECTION  */
 #include "tree.h"
 #include "flags.h"
 #include "java-tree.h"
@@ -42,7 +43,6 @@  the Free Software Foundation; either ver
 #include "cgraph.h"
 #include "tree-iterator.h"
 #include "vecprim.h"
-#include "tm.h"         /* FIXME: For gcc_obstack_init from defaults.h.  */
 #include "target.h"
 
 /* DOS brain-damage */
Index: java/decl.c
===================================================================
--- java/decl.c	(revision 167152)
+++ java/decl.c	(working copy)
@@ -28,6 +28,7 @@  the Free Software Foundation; either ver
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm.h"
 #include "tree.h"
 #include "diagnostic-core.h"
 #include "toplev.h"
Index: java/jcf-parse.c
===================================================================
--- java/jcf-parse.c	(revision 167152)
+++ java/jcf-parse.c	(working copy)
@@ -27,6 +27,7 @@  the Free Software Foundation; either ver
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm.h"
 #include "tree.h"
 #include "obstack.h"
 #include "flags.h"
Index: tree-emutls.c
===================================================================
--- tree-emutls.c	(revision 167152)
+++ tree-emutls.c	(working copy)
@@ -21,6 +21,7 @@  Free Software Foundation; either version
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm-holdover.h"
 #include "tree.h"
 #include "gimple.h"
 #include "tree-pass.h"
Index: expr.c
===================================================================
--- expr.c	(revision 167152)
+++ expr.c	(working copy)
@@ -8405,7 +8405,7 @@  expand_expr_real_1 (tree exp, rtx target
 	    int nregs = hard_regno_nregs[i][GET_MODE (decl_rtl)];
 	    while (nregs)
 	      {
-		SET_HARD_REG_BIT (crtl->asm_clobbers, i);
+		SET_HARD_REG_BIT (ctmrtl->asm_clobbers, i);
 		i++;
 		nregs--;
 	      }
Index: fortran/f95-lang.c
===================================================================
--- fortran/f95-lang.c	(revision 167152)
+++ fortran/f95-lang.c	(working copy)
@@ -28,13 +28,13 @@  Software Foundation; either version 3, o
 #include "ansidecl.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm.h"
 #include "tree.h"
 #include "gimple.h"
 #include "flags.h"
 #include "langhooks.h"
 #include "langhooks-def.h"
 #include "timevar.h"
-#include "tm.h"
 #include "function.h"
 #include "ggc.h"
 #include "toplev.h"
Index: function.c
===================================================================
--- function.c	(revision 167152)
+++ function.c	(working copy)
@@ -215,6 +215,7 @@  free_after_compilation (struct function 
     free (crtl->emit.regno_pointer_align);
 
   memset (crtl, 0, sizeof (struct rtl_data));
+  memset (ctmrtl, 0, sizeof (struct rtl_tm_data));
   f->eh = NULL;
   f->machine = NULL;
   f->cfg = NULL;
@@ -3464,7 +3465,7 @@  assign_parms (tree fndecl)
   /* For stdarg.h function, save info about
      regs and stack space used by the named args.  */
 
-  crtl->args.info = all.args_so_far;
+  ctmrtl->args_info = all.args_so_far;
 
   /* Set the rtx used for the function return value.  Put this in its
      own variable so any optimizers that need this information don't have
Index: function.h
===================================================================
--- function.h	(revision 167152)
+++ function.h	(working copy)
@@ -25,8 +25,9 @@  Software Foundation; either version 3, o
 #include "tree.h"
 #include "hashtab.h"
 #include "vecprim.h"
-#include "tm.h"		/* For CUMULATIVE_ARGS.  */
+#ifdef GCC_TM_H
 #include "hard-reg-set.h"
+#endif /* GCC_TM_H */
 
 /* Stack of pending (incomplete) sequences saved by `start_sequence'.
    Each element describes one pending sequence.
@@ -208,10 +209,6 @@  struct GTY(()) incoming_args {
      anonymous arg can be found, if there is one.  */
   rtx arg_offset_rtx;
 
-  /* Quantities of various kinds of registers
-     used for the current function's args.  */
-  CUMULATIVE_ARGS info;
-
   /* The arg pointer hard register, or the pseudo into which it was copied.  */
   rtx internal_arg_pointer;
 };
@@ -433,6 +430,15 @@  struct GTY(()) rtl_data {
      TREE_NOTHROW (current_function_decl) it is set even for overwritable
      function where currently compiled version of it is nothrow.  */
   bool nothrow;
+};
+
+#ifdef GCC_TM_H
+/* Datastructures maintained for currently processed function in RTL form,
+   which require inclusion of tm.h .  */
+struct GTY(()) rtl_tm_data {
+  /* Quantities of various kinds of registers
+     used for the current function's args.  */
+  CUMULATIVE_ARGS args_info;
 
   /* Like regs_ever_live, but 1 if a reg is set or clobbered from an
      asm.  Unlike regs_ever_live, elements of this array corresponding
@@ -440,6 +446,7 @@  struct GTY(()) rtl_data {
      sets them.  */
   HARD_REG_SET asm_clobbers;
 };
+#endif /* GCC_TM_H */
 
 #define return_label (crtl->x_return_label)
 #define naked_return_label (crtl->x_naked_return_label)
@@ -457,11 +464,13 @@  struct GTY(()) rtl_data {
 #define stack_realign_drap (crtl->stack_realign_needed && crtl->need_drap)
 
 extern GTY(()) struct rtl_data x_rtl;
+extern GTY(()) struct rtl_tm_data x_tm_rtl;
 
 /* Accessor to RTL datastructures.  We keep them statically allocated now since
    we never keep multiple functions.  For threaded compiler we might however
    want to do differently.  */
 #define crtl (&x_rtl)
+#define ctmrtl (&x_tm_rtl)
 
 struct GTY(()) stack_usage
 {
@@ -746,10 +755,12 @@  extern const char *current_function_name
 
 extern void do_warn_unused_parameter (tree);
 
+#ifdef GCC_TM_H
 extern bool pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
 			       tree, bool);
 extern bool reference_callee_copied (CUMULATIVE_ARGS *, enum machine_mode,
 				     tree, bool);
+#endif /* GCC_TM_H */
 
 extern void used_types_insert (tree);
 
Index: tree-affine.c
===================================================================
--- tree-affine.c	(revision 167152)
+++ tree-affine.c	(working copy)
@@ -20,6 +20,7 @@  Free Software Foundation; either version
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm-holdover.h"
 #include "tree.h"
 #include "output.h"
 #include "tree-pretty-print.h"
Index: emit-rtl.c
===================================================================
--- emit-rtl.c	(revision 167152)
+++ emit-rtl.c	(working copy)
@@ -78,6 +78,7 @@  enum machine_mode ptr_mode;	/* Mode whos
 /* Datastructures maintained for currently processed function in RTL form.  */
 
 struct rtl_data x_rtl;
+struct rtl_tm_data x_tm_rtl;
 
 /* Indexed by pseudo register number, gives the rtx for that pseudo.
    Allocated in parallel with regno_pointer_align.
Index: ipa-prop.c
===================================================================
--- ipa-prop.c	(revision 167152)
+++ ipa-prop.c	(working copy)
@@ -21,6 +21,7 @@  Software Foundation; either version 3, o
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tm.h" /* For TARGET_PTRMEMFUNC_VBIT_LOCATION.  */
 #include "tree.h"
 #include "langhooks.h"
 #include "ggc.h"
Index: ira.c
===================================================================
--- ira.c	(revision 167152)
+++ ira.c	(working copy)
@@ -1328,7 +1328,7 @@  compute_regs_asm_clobbered (void)
 		      + hard_regno_nregs[dregno][mode] - 1;
 
 		    for (i = dregno; i <= end; ++i)
-		      SET_HARD_REG_BIT(crtl->asm_clobbers, i);
+		      SET_HARD_REG_BIT(ctmrtl->asm_clobbers, i);
 		  }
 	      }
 	}
@@ -1374,7 +1374,7 @@  ira_setup_eliminable_regset (void)
 	= (! targetm.can_eliminate (eliminables[i].from, eliminables[i].to)
 	   || (eliminables[i].to == STACK_POINTER_REGNUM && need_fp));
 
-      if (!TEST_HARD_REG_BIT (crtl->asm_clobbers, eliminables[i].from))
+      if (!TEST_HARD_REG_BIT (ctmrtl->asm_clobbers, eliminables[i].from))
 	{
 	    SET_HARD_REG_BIT (eliminable_regset, eliminables[i].from);
 
@@ -1388,7 +1388,7 @@  ira_setup_eliminable_regset (void)
 	df_set_regs_ever_live (eliminables[i].from, true);
     }
 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
-  if (!TEST_HARD_REG_BIT (crtl->asm_clobbers, HARD_FRAME_POINTER_REGNUM))
+  if (!TEST_HARD_REG_BIT (ctmrtl->asm_clobbers, HARD_FRAME_POINTER_REGNUM))
     {
       SET_HARD_REG_BIT (eliminable_regset, HARD_FRAME_POINTER_REGNUM);
       if (need_fp)
@@ -1402,7 +1402,7 @@  ira_setup_eliminable_regset (void)
 #endif
 
 #else
-  if (!TEST_HARD_REG_BIT (crtl->asm_clobbers, HARD_FRAME_POINTER_REGNUM))
+  if (!TEST_HARD_REG_BIT (ctmrtl->asm_clobbers, HARD_FRAME_POINTER_REGNUM))
     {
       SET_HARD_REG_BIT (eliminable_regset, FRAME_POINTER_REGNUM);
       if (need_fp)
Index: Makefile.in
===================================================================
--- Makefile.in	(revision 167152)
+++ Makefile.in	(working copy)
@@ -2590,7 +2590,7 @@  tree-ssa-loop-ivopts.o : tree-ssa-loop-i
    tree-affine.h pointer-set.h $(TARGET_H) tree-pretty-print.h \
    gimple-pretty-print.h tree-ssa-propagate.h
 tree-affine.o : tree-affine.c tree-affine.h $(CONFIG_H) pointer-set.h \
-   $(SYSTEM_H) $(TREE_H) $(GIMPLE_H) \
+   $(SYSTEM_H) $(TREE_H) $(GIMPLE_H) tm-holdover.h \
    output.h $(DIAGNOSTIC_H) coretypes.h $(TREE_DUMP_H) $(FLAGS_H) \
    tree-pretty-print.h
 tree-ssa-loop-manip.o : tree-ssa-loop-manip.c $(TREE_FLOW_H) $(CONFIG_H) \
@@ -3176,7 +3176,7 @@  tree-complex.o : tree-complex.c $(CONFIG
     tree-iterator.h $(TREE_PASS_H) tree-ssa-propagate.h $(DIAGNOSTIC_H)
 tree-emutls.o : tree-emutls.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
     $(GIMPLE_H) $(TREE_PASS_H) $(TREE_FLOW_H) $(CGRAPH_H) langhooks.h \
-    $(TARGET_H) targhooks.h tree-iterator.h
+    $(TARGET_H) targhooks.h tree-iterator.h tm-holdover.h
 tree-vect-generic.o : tree-vect-generic.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) \
     $(TM_H) $(TREE_FLOW_H) $(GIMPLE_H) tree-iterator.h $(TREE_PASS_H) \
     $(FLAGS_H) $(OPTABS_H) $(MACHMODE_H) $(EXPR_H) \
@@ -3708,6 +3708,15 @@  s-constrs-h: $(MD_DEPS) build/genpreds$(
 	$(SHELL) $(srcdir)/../move-if-change tmp-constrs.h tm-constrs.h
 	$(STAMP) s-constrs-h
 
+tm-holdover.h : s-holdover; @true
+s-holdover: $(tm_file_list)
+	echo '/* Target macros that remain in frontends / tree-optimizers.  */'\
+	  >> tmp-holdover.h
+	grep '^#[ 	]define[ 	]*BITS_PER_UNIT' $(tm_file_list) \
+	  >> tmp-holdover.h \
+	|| echo '#define BITS_PER_UNIT 8' >> tmp-holdover.h
+	$(SHELL) $(srcdir)/../move-if-change tmp-holdover.h tm-holdover.h
+
 target-hooks-def.h: s-target-hooks-def-h; @true
 # make sure that when we build info files, the used tm.texi is up to date.
 $(srcdir)/doc/tm.texi: s-tm-texi; @true
Index: config/alpha/alpha.c
===================================================================
--- config/alpha/alpha.c	(revision 167152)
+++ config/alpha/alpha.c	(working copy)
@@ -186,9 +186,9 @@  struct alpha_rtx_cost_data
 
 /* Get the number of args of a function in one of two ways.  */
 #if TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK
-#define NUM_ARGS crtl->args.info.num_args
+#define NUM_ARGS ctmrtl->args_info.num_args
 #else
-#define NUM_ARGS crtl->args.info
+#define NUM_ARGS ctmrtl->args_info
 #endif
 
 #define REG_PV 27
Index: config/frv/frv.c
===================================================================
--- config/frv/frv.c	(revision 167152)
+++ config/frv/frv.c	(working copy)
@@ -2253,7 +2253,7 @@  frv_expand_builtin_saveregs (void)
 frv_expand_builtin_va_start (tree valist, rtx nextarg)
 {
   tree t;
-  int num = crtl->args.info - FIRST_ARG_REGNUM - FRV_NUM_ARG_REGS;
+  int num = ctmrtl->args_info - FIRST_ARG_REGNUM - FRV_NUM_ARG_REGS;
 
   nextarg = gen_rtx_PLUS (Pmode, virtual_incoming_args_rtx,
 			  GEN_INT (UNITS_PER_WORD * num));
@@ -2261,7 +2261,7 @@  frv_expand_builtin_va_start (tree valist
   if (TARGET_DEBUG_ARG)
     {
       fprintf (stderr, "va_start: args_info = %d, num = %d\n",
-	       crtl->args.info, num);
+	       ctmrtl->args_info, num);
 
       debug_rtx (nextarg);
     }
Index: config/s390/s390.c
===================================================================
--- config/s390/s390.c	(revision 167152)
+++ config/s390/s390.c	(working copy)
@@ -7225,9 +7225,9 @@  s390_register_info (int clobbered_regs[]
     {
       /* Varargs functions need to save gprs 2 to 6.  */
       if (cfun->va_list_gpr_size
-	  && crtl->args.info.gprs < GP_ARG_NUM_REG)
+	  && ctmrtl->args_info.gprs < GP_ARG_NUM_REG)
 	{
-	  int min_gpr = crtl->args.info.gprs;
+	  int min_gpr = ctmrtl->args_info.gprs;
 	  int max_gpr = min_gpr + cfun->va_list_gpr_size;
 	  if (max_gpr > GP_ARG_NUM_REG)
 	    max_gpr = GP_ARG_NUM_REG;
@@ -7249,9 +7249,9 @@  s390_register_info (int clobbered_regs[]
 
       /* Mark f0, f2 for 31 bit and f0-f4 for 64 bit to be saved.  */
       if (TARGET_HARD_FLOAT && cfun->va_list_fpr_size
-	  && crtl->args.info.fprs < FP_ARG_NUM_REG)
+	  && ctmrtl->args_info.fprs < FP_ARG_NUM_REG)
 	{
-	  int min_fpr = crtl->args.info.fprs;
+	  int min_fpr = ctmrtl->args_info.fprs;
 	  int max_fpr = min_fpr + cfun->va_list_fpr_size;
 	  if (max_fpr > FP_ARG_NUM_REG)
 	    max_fpr = FP_ARG_NUM_REG;
@@ -8720,7 +8720,7 @@  s390_build_builtin_va_list (void)
    The following global variables are used to initialize
    the va_list structure:
 
-     crtl->args.info:
+     ctmrtl->args_info:
        holds number of gprs and fprs used for named arguments.
      crtl->args.arg_offset_rtx:
        holds the offset of the first anonymous stack argument
@@ -8747,8 +8747,8 @@  s390_va_start (tree valist, rtx nextarg 
 
   /* Count number of gp and fp argument registers used.  */
 
-  n_gpr = crtl->args.info.gprs;
-  n_fpr = crtl->args.info.fprs;
+  n_gpr = ctmrtl->args_info.gprs;
+  n_fpr = ctmrtl->args_info.fprs;
 
   if (cfun->va_list_gpr_size)
     {
Index: config/spu/spu.c
===================================================================
--- config/spu/spu.c	(revision 167152)
+++ config/spu/spu.c	(working copy)
@@ -4140,7 +4140,7 @@  spu_build_builtin_va_list (void)
    The following global variables are used to initialize
    the va_list structure:
 
-     crtl->args.info;
+     ctmrtl->args_info;
        the CUMULATIVE_ARGS for this function
 
      crtl->args.arg_offset_rtx:
Index: config/sparc/sparc.c
===================================================================
--- config/sparc/sparc.c	(revision 167152)
+++ config/sparc/sparc.c	(working copy)
@@ -6190,7 +6190,7 @@  sparc_function_value_regno_p (const unsi
 static rtx
 sparc_builtin_saveregs (void)
 {
-  int first_reg = crtl->args.info.words;
+  int first_reg = ctmrtl->args_info.words;
   rtx address;
   int regno;
 
Index: config/i386/i386.c
===================================================================
--- config/i386/i386.c	(revision 167152)
+++ config/i386/i386.c	(working copy)
@@ -7953,9 +7953,9 @@  ix86_va_start (tree valist, rtx nextarg)
 		f_sav, NULL_TREE);
 
   /* Count number of gp and fp argument registers used.  */
-  words = crtl->args.info.words;
-  n_gpr = crtl->args.info.regno;
-  n_fpr = crtl->args.info.sse_regno;
+  words = ctmrtl->args_info.words;
+  n_gpr = ctmrtl->args_info.regno;
+  n_fpr = ctmrtl->args_info.sse_regno;
 
   if (cfun->va_list_gpr_size)
     {
Index: config/sh/sh.c
===================================================================
--- config/sh/sh.c	(revision 167152)
+++ config/sh/sh.c	(working copy)
@@ -6599,7 +6599,7 @@  calc_live_regs (HARD_REG_SET *live_regs_
   /* Force PR to be live if the prologue has to call the SHmedia
      argument decoder or register saver.  */
   if (TARGET_SHCOMPACT
-      && ((crtl->args.info.call_cookie
+      && ((ctmrtl->args_info.call_cookie
 	   & ~ CALL_COOKIE_RET_TRAMP (1))
 	  || crtl->saves_all_registers))
     pr_live = 1;
@@ -6626,7 +6626,7 @@  calc_live_regs (HARD_REG_SET *live_regs_
 	  : (/* Only push those regs which are used and need to be saved.  */
 	     (TARGET_SHCOMPACT
 	      && flag_pic
-	      && crtl->args.info.call_cookie
+	      && ctmrtl->args_info.call_cookie
 	      && reg == PIC_OFFSET_TABLE_REGNUM)
 	     || (df_regs_ever_live_p (reg)
 		 && ((!call_really_used_regs[reg]
@@ -6883,15 +6883,15 @@  sh_expand_prologue (void)
   pretend_args = crtl->args.pretend_args_size;
   if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl)
       && (NPARM_REGS(SImode)
-	  > crtl->args.info.arg_count[(int) SH_ARG_INT]))
+	  > ctmrtl->args_info.arg_count[(int) SH_ARG_INT]))
     pretend_args = 0;
 
   output_stack_adjust (-pretend_args
-		       - crtl->args.info.stack_regs * 8,
+		       - ctmrtl->args_info.stack_regs * 8,
 		       stack_pointer_rtx, 0, NULL, true);
-  stack_usage = pretend_args + crtl->args.info.stack_regs * 8;
+  stack_usage = pretend_args + ctmrtl->args_info.stack_regs * 8;
 
-  if (TARGET_SHCOMPACT && flag_pic && crtl->args.info.call_cookie)
+  if (TARGET_SHCOMPACT && flag_pic && ctmrtl->args_info.call_cookie)
     /* We're going to use the PIC register to load the address of the
        incoming-argument decoder and/or of the return trampoline from
        the GOT, so make sure the PIC register is preserved and
@@ -6899,7 +6899,7 @@  sh_expand_prologue (void)
     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
 
   if (TARGET_SHCOMPACT
-      && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
+      && (ctmrtl->args_info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
     {
       int reg;
 
@@ -6907,20 +6907,20 @@  sh_expand_prologue (void)
 	 be pushed onto the stack live, so that register renaming
 	 doesn't overwrite them.  */
       for (reg = 0; reg < NPARM_REGS (SImode); reg++)
-	if (CALL_COOKIE_STACKSEQ_GET (crtl->args.info.call_cookie)
+	if (CALL_COOKIE_STACKSEQ_GET (ctmrtl->args_info.call_cookie)
 	    >= NPARM_REGS (SImode) - reg)
 	  for (; reg < NPARM_REGS (SImode); reg++)
 	    emit_insn (gen_shcompact_preserve_incoming_args
 		       (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
 	else if (CALL_COOKIE_INT_REG_GET
-		 (crtl->args.info.call_cookie, reg) == 1)
+		 (ctmrtl->args_info.call_cookie, reg) == 1)
 	  emit_insn (gen_shcompact_preserve_incoming_args
 		     (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
 
       emit_move_insn (gen_rtx_REG (Pmode, MACL_REG),
 		      stack_pointer_rtx);
       emit_move_insn (gen_rtx_REG (SImode, R0_REG),
-		      GEN_INT (crtl->args.info.call_cookie));
+		      GEN_INT (ctmrtl->args_info.call_cookie));
       emit_move_insn (gen_rtx_REG (SImode, MACH_REG),
 		      gen_rtx_REG (SImode, R0_REG));
     }
@@ -6944,7 +6944,7 @@  sh_expand_prologue (void)
 	      int rn = NPARM_REGS(SImode) + FIRST_PARM_REG - i - 1;
 
 	      if (i >= (NPARM_REGS(SImode)
-			- crtl->args.info.arg_count[(int) SH_ARG_INT]
+			- ctmrtl->args_info.arg_count[(int) SH_ARG_INT]
 			))
 		break;
 	      push (rn);
@@ -7206,7 +7206,7 @@  sh_expand_prologue (void)
     frame_insn (GEN_MOV (hard_frame_pointer_rtx, stack_pointer_rtx));
 
   if (TARGET_SHCOMPACT
-      && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
+      && (ctmrtl->args_info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
     {
       /* This must NOT go through the PLT, otherwise mach and macl
 	 may be clobbered.  */
@@ -7499,7 +7499,7 @@  sh_expand_epilogue (bool sibcall_p)
 
   output_stack_adjust (crtl->args.pretend_args_size
 		       + save_size + d_rounding
-		       + crtl->args.info.stack_regs * 8,
+		       + ctmrtl->args_info.stack_regs * 8,
 		       stack_pointer_rtx, e, NULL, false);
 
   if (crtl->calls_eh_return)
@@ -7622,11 +7622,11 @@  sh_output_function_epilogue (FILE *file 
 sh_builtin_saveregs (void)
 {
   /* First unnamed integer register.  */
-  int first_intreg = crtl->args.info.arg_count[(int) SH_ARG_INT];
+  int first_intreg = ctmrtl->args_info.arg_count[(int) SH_ARG_INT];
   /* Number of integer registers we need to save.  */
   int n_intregs = MAX (0, NPARM_REGS (SImode) - first_intreg);
   /* First unnamed SFmode float reg */
-  int first_floatreg = crtl->args.info.arg_count[(int) SH_ARG_FLOAT];
+  int first_floatreg = ctmrtl->args_info.arg_count[(int) SH_ARG_FLOAT];
   /* Number of SFmode float regs to save.  */
   int n_floatregs = MAX (0, NPARM_REGS (SFmode) - first_floatreg);
   rtx regbuf, fpregs;
@@ -7641,22 +7641,22 @@  sh_builtin_saveregs (void)
 
 	  while (pushregs < NPARM_REGS (SImode) - 1
 		 && (CALL_COOKIE_INT_REG_GET
-			(crtl->args.info.call_cookie,
+			(ctmrtl->args_info.call_cookie,
 			 NPARM_REGS (SImode) - pushregs)
 		     == 1))
 	    {
-	      crtl->args.info.call_cookie
+	      ctmrtl->args_info.call_cookie
 		&= ~ CALL_COOKIE_INT_REG (NPARM_REGS (SImode)
 					  - pushregs, 1);
 	      pushregs++;
 	    }
 
 	  if (pushregs == NPARM_REGS (SImode))
-	    crtl->args.info.call_cookie
+	    ctmrtl->args_info.call_cookie
 	      |= (CALL_COOKIE_INT_REG (0, 1)
 		  | CALL_COOKIE_STACKSEQ (pushregs - 1));
 	  else
-	    crtl->args.info.call_cookie
+	    ctmrtl->args_info.call_cookie
 	      |= CALL_COOKIE_STACKSEQ (pushregs);
 
 	  crtl->args.pretend_args_size += 8 * n_intregs;
@@ -7866,7 +7866,7 @@  sh_va_start (tree valist, rtx nextarg)
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
-  nfp = crtl->args.info.arg_count[SH_ARG_FLOAT];
+  nfp = ctmrtl->args_info.arg_count[SH_ARG_FLOAT];
   if (nfp < 8)
     nfp = 8 - nfp;
   else
@@ -7881,7 +7881,7 @@  sh_va_start (tree valist, rtx nextarg)
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
-  nint = crtl->args.info.arg_count[SH_ARG_INT];
+  nint = ctmrtl->args_info.arg_count[SH_ARG_INT];
   if (nint < 4)
     nint = 4 - nint;
   else
@@ -8668,11 +8668,11 @@  initial_elimination_offset (int from, in
 
   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
     return total_saved_regs_space + total_auto_space
-      + crtl->args.info.byref_regs * 8;
+      + ctmrtl->args_info.byref_regs * 8;
 
   if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
     return total_saved_regs_space + total_auto_space
-      + crtl->args.info.byref_regs * 8;
+      + ctmrtl->args_info.byref_regs * 8;
 
   /* Initial gap between fp and sp is 0.  */
   if (from == HARD_FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
@@ -10283,7 +10283,7 @@  sh_allocate_initial_value (rtx hard_reg)
       if (current_function_is_leaf
 	  && ! sh_pr_n_sets ()
 	  && ! (TARGET_SHCOMPACT
-		&& ((crtl->args.info.call_cookie
+		&& ((ctmrtl->args_info.call_cookie
 		     & ~ CALL_COOKIE_RET_TRAMP (1))
 		    || crtl->saves_all_registers)))
 	x = hard_reg;
@@ -10893,7 +10893,7 @@  sh_function_ok_for_sibcall (tree decl, t
 {
   return (1
 	  && (! TARGET_SHCOMPACT
-	      || crtl->args.info.stack_regs == 0)
+	      || ctmrtl->args_info.stack_regs == 0)
 	  && ! sh_cfun_interrupt_handler_p ()
 	  && (! flag_pic
 	      || (decl && ! TREE_PUBLIC (decl))
@@ -11808,7 +11808,7 @@  sh_get_pr_initial_val (void)
      PR register on SHcompact, because it might be clobbered by the prologue.
      We check first if that is known to be the case.  */
   if (TARGET_SHCOMPACT
-      && ((crtl->args.info.call_cookie
+      && ((ctmrtl->args_info.call_cookie
 	   & ~ CALL_COOKIE_RET_TRAMP (1))
 	  || crtl->saves_all_registers))
     return gen_frame_mem (SImode, return_address_pointer_rtx);
Index: config/sh/sh.md
===================================================================
--- config/sh/sh.md	(revision 167152)
+++ config/sh/sh.md	(working copy)
@@ -9017,7 +9017,7 @@  (define_expand "return"
     }
 
   if (TARGET_SHCOMPACT
-      && (crtl->args.info.call_cookie & CALL_COOKIE_RET_TRAMP (1)))
+      && (ctmrtl->args_info.call_cookie & CALL_COOKIE_RET_TRAMP (1)))
     {
       emit_jump_insn (gen_shcompact_return_tramp ());
       DONE;
@@ -9027,7 +9027,7 @@  (define_expand "return"
 (define_insn "*return_i"
   [(return)]
   "TARGET_SH1 && ! (TARGET_SHCOMPACT
-		    && (crtl->args.info.call_cookie
+		    && (ctmrtl->args_info.call_cookie
 			& CALL_COOKIE_RET_TRAMP (1)))
    && reload_completed
    && lookup_attribute (\"trap_exit\",
@@ -9054,7 +9054,7 @@  (define_insn "*return_trapa"
 (define_expand "shcompact_return_tramp"
   [(return)]
   "TARGET_SHCOMPACT
-   && (crtl->args.info.call_cookie & CALL_COOKIE_RET_TRAMP (1))"
+   && (ctmrtl->args_info.call_cookie & CALL_COOKIE_RET_TRAMP (1))"
   "
 {
   rtx reg = gen_rtx_REG (Pmode, R0_REG);
@@ -9067,7 +9067,7 @@  (define_expand "shcompact_return_tramp"
 (define_insn "shcompact_return_tramp_i"
   [(parallel [(return) (use (reg:SI R0_REG))])]
   "TARGET_SHCOMPACT
-   && (crtl->args.info.call_cookie & CALL_COOKIE_RET_TRAMP (1))"
+   && (ctmrtl->args_info.call_cookie & CALL_COOKIE_RET_TRAMP (1))"
   "jmp	@r0%#"
   [(set_attr "type" "jump_ind")
    (set_attr "needs_delay_slot" "yes")])
Index: config/avr/avr.c
===================================================================
--- config/avr/avr.c	(revision 167152)
+++ config/avr/avr.c	(working copy)
@@ -2772,7 +2772,7 @@  out_movhi_mr_r (rtx insn, rtx op[], int 
 avr_frame_pointer_required_p (void)
 {
   return (cfun->calls_alloca
-	  || crtl->args.info.nregs == 0
+	  || ctmrtl->args_info.nregs == 0
   	  || get_frame_size () > 0);
 }
 
Index: config/xtensa/xtensa.c
===================================================================
--- config/xtensa/xtensa.c	(revision 167152)
+++ config/xtensa/xtensa.c	(working copy)
@@ -2752,7 +2752,7 @@  xtensa_build_builtin_va_list (void)
 xtensa_builtin_saveregs (void)
 {
   rtx gp_regs;
-  int arg_words = crtl->args.info.arg_words;
+  int arg_words = ctmrtl->args_info.arg_words;
   int gp_left = MAX_ARGS_IN_REGISTERS - arg_words;
 
   if (gp_left <= 0)
@@ -2789,7 +2789,7 @@  xtensa_va_start (tree valist, rtx nextar
   tree t, u;
   int arg_words;
 
-  arg_words = crtl->args.info.arg_words;
+  arg_words = ctmrtl->args_info.arg_words;
 
   f_stk = TYPE_FIELDS (va_list_type_node);
   f_reg = DECL_CHAIN (f_stk);
@@ -3184,7 +3184,7 @@  order_regs_for_local_alloc (void)
 
       /* Use the AR registers in increasing order (skipping a0 and a1)
 	 but save the incoming argument registers for a last resort.  */
-      num_arg_regs = crtl->args.info.arg_words;
+      num_arg_regs = ctmrtl->args_info.arg_words;
       if (num_arg_regs > MAX_ARGS_IN_REGISTERS)
 	num_arg_regs = MAX_ARGS_IN_REGISTERS;
       for (i = GP_ARG_FIRST; i < 16 - num_arg_regs; i++)
Index: config/stormy16/stormy16.c
===================================================================
--- config/stormy16/stormy16.c	(revision 167152)
+++ config/stormy16/stormy16.c	(working copy)
@@ -1350,7 +1350,7 @@  xstormy16_expand_builtin_va_start (tree 
 
   t = build2 (MODIFY_EXPR, TREE_TYPE (count), count,
 	      build_int_cst (NULL_TREE,
-			     crtl->args.info * UNITS_PER_WORD));
+			     ctmrtl->args_info * UNITS_PER_WORD));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
Index: config/m68hc11/m68hc11.c
===================================================================
--- config/m68hc11/m68hc11.c	(revision 167152)
+++ config/m68hc11/m68hc11.c	(working copy)
@@ -1669,7 +1669,7 @@  expand_prologue (void)
      If the first argument is a 32-bit quantity, the D+X registers
      are used.  Use Y to compute the frame.  Otherwise, X is cheaper.
      For 68HC12, this scratch register is not used.  */
-  if (crtl->args.info.nregs == 2)
+  if (ctmrtl->args_info.nregs == 2)
     scratch = iy_reg;
   else
     scratch = ix_reg;
Index: config/iq2000/iq2000.c
===================================================================
--- config/iq2000/iq2000.c	(revision 167152)
+++ config/iq2000/iq2000.c	(working copy)
@@ -1414,7 +1414,7 @@  iq2000_va_start (tree valist, rtx nextar
   /* Find out how many non-float named formals.  */
   int gpr_save_area_size;
   /* Note UNITS_PER_WORD is 4 bytes.  */
-  int_arg_words = crtl->args.info.arg_words;
+  int_arg_words = ctmrtl->args_info.arg_words;
 
   if (int_arg_words < 8 )
     /* Adjust for the prologue's economy measure.  */
Index: config/ia64/ia64.c
===================================================================
--- config/ia64/ia64.c	(revision 167152)
+++ config/ia64/ia64.c	(working copy)
@@ -3300,7 +3300,7 @@  #define PRINTREG(a) if (current_frame_in
   /* We don't need an alloc instruction if we've used no outputs or locals.  */
   if (current_frame_info.n_local_regs == 0
       && current_frame_info.n_output_regs == 0
-      && current_frame_info.n_input_regs <= crtl->args.info.int_regs
+      && current_frame_info.n_input_regs <= ctmrtl->args_info.int_regs
       && !TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM))
     {
       /* If there is no alloc, but there are input registers used, then we
Index: config/rs6000/rs6000.c
===================================================================
--- config/rs6000/rs6000.c	(revision 167152)
+++ config/rs6000/rs6000.c	(working copy)
@@ -9465,10 +9465,10 @@  rs6000_va_start (tree valist, rtx nextar
 		f_sav, NULL_TREE);
 
   /* Count number of gp and fp argument registers used.  */
-  words = crtl->args.info.words;
-  n_gpr = MIN (crtl->args.info.sysv_gregno - GP_ARG_MIN_REG,
+  words = ctmrtl->args_info.words;
+  n_gpr = MIN (ctmrtl->args_info.sysv_gregno - GP_ARG_MIN_REG,
 	       GP_ARG_NUM_REG);
-  n_fpr = MIN (crtl->args.info.fregno - FP_ARG_MIN_REG,
+  n_fpr = MIN (ctmrtl->args_info.fregno - FP_ARG_MIN_REG,
 	       FP_ARG_NUM_REG);
 
   if (TARGET_DEBUG_ARG)
@@ -18170,7 +18170,7 @@  compute_vrsave_mask (void)
      them in again.  More importantly, the mask we compute here is
      used to generate CLOBBERs in the set_vrsave insn, and we do not
      wish the argument registers to die.  */
-  for (i = crtl->args.info.vregno - 1; i >= ALTIVEC_ARG_MIN_REG; --i)
+  for (i = ctmrtl->args_info.vregno - 1; i >= ALTIVEC_ARG_MIN_REG; --i)
     mask &= ~ALTIVEC_REG_BIT (i);
 
   /* Similarly, remove the return value from the set.  */
Index: config/arc/arc.c
===================================================================
--- config/arc/arc.c	(revision 167152)
+++ config/arc/arc.c	(working copy)
@@ -2298,8 +2298,8 @@  arc_ccfsm_record_branch_deleted (void)
 arc_va_start (tree valist, rtx nextarg)
 {
   /* See arc_setup_incoming_varargs for reasons for this oddity.  */
-  if (crtl->args.info < 8
-      && (crtl->args.info & 1))
+  if (ctmrtl->args_info < 8
+      && (ctmrtl->args_info & 1))
     nextarg = plus_constant (nextarg, UNITS_PER_WORD);
 
   std_expand_builtin_va_start (valist, nextarg);
Index: config/arm/arm.c
===================================================================
--- config/arm/arm.c	(revision 167152)
+++ config/arm/arm.c	(working copy)
@@ -5258,7 +5258,7 @@  thumb_find_work_register (unsigned long 
   if (! cfun->machine->uses_anonymous_args
       && crtl->args.size >= 0
       && crtl->args.size <= (LAST_ARG_REGNUM * UNITS_PER_WORD)
-      && crtl->args.info.nregs < 4)
+      && ctmrtl->args_info.nregs < 4)
     return LAST_ARG_REGNUM;
 
   /* Otherwise look for a call-saved register that is going to be pushed.  */
Index: config/mips/mips.c
===================================================================
--- config/mips/mips.c	(revision 167152)
+++ config/mips/mips.c	(working copy)
@@ -5495,7 +5495,7 @@  mips_va_start (tree valist, rtx nextarg)
       int fpr_save_area_size;
       int fpr_offset;
 
-      cum = &crtl->args.info;
+      cum = &ctmrtl->args_info;
       gpr_save_area_size
 	= (MAX_ARGS_IN_REGISTERS - cum->num_gprs) * UNITS_PER_WORD;
       fpr_save_area_size
@@ -6038,7 +6038,7 @@  mips16_build_function_stub (void)
   fprintf (asm_out_file, "\t# Stub function for %s (",
 	   current_function_name ());
   separator = "";
-  for (f = (unsigned int) crtl->args.info.fp_code; f != 0; f >>= 2)
+  for (f = (unsigned int) ctmrtl->args_info.fp_code; f != 0; f >>= 2)
     {
       fprintf (asm_out_file, "%s%s", separator,
 	       (f & 3) == 1 ? "float" : "double");
@@ -6074,7 +6074,7 @@  mips16_build_function_stub (void)
   output_asm_insn ("la\t%^,%0", &symbol);
 
   /* Move the arguments from floating-point registers to general registers.  */
-  mips_output_args_xfer (crtl->args.info.fp_code, 'f');
+  mips_output_args_xfer (ctmrtl->args_info.fp_code, 'f');
 
   /* Jump to the MIPS16 function.  */
   output_asm_insn ("jr\t%^", NULL);
@@ -9846,7 +9846,7 @@  mips_output_function_prologue (FILE *fil
      floating-point arguments.  */
   if (TARGET_MIPS16
       && TARGET_HARD_FLOAT_ABI
-      && crtl->args.info.fp_code != 0)
+      && ctmrtl->args_info.fp_code != 0)
     mips16_build_function_stub ();
 
   /* Get the function name the same way that toplev.c does before calling
Index: config/mmix/mmix.c
===================================================================
--- config/mmix/mmix.c	(revision 167152)
+++ config/mmix/mmix.c	(working copy)
@@ -904,9 +904,9 @@  mmix_reorg (void)
      wasteful to optimize for unused parameter registers.  As of
      2002-04-30, df_regs_ever_live_p (n) seems to be set for only-reads too, but
      that might change.  */
-  if (!TARGET_ABI_GNU && regno < crtl->args.info.regs - 1)
+  if (!TARGET_ABI_GNU && regno < ctmrtl->args_info.regs - 1)
     {
-      regno = crtl->args.info.regs - 1;
+      regno = ctmrtl->args_info.regs - 1;
 
       /* We don't want to let this cause us to go over the limit and make
 	 incoming parameter registers be misnumbered and treating the last
Index: java/Make-lang.in
===================================================================
--- java/Make-lang.in	(revision 167152)
+++ java/Make-lang.in	(working copy)
@@ -297,7 +297,7 @@  java/jcf-depend.o: java/jcf-depend.c $(C
 java/jcf-parse.o: java/jcf-parse.c $(CONFIG_H) $(JAVA_TREE_H) $(FLAGS_H) \
   input.h java/java-except.h $(SYSTEM_H) coretypes.h toplev.h \
   java/parse.h $(GGC_H) debug.h $(REAL_H) gt-java-jcf-parse.h \
-  java/jcf-reader.c java/zipfile.h java/jcf.h $(BITMAP_H)
+  java/jcf-reader.c java/zipfile.h java/jcf.h $(BITMAP_H) $(TM_H)
 java/jvgenmain.o: java/jvgenmain.c $(CONFIG_H) $(JAVA_TREE_H) $(SYSTEM_H) \
   coretypes.h $(TM_H) intl.h
 java/lang.o: java/lang.c $(CONFIG_H) $(JAVA_TREE_H) java/jcf.h input.h \