OSDN Git Service

2004-07-14 Paolo Bonzini <bonzini@gnu.org>
[pf3gnuchains/gcc-fork.git] / gcc / emit-rtl.c
1 /* Emit RTL for the GCC expander.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22
23 /* Middle-to-low level generation of rtx code and insns.
24
25    This file contains support functions for creating rtl expressions
26    and manipulating them in the doubly-linked chain of insns.
27
28    The patterns of the insns are created by machine-dependent
29    routines in insn-emit.c, which is generated automatically from
30    the machine description.  These routines make the individual rtx's
31    of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch],
32    which are automatically generated from rtl.def; what is machine
33    dependent is the kind of rtx's they make and what arguments they
34    use.  */
35
36 #include "config.h"
37 #include "system.h"
38 #include "coretypes.h"
39 #include "tm.h"
40 #include "toplev.h"
41 #include "rtl.h"
42 #include "tree.h"
43 #include "tm_p.h"
44 #include "flags.h"
45 #include "function.h"
46 #include "expr.h"
47 #include "regs.h"
48 #include "hard-reg-set.h"
49 #include "hashtab.h"
50 #include "insn-config.h"
51 #include "recog.h"
52 #include "real.h"
53 #include "bitmap.h"
54 #include "basic-block.h"
55 #include "ggc.h"
56 #include "debug.h"
57 #include "langhooks.h"
58
59 /* Commonly used modes.  */
60
61 enum machine_mode byte_mode;    /* Mode whose width is BITS_PER_UNIT.  */
62 enum machine_mode word_mode;    /* Mode whose width is BITS_PER_WORD.  */
63 enum machine_mode double_mode;  /* Mode whose width is DOUBLE_TYPE_SIZE.  */
64 enum machine_mode ptr_mode;     /* Mode whose width is POINTER_SIZE.  */
65
66
67 /* This is *not* reset after each function.  It gives each CODE_LABEL
68    in the entire compilation a unique label number.  */
69
70 static GTY(()) int label_num = 1;
71
72 /* Highest label number in current function.
73    Zero means use the value of label_num instead.
74    This is nonzero only when belatedly compiling an inline function.  */
75
76 static int last_label_num;
77
78 /* Value label_num had when set_new_last_label_num was called.
79    If label_num has not changed since then, last_label_num is valid.  */
80
81 static int base_label_num;
82
83 /* Nonzero means do not generate NOTEs for source line numbers.  */
84
85 static int no_line_numbers;
86
87 /* Commonly used rtx's, so that we only need space for one copy.
88    These are initialized once for the entire compilation.
89    All of these are unique; no other rtx-object will be equal to any
90    of these.  */
91
92 rtx global_rtl[GR_MAX];
93
94 /* Commonly used RTL for hard registers.  These objects are not necessarily
95    unique, so we allocate them separately from global_rtl.  They are
96    initialized once per compilation unit, then copied into regno_reg_rtx
97    at the beginning of each function.  */
98 static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
99
100 /* We record floating-point CONST_DOUBLEs in each floating-point mode for
101    the values of 0, 1, and 2.  For the integer entries and VOIDmode, we
102    record a copy of const[012]_rtx.  */
103
104 rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
105
106 rtx const_true_rtx;
107
108 REAL_VALUE_TYPE dconst0;
109 REAL_VALUE_TYPE dconst1;
110 REAL_VALUE_TYPE dconst2;
111 REAL_VALUE_TYPE dconst3;
112 REAL_VALUE_TYPE dconst10;
113 REAL_VALUE_TYPE dconstm1;
114 REAL_VALUE_TYPE dconstm2;
115 REAL_VALUE_TYPE dconsthalf;
116 REAL_VALUE_TYPE dconstthird;
117 REAL_VALUE_TYPE dconstpi;
118 REAL_VALUE_TYPE dconste;
119
120 /* All references to the following fixed hard registers go through
121    these unique rtl objects.  On machines where the frame-pointer and
122    arg-pointer are the same register, they use the same unique object.
123
124    After register allocation, other rtl objects which used to be pseudo-regs
125    may be clobbered to refer to the frame-pointer register.
126    But references that were originally to the frame-pointer can be
127    distinguished from the others because they contain frame_pointer_rtx.
128
129    When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
130    tricky: until register elimination has taken place hard_frame_pointer_rtx
131    should be used if it is being set, and frame_pointer_rtx otherwise.  After
132    register elimination hard_frame_pointer_rtx should always be used.
133    On machines where the two registers are same (most) then these are the
134    same.
135
136    In an inline procedure, the stack and frame pointer rtxs may not be
137    used for anything else.  */
138 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
139 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
140 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
141
142 /* This is used to implement __builtin_return_address for some machines.
143    See for instance the MIPS port.  */
144 rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
145
146 /* We make one copy of (const_int C) where C is in
147    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
148    to save space during the compilation and simplify comparisons of
149    integers.  */
150
151 rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
152
153 /* A hash table storing CONST_INTs whose absolute value is greater
154    than MAX_SAVED_CONST_INT.  */
155
156 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
157      htab_t const_int_htab;
158
159 /* A hash table storing memory attribute structures.  */
160 static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
161      htab_t mem_attrs_htab;
162
163 /* A hash table storing register attribute structures.  */
164 static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
165      htab_t reg_attrs_htab;
166
167 /* A hash table storing all CONST_DOUBLEs.  */
168 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
169      htab_t const_double_htab;
170
171 #define first_insn (cfun->emit->x_first_insn)
172 #define last_insn (cfun->emit->x_last_insn)
173 #define cur_insn_uid (cfun->emit->x_cur_insn_uid)
174 #define last_location (cfun->emit->x_last_location)
175 #define first_label_num (cfun->emit->x_first_label_num)
176
177 static rtx make_jump_insn_raw (rtx);
178 static rtx make_call_insn_raw (rtx);
179 static rtx find_line_note (rtx);
180 static rtx change_address_1 (rtx, enum machine_mode, rtx, int);
181 static void unshare_all_decls (tree);
182 static void reset_used_decls (tree);
183 static void mark_label_nuses (rtx);
184 static hashval_t const_int_htab_hash (const void *);
185 static int const_int_htab_eq (const void *, const void *);
186 static hashval_t const_double_htab_hash (const void *);
187 static int const_double_htab_eq (const void *, const void *);
188 static rtx lookup_const_double (rtx);
189 static hashval_t mem_attrs_htab_hash (const void *);
190 static int mem_attrs_htab_eq (const void *, const void *);
191 static mem_attrs *get_mem_attrs (HOST_WIDE_INT, tree, rtx, rtx, unsigned int,
192                                  enum machine_mode);
193 static hashval_t reg_attrs_htab_hash (const void *);
194 static int reg_attrs_htab_eq (const void *, const void *);
195 static reg_attrs *get_reg_attrs (tree, int);
196 static tree component_ref_for_mem_expr (tree);
197 static rtx gen_const_vector_0 (enum machine_mode);
198 static rtx gen_complex_constant_part (enum machine_mode, rtx, int);
199 static void copy_rtx_if_shared_1 (rtx *orig);
200
201 /* Probability of the conditional branch currently proceeded by try_split.
202    Set to -1 otherwise.  */
203 int split_branch_probability = -1;
204 \f
205 /* Returns a hash code for X (which is a really a CONST_INT).  */
206
207 static hashval_t
208 const_int_htab_hash (const void *x)
209 {
210   return (hashval_t) INTVAL ((rtx) x);
211 }
212
213 /* Returns nonzero if the value represented by X (which is really a
214    CONST_INT) is the same as that given by Y (which is really a
215    HOST_WIDE_INT *).  */
216
217 static int
218 const_int_htab_eq (const void *x, const void *y)
219 {
220   return (INTVAL ((rtx) x) == *((const HOST_WIDE_INT *) y));
221 }
222
223 /* Returns a hash code for X (which is really a CONST_DOUBLE).  */
224 static hashval_t
225 const_double_htab_hash (const void *x)
226 {
227   rtx value = (rtx) x;
228   hashval_t h;
229
230   if (GET_MODE (value) == VOIDmode)
231     h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
232   else
233     {
234       h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
235       /* MODE is used in the comparison, so it should be in the hash.  */
236       h ^= GET_MODE (value);
237     }
238   return h;
239 }
240
241 /* Returns nonzero if the value represented by X (really a ...)
242    is the same as that represented by Y (really a ...) */
243 static int
244 const_double_htab_eq (const void *x, const void *y)
245 {
246   rtx a = (rtx)x, b = (rtx)y;
247
248   if (GET_MODE (a) != GET_MODE (b))
249     return 0;
250   if (GET_MODE (a) == VOIDmode)
251     return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
252             && CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
253   else
254     return real_identical (CONST_DOUBLE_REAL_VALUE (a),
255                            CONST_DOUBLE_REAL_VALUE (b));
256 }
257
258 /* Returns a hash code for X (which is a really a mem_attrs *).  */
259
260 static hashval_t
261 mem_attrs_htab_hash (const void *x)
262 {
263   mem_attrs *p = (mem_attrs *) x;
264
265   return (p->alias ^ (p->align * 1000)
266           ^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
267           ^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
268           ^ (size_t) p->expr);
269 }
270
271 /* Returns nonzero if the value represented by X (which is really a
272    mem_attrs *) is the same as that given by Y (which is also really a
273    mem_attrs *).  */
274
275 static int
276 mem_attrs_htab_eq (const void *x, const void *y)
277 {
278   mem_attrs *p = (mem_attrs *) x;
279   mem_attrs *q = (mem_attrs *) y;
280
281   return (p->alias == q->alias && p->expr == q->expr && p->offset == q->offset
282           && p->size == q->size && p->align == q->align);
283 }
284
285 /* Allocate a new mem_attrs structure and insert it into the hash table if
286    one identical to it is not already in the table.  We are doing this for
287    MEM of mode MODE.  */
288
289 static mem_attrs *
290 get_mem_attrs (HOST_WIDE_INT alias, tree expr, rtx offset, rtx size,
291                unsigned int align, enum machine_mode mode)
292 {
293   mem_attrs attrs;
294   void **slot;
295
296   /* If everything is the default, we can just return zero.
297      This must match what the corresponding MEM_* macros return when the
298      field is not present.  */
299   if (alias == 0 && expr == 0 && offset == 0
300       && (size == 0
301           || (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
302       && (STRICT_ALIGNMENT && mode != BLKmode
303           ? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
304     return 0;
305
306   attrs.alias = alias;
307   attrs.expr = expr;
308   attrs.offset = offset;
309   attrs.size = size;
310   attrs.align = align;
311
312   slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
313   if (*slot == 0)
314     {
315       *slot = ggc_alloc (sizeof (mem_attrs));
316       memcpy (*slot, &attrs, sizeof (mem_attrs));
317     }
318
319   return *slot;
320 }
321
322 /* Returns a hash code for X (which is a really a reg_attrs *).  */
323
324 static hashval_t
325 reg_attrs_htab_hash (const void *x)
326 {
327   reg_attrs *p = (reg_attrs *) x;
328
329   return ((p->offset * 1000) ^ (long) p->decl);
330 }
331
332 /* Returns nonzero if the value represented by X (which is really a
333    reg_attrs *) is the same as that given by Y (which is also really a
334    reg_attrs *).  */
335
336 static int
337 reg_attrs_htab_eq (const void *x, const void *y)
338 {
339   reg_attrs *p = (reg_attrs *) x;
340   reg_attrs *q = (reg_attrs *) y;
341
342   return (p->decl == q->decl && p->offset == q->offset);
343 }
344 /* Allocate a new reg_attrs structure and insert it into the hash table if
345    one identical to it is not already in the table.  We are doing this for
346    MEM of mode MODE.  */
347
348 static reg_attrs *
349 get_reg_attrs (tree decl, int offset)
350 {
351   reg_attrs attrs;
352   void **slot;
353
354   /* If everything is the default, we can just return zero.  */
355   if (decl == 0 && offset == 0)
356     return 0;
357
358   attrs.decl = decl;
359   attrs.offset = offset;
360
361   slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
362   if (*slot == 0)
363     {
364       *slot = ggc_alloc (sizeof (reg_attrs));
365       memcpy (*slot, &attrs, sizeof (reg_attrs));
366     }
367
368   return *slot;
369 }
370
371 /* Generate a new REG rtx.  Make sure ORIGINAL_REGNO is set properly, and
372    don't attempt to share with the various global pieces of rtl (such as
373    frame_pointer_rtx).  */
374
375 rtx
376 gen_raw_REG (enum machine_mode mode, int regno)
377 {
378   rtx x = gen_rtx_raw_REG (mode, regno);
379   ORIGINAL_REGNO (x) = regno;
380   return x;
381 }
382
383 /* There are some RTL codes that require special attention; the generation
384    functions do the raw handling.  If you add to this list, modify
385    special_rtx in gengenrtl.c as well.  */
386
387 rtx
388 gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
389 {
390   void **slot;
391
392   if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
393     return const_int_rtx[arg + MAX_SAVED_CONST_INT];
394
395 #if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
396   if (const_true_rtx && arg == STORE_FLAG_VALUE)
397     return const_true_rtx;
398 #endif
399
400   /* Look up the CONST_INT in the hash table.  */
401   slot = htab_find_slot_with_hash (const_int_htab, &arg,
402                                    (hashval_t) arg, INSERT);
403   if (*slot == 0)
404     *slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
405
406   return (rtx) *slot;
407 }
408
409 rtx
410 gen_int_mode (HOST_WIDE_INT c, enum machine_mode mode)
411 {
412   return GEN_INT (trunc_int_for_mode (c, mode));
413 }
414
415 /* CONST_DOUBLEs might be created from pairs of integers, or from
416    REAL_VALUE_TYPEs.  Also, their length is known only at run time,
417    so we cannot use gen_rtx_raw_CONST_DOUBLE.  */
418
419 /* Determine whether REAL, a CONST_DOUBLE, already exists in the
420    hash table.  If so, return its counterpart; otherwise add it
421    to the hash table and return it.  */
422 static rtx
423 lookup_const_double (rtx real)
424 {
425   void **slot = htab_find_slot (const_double_htab, real, INSERT);
426   if (*slot == 0)
427     *slot = real;
428
429   return (rtx) *slot;
430 }
431
432 /* Return a CONST_DOUBLE rtx for a floating-point value specified by
433    VALUE in mode MODE.  */
434 rtx
435 const_double_from_real_value (REAL_VALUE_TYPE value, enum machine_mode mode)
436 {
437   rtx real = rtx_alloc (CONST_DOUBLE);
438   PUT_MODE (real, mode);
439
440   memcpy (&CONST_DOUBLE_LOW (real), &value, sizeof (REAL_VALUE_TYPE));
441
442   return lookup_const_double (real);
443 }
444
445 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
446    of ints: I0 is the low-order word and I1 is the high-order word.
447    Do not use this routine for non-integer modes; convert to
448    REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE.  */
449
450 rtx
451 immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
452 {
453   rtx value;
454   unsigned int i;
455
456   if (mode != VOIDmode)
457     {
458       int width;
459       if (GET_MODE_CLASS (mode) != MODE_INT
460           && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT
461           /* We can get a 0 for an error mark.  */
462           && GET_MODE_CLASS (mode) != MODE_VECTOR_INT
463           && GET_MODE_CLASS (mode) != MODE_VECTOR_FLOAT)
464         abort ();
465
466       /* We clear out all bits that don't belong in MODE, unless they and
467          our sign bit are all one.  So we get either a reasonable negative
468          value or a reasonable unsigned value for this mode.  */
469       width = GET_MODE_BITSIZE (mode);
470       if (width < HOST_BITS_PER_WIDE_INT
471           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
472               != ((HOST_WIDE_INT) (-1) << (width - 1))))
473         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
474       else if (width == HOST_BITS_PER_WIDE_INT
475                && ! (i1 == ~0 && i0 < 0))
476         i1 = 0;
477       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
478         /* We cannot represent this value as a constant.  */
479         abort ();
480
481       /* If this would be an entire word for the target, but is not for
482          the host, then sign-extend on the host so that the number will
483          look the same way on the host that it would on the target.
484
485          For example, when building a 64 bit alpha hosted 32 bit sparc
486          targeted compiler, then we want the 32 bit unsigned value -1 to be
487          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
488          The latter confuses the sparc backend.  */
489
490       if (width < HOST_BITS_PER_WIDE_INT
491           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
492         i0 |= ((HOST_WIDE_INT) (-1) << width);
493
494       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a
495          CONST_INT.
496
497          ??? Strictly speaking, this is wrong if we create a CONST_INT for
498          a large unsigned constant with the size of MODE being
499          HOST_BITS_PER_WIDE_INT and later try to interpret that constant
500          in a wider mode.  In that case we will mis-interpret it as a
501          negative number.
502
503          Unfortunately, the only alternative is to make a CONST_DOUBLE for
504          any constant in any mode if it is an unsigned constant larger
505          than the maximum signed integer in an int on the host.  However,
506          doing this will break everyone that always expects to see a
507          CONST_INT for SImode and smaller.
508
509          We have always been making CONST_INTs in this case, so nothing
510          new is being broken.  */
511
512       if (width <= HOST_BITS_PER_WIDE_INT)
513         i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
514     }
515
516   /* If this integer fits in one word, return a CONST_INT.  */
517   if ((i1 == 0 && i0 >= 0) || (i1 == ~0 && i0 < 0))
518     return GEN_INT (i0);
519
520   /* We use VOIDmode for integers.  */
521   value = rtx_alloc (CONST_DOUBLE);
522   PUT_MODE (value, VOIDmode);
523
524   CONST_DOUBLE_LOW (value) = i0;
525   CONST_DOUBLE_HIGH (value) = i1;
526
527   for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
528     XWINT (value, i) = 0;
529
530   return lookup_const_double (value);
531 }
532
533 rtx
534 gen_rtx_REG (enum machine_mode mode, unsigned int regno)
535 {
536   /* In case the MD file explicitly references the frame pointer, have
537      all such references point to the same frame pointer.  This is
538      used during frame pointer elimination to distinguish the explicit
539      references to these registers from pseudos that happened to be
540      assigned to them.
541
542      If we have eliminated the frame pointer or arg pointer, we will
543      be using it as a normal register, for example as a spill
544      register.  In such cases, we might be accessing it in a mode that
545      is not Pmode and therefore cannot use the pre-allocated rtx.
546
547      Also don't do this when we are making new REGs in reload, since
548      we don't want to get confused with the real pointers.  */
549
550   if (mode == Pmode && !reload_in_progress)
551     {
552       if (regno == FRAME_POINTER_REGNUM
553           && (!reload_completed || frame_pointer_needed))
554         return frame_pointer_rtx;
555 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
556       if (regno == HARD_FRAME_POINTER_REGNUM
557           && (!reload_completed || frame_pointer_needed))
558         return hard_frame_pointer_rtx;
559 #endif
560 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
561       if (regno == ARG_POINTER_REGNUM)
562         return arg_pointer_rtx;
563 #endif
564 #ifdef RETURN_ADDRESS_POINTER_REGNUM
565       if (regno == RETURN_ADDRESS_POINTER_REGNUM)
566         return return_address_pointer_rtx;
567 #endif
568       if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
569           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
570         return pic_offset_table_rtx;
571       if (regno == STACK_POINTER_REGNUM)
572         return stack_pointer_rtx;
573     }
574
575 #if 0
576   /* If the per-function register table has been set up, try to re-use
577      an existing entry in that table to avoid useless generation of RTL.
578
579      This code is disabled for now until we can fix the various backends
580      which depend on having non-shared hard registers in some cases.   Long
581      term we want to re-enable this code as it can significantly cut down
582      on the amount of useless RTL that gets generated.
583
584      We'll also need to fix some code that runs after reload that wants to
585      set ORIGINAL_REGNO.  */
586
587   if (cfun
588       && cfun->emit
589       && regno_reg_rtx
590       && regno < FIRST_PSEUDO_REGISTER
591       && reg_raw_mode[regno] == mode)
592     return regno_reg_rtx[regno];
593 #endif
594
595   return gen_raw_REG (mode, regno);
596 }
597
598 rtx
599 gen_rtx_MEM (enum machine_mode mode, rtx addr)
600 {
601   rtx rt = gen_rtx_raw_MEM (mode, addr);
602
603   /* This field is not cleared by the mere allocation of the rtx, so
604      we clear it here.  */
605   MEM_ATTRS (rt) = 0;
606
607   return rt;
608 }
609
610 rtx
611 gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
612 {
613   /* This is the most common failure type.
614      Catch it early so we can see who does it.  */
615   if ((offset % GET_MODE_SIZE (mode)) != 0)
616     abort ();
617
618   /* This check isn't usable right now because combine will
619      throw arbitrary crap like a CALL into a SUBREG in
620      gen_lowpart_for_combine so we must just eat it.  */
621 #if 0
622   /* Check for this too.  */
623   if (offset >= GET_MODE_SIZE (GET_MODE (reg)))
624     abort ();
625 #endif
626   return gen_rtx_raw_SUBREG (mode, reg, offset);
627 }
628
629 /* Generate a SUBREG representing the least-significant part of REG if MODE
630    is smaller than mode of REG, otherwise paradoxical SUBREG.  */
631
632 rtx
633 gen_lowpart_SUBREG (enum machine_mode mode, rtx reg)
634 {
635   enum machine_mode inmode;
636
637   inmode = GET_MODE (reg);
638   if (inmode == VOIDmode)
639     inmode = mode;
640   return gen_rtx_SUBREG (mode, reg,
641                          subreg_lowpart_offset (mode, inmode));
642 }
643 \f
644 /* gen_rtvec (n, [rt1, ..., rtn])
645 **
646 **          This routine creates an rtvec and stores within it the
647 **      pointers to rtx's which are its arguments.
648 */
649
650 /*VARARGS1*/
651 rtvec
652 gen_rtvec (int n, ...)
653 {
654   int i, save_n;
655   rtx *vector;
656   va_list p;
657
658   va_start (p, n);
659
660   if (n == 0)
661     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
662
663   vector = alloca (n * sizeof (rtx));
664
665   for (i = 0; i < n; i++)
666     vector[i] = va_arg (p, rtx);
667
668   /* The definition of VA_* in K&R C causes `n' to go out of scope.  */
669   save_n = n;
670   va_end (p);
671
672   return gen_rtvec_v (save_n, vector);
673 }
674
675 rtvec
676 gen_rtvec_v (int n, rtx *argp)
677 {
678   int i;
679   rtvec rt_val;
680
681   if (n == 0)
682     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
683
684   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
685
686   for (i = 0; i < n; i++)
687     rt_val->elem[i] = *argp++;
688
689   return rt_val;
690 }
691 \f
692 /* Generate a REG rtx for a new pseudo register of mode MODE.
693    This pseudo is assigned the next sequential register number.  */
694
695 rtx
696 gen_reg_rtx (enum machine_mode mode)
697 {
698   struct function *f = cfun;
699   rtx val;
700
701   /* Don't let anything called after initial flow analysis create new
702      registers.  */
703   if (no_new_pseudos)
704     abort ();
705
706   if (generating_concat_p
707       && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
708           || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
709     {
710       /* For complex modes, don't make a single pseudo.
711          Instead, make a CONCAT of two pseudos.
712          This allows noncontiguous allocation of the real and imaginary parts,
713          which makes much better code.  Besides, allocating DCmode
714          pseudos overstrains reload on some machines like the 386.  */
715       rtx realpart, imagpart;
716       enum machine_mode partmode = GET_MODE_INNER (mode);
717
718       realpart = gen_reg_rtx (partmode);
719       imagpart = gen_reg_rtx (partmode);
720       return gen_rtx_CONCAT (mode, realpart, imagpart);
721     }
722
723   /* Make sure regno_pointer_align, and regno_reg_rtx are large
724      enough to have an element for this pseudo reg number.  */
725
726   if (reg_rtx_no == f->emit->regno_pointer_align_length)
727     {
728       int old_size = f->emit->regno_pointer_align_length;
729       char *new;
730       rtx *new1;
731
732       new = ggc_realloc (f->emit->regno_pointer_align, old_size * 2);
733       memset (new + old_size, 0, old_size);
734       f->emit->regno_pointer_align = (unsigned char *) new;
735
736       new1 = ggc_realloc (f->emit->x_regno_reg_rtx,
737                           old_size * 2 * sizeof (rtx));
738       memset (new1 + old_size, 0, old_size * sizeof (rtx));
739       regno_reg_rtx = new1;
740
741       f->emit->regno_pointer_align_length = old_size * 2;
742     }
743
744   val = gen_raw_REG (mode, reg_rtx_no);
745   regno_reg_rtx[reg_rtx_no++] = val;
746   return val;
747 }
748
749 /* Generate a register with same attributes as REG, but offsetted by OFFSET.
750    Do the big endian correction if needed.  */
751
752 rtx
753 gen_rtx_REG_offset (rtx reg, enum machine_mode mode, unsigned int regno, int offset)
754 {
755   rtx new = gen_rtx_REG (mode, regno);
756   tree decl;
757   HOST_WIDE_INT var_size;
758
759   /* PR middle-end/14084
760      The problem appears when a variable is stored in a larger register
761      and later it is used in the original mode or some mode in between
762      or some part of variable is accessed.
763
764      On little endian machines there is no problem because
765      the REG_OFFSET of the start of the variable is the same when
766      accessed in any mode (it is 0).
767
768      However, this is not true on big endian machines.
769      The offset of the start of the variable is different when accessed
770      in different modes.
771      When we are taking a part of the REG we have to change the OFFSET
772      from offset WRT size of mode of REG to offset WRT size of variable.
773
774      If we would not do the big endian correction the resulting REG_OFFSET
775      would be larger than the size of the DECL.
776
777      Examples of correction, for BYTES_BIG_ENDIAN WORDS_BIG_ENDIAN machine:
778
779      REG.mode  MODE  DECL size  old offset  new offset  description
780      DI        SI    4          4           0           int32 in SImode
781      DI        SI    1          4           0           char in SImode
782      DI        QI    1          7           0           char in QImode
783      DI        QI    4          5           1           1st element in QImode
784                                                         of char[4]
785      DI        HI    4          6           2           1st element in HImode
786                                                         of int16[2]
787
788      If the size of DECL is equal or greater than the size of REG
789      we can't do this correction because the register holds the
790      whole variable or a part of the variable and thus the REG_OFFSET
791      is already correct.  */
792
793   decl = REG_EXPR (reg);
794   if ((BYTES_BIG_ENDIAN || WORDS_BIG_ENDIAN)
795       && decl != NULL
796       && offset > 0
797       && GET_MODE_SIZE (GET_MODE (reg)) > GET_MODE_SIZE (mode)
798       && ((var_size = int_size_in_bytes (TREE_TYPE (decl))) > 0
799           && var_size < GET_MODE_SIZE (GET_MODE (reg))))
800     {
801       int offset_le;
802
803       /* Convert machine endian to little endian WRT size of mode of REG.  */
804       if (WORDS_BIG_ENDIAN)
805         offset_le = ((GET_MODE_SIZE (GET_MODE (reg)) - 1 - offset)
806                      / UNITS_PER_WORD) * UNITS_PER_WORD;
807       else
808         offset_le = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
809
810       if (BYTES_BIG_ENDIAN)
811         offset_le += ((GET_MODE_SIZE (GET_MODE (reg)) - 1 - offset)
812                       % UNITS_PER_WORD);
813       else
814         offset_le += offset % UNITS_PER_WORD;
815
816       if (offset_le >= var_size)
817         {
818           /* MODE is wider than the variable so the new reg will cover
819              the whole variable so the resulting OFFSET should be 0.  */
820           offset = 0;
821         }
822       else
823         {
824           /* Convert little endian to machine endian WRT size of variable.  */
825           if (WORDS_BIG_ENDIAN)
826             offset = ((var_size - 1 - offset_le)
827                       / UNITS_PER_WORD) * UNITS_PER_WORD;
828           else
829             offset = (offset_le / UNITS_PER_WORD) * UNITS_PER_WORD;
830
831           if (BYTES_BIG_ENDIAN)
832             offset += ((var_size - 1 - offset_le)
833                        % UNITS_PER_WORD);
834           else
835             offset += offset_le % UNITS_PER_WORD;
836         }
837     }
838
839   REG_ATTRS (new) = get_reg_attrs (REG_EXPR (reg),
840                                    REG_OFFSET (reg) + offset);
841   return new;
842 }
843
844 /* Set the decl for MEM to DECL.  */
845
846 void
847 set_reg_attrs_from_mem (rtx reg, rtx mem)
848 {
849   if (MEM_OFFSET (mem) && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
850     REG_ATTRS (reg)
851       = get_reg_attrs (MEM_EXPR (mem), INTVAL (MEM_OFFSET (mem)));
852 }
853
854 /* Set the register attributes for registers contained in PARM_RTX.
855    Use needed values from memory attributes of MEM.  */
856
857 void
858 set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
859 {
860   if (REG_P (parm_rtx))
861     set_reg_attrs_from_mem (parm_rtx, mem);
862   else if (GET_CODE (parm_rtx) == PARALLEL)
863     {
864       /* Check for a NULL entry in the first slot, used to indicate that the
865          parameter goes both on the stack and in registers.  */
866       int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
867       for (; i < XVECLEN (parm_rtx, 0); i++)
868         {
869           rtx x = XVECEXP (parm_rtx, 0, i);
870           if (REG_P (XEXP (x, 0)))
871             REG_ATTRS (XEXP (x, 0))
872               = get_reg_attrs (MEM_EXPR (mem),
873                                INTVAL (XEXP (x, 1)));
874         }
875     }
876 }
877
878 /* Assign the RTX X to declaration T.  */
879 void
880 set_decl_rtl (tree t, rtx x)
881 {
882   DECL_CHECK (t)->decl.rtl = x;
883
884   if (!x)
885     return;
886   /* For register, we maintain the reverse information too.  */
887   if (REG_P (x))
888     REG_ATTRS (x) = get_reg_attrs (t, 0);
889   else if (GET_CODE (x) == SUBREG)
890     REG_ATTRS (SUBREG_REG (x))
891       = get_reg_attrs (t, -SUBREG_BYTE (x));
892   if (GET_CODE (x) == CONCAT)
893     {
894       if (REG_P (XEXP (x, 0)))
895         REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
896       if (REG_P (XEXP (x, 1)))
897         REG_ATTRS (XEXP (x, 1))
898           = get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
899     }
900   if (GET_CODE (x) == PARALLEL)
901     {
902       int i;
903       for (i = 0; i < XVECLEN (x, 0); i++)
904         {
905           rtx y = XVECEXP (x, 0, i);
906           if (REG_P (XEXP (y, 0)))
907             REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
908         }
909     }
910 }
911
912 /* Assign the RTX X to parameter declaration T.  */
913 void
914 set_decl_incoming_rtl (tree t, rtx x)
915 {
916   DECL_INCOMING_RTL (t) = x;
917
918   if (!x)
919     return;
920   /* For register, we maintain the reverse information too.  */
921   if (REG_P (x))
922     REG_ATTRS (x) = get_reg_attrs (t, 0);
923   else if (GET_CODE (x) == SUBREG)
924     REG_ATTRS (SUBREG_REG (x))
925       = get_reg_attrs (t, -SUBREG_BYTE (x));
926   if (GET_CODE (x) == CONCAT)
927     {
928       if (REG_P (XEXP (x, 0)))
929         REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
930       if (REG_P (XEXP (x, 1)))
931         REG_ATTRS (XEXP (x, 1))
932           = get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
933     }
934   if (GET_CODE (x) == PARALLEL)
935     {
936       int i, start;
937
938       /* Check for a NULL entry, used to indicate that the parameter goes
939          both on the stack and in registers.  */
940       if (XEXP (XVECEXP (x, 0, 0), 0))
941         start = 0;
942       else
943         start = 1;
944
945       for (i = start; i < XVECLEN (x, 0); i++)
946         {
947           rtx y = XVECEXP (x, 0, i);
948           if (REG_P (XEXP (y, 0)))
949             REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
950         }
951     }
952 }
953
954 /* Identify REG (which may be a CONCAT) as a user register.  */
955
956 void
957 mark_user_reg (rtx reg)
958 {
959   if (GET_CODE (reg) == CONCAT)
960     {
961       REG_USERVAR_P (XEXP (reg, 0)) = 1;
962       REG_USERVAR_P (XEXP (reg, 1)) = 1;
963     }
964   else if (REG_P (reg))
965     REG_USERVAR_P (reg) = 1;
966   else
967     abort ();
968 }
969
970 /* Identify REG as a probable pointer register and show its alignment
971    as ALIGN, if nonzero.  */
972
973 void
974 mark_reg_pointer (rtx reg, int align)
975 {
976   if (! REG_POINTER (reg))
977     {
978       REG_POINTER (reg) = 1;
979
980       if (align)
981         REGNO_POINTER_ALIGN (REGNO (reg)) = align;
982     }
983   else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
984     /* We can no-longer be sure just how aligned this pointer is.  */
985     REGNO_POINTER_ALIGN (REGNO (reg)) = align;
986 }
987
988 /* Return 1 plus largest pseudo reg number used in the current function.  */
989
990 int
991 max_reg_num (void)
992 {
993   return reg_rtx_no;
994 }
995
996 /* Return 1 + the largest label number used so far in the current function.  */
997
998 int
999 max_label_num (void)
1000 {
1001   if (last_label_num && label_num == base_label_num)
1002     return last_label_num;
1003   return label_num;
1004 }
1005
1006 /* Return first label number used in this function (if any were used).  */
1007
1008 int
1009 get_first_label_num (void)
1010 {
1011   return first_label_num;
1012 }
1013
1014 /* If the rtx for label was created during the expansion of a nested
1015    function, then first_label_num won't include this label number.
1016    Fix this now so that array indicies work later.  */
1017
1018 void
1019 maybe_set_first_label_num (rtx x)
1020 {
1021   if (CODE_LABEL_NUMBER (x) < first_label_num)
1022     first_label_num = CODE_LABEL_NUMBER (x);
1023 }
1024 \f
1025 /* Return the final regno of X, which is a SUBREG of a hard
1026    register.  */
1027 int
1028 subreg_hard_regno (rtx x, int check_mode)
1029 {
1030   enum machine_mode mode = GET_MODE (x);
1031   unsigned int byte_offset, base_regno, final_regno;
1032   rtx reg = SUBREG_REG (x);
1033
1034   /* This is where we attempt to catch illegal subregs
1035      created by the compiler.  */
1036   if (GET_CODE (x) != SUBREG
1037       || !REG_P (reg))
1038     abort ();
1039   base_regno = REGNO (reg);
1040   if (base_regno >= FIRST_PSEUDO_REGISTER)
1041     abort ();
1042   if (check_mode && ! HARD_REGNO_MODE_OK (base_regno, GET_MODE (reg)))
1043     abort ();
1044 #ifdef ENABLE_CHECKING
1045   if (!subreg_offset_representable_p (REGNO (reg), GET_MODE (reg),
1046                                       SUBREG_BYTE (x), mode))
1047     abort ();
1048 #endif
1049   /* Catch non-congruent offsets too.  */
1050   byte_offset = SUBREG_BYTE (x);
1051   if ((byte_offset % GET_MODE_SIZE (mode)) != 0)
1052     abort ();
1053
1054   final_regno = subreg_regno (x);
1055
1056   return final_regno;
1057 }
1058
1059 /* Return a value representing some low-order bits of X, where the number
1060    of low-order bits is given by MODE.  Note that no conversion is done
1061    between floating-point and fixed-point values, rather, the bit
1062    representation is returned.
1063
1064    This function handles the cases in common between gen_lowpart, below,
1065    and two variants in cse.c and combine.c.  These are the cases that can
1066    be safely handled at all points in the compilation.
1067
1068    If this is not a case we can handle, return 0.  */
1069
1070 rtx
1071 gen_lowpart_common (enum machine_mode mode, rtx x)
1072 {
1073   int msize = GET_MODE_SIZE (mode);
1074   int xsize;
1075   int offset = 0;
1076   enum machine_mode innermode;
1077
1078   /* Unfortunately, this routine doesn't take a parameter for the mode of X,
1079      so we have to make one up.  Yuk.  */
1080   innermode = GET_MODE (x);
1081   if (GET_CODE (x) == CONST_INT && msize <= HOST_BITS_PER_WIDE_INT)
1082     innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
1083   else if (innermode == VOIDmode)
1084     innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0);
1085   
1086   xsize = GET_MODE_SIZE (innermode);
1087
1088   if (innermode == VOIDmode || innermode == BLKmode)
1089     abort ();
1090
1091   if (innermode == mode)
1092     return x;
1093
1094   /* MODE must occupy no more words than the mode of X.  */
1095   if ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
1096       > ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
1097     return 0;
1098
1099   /* Don't allow generating paradoxical FLOAT_MODE subregs.  */
1100   if (GET_MODE_CLASS (mode) == MODE_FLOAT && msize > xsize)
1101     return 0;
1102
1103   offset = subreg_lowpart_offset (mode, innermode);
1104
1105   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
1106       && (GET_MODE_CLASS (mode) == MODE_INT
1107           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
1108     {
1109       /* If we are getting the low-order part of something that has been
1110          sign- or zero-extended, we can either just use the object being
1111          extended or make a narrower extension.  If we want an even smaller
1112          piece than the size of the object being extended, call ourselves
1113          recursively.
1114
1115          This case is used mostly by combine and cse.  */
1116
1117       if (GET_MODE (XEXP (x, 0)) == mode)
1118         return XEXP (x, 0);
1119       else if (msize < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
1120         return gen_lowpart_common (mode, XEXP (x, 0));
1121       else if (msize < xsize)
1122         return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
1123     }
1124   else if (GET_CODE (x) == SUBREG || REG_P (x)
1125            || GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
1126            || GET_CODE (x) == CONST_DOUBLE || GET_CODE (x) == CONST_INT)
1127     return simplify_gen_subreg (mode, x, innermode, offset);
1128
1129   /* Otherwise, we can't do this.  */
1130   return 0;
1131 }
1132 \f
1133 /* Return the constant real or imaginary part (which has mode MODE)
1134    of a complex value X.  The IMAGPART_P argument determines whether
1135    the real or complex component should be returned.  This function
1136    returns NULL_RTX if the component isn't a constant.  */
1137
1138 static rtx
1139 gen_complex_constant_part (enum machine_mode mode, rtx x, int imagpart_p)
1140 {
1141   tree decl, part;
1142
1143   if (MEM_P (x)
1144       && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
1145     {
1146       decl = SYMBOL_REF_DECL (XEXP (x, 0));
1147       if (decl != NULL_TREE && TREE_CODE (decl) == COMPLEX_CST)
1148         {
1149           part = imagpart_p ? TREE_IMAGPART (decl) : TREE_REALPART (decl);
1150           if (TREE_CODE (part) == REAL_CST
1151               || TREE_CODE (part) == INTEGER_CST)
1152             return expand_expr (part, NULL_RTX, mode, 0);
1153         }
1154     }
1155   return NULL_RTX;
1156 }
1157
1158 /* Return the real part (which has mode MODE) of a complex value X.
1159    This always comes at the low address in memory.  */
1160
1161 rtx
1162 gen_realpart (enum machine_mode mode, rtx x)
1163 {
1164   rtx part;
1165
1166   /* Handle complex constants.  */
1167   part = gen_complex_constant_part (mode, x, 0);
1168   if (part != NULL_RTX)
1169     return part;
1170
1171   if (WORDS_BIG_ENDIAN
1172       && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1173       && REG_P (x)
1174       && REGNO (x) < FIRST_PSEUDO_REGISTER)
1175     internal_error
1176       ("can't access real part of complex value in hard register");
1177   else if (WORDS_BIG_ENDIAN)
1178     return gen_highpart (mode, x);
1179   else
1180     return gen_lowpart (mode, x);
1181 }
1182
1183 /* Return the imaginary part (which has mode MODE) of a complex value X.
1184    This always comes at the high address in memory.  */
1185
1186 rtx
1187 gen_imagpart (enum machine_mode mode, rtx x)
1188 {
1189   rtx part;
1190
1191   /* Handle complex constants.  */
1192   part = gen_complex_constant_part (mode, x, 1);
1193   if (part != NULL_RTX)
1194     return part;
1195
1196   if (WORDS_BIG_ENDIAN)
1197     return gen_lowpart (mode, x);
1198   else if (! WORDS_BIG_ENDIAN
1199            && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1200            && REG_P (x)
1201            && REGNO (x) < FIRST_PSEUDO_REGISTER)
1202     internal_error
1203       ("can't access imaginary part of complex value in hard register");
1204   else
1205     return gen_highpart (mode, x);
1206 }
1207 \f
1208 rtx
1209 gen_highpart (enum machine_mode mode, rtx x)
1210 {
1211   unsigned int msize = GET_MODE_SIZE (mode);
1212   rtx result;
1213
1214   /* This case loses if X is a subreg.  To catch bugs early,
1215      complain if an invalid MODE is used even in other cases.  */
1216   if (msize > UNITS_PER_WORD
1217       && msize != (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)))
1218     abort ();
1219
1220   result = simplify_gen_subreg (mode, x, GET_MODE (x),
1221                                 subreg_highpart_offset (mode, GET_MODE (x)));
1222
1223   /* simplify_gen_subreg is not guaranteed to return a valid operand for
1224      the target if we have a MEM.  gen_highpart must return a valid operand,
1225      emitting code if necessary to do so.  */
1226   if (result != NULL_RTX && MEM_P (result))
1227     result = validize_mem (result);
1228
1229   if (!result)
1230     abort ();
1231   return result;
1232 }
1233
1234 /* Like gen_highpart, but accept mode of EXP operand in case EXP can
1235    be VOIDmode constant.  */
1236 rtx
1237 gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx exp)
1238 {
1239   if (GET_MODE (exp) != VOIDmode)
1240     {
1241       if (GET_MODE (exp) != innermode)
1242         abort ();
1243       return gen_highpart (outermode, exp);
1244     }
1245   return simplify_gen_subreg (outermode, exp, innermode,
1246                               subreg_highpart_offset (outermode, innermode));
1247 }
1248
1249 /* Return offset in bytes to get OUTERMODE low part
1250    of the value in mode INNERMODE stored in memory in target format.  */
1251
1252 unsigned int
1253 subreg_lowpart_offset (enum machine_mode outermode, enum machine_mode innermode)
1254 {
1255   unsigned int offset = 0;
1256   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1257
1258   if (difference > 0)
1259     {
1260       if (WORDS_BIG_ENDIAN)
1261         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1262       if (BYTES_BIG_ENDIAN)
1263         offset += difference % UNITS_PER_WORD;
1264     }
1265
1266   return offset;
1267 }
1268
1269 /* Return offset in bytes to get OUTERMODE high part
1270    of the value in mode INNERMODE stored in memory in target format.  */
1271 unsigned int
1272 subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode)
1273 {
1274   unsigned int offset = 0;
1275   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1276
1277   if (GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
1278     abort ();
1279
1280   if (difference > 0)
1281     {
1282       if (! WORDS_BIG_ENDIAN)
1283         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1284       if (! BYTES_BIG_ENDIAN)
1285         offset += difference % UNITS_PER_WORD;
1286     }
1287
1288   return offset;
1289 }
1290
1291 /* Return 1 iff X, assumed to be a SUBREG,
1292    refers to the least significant part of its containing reg.
1293    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1294
1295 int
1296 subreg_lowpart_p (rtx x)
1297 {
1298   if (GET_CODE (x) != SUBREG)
1299     return 1;
1300   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1301     return 0;
1302
1303   return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
1304           == SUBREG_BYTE (x));
1305 }
1306 \f
1307 /* Return subword OFFSET of operand OP.
1308    The word number, OFFSET, is interpreted as the word number starting
1309    at the low-order address.  OFFSET 0 is the low-order word if not
1310    WORDS_BIG_ENDIAN, otherwise it is the high-order word.
1311
1312    If we cannot extract the required word, we return zero.  Otherwise,
1313    an rtx corresponding to the requested word will be returned.
1314
1315    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1316    reload has completed, a valid address will always be returned.  After
1317    reload, if a valid address cannot be returned, we return zero.
1318
1319    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1320    it is the responsibility of the caller.
1321
1322    MODE is the mode of OP in case it is a CONST_INT.
1323
1324    ??? This is still rather broken for some cases.  The problem for the
1325    moment is that all callers of this thing provide no 'goal mode' to
1326    tell us to work with.  This exists because all callers were written
1327    in a word based SUBREG world.
1328    Now use of this function can be deprecated by simplify_subreg in most
1329    cases.
1330  */
1331
1332 rtx
1333 operand_subword (rtx op, unsigned int offset, int validate_address, enum machine_mode mode)
1334 {
1335   if (mode == VOIDmode)
1336     mode = GET_MODE (op);
1337
1338   if (mode == VOIDmode)
1339     abort ();
1340
1341   /* If OP is narrower than a word, fail.  */
1342   if (mode != BLKmode
1343       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1344     return 0;
1345
1346   /* If we want a word outside OP, return zero.  */
1347   if (mode != BLKmode
1348       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1349     return const0_rtx;
1350
1351   /* Form a new MEM at the requested address.  */
1352   if (MEM_P (op))
1353     {
1354       rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1355
1356       if (! validate_address)
1357         return new;
1358
1359       else if (reload_completed)
1360         {
1361           if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
1362             return 0;
1363         }
1364       else
1365         return replace_equiv_address (new, XEXP (new, 0));
1366     }
1367
1368   /* Rest can be handled by simplify_subreg.  */
1369   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1370 }
1371
1372 /* Similar to `operand_subword', but never return 0.  If we can't extract
1373    the required subword, put OP into a register and try again.  If that fails,
1374    abort.  We always validate the address in this case.
1375
1376    MODE is the mode of OP, in case it is CONST_INT.  */
1377
1378 rtx
1379 operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
1380 {
1381   rtx result = operand_subword (op, offset, 1, mode);
1382
1383   if (result)
1384     return result;
1385
1386   if (mode != BLKmode && mode != VOIDmode)
1387     {
1388       /* If this is a register which can not be accessed by words, copy it
1389          to a pseudo register.  */
1390       if (REG_P (op))
1391         op = copy_to_reg (op);
1392       else
1393         op = force_reg (mode, op);
1394     }
1395
1396   result = operand_subword (op, offset, 1, mode);
1397   if (result == 0)
1398     abort ();
1399
1400   return result;
1401 }
1402 \f
1403 /* Given a compare instruction, swap the operands.
1404    A test instruction is changed into a compare of 0 against the operand.  */
1405
1406 void
1407 reverse_comparison (rtx insn)
1408 {
1409   rtx body = PATTERN (insn);
1410   rtx comp;
1411
1412   if (GET_CODE (body) == SET)
1413     comp = SET_SRC (body);
1414   else
1415     comp = SET_SRC (XVECEXP (body, 0, 0));
1416
1417   if (GET_CODE (comp) == COMPARE)
1418     {
1419       rtx op0 = XEXP (comp, 0);
1420       rtx op1 = XEXP (comp, 1);
1421       XEXP (comp, 0) = op1;
1422       XEXP (comp, 1) = op0;
1423     }
1424   else
1425     {
1426       rtx new = gen_rtx_COMPARE (VOIDmode,
1427                                  CONST0_RTX (GET_MODE (comp)), comp);
1428       if (GET_CODE (body) == SET)
1429         SET_SRC (body) = new;
1430       else
1431         SET_SRC (XVECEXP (body, 0, 0)) = new;
1432     }
1433 }
1434 \f
1435 /* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
1436    or (2) a component ref of something variable.  Represent the later with
1437    a NULL expression.  */
1438
1439 static tree
1440 component_ref_for_mem_expr (tree ref)
1441 {
1442   tree inner = TREE_OPERAND (ref, 0);
1443
1444   if (TREE_CODE (inner) == COMPONENT_REF)
1445     inner = component_ref_for_mem_expr (inner);
1446   else
1447     {
1448       /* Now remove any conversions: they don't change what the underlying
1449          object is.  Likewise for SAVE_EXPR.  */
1450       while (TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR
1451              || TREE_CODE (inner) == NON_LVALUE_EXPR
1452              || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1453              || TREE_CODE (inner) == SAVE_EXPR)
1454         inner = TREE_OPERAND (inner, 0);
1455
1456       if (! DECL_P (inner))
1457         inner = NULL_TREE;
1458     }
1459
1460   if (inner == TREE_OPERAND (ref, 0))
1461     return ref;
1462   else
1463     return build (COMPONENT_REF, TREE_TYPE (ref), inner, TREE_OPERAND (ref, 1),
1464                   NULL_TREE);
1465 }
1466
1467 /* Returns 1 if both MEM_EXPR can be considered equal
1468    and 0 otherwise.  */
1469
1470 int
1471 mem_expr_equal_p (tree expr1, tree expr2)
1472 {
1473   if (expr1 == expr2)
1474     return 1;
1475
1476   if (! expr1 || ! expr2)
1477     return 0;
1478
1479   if (TREE_CODE (expr1) != TREE_CODE (expr2))
1480     return 0;
1481
1482   if (TREE_CODE (expr1) == COMPONENT_REF)
1483     return 
1484       mem_expr_equal_p (TREE_OPERAND (expr1, 0),
1485                         TREE_OPERAND (expr2, 0))
1486       && mem_expr_equal_p (TREE_OPERAND (expr1, 1), /* field decl */
1487                            TREE_OPERAND (expr2, 1));
1488   
1489   if (TREE_CODE (expr1) == INDIRECT_REF)
1490     return mem_expr_equal_p (TREE_OPERAND (expr1, 0),
1491                              TREE_OPERAND (expr2, 0));
1492   
1493   /* Decls with different pointers can't be equal.  */
1494   if (DECL_P (expr1))
1495     return 0;
1496
1497   abort(); /* ARRAY_REFs, ARRAY_RANGE_REFs and BIT_FIELD_REFs should already
1498               have been resolved here.  */
1499 }
1500
1501 /* Given REF, a MEM, and T, either the type of X or the expression
1502    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
1503    if we are making a new object of this type.  BITPOS is nonzero if
1504    there is an offset outstanding on T that will be applied later.  */
1505
1506 void
1507 set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
1508                                  HOST_WIDE_INT bitpos)
1509 {
1510   HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
1511   tree expr = MEM_EXPR (ref);
1512   rtx offset = MEM_OFFSET (ref);
1513   rtx size = MEM_SIZE (ref);
1514   unsigned int align = MEM_ALIGN (ref);
1515   HOST_WIDE_INT apply_bitpos = 0;
1516   tree type;
1517
1518   /* It can happen that type_for_mode was given a mode for which there
1519      is no language-level type.  In which case it returns NULL, which
1520      we can see here.  */
1521   if (t == NULL_TREE)
1522     return;
1523
1524   type = TYPE_P (t) ? t : TREE_TYPE (t);
1525   if (type == error_mark_node)
1526     return;
1527
1528   /* If we have already set DECL_RTL = ref, get_alias_set will get the
1529      wrong answer, as it assumes that DECL_RTL already has the right alias
1530      info.  Callers should not set DECL_RTL until after the call to
1531      set_mem_attributes.  */
1532   if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
1533     abort ();
1534
1535   /* Get the alias set from the expression or type (perhaps using a
1536      front-end routine) and use it.  */
1537   alias = get_alias_set (t);
1538
1539   MEM_VOLATILE_P (ref) |= TYPE_VOLATILE (type);
1540   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
1541   RTX_UNCHANGING_P (ref)
1542     |= ((lang_hooks.honor_readonly
1543          && (TYPE_READONLY (type) || (t != type && TREE_READONLY (t))))
1544         || (! TYPE_P (t) && TREE_CONSTANT (t)));
1545   MEM_POINTER (ref) = POINTER_TYPE_P (type);
1546   MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (t);
1547
1548   /* If we are making an object of this type, or if this is a DECL, we know
1549      that it is a scalar if the type is not an aggregate.  */
1550   if ((objectp || DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
1551     MEM_SCALAR_P (ref) = 1;
1552
1553   /* We can set the alignment from the type if we are making an object,
1554      this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
1555   if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type))
1556     align = MAX (align, TYPE_ALIGN (type));
1557
1558   /* If the size is known, we can set that.  */
1559   if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
1560     size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
1561
1562   /* If T is not a type, we may be able to deduce some more information about
1563      the expression.  */
1564   if (! TYPE_P (t))
1565     {
1566       maybe_set_unchanging (ref, t);
1567       if (TREE_THIS_VOLATILE (t))
1568         MEM_VOLATILE_P (ref) = 1;
1569
1570       /* Now remove any conversions: they don't change what the underlying
1571          object is.  Likewise for SAVE_EXPR.  */
1572       while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
1573              || TREE_CODE (t) == NON_LVALUE_EXPR
1574              || TREE_CODE (t) == VIEW_CONVERT_EXPR
1575              || TREE_CODE (t) == SAVE_EXPR)
1576         t = TREE_OPERAND (t, 0);
1577
1578       /* If this expression can't be addressed (e.g., it contains a reference
1579          to a non-addressable field), show we don't change its alias set.  */
1580       if (! can_address_p (t))
1581         MEM_KEEP_ALIAS_SET_P (ref) = 1;
1582
1583       /* If this is a decl, set the attributes of the MEM from it.  */
1584       if (DECL_P (t))
1585         {
1586           expr = t;
1587           offset = const0_rtx;
1588           apply_bitpos = bitpos;
1589           size = (DECL_SIZE_UNIT (t)
1590                   && host_integerp (DECL_SIZE_UNIT (t), 1)
1591                   ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
1592           align = DECL_ALIGN (t);
1593         }
1594
1595       /* If this is a constant, we know the alignment.  */
1596       else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
1597         {
1598           align = TYPE_ALIGN (type);
1599 #ifdef CONSTANT_ALIGNMENT
1600           align = CONSTANT_ALIGNMENT (t, align);
1601 #endif
1602         }
1603
1604       /* If this is a field reference and not a bit-field, record it.  */
1605       /* ??? There is some information that can be gleened from bit-fields,
1606          such as the word offset in the structure that might be modified.
1607          But skip it for now.  */
1608       else if (TREE_CODE (t) == COMPONENT_REF
1609                && ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
1610         {
1611           expr = component_ref_for_mem_expr (t);
1612           offset = const0_rtx;
1613           apply_bitpos = bitpos;
1614           /* ??? Any reason the field size would be different than
1615              the size we got from the type?  */
1616         }
1617
1618       /* If this is an array reference, look for an outer field reference.  */
1619       else if (TREE_CODE (t) == ARRAY_REF)
1620         {
1621           tree off_tree = size_zero_node;
1622           /* We can't modify t, because we use it at the end of the
1623              function.  */
1624           tree t2 = t;
1625
1626           do
1627             {
1628               tree index = TREE_OPERAND (t2, 1);
1629               tree low_bound = array_ref_low_bound (t2);
1630               tree unit_size = array_ref_element_size (t2);
1631
1632               /* We assume all arrays have sizes that are a multiple of a byte.
1633                  First subtract the lower bound, if any, in the type of the
1634                  index, then convert to sizetype and multiply by the size of
1635                  the array element.  */
1636               if (! integer_zerop (low_bound))
1637                 index = fold (build (MINUS_EXPR, TREE_TYPE (index),
1638                                      index, low_bound));
1639
1640               off_tree = size_binop (PLUS_EXPR,
1641                                      size_binop (MULT_EXPR, convert (sizetype,
1642                                                                      index),
1643                                                  unit_size),
1644                                      off_tree);
1645               t2 = TREE_OPERAND (t2, 0);
1646             }
1647           while (TREE_CODE (t2) == ARRAY_REF);
1648
1649           if (DECL_P (t2))
1650             {
1651               expr = t2;
1652               offset = NULL;
1653               if (host_integerp (off_tree, 1))
1654                 {
1655                   HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
1656                   HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
1657                   align = DECL_ALIGN (t2);
1658                   if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
1659                     align = aoff;
1660                   offset = GEN_INT (ioff);
1661                   apply_bitpos = bitpos;
1662                 }
1663             }
1664           else if (TREE_CODE (t2) == COMPONENT_REF)
1665             {
1666               expr = component_ref_for_mem_expr (t2);
1667               if (host_integerp (off_tree, 1))
1668                 {
1669                   offset = GEN_INT (tree_low_cst (off_tree, 1));
1670                   apply_bitpos = bitpos;
1671                 }
1672               /* ??? Any reason the field size would be different than
1673                  the size we got from the type?  */
1674             }
1675           else if (flag_argument_noalias > 1
1676                    && TREE_CODE (t2) == INDIRECT_REF
1677                    && TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
1678             {
1679               expr = t2;
1680               offset = NULL;
1681             }
1682         }
1683
1684       /* If this is a Fortran indirect argument reference, record the
1685          parameter decl.  */
1686       else if (flag_argument_noalias > 1
1687                && TREE_CODE (t) == INDIRECT_REF
1688                && TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
1689         {
1690           expr = t;
1691           offset = NULL;
1692         }
1693     }
1694
1695   /* If we modified OFFSET based on T, then subtract the outstanding
1696      bit position offset.  Similarly, increase the size of the accessed
1697      object to contain the negative offset.  */
1698   if (apply_bitpos)
1699     {
1700       offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
1701       if (size)
1702         size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
1703     }
1704
1705   /* Now set the attributes we computed above.  */
1706   MEM_ATTRS (ref)
1707     = get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));
1708
1709   /* If this is already known to be a scalar or aggregate, we are done.  */
1710   if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
1711     return;
1712
1713   /* If it is a reference into an aggregate, this is part of an aggregate.
1714      Otherwise we don't know.  */
1715   else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
1716            || TREE_CODE (t) == ARRAY_RANGE_REF
1717            || TREE_CODE (t) == BIT_FIELD_REF)
1718     MEM_IN_STRUCT_P (ref) = 1;
1719 }
1720
1721 void
1722 set_mem_attributes (rtx ref, tree t, int objectp)
1723 {
1724   set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
1725 }
1726
1727 /* Set the decl for MEM to DECL.  */
1728
1729 void
1730 set_mem_attrs_from_reg (rtx mem, rtx reg)
1731 {
1732   MEM_ATTRS (mem)
1733     = get_mem_attrs (MEM_ALIAS_SET (mem), REG_EXPR (reg),
1734                      GEN_INT (REG_OFFSET (reg)),
1735                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1736 }
1737
1738 /* Set the alias set of MEM to SET.  */
1739
1740 void
1741 set_mem_alias_set (rtx mem, HOST_WIDE_INT set)
1742 {
1743 #ifdef ENABLE_CHECKING
1744   /* If the new and old alias sets don't conflict, something is wrong.  */
1745   if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
1746     abort ();
1747 #endif
1748
1749   MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
1750                                    MEM_SIZE (mem), MEM_ALIGN (mem),
1751                                    GET_MODE (mem));
1752 }
1753
1754 /* Set the alignment of MEM to ALIGN bits.  */
1755
1756 void
1757 set_mem_align (rtx mem, unsigned int align)
1758 {
1759   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1760                                    MEM_OFFSET (mem), MEM_SIZE (mem), align,
1761                                    GET_MODE (mem));
1762 }
1763
1764 /* Set the expr for MEM to EXPR.  */
1765
1766 void
1767 set_mem_expr (rtx mem, tree expr)
1768 {
1769   MEM_ATTRS (mem)
1770     = get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
1771                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1772 }
1773
1774 /* Set the offset of MEM to OFFSET.  */
1775
1776 void
1777 set_mem_offset (rtx mem, rtx offset)
1778 {
1779   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1780                                    offset, MEM_SIZE (mem), MEM_ALIGN (mem),
1781                                    GET_MODE (mem));
1782 }
1783
1784 /* Set the size of MEM to SIZE.  */
1785
1786 void
1787 set_mem_size (rtx mem, rtx size)
1788 {
1789   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1790                                    MEM_OFFSET (mem), size, MEM_ALIGN (mem),
1791                                    GET_MODE (mem));
1792 }
1793 \f
1794 /* Return a memory reference like MEMREF, but with its mode changed to MODE
1795    and its address changed to ADDR.  (VOIDmode means don't change the mode.
1796    NULL for ADDR means don't change the address.)  VALIDATE is nonzero if the
1797    returned memory location is required to be valid.  The memory
1798    attributes are not changed.  */
1799
1800 static rtx
1801 change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
1802 {
1803   rtx new;
1804
1805   if (!MEM_P (memref))
1806     abort ();
1807   if (mode == VOIDmode)
1808     mode = GET_MODE (memref);
1809   if (addr == 0)
1810     addr = XEXP (memref, 0);
1811   if (mode == GET_MODE (memref) && addr == XEXP (memref, 0)
1812       && (!validate || memory_address_p (mode, addr)))
1813     return memref;
1814
1815   if (validate)
1816     {
1817       if (reload_in_progress || reload_completed)
1818         {
1819           if (! memory_address_p (mode, addr))
1820             abort ();
1821         }
1822       else
1823         addr = memory_address (mode, addr);
1824     }
1825
1826   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
1827     return memref;
1828
1829   new = gen_rtx_MEM (mode, addr);
1830   MEM_COPY_ATTRIBUTES (new, memref);
1831   return new;
1832 }
1833
1834 /* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
1835    way we are changing MEMREF, so we only preserve the alias set.  */
1836
1837 rtx
1838 change_address (rtx memref, enum machine_mode mode, rtx addr)
1839 {
1840   rtx new = change_address_1 (memref, mode, addr, 1), size;
1841   enum machine_mode mmode = GET_MODE (new);
1842   unsigned int align;
1843
1844   size = mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode));
1845   align = mmode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mmode);
1846
1847   /* If there are no changes, just return the original memory reference.  */
1848   if (new == memref)
1849     {
1850       if (MEM_ATTRS (memref) == 0
1851           || (MEM_EXPR (memref) == NULL
1852               && MEM_OFFSET (memref) == NULL
1853               && MEM_SIZE (memref) == size
1854               && MEM_ALIGN (memref) == align))
1855         return new;
1856
1857       new = gen_rtx_MEM (mmode, XEXP (memref, 0));
1858       MEM_COPY_ATTRIBUTES (new, memref);
1859     }
1860
1861   MEM_ATTRS (new)
1862     = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0, size, align, mmode);
1863
1864   return new;
1865 }
1866
1867 /* Return a memory reference like MEMREF, but with its mode changed
1868    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
1869    nonzero, the memory address is forced to be valid.
1870    If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
1871    and caller is responsible for adjusting MEMREF base register.  */
1872
1873 rtx
1874 adjust_address_1 (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset,
1875                   int validate, int adjust)
1876 {
1877   rtx addr = XEXP (memref, 0);
1878   rtx new;
1879   rtx memoffset = MEM_OFFSET (memref);
1880   rtx size = 0;
1881   unsigned int memalign = MEM_ALIGN (memref);
1882
1883   /* If there are no changes, just return the original memory reference.  */
1884   if (mode == GET_MODE (memref) && !offset
1885       && (!validate || memory_address_p (mode, addr)))
1886     return memref;
1887
1888   /* ??? Prefer to create garbage instead of creating shared rtl.
1889      This may happen even if offset is nonzero -- consider
1890      (plus (plus reg reg) const_int) -- so do this always.  */
1891   addr = copy_rtx (addr);
1892
1893   if (adjust)
1894     {
1895       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
1896          object, we can merge it into the LO_SUM.  */
1897       if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
1898           && offset >= 0
1899           && (unsigned HOST_WIDE_INT) offset
1900               < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
1901         addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
1902                                plus_constant (XEXP (addr, 1), offset));
1903       else
1904         addr = plus_constant (addr, offset);
1905     }
1906
1907   new = change_address_1 (memref, mode, addr, validate);
1908
1909   /* Compute the new values of the memory attributes due to this adjustment.
1910      We add the offsets and update the alignment.  */
1911   if (memoffset)
1912     memoffset = GEN_INT (offset + INTVAL (memoffset));
1913
1914   /* Compute the new alignment by taking the MIN of the alignment and the
1915      lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
1916      if zero.  */
1917   if (offset != 0)
1918     memalign
1919       = MIN (memalign,
1920              (unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
1921
1922   /* We can compute the size in a number of ways.  */
1923   if (GET_MODE (new) != BLKmode)
1924     size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
1925   else if (MEM_SIZE (memref))
1926     size = plus_constant (MEM_SIZE (memref), -offset);
1927
1928   MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
1929                                    memoffset, size, memalign, GET_MODE (new));
1930
1931   /* At some point, we should validate that this offset is within the object,
1932      if all the appropriate values are known.  */
1933   return new;
1934 }
1935
1936 /* Return a memory reference like MEMREF, but with its mode changed
1937    to MODE and its address changed to ADDR, which is assumed to be
1938    MEMREF offseted by OFFSET bytes.  If VALIDATE is
1939    nonzero, the memory address is forced to be valid.  */
1940
1941 rtx
1942 adjust_automodify_address_1 (rtx memref, enum machine_mode mode, rtx addr,
1943                              HOST_WIDE_INT offset, int validate)
1944 {
1945   memref = change_address_1 (memref, VOIDmode, addr, validate);
1946   return adjust_address_1 (memref, mode, offset, validate, 0);
1947 }
1948
1949 /* Return a memory reference like MEMREF, but whose address is changed by
1950    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
1951    known to be in OFFSET (possibly 1).  */
1952
1953 rtx
1954 offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
1955 {
1956   rtx new, addr = XEXP (memref, 0);
1957
1958   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1959
1960   /* At this point we don't know _why_ the address is invalid.  It
1961      could have secondary memory references, multiplies or anything.
1962
1963      However, if we did go and rearrange things, we can wind up not
1964      being able to recognize the magic around pic_offset_table_rtx.
1965      This stuff is fragile, and is yet another example of why it is
1966      bad to expose PIC machinery too early.  */
1967   if (! memory_address_p (GET_MODE (memref), new)
1968       && GET_CODE (addr) == PLUS
1969       && XEXP (addr, 0) == pic_offset_table_rtx)
1970     {
1971       addr = force_reg (GET_MODE (addr), addr);
1972       new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1973     }
1974
1975   update_temp_slot_address (XEXP (memref, 0), new);
1976   new = change_address_1 (memref, VOIDmode, new, 1);
1977
1978   /* If there are no changes, just return the original memory reference.  */
1979   if (new == memref)
1980     return new;
1981
1982   /* Update the alignment to reflect the offset.  Reset the offset, which
1983      we don't know.  */
1984   MEM_ATTRS (new)
1985     = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
1986                      MIN (MEM_ALIGN (memref), pow2 * BITS_PER_UNIT),
1987                      GET_MODE (new));
1988   return new;
1989 }
1990
1991 /* Return a memory reference like MEMREF, but with its address changed to
1992    ADDR.  The caller is asserting that the actual piece of memory pointed
1993    to is the same, just the form of the address is being changed, such as
1994    by putting something into a register.  */
1995
1996 rtx
1997 replace_equiv_address (rtx memref, rtx addr)
1998 {
1999   /* change_address_1 copies the memory attribute structure without change
2000      and that's exactly what we want here.  */
2001   update_temp_slot_address (XEXP (memref, 0), addr);
2002   return change_address_1 (memref, VOIDmode, addr, 1);
2003 }
2004
2005 /* Likewise, but the reference is not required to be valid.  */
2006
2007 rtx
2008 replace_equiv_address_nv (rtx memref, rtx addr)
2009 {
2010   return change_address_1 (memref, VOIDmode, addr, 0);
2011 }
2012
2013 /* Return a memory reference like MEMREF, but with its mode widened to
2014    MODE and offset by OFFSET.  This would be used by targets that e.g.
2015    cannot issue QImode memory operations and have to use SImode memory
2016    operations plus masking logic.  */
2017
2018 rtx
2019 widen_memory_access (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset)
2020 {
2021   rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
2022   tree expr = MEM_EXPR (new);
2023   rtx memoffset = MEM_OFFSET (new);
2024   unsigned int size = GET_MODE_SIZE (mode);
2025
2026   /* If there are no changes, just return the original memory reference.  */
2027   if (new == memref)
2028     return new;
2029
2030   /* If we don't know what offset we were at within the expression, then
2031      we can't know if we've overstepped the bounds.  */
2032   if (! memoffset)
2033     expr = NULL_TREE;
2034
2035   while (expr)
2036     {
2037       if (TREE_CODE (expr) == COMPONENT_REF)
2038         {
2039           tree field = TREE_OPERAND (expr, 1);
2040           tree offset = component_ref_field_offset (expr);
2041
2042           if (! DECL_SIZE_UNIT (field))
2043             {
2044               expr = NULL_TREE;
2045               break;
2046             }
2047
2048           /* Is the field at least as large as the access?  If so, ok,
2049              otherwise strip back to the containing structure.  */
2050           if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
2051               && compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
2052               && INTVAL (memoffset) >= 0)
2053             break;
2054
2055           if (! host_integerp (offset, 1))
2056             {
2057               expr = NULL_TREE;
2058               break;
2059             }
2060
2061           expr = TREE_OPERAND (expr, 0);
2062           memoffset
2063             = (GEN_INT (INTVAL (memoffset)
2064                         + tree_low_cst (offset, 1)
2065                         + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
2066                            / BITS_PER_UNIT)));
2067         }
2068       /* Similarly for the decl.  */
2069       else if (DECL_P (expr)
2070                && DECL_SIZE_UNIT (expr)
2071                && TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
2072                && compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
2073                && (! memoffset || INTVAL (memoffset) >= 0))
2074         break;
2075       else
2076         {
2077           /* The widened memory access overflows the expression, which means
2078              that it could alias another expression.  Zap it.  */
2079           expr = NULL_TREE;
2080           break;
2081         }
2082     }
2083
2084   if (! expr)
2085     memoffset = NULL_RTX;
2086
2087   /* The widened memory may alias other stuff, so zap the alias set.  */
2088   /* ??? Maybe use get_alias_set on any remaining expression.  */
2089
2090   MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
2091                                    MEM_ALIGN (new), mode);
2092
2093   return new;
2094 }
2095 \f
2096 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
2097
2098 rtx
2099 gen_label_rtx (void)
2100 {
2101   return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
2102                              NULL, label_num++, NULL);
2103 }
2104 \f
2105 /* For procedure integration.  */
2106
2107 /* Install new pointers to the first and last insns in the chain.
2108    Also, set cur_insn_uid to one higher than the last in use.
2109    Used for an inline-procedure after copying the insn chain.  */
2110
2111 void
2112 set_new_first_and_last_insn (rtx first, rtx last)
2113 {
2114   rtx insn;
2115
2116   first_insn = first;
2117   last_insn = last;
2118   cur_insn_uid = 0;
2119
2120   for (insn = first; insn; insn = NEXT_INSN (insn))
2121     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
2122
2123   cur_insn_uid++;
2124 }
2125
2126 /* Set the last label number found in the current function.
2127    This is used when belatedly compiling an inline function.  */
2128
2129 void
2130 set_new_last_label_num (int last)
2131 {
2132   base_label_num = label_num;
2133   last_label_num = last;
2134 }
2135 \f
2136 /* Restore all variables describing the current status from the structure *P.
2137    This is used after a nested function.  */
2138
2139 void
2140 restore_emit_status (struct function *p ATTRIBUTE_UNUSED)
2141 {
2142   last_label_num = 0;
2143 }
2144 \f
2145 /* Go through all the RTL insn bodies and copy any invalid shared
2146    structure.  This routine should only be called once.  */
2147
2148 static void
2149 unshare_all_rtl_1 (tree fndecl, rtx insn)
2150 {
2151   tree decl;
2152
2153   /* Make sure that virtual parameters are not shared.  */
2154   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
2155     SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));
2156
2157   /* Make sure that virtual stack slots are not shared.  */
2158   unshare_all_decls (DECL_INITIAL (fndecl));
2159
2160   /* Unshare just about everything else.  */
2161   unshare_all_rtl_in_chain (insn);
2162
2163   /* Make sure the addresses of stack slots found outside the insn chain
2164      (such as, in DECL_RTL of a variable) are not shared
2165      with the insn chain.
2166
2167      This special care is necessary when the stack slot MEM does not
2168      actually appear in the insn chain.  If it does appear, its address
2169      is unshared from all else at that point.  */
2170   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
2171 }
2172
2173 /* Go through all the RTL insn bodies and copy any invalid shared
2174    structure, again.  This is a fairly expensive thing to do so it
2175    should be done sparingly.  */
2176
2177 void
2178 unshare_all_rtl_again (rtx insn)
2179 {
2180   rtx p;
2181   tree decl;
2182
2183   for (p = insn; p; p = NEXT_INSN (p))
2184     if (INSN_P (p))
2185       {
2186         reset_used_flags (PATTERN (p));
2187         reset_used_flags (REG_NOTES (p));
2188         reset_used_flags (LOG_LINKS (p));
2189       }
2190
2191   /* Make sure that virtual stack slots are not shared.  */
2192   reset_used_decls (DECL_INITIAL (cfun->decl));
2193
2194   /* Make sure that virtual parameters are not shared.  */
2195   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
2196     reset_used_flags (DECL_RTL (decl));
2197
2198   reset_used_flags (stack_slot_list);
2199
2200   unshare_all_rtl_1 (cfun->decl, insn);
2201 }
2202
2203 void
2204 unshare_all_rtl (void)
2205 {
2206   unshare_all_rtl_1 (current_function_decl, get_insns ());
2207 }
2208
2209 /* Check that ORIG is not marked when it should not be and mark ORIG as in use,
2210    Recursively does the same for subexpressions.  */
2211
2212 static void
2213 verify_rtx_sharing (rtx orig, rtx insn)
2214 {
2215   rtx x = orig;
2216   int i;
2217   enum rtx_code code;
2218   const char *format_ptr;
2219
2220   if (x == 0)
2221     return;
2222
2223   code = GET_CODE (x);
2224
2225   /* These types may be freely shared.  */
2226
2227   switch (code)
2228     {
2229     case REG:
2230     case CONST_INT:
2231     case CONST_DOUBLE:
2232     case CONST_VECTOR:
2233     case SYMBOL_REF:
2234     case LABEL_REF:
2235     case CODE_LABEL:
2236     case PC:
2237     case CC0:
2238     case SCRATCH:
2239       return;
2240       /* SCRATCH must be shared because they represent distinct values.  */
2241     case CLOBBER:
2242       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2243         return;
2244       break;
2245
2246     case CONST:
2247       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2248          a LABEL_REF, it isn't sharable.  */
2249       if (GET_CODE (XEXP (x, 0)) == PLUS
2250           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2251           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2252         return;
2253       break;
2254
2255     case MEM:
2256       /* A MEM is allowed to be shared if its address is constant.  */
2257       if (CONSTANT_ADDRESS_P (XEXP (x, 0))
2258           || reload_completed || reload_in_progress)
2259         return;
2260
2261       break;
2262
2263     default:
2264       break;
2265     }
2266
2267   /* This rtx may not be shared.  If it has already been seen,
2268      replace it with a copy of itself.  */
2269
2270   if (RTX_FLAG (x, used))
2271     {
2272       error ("Invalid rtl sharing found in the insn");
2273       debug_rtx (insn);
2274       error ("Shared rtx");
2275       debug_rtx (x);
2276       abort ();
2277     }
2278   RTX_FLAG (x, used) = 1;
2279
2280   /* Now scan the subexpressions recursively.  */
2281
2282   format_ptr = GET_RTX_FORMAT (code);
2283
2284   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2285     {
2286       switch (*format_ptr++)
2287         {
2288         case 'e':
2289           verify_rtx_sharing (XEXP (x, i), insn);
2290           break;
2291
2292         case 'E':
2293           if (XVEC (x, i) != NULL)
2294             {
2295               int j;
2296               int len = XVECLEN (x, i);
2297
2298               for (j = 0; j < len; j++)
2299                 {
2300                   /* We allow sharing of ASM_OPERANDS inside single instruction.  */
2301                   if (j && GET_CODE (XVECEXP (x, i, j)) == SET
2302                       && GET_CODE (SET_SRC (XVECEXP (x, i, j))) == ASM_OPERANDS)
2303                     verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
2304                   else
2305                     verify_rtx_sharing (XVECEXP (x, i, j), insn);
2306                 }
2307             }
2308           break;
2309         }
2310     }
2311   return;
2312 }
2313
2314 /* Go through all the RTL insn bodies and check that there is no unexpected
2315    sharing in between the subexpressions.  */
2316
2317 void
2318 verify_rtl_sharing (void)
2319 {
2320   rtx p;
2321
2322   for (p = get_insns (); p; p = NEXT_INSN (p))
2323     if (INSN_P (p))
2324       {
2325         reset_used_flags (PATTERN (p));
2326         reset_used_flags (REG_NOTES (p));
2327         reset_used_flags (LOG_LINKS (p));
2328       }
2329
2330   for (p = get_insns (); p; p = NEXT_INSN (p))
2331     if (INSN_P (p))
2332       {
2333         verify_rtx_sharing (PATTERN (p), p);
2334         verify_rtx_sharing (REG_NOTES (p), p);
2335         verify_rtx_sharing (LOG_LINKS (p), p);
2336       }
2337 }
2338
2339 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2340    Assumes the mark bits are cleared at entry.  */
2341
2342 void
2343 unshare_all_rtl_in_chain (rtx insn)
2344 {
2345   for (; insn; insn = NEXT_INSN (insn))
2346     if (INSN_P (insn))
2347       {
2348         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2349         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2350         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
2351       }
2352 }
2353
2354 /* Go through all virtual stack slots of a function and copy any
2355    shared structure.  */
2356 static void
2357 unshare_all_decls (tree blk)
2358 {
2359   tree t;
2360
2361   /* Copy shared decls.  */
2362   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2363     if (DECL_RTL_SET_P (t))
2364       SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
2365
2366   /* Now process sub-blocks.  */
2367   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2368     unshare_all_decls (t);
2369 }
2370
2371 /* Go through all virtual stack slots of a function and mark them as
2372    not shared.  */
2373 static void
2374 reset_used_decls (tree blk)
2375 {
2376   tree t;
2377
2378   /* Mark decls.  */
2379   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2380     if (DECL_RTL_SET_P (t))
2381       reset_used_flags (DECL_RTL (t));
2382
2383   /* Now process sub-blocks.  */
2384   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2385     reset_used_decls (t);
2386 }
2387
2388 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
2389    placed in the result directly, rather than being copied.  MAY_SHARE is
2390    either a MEM of an EXPR_LIST of MEMs.  */
2391
2392 rtx
2393 copy_most_rtx (rtx orig, rtx may_share)
2394 {
2395   rtx copy;
2396   int i, j;
2397   RTX_CODE code;
2398   const char *format_ptr;
2399
2400   if (orig == may_share
2401       || (GET_CODE (may_share) == EXPR_LIST
2402           && in_expr_list_p (may_share, orig)))
2403     return orig;
2404
2405   code = GET_CODE (orig);
2406
2407   switch (code)
2408     {
2409     case REG:
2410     case CONST_INT:
2411     case CONST_DOUBLE:
2412     case CONST_VECTOR:
2413     case SYMBOL_REF:
2414     case CODE_LABEL:
2415     case PC:
2416     case CC0:
2417       return orig;
2418     default:
2419       break;
2420     }
2421
2422   copy = rtx_alloc (code);
2423   PUT_MODE (copy, GET_MODE (orig));
2424   RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
2425   RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
2426   RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
2427   RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
2428   RTX_FLAG (copy, return_val) = RTX_FLAG (orig, return_val);
2429
2430   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2431
2432   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2433     {
2434       switch (*format_ptr++)
2435         {
2436         case 'e':
2437           XEXP (copy, i) = XEXP (orig, i);
2438           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
2439             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
2440           break;
2441
2442         case 'u':
2443           XEXP (copy, i) = XEXP (orig, i);
2444           break;
2445
2446         case 'E':
2447         case 'V':
2448           XVEC (copy, i) = XVEC (orig, i);
2449           if (XVEC (orig, i) != NULL)
2450             {
2451               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2452               for (j = 0; j < XVECLEN (copy, i); j++)
2453                 XVECEXP (copy, i, j)
2454                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
2455             }
2456           break;
2457
2458         case 'w':
2459           XWINT (copy, i) = XWINT (orig, i);
2460           break;
2461
2462         case 'n':
2463         case 'i':
2464           XINT (copy, i) = XINT (orig, i);
2465           break;
2466
2467         case 't':
2468           XTREE (copy, i) = XTREE (orig, i);
2469           break;
2470
2471         case 's':
2472         case 'S':
2473           XSTR (copy, i) = XSTR (orig, i);
2474           break;
2475
2476         case '0':
2477           X0ANY (copy, i) = X0ANY (orig, i);
2478           break;
2479
2480         default:
2481           abort ();
2482         }
2483     }
2484   return copy;
2485 }
2486
2487 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2488    Recursively does the same for subexpressions.  Uses
2489    copy_rtx_if_shared_1 to reduce stack space.  */
2490
2491 rtx
2492 copy_rtx_if_shared (rtx orig)
2493 {
2494   copy_rtx_if_shared_1 (&orig);
2495   return orig;
2496 }
2497
2498 /* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
2499    use.  Recursively does the same for subexpressions.  */
2500
2501 static void
2502 copy_rtx_if_shared_1 (rtx *orig1)
2503 {
2504   rtx x;
2505   int i;
2506   enum rtx_code code;
2507   rtx *last_ptr;
2508   const char *format_ptr;
2509   int copied = 0;
2510   int length;
2511
2512   /* Repeat is used to turn tail-recursion into iteration.  */
2513 repeat:
2514   x = *orig1;
2515
2516   if (x == 0)
2517     return;
2518
2519   code = GET_CODE (x);
2520
2521   /* These types may be freely shared.  */
2522
2523   switch (code)
2524     {
2525     case REG:
2526     case CONST_INT:
2527     case CONST_DOUBLE:
2528     case CONST_VECTOR:
2529     case SYMBOL_REF:
2530     case LABEL_REF:
2531     case CODE_LABEL:
2532     case PC:
2533     case CC0:
2534     case SCRATCH:
2535       /* SCRATCH must be shared because they represent distinct values.  */
2536       return;
2537     case CLOBBER:
2538       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2539         return;
2540       break;
2541
2542     case CONST:
2543       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2544          a LABEL_REF, it isn't sharable.  */
2545       if (GET_CODE (XEXP (x, 0)) == PLUS
2546           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2547           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2548         return;
2549       break;
2550
2551     case INSN:
2552     case JUMP_INSN:
2553     case CALL_INSN:
2554     case NOTE:
2555     case BARRIER:
2556       /* The chain of insns is not being copied.  */
2557       return;
2558
2559     default:
2560       break;
2561     }
2562
2563   /* This rtx may not be shared.  If it has already been seen,
2564      replace it with a copy of itself.  */
2565
2566   if (RTX_FLAG (x, used))
2567     {
2568       rtx copy;
2569
2570       copy = rtx_alloc (code);
2571       memcpy (copy, x, RTX_SIZE (code));
2572       x = copy;
2573       copied = 1;
2574     }
2575   RTX_FLAG (x, used) = 1;
2576
2577   /* Now scan the subexpressions recursively.
2578      We can store any replaced subexpressions directly into X
2579      since we know X is not shared!  Any vectors in X
2580      must be copied if X was copied.  */
2581
2582   format_ptr = GET_RTX_FORMAT (code);
2583   length = GET_RTX_LENGTH (code);
2584   last_ptr = NULL;
2585   
2586   for (i = 0; i < length; i++)
2587     {
2588       switch (*format_ptr++)
2589         {
2590         case 'e':
2591           if (last_ptr)
2592             copy_rtx_if_shared_1 (last_ptr);
2593           last_ptr = &XEXP (x, i);
2594           break;
2595
2596         case 'E':
2597           if (XVEC (x, i) != NULL)
2598             {
2599               int j;
2600               int len = XVECLEN (x, i);
2601               
2602               /* Copy the vector iff I copied the rtx and the length
2603                  is nonzero.  */
2604               if (copied && len > 0)
2605                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2606               
2607               /* Call recursively on all inside the vector.  */
2608               for (j = 0; j < len; j++)
2609                 {
2610                   if (last_ptr)
2611                     copy_rtx_if_shared_1 (last_ptr);
2612                   last_ptr = &XVECEXP (x, i, j);
2613                 }
2614             }
2615           break;
2616         }
2617     }
2618   *orig1 = x;
2619   if (last_ptr)
2620     {
2621       orig1 = last_ptr;
2622       goto repeat;
2623     }
2624   return;
2625 }
2626
2627 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2628    to look for shared sub-parts.  */
2629
2630 void
2631 reset_used_flags (rtx x)
2632 {
2633   int i, j;
2634   enum rtx_code code;
2635   const char *format_ptr;
2636   int length;
2637
2638   /* Repeat is used to turn tail-recursion into iteration.  */
2639 repeat:
2640   if (x == 0)
2641     return;
2642
2643   code = GET_CODE (x);
2644
2645   /* These types may be freely shared so we needn't do any resetting
2646      for them.  */
2647
2648   switch (code)
2649     {
2650     case REG:
2651     case CONST_INT:
2652     case CONST_DOUBLE:
2653     case CONST_VECTOR:
2654     case SYMBOL_REF:
2655     case CODE_LABEL:
2656     case PC:
2657     case CC0:
2658       return;
2659
2660     case INSN:
2661     case JUMP_INSN:
2662     case CALL_INSN:
2663     case NOTE:
2664     case LABEL_REF:
2665     case BARRIER:
2666       /* The chain of insns is not being copied.  */
2667       return;
2668
2669     default:
2670       break;
2671     }
2672
2673   RTX_FLAG (x, used) = 0;
2674
2675   format_ptr = GET_RTX_FORMAT (code);
2676   length = GET_RTX_LENGTH (code);
2677   
2678   for (i = 0; i < length; i++)
2679     {
2680       switch (*format_ptr++)
2681         {
2682         case 'e':
2683           if (i == length-1)
2684             {
2685               x = XEXP (x, i);
2686               goto repeat;
2687             }
2688           reset_used_flags (XEXP (x, i));
2689           break;
2690
2691         case 'E':
2692           for (j = 0; j < XVECLEN (x, i); j++)
2693             reset_used_flags (XVECEXP (x, i, j));
2694           break;
2695         }
2696     }
2697 }
2698
2699 /* Set all the USED bits in X to allow copy_rtx_if_shared to be used
2700    to look for shared sub-parts.  */
2701
2702 void
2703 set_used_flags (rtx x)
2704 {
2705   int i, j;
2706   enum rtx_code code;
2707   const char *format_ptr;
2708
2709   if (x == 0)
2710     return;
2711
2712   code = GET_CODE (x);
2713
2714   /* These types may be freely shared so we needn't do any resetting
2715      for them.  */
2716
2717   switch (code)
2718     {
2719     case REG:
2720     case CONST_INT:
2721     case CONST_DOUBLE:
2722     case CONST_VECTOR:
2723     case SYMBOL_REF:
2724     case CODE_LABEL:
2725     case PC:
2726     case CC0:
2727       return;
2728
2729     case INSN:
2730     case JUMP_INSN:
2731     case CALL_INSN:
2732     case NOTE:
2733     case LABEL_REF:
2734     case BARRIER:
2735       /* The chain of insns is not being copied.  */
2736       return;
2737
2738     default:
2739       break;
2740     }
2741
2742   RTX_FLAG (x, used) = 1;
2743
2744   format_ptr = GET_RTX_FORMAT (code);
2745   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2746     {
2747       switch (*format_ptr++)
2748         {
2749         case 'e':
2750           set_used_flags (XEXP (x, i));
2751           break;
2752
2753         case 'E':
2754           for (j = 0; j < XVECLEN (x, i); j++)
2755             set_used_flags (XVECEXP (x, i, j));
2756           break;
2757         }
2758     }
2759 }
2760 \f
2761 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2762    Return X or the rtx for the pseudo reg the value of X was copied into.
2763    OTHER must be valid as a SET_DEST.  */
2764
2765 rtx
2766 make_safe_from (rtx x, rtx other)
2767 {
2768   while (1)
2769     switch (GET_CODE (other))
2770       {
2771       case SUBREG:
2772         other = SUBREG_REG (other);
2773         break;
2774       case STRICT_LOW_PART:
2775       case SIGN_EXTEND:
2776       case ZERO_EXTEND:
2777         other = XEXP (other, 0);
2778         break;
2779       default:
2780         goto done;
2781       }
2782  done:
2783   if ((MEM_P (other)
2784        && ! CONSTANT_P (x)
2785        && !REG_P (x)
2786        && GET_CODE (x) != SUBREG)
2787       || (REG_P (other)
2788           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2789               || reg_mentioned_p (other, x))))
2790     {
2791       rtx temp = gen_reg_rtx (GET_MODE (x));
2792       emit_move_insn (temp, x);
2793       return temp;
2794     }
2795   return x;
2796 }
2797 \f
2798 /* Emission of insns (adding them to the doubly-linked list).  */
2799
2800 /* Return the first insn of the current sequence or current function.  */
2801
2802 rtx
2803 get_insns (void)
2804 {
2805   return first_insn;
2806 }
2807
2808 /* Specify a new insn as the first in the chain.  */
2809
2810 void
2811 set_first_insn (rtx insn)
2812 {
2813   if (PREV_INSN (insn) != 0)
2814     abort ();
2815   first_insn = insn;
2816 }
2817
2818 /* Return the last insn emitted in current sequence or current function.  */
2819
2820 rtx
2821 get_last_insn (void)
2822 {
2823   return last_insn;
2824 }
2825
2826 /* Specify a new insn as the last in the chain.  */
2827
2828 void
2829 set_last_insn (rtx insn)
2830 {
2831   if (NEXT_INSN (insn) != 0)
2832     abort ();
2833   last_insn = insn;
2834 }
2835
2836 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2837
2838 rtx
2839 get_last_insn_anywhere (void)
2840 {
2841   struct sequence_stack *stack;
2842   if (last_insn)
2843     return last_insn;
2844   for (stack = seq_stack; stack; stack = stack->next)
2845     if (stack->last != 0)
2846       return stack->last;
2847   return 0;
2848 }
2849
2850 /* Return the first nonnote insn emitted in current sequence or current
2851    function.  This routine looks inside SEQUENCEs.  */
2852
2853 rtx
2854 get_first_nonnote_insn (void)
2855 {
2856   rtx insn = first_insn;
2857
2858   while (insn)
2859     {
2860       insn = next_insn (insn);
2861       if (insn == 0 || !NOTE_P (insn))
2862         break;
2863     }
2864
2865   return insn;
2866 }
2867
2868 /* Return the last nonnote insn emitted in current sequence or current
2869    function.  This routine looks inside SEQUENCEs.  */
2870
2871 rtx
2872 get_last_nonnote_insn (void)
2873 {
2874   rtx insn = last_insn;
2875
2876   while (insn)
2877     {
2878       insn = previous_insn (insn);
2879       if (insn == 0 || !NOTE_P (insn))
2880         break;
2881     }
2882
2883   return insn;
2884 }
2885
2886 /* Return a number larger than any instruction's uid in this function.  */
2887
2888 int
2889 get_max_uid (void)
2890 {
2891   return cur_insn_uid;
2892 }
2893
2894 /* Renumber instructions so that no instruction UIDs are wasted.  */
2895
2896 void
2897 renumber_insns (FILE *stream)
2898 {
2899   rtx insn;
2900
2901   /* If we're not supposed to renumber instructions, don't.  */
2902   if (!flag_renumber_insns)
2903     return;
2904
2905   /* If there aren't that many instructions, then it's not really
2906      worth renumbering them.  */
2907   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
2908     return;
2909
2910   cur_insn_uid = 1;
2911
2912   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2913     {
2914       if (stream)
2915         fprintf (stream, "Renumbering insn %d to %d\n",
2916                  INSN_UID (insn), cur_insn_uid);
2917       INSN_UID (insn) = cur_insn_uid++;
2918     }
2919 }
2920 \f
2921 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2922    of the sequence.  */
2923
2924 rtx
2925 next_insn (rtx insn)
2926 {
2927   if (insn)
2928     {
2929       insn = NEXT_INSN (insn);
2930       if (insn && NONJUMP_INSN_P (insn)
2931           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2932         insn = XVECEXP (PATTERN (insn), 0, 0);
2933     }
2934
2935   return insn;
2936 }
2937
2938 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2939    of the sequence.  */
2940
2941 rtx
2942 previous_insn (rtx insn)
2943 {
2944   if (insn)
2945     {
2946       insn = PREV_INSN (insn);
2947       if (insn && NONJUMP_INSN_P (insn)
2948           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2949         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2950     }
2951
2952   return insn;
2953 }
2954
2955 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2956    look inside SEQUENCEs.  */
2957
2958 rtx
2959 next_nonnote_insn (rtx insn)
2960 {
2961   while (insn)
2962     {
2963       insn = NEXT_INSN (insn);
2964       if (insn == 0 || !NOTE_P (insn))
2965         break;
2966     }
2967
2968   return insn;
2969 }
2970
2971 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2972    not look inside SEQUENCEs.  */
2973
2974 rtx
2975 prev_nonnote_insn (rtx insn)
2976 {
2977   while (insn)
2978     {
2979       insn = PREV_INSN (insn);
2980       if (insn == 0 || !NOTE_P (insn))
2981         break;
2982     }
2983
2984   return insn;
2985 }
2986
2987 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2988    or 0, if there is none.  This routine does not look inside
2989    SEQUENCEs.  */
2990
2991 rtx
2992 next_real_insn (rtx insn)
2993 {
2994   while (insn)
2995     {
2996       insn = NEXT_INSN (insn);
2997       if (insn == 0 || INSN_P (insn))
2998         break;
2999     }
3000
3001   return insn;
3002 }
3003
3004 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
3005    or 0, if there is none.  This routine does not look inside
3006    SEQUENCEs.  */
3007
3008 rtx
3009 prev_real_insn (rtx insn)
3010 {
3011   while (insn)
3012     {
3013       insn = PREV_INSN (insn);
3014       if (insn == 0 || INSN_P (insn))
3015         break;
3016     }
3017
3018   return insn;
3019 }
3020
3021 /* Return the last CALL_INSN in the current list, or 0 if there is none.
3022    This routine does not look inside SEQUENCEs.  */
3023
3024 rtx
3025 last_call_insn (void)
3026 {
3027   rtx insn;
3028
3029   for (insn = get_last_insn ();
3030        insn && !CALL_P (insn);
3031        insn = PREV_INSN (insn))
3032     ;
3033
3034   return insn;
3035 }
3036
3037 /* Find the next insn after INSN that really does something.  This routine
3038    does not look inside SEQUENCEs.  Until reload has completed, this is the
3039    same as next_real_insn.  */
3040
3041 int
3042 active_insn_p (rtx insn)
3043 {
3044   return (CALL_P (insn) || JUMP_P (insn)
3045           || (NONJUMP_INSN_P (insn)
3046               && (! reload_completed
3047                   || (GET_CODE (PATTERN (insn)) != USE
3048                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
3049 }
3050
3051 rtx
3052 next_active_insn (rtx insn)
3053 {
3054   while (insn)
3055     {
3056       insn = NEXT_INSN (insn);
3057       if (insn == 0 || active_insn_p (insn))
3058         break;
3059     }
3060
3061   return insn;
3062 }
3063
3064 /* Find the last insn before INSN that really does something.  This routine
3065    does not look inside SEQUENCEs.  Until reload has completed, this is the
3066    same as prev_real_insn.  */
3067
3068 rtx
3069 prev_active_insn (rtx insn)
3070 {
3071   while (insn)
3072     {
3073       insn = PREV_INSN (insn);
3074       if (insn == 0 || active_insn_p (insn))
3075         break;
3076     }
3077
3078   return insn;
3079 }
3080
3081 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
3082
3083 rtx
3084 next_label (rtx insn)
3085 {
3086   while (insn)
3087     {
3088       insn = NEXT_INSN (insn);
3089       if (insn == 0 || LABEL_P (insn))
3090         break;
3091     }
3092
3093   return insn;
3094 }
3095
3096 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
3097
3098 rtx
3099 prev_label (rtx insn)
3100 {
3101   while (insn)
3102     {
3103       insn = PREV_INSN (insn);
3104       if (insn == 0 || LABEL_P (insn))
3105         break;
3106     }
3107
3108   return insn;
3109 }
3110
3111 /* Return the last label to mark the same position as LABEL.  Return null
3112    if LABEL itself is null.  */
3113
3114 rtx
3115 skip_consecutive_labels (rtx label)
3116 {
3117   rtx insn;
3118
3119   for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
3120     if (LABEL_P (insn))
3121       label = insn;
3122
3123   return label;
3124 }
3125 \f
3126 #ifdef HAVE_cc0
3127 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
3128    and REG_CC_USER notes so we can find it.  */
3129
3130 void
3131 link_cc0_insns (rtx insn)
3132 {
3133   rtx user = next_nonnote_insn (insn);
3134
3135   if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
3136     user = XVECEXP (PATTERN (user), 0, 0);
3137
3138   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
3139                                         REG_NOTES (user));
3140   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
3141 }
3142
3143 /* Return the next insn that uses CC0 after INSN, which is assumed to
3144    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
3145    applied to the result of this function should yield INSN).
3146
3147    Normally, this is simply the next insn.  However, if a REG_CC_USER note
3148    is present, it contains the insn that uses CC0.
3149
3150    Return 0 if we can't find the insn.  */
3151
3152 rtx
3153 next_cc0_user (rtx insn)
3154 {
3155   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
3156
3157   if (note)
3158     return XEXP (note, 0);
3159
3160   insn = next_nonnote_insn (insn);
3161   if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
3162     insn = XVECEXP (PATTERN (insn), 0, 0);
3163
3164   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
3165     return insn;
3166
3167   return 0;
3168 }
3169
3170 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
3171    note, it is the previous insn.  */
3172
3173 rtx
3174 prev_cc0_setter (rtx insn)
3175 {
3176   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
3177
3178   if (note)
3179     return XEXP (note, 0);
3180
3181   insn = prev_nonnote_insn (insn);
3182   if (! sets_cc0_p (PATTERN (insn)))
3183     abort ();
3184
3185   return insn;
3186 }
3187 #endif
3188
3189 /* Increment the label uses for all labels present in rtx.  */
3190
3191 static void
3192 mark_label_nuses (rtx x)
3193 {
3194   enum rtx_code code;
3195   int i, j;
3196   const char *fmt;
3197
3198   code = GET_CODE (x);
3199   if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
3200     LABEL_NUSES (XEXP (x, 0))++;
3201
3202   fmt = GET_RTX_FORMAT (code);
3203   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3204     {
3205       if (fmt[i] == 'e')
3206         mark_label_nuses (XEXP (x, i));
3207       else if (fmt[i] == 'E')
3208         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3209           mark_label_nuses (XVECEXP (x, i, j));
3210     }
3211 }
3212
3213 \f
3214 /* Try splitting insns that can be split for better scheduling.
3215    PAT is the pattern which might split.
3216    TRIAL is the insn providing PAT.
3217    LAST is nonzero if we should return the last insn of the sequence produced.
3218
3219    If this routine succeeds in splitting, it returns the first or last
3220    replacement insn depending on the value of LAST.  Otherwise, it
3221    returns TRIAL.  If the insn to be returned can be split, it will be.  */
3222
3223 rtx
3224 try_split (rtx pat, rtx trial, int last)
3225 {
3226   rtx before = PREV_INSN (trial);
3227   rtx after = NEXT_INSN (trial);
3228   int has_barrier = 0;
3229   rtx tem;
3230   rtx note, seq;
3231   int probability;
3232   rtx insn_last, insn;
3233   int njumps = 0;
3234
3235   if (any_condjump_p (trial)
3236       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
3237     split_branch_probability = INTVAL (XEXP (note, 0));
3238   probability = split_branch_probability;
3239
3240   seq = split_insns (pat, trial);
3241
3242   split_branch_probability = -1;
3243
3244   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
3245      We may need to handle this specially.  */
3246   if (after && BARRIER_P (after))
3247     {
3248       has_barrier = 1;
3249       after = NEXT_INSN (after);
3250     }
3251
3252   if (!seq)
3253     return trial;
3254
3255   /* Avoid infinite loop if any insn of the result matches
3256      the original pattern.  */
3257   insn_last = seq;
3258   while (1)
3259     {
3260       if (INSN_P (insn_last)
3261           && rtx_equal_p (PATTERN (insn_last), pat))
3262         return trial;
3263       if (!NEXT_INSN (insn_last))
3264         break;
3265       insn_last = NEXT_INSN (insn_last);
3266     }
3267
3268   /* Mark labels.  */
3269   for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3270     {
3271       if (JUMP_P (insn))
3272         {
3273           mark_jump_label (PATTERN (insn), insn, 0);
3274           njumps++;
3275           if (probability != -1
3276               && any_condjump_p (insn)
3277               && !find_reg_note (insn, REG_BR_PROB, 0))
3278             {
3279               /* We can preserve the REG_BR_PROB notes only if exactly
3280                  one jump is created, otherwise the machine description
3281                  is responsible for this step using
3282                  split_branch_probability variable.  */
3283               if (njumps != 1)
3284                 abort ();
3285               REG_NOTES (insn)
3286                 = gen_rtx_EXPR_LIST (REG_BR_PROB,
3287                                      GEN_INT (probability),
3288                                      REG_NOTES (insn));
3289             }
3290         }
3291     }
3292
3293   /* If we are splitting a CALL_INSN, look for the CALL_INSN
3294      in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3295   if (CALL_P (trial))
3296     {
3297       for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3298         if (CALL_P (insn))
3299           {
3300             rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
3301             while (*p)
3302               p = &XEXP (*p, 1);
3303             *p = CALL_INSN_FUNCTION_USAGE (trial);
3304             SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
3305           }
3306     }
3307
3308   /* Copy notes, particularly those related to the CFG.  */
3309   for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
3310     {
3311       switch (REG_NOTE_KIND (note))
3312         {
3313         case REG_EH_REGION:
3314           insn = insn_last;
3315           while (insn != NULL_RTX)
3316             {
3317               if (CALL_P (insn)
3318                   || (flag_non_call_exceptions
3319                       && may_trap_p (PATTERN (insn))))
3320                 REG_NOTES (insn)
3321                   = gen_rtx_EXPR_LIST (REG_EH_REGION,
3322                                        XEXP (note, 0),
3323                                        REG_NOTES (insn));
3324               insn = PREV_INSN (insn);
3325             }
3326           break;
3327
3328         case REG_NORETURN:
3329         case REG_SETJMP:
3330         case REG_ALWAYS_RETURN:
3331           insn = insn_last;
3332           while (insn != NULL_RTX)
3333             {
3334               if (CALL_P (insn))
3335                 REG_NOTES (insn)
3336                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3337                                        XEXP (note, 0),
3338                                        REG_NOTES (insn));
3339               insn = PREV_INSN (insn);
3340             }
3341           break;
3342
3343         case REG_NON_LOCAL_GOTO:
3344           insn = insn_last;
3345           while (insn != NULL_RTX)
3346             {
3347               if (JUMP_P (insn))
3348                 REG_NOTES (insn)
3349                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3350                                        XEXP (note, 0),
3351                                        REG_NOTES (insn));
3352               insn = PREV_INSN (insn);
3353             }
3354           break;
3355
3356         default:
3357           break;
3358         }
3359     }
3360
3361   /* If there are LABELS inside the split insns increment the
3362      usage count so we don't delete the label.  */
3363   if (NONJUMP_INSN_P (trial))
3364     {
3365       insn = insn_last;
3366       while (insn != NULL_RTX)
3367         {
3368           if (NONJUMP_INSN_P (insn))
3369             mark_label_nuses (PATTERN (insn));
3370
3371           insn = PREV_INSN (insn);
3372         }
3373     }
3374
3375   tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));
3376
3377   delete_insn (trial);
3378   if (has_barrier)
3379     emit_barrier_after (tem);
3380
3381   /* Recursively call try_split for each new insn created; by the
3382      time control returns here that insn will be fully split, so
3383      set LAST and continue from the insn after the one returned.
3384      We can't use next_active_insn here since AFTER may be a note.
3385      Ignore deleted insns, which can be occur if not optimizing.  */
3386   for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3387     if (! INSN_DELETED_P (tem) && INSN_P (tem))
3388       tem = try_split (PATTERN (tem), tem, 1);
3389
3390   /* Return either the first or the last insn, depending on which was
3391      requested.  */
3392   return last
3393     ? (after ? PREV_INSN (after) : last_insn)
3394     : NEXT_INSN (before);
3395 }
3396 \f
3397 /* Make and return an INSN rtx, initializing all its slots.
3398    Store PATTERN in the pattern slots.  */
3399
3400 rtx
3401 make_insn_raw (rtx pattern)
3402 {
3403   rtx insn;
3404
3405   insn = rtx_alloc (INSN);
3406
3407   INSN_UID (insn) = cur_insn_uid++;
3408   PATTERN (insn) = pattern;
3409   INSN_CODE (insn) = -1;
3410   LOG_LINKS (insn) = NULL;
3411   REG_NOTES (insn) = NULL;
3412   INSN_LOCATOR (insn) = 0;
3413   BLOCK_FOR_INSN (insn) = NULL;
3414
3415 #ifdef ENABLE_RTL_CHECKING
3416   if (insn
3417       && INSN_P (insn)
3418       && (returnjump_p (insn)
3419           || (GET_CODE (insn) == SET
3420               && SET_DEST (insn) == pc_rtx)))
3421     {
3422       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
3423       debug_rtx (insn);
3424     }
3425 #endif
3426
3427   return insn;
3428 }
3429
3430 /* Like `make_insn_raw' but make a JUMP_INSN instead of an insn.  */
3431
3432 static rtx
3433 make_jump_insn_raw (rtx pattern)
3434 {
3435   rtx insn;
3436
3437   insn = rtx_alloc (JUMP_INSN);
3438   INSN_UID (insn) = cur_insn_uid++;
3439
3440   PATTERN (insn) = pattern;
3441   INSN_CODE (insn) = -1;
3442   LOG_LINKS (insn) = NULL;
3443   REG_NOTES (insn) = NULL;
3444   JUMP_LABEL (insn) = NULL;
3445   INSN_LOCATOR (insn) = 0;
3446   BLOCK_FOR_INSN (insn) = NULL;
3447
3448   return insn;
3449 }
3450
3451 /* Like `make_insn_raw' but make a CALL_INSN instead of an insn.  */
3452
3453 static rtx
3454 make_call_insn_raw (rtx pattern)
3455 {
3456   rtx insn;
3457
3458   insn = rtx_alloc (CALL_INSN);
3459   INSN_UID (insn) = cur_insn_uid++;
3460
3461   PATTERN (insn) = pattern;
3462   INSN_CODE (insn) = -1;
3463   LOG_LINKS (insn) = NULL;
3464   REG_NOTES (insn) = NULL;
3465   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3466   INSN_LOCATOR (insn) = 0;
3467   BLOCK_FOR_INSN (insn) = NULL;
3468
3469   return insn;
3470 }
3471 \f
3472 /* Add INSN to the end of the doubly-linked list.
3473    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3474
3475 void
3476 add_insn (rtx insn)
3477 {
3478   PREV_INSN (insn) = last_insn;
3479   NEXT_INSN (insn) = 0;
3480
3481   if (NULL != last_insn)
3482     NEXT_INSN (last_insn) = insn;
3483
3484   if (NULL == first_insn)
3485     first_insn = insn;
3486
3487   last_insn = insn;
3488 }
3489
3490 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3491    the next should be the only functions called to insert an insn once
3492    delay slots have been filled since only they know how to update a
3493    SEQUENCE.  */
3494
3495 void
3496 add_insn_after (rtx insn, rtx after)
3497 {
3498   rtx next = NEXT_INSN (after);
3499   basic_block bb;
3500
3501   if (optimize && INSN_DELETED_P (after))
3502     abort ();
3503
3504   NEXT_INSN (insn) = next;
3505   PREV_INSN (insn) = after;
3506
3507   if (next)
3508     {
3509       PREV_INSN (next) = insn;
3510       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3511         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3512     }
3513   else if (last_insn == after)
3514     last_insn = insn;
3515   else
3516     {
3517       struct sequence_stack *stack = seq_stack;
3518       /* Scan all pending sequences too.  */
3519       for (; stack; stack = stack->next)
3520         if (after == stack->last)
3521           {
3522             stack->last = insn;
3523             break;
3524           }
3525
3526       if (stack == 0)
3527         abort ();
3528     }
3529
3530   if (!BARRIER_P (after)
3531       && !BARRIER_P (insn)
3532       && (bb = BLOCK_FOR_INSN (after)))
3533     {
3534       set_block_for_insn (insn, bb);
3535       if (INSN_P (insn))
3536         bb->flags |= BB_DIRTY;
3537       /* Should not happen as first in the BB is always
3538          either NOTE or LABEL.  */
3539       if (BB_END (bb) == after
3540           /* Avoid clobbering of structure when creating new BB.  */
3541           && !BARRIER_P (insn)
3542           && (!NOTE_P (insn)
3543               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3544         BB_END (bb) = insn;
3545     }
3546
3547   NEXT_INSN (after) = insn;
3548   if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
3549     {
3550       rtx sequence = PATTERN (after);
3551       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3552     }
3553 }
3554
3555 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3556    the previous should be the only functions called to insert an insn once
3557    delay slots have been filled since only they know how to update a
3558    SEQUENCE.  */
3559
3560 void
3561 add_insn_before (rtx insn, rtx before)
3562 {
3563   rtx prev = PREV_INSN (before);
3564   basic_block bb;
3565
3566   if (optimize && INSN_DELETED_P (before))
3567     abort ();
3568
3569   PREV_INSN (insn) = prev;
3570   NEXT_INSN (insn) = before;
3571
3572   if (prev)
3573     {
3574       NEXT_INSN (prev) = insn;
3575       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3576         {
3577           rtx sequence = PATTERN (prev);
3578           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3579         }
3580     }
3581   else if (first_insn == before)
3582     first_insn = insn;
3583   else
3584     {
3585       struct sequence_stack *stack = seq_stack;
3586       /* Scan all pending sequences too.  */
3587       for (; stack; stack = stack->next)
3588         if (before == stack->first)
3589           {
3590             stack->first = insn;
3591             break;
3592           }
3593
3594       if (stack == 0)
3595         abort ();
3596     }
3597
3598   if (!BARRIER_P (before)
3599       && !BARRIER_P (insn)
3600       && (bb = BLOCK_FOR_INSN (before)))
3601     {
3602       set_block_for_insn (insn, bb);
3603       if (INSN_P (insn))
3604         bb->flags |= BB_DIRTY;
3605       /* Should not happen as first in the BB is always
3606          either NOTE or LABEl.  */
3607       if (BB_HEAD (bb) == insn
3608           /* Avoid clobbering of structure when creating new BB.  */
3609           && !BARRIER_P (insn)
3610           && (!NOTE_P (insn)
3611               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3612         abort ();
3613     }
3614
3615   PREV_INSN (before) = insn;
3616   if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
3617     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3618 }
3619
3620 /* Remove an insn from its doubly-linked list.  This function knows how
3621    to handle sequences.  */
3622 void
3623 remove_insn (rtx insn)
3624 {
3625   rtx next = NEXT_INSN (insn);
3626   rtx prev = PREV_INSN (insn);
3627   basic_block bb;
3628
3629   if (prev)
3630     {
3631       NEXT_INSN (prev) = next;
3632       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3633         {
3634           rtx sequence = PATTERN (prev);
3635           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3636         }
3637     }
3638   else if (first_insn == insn)
3639     first_insn = next;
3640   else
3641     {
3642       struct sequence_stack *stack = seq_stack;
3643       /* Scan all pending sequences too.  */
3644       for (; stack; stack = stack->next)
3645         if (insn == stack->first)
3646           {
3647             stack->first = next;
3648             break;
3649           }
3650
3651       if (stack == 0)
3652         abort ();
3653     }
3654
3655   if (next)
3656     {
3657       PREV_INSN (next) = prev;
3658       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3659         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3660     }
3661   else if (last_insn == insn)
3662     last_insn = prev;
3663   else
3664     {
3665       struct sequence_stack *stack = seq_stack;
3666       /* Scan all pending sequences too.  */
3667       for (; stack; stack = stack->next)
3668         if (insn == stack->last)
3669           {
3670             stack->last = prev;
3671             break;
3672           }
3673
3674       if (stack == 0)
3675         abort ();
3676     }
3677   if (!BARRIER_P (insn)
3678       && (bb = BLOCK_FOR_INSN (insn)))
3679     {
3680       if (INSN_P (insn))
3681         bb->flags |= BB_DIRTY;
3682       if (BB_HEAD (bb) == insn)