OSDN Git Service

abc16d5bec572322edd60a53cd2782aa7fd92a90
[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 QUEUED:
2231     case CONST_INT:
2232     case CONST_DOUBLE:
2233     case CONST_VECTOR:
2234     case SYMBOL_REF:
2235     case LABEL_REF:
2236     case CODE_LABEL:
2237     case PC:
2238     case CC0:
2239     case SCRATCH:
2240       return;
2241       /* SCRATCH must be shared because they represent distinct values.  */
2242     case CLOBBER:
2243       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2244         return;
2245       break;
2246
2247     case CONST:
2248       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2249          a LABEL_REF, it isn't sharable.  */
2250       if (GET_CODE (XEXP (x, 0)) == PLUS
2251           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2252           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2253         return;
2254       break;
2255
2256     case MEM:
2257       /* A MEM is allowed to be shared if its address is constant.  */
2258       if (CONSTANT_ADDRESS_P (XEXP (x, 0))
2259           || reload_completed || reload_in_progress)
2260         return;
2261
2262       break;
2263
2264     default:
2265       break;
2266     }
2267
2268   /* This rtx may not be shared.  If it has already been seen,
2269      replace it with a copy of itself.  */
2270
2271   if (RTX_FLAG (x, used))
2272     {
2273       error ("Invalid rtl sharing found in the insn");
2274       debug_rtx (insn);
2275       error ("Shared rtx");
2276       debug_rtx (x);
2277       abort ();
2278     }
2279   RTX_FLAG (x, used) = 1;
2280
2281   /* Now scan the subexpressions recursively.  */
2282
2283   format_ptr = GET_RTX_FORMAT (code);
2284
2285   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2286     {
2287       switch (*format_ptr++)
2288         {
2289         case 'e':
2290           verify_rtx_sharing (XEXP (x, i), insn);
2291           break;
2292
2293         case 'E':
2294           if (XVEC (x, i) != NULL)
2295             {
2296               int j;
2297               int len = XVECLEN (x, i);
2298
2299               for (j = 0; j < len; j++)
2300                 {
2301                   /* We allow sharing of ASM_OPERANDS inside single instruction.  */
2302                   if (j && GET_CODE (XVECEXP (x, i, j)) == SET
2303                       && GET_CODE (SET_SRC (XVECEXP (x, i, j))) == ASM_OPERANDS)
2304                     verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
2305                   else
2306                     verify_rtx_sharing (XVECEXP (x, i, j), insn);
2307                 }
2308             }
2309           break;
2310         }
2311     }
2312   return;
2313 }
2314
2315 /* Go through all the RTL insn bodies and check that there is no unexpected
2316    sharing in between the subexpressions.  */
2317
2318 void
2319 verify_rtl_sharing (void)
2320 {
2321   rtx p;
2322
2323   for (p = get_insns (); p; p = NEXT_INSN (p))
2324     if (INSN_P (p))
2325       {
2326         reset_used_flags (PATTERN (p));
2327         reset_used_flags (REG_NOTES (p));
2328         reset_used_flags (LOG_LINKS (p));
2329       }
2330
2331   for (p = get_insns (); p; p = NEXT_INSN (p))
2332     if (INSN_P (p))
2333       {
2334         verify_rtx_sharing (PATTERN (p), p);
2335         verify_rtx_sharing (REG_NOTES (p), p);
2336         verify_rtx_sharing (LOG_LINKS (p), p);
2337       }
2338 }
2339
2340 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2341    Assumes the mark bits are cleared at entry.  */
2342
2343 void
2344 unshare_all_rtl_in_chain (rtx insn)
2345 {
2346   for (; insn; insn = NEXT_INSN (insn))
2347     if (INSN_P (insn))
2348       {
2349         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2350         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2351         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
2352       }
2353 }
2354
2355 /* Go through all virtual stack slots of a function and copy any
2356    shared structure.  */
2357 static void
2358 unshare_all_decls (tree blk)
2359 {
2360   tree t;
2361
2362   /* Copy shared decls.  */
2363   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2364     if (DECL_RTL_SET_P (t))
2365       SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
2366
2367   /* Now process sub-blocks.  */
2368   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2369     unshare_all_decls (t);
2370 }
2371
2372 /* Go through all virtual stack slots of a function and mark them as
2373    not shared.  */
2374 static void
2375 reset_used_decls (tree blk)
2376 {
2377   tree t;
2378
2379   /* Mark decls.  */
2380   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2381     if (DECL_RTL_SET_P (t))
2382       reset_used_flags (DECL_RTL (t));
2383
2384   /* Now process sub-blocks.  */
2385   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2386     reset_used_decls (t);
2387 }
2388
2389 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
2390    placed in the result directly, rather than being copied.  MAY_SHARE is
2391    either a MEM of an EXPR_LIST of MEMs.  */
2392
2393 rtx
2394 copy_most_rtx (rtx orig, rtx may_share)
2395 {
2396   rtx copy;
2397   int i, j;
2398   RTX_CODE code;
2399   const char *format_ptr;
2400
2401   if (orig == may_share
2402       || (GET_CODE (may_share) == EXPR_LIST
2403           && in_expr_list_p (may_share, orig)))
2404     return orig;
2405
2406   code = GET_CODE (orig);
2407
2408   switch (code)
2409     {
2410     case REG:
2411     case QUEUED:
2412     case CONST_INT:
2413     case CONST_DOUBLE:
2414     case CONST_VECTOR:
2415     case SYMBOL_REF:
2416     case CODE_LABEL:
2417     case PC:
2418     case CC0:
2419       return orig;
2420     default:
2421       break;
2422     }
2423
2424   copy = rtx_alloc (code);
2425   PUT_MODE (copy, GET_MODE (orig));
2426   RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
2427   RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
2428   RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
2429   RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
2430   RTX_FLAG (copy, return_val) = RTX_FLAG (orig, return_val);
2431
2432   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2433
2434   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2435     {
2436       switch (*format_ptr++)
2437         {
2438         case 'e':
2439           XEXP (copy, i) = XEXP (orig, i);
2440           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
2441             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
2442           break;
2443
2444         case 'u':
2445           XEXP (copy, i) = XEXP (orig, i);
2446           break;
2447
2448         case 'E':
2449         case 'V':
2450           XVEC (copy, i) = XVEC (orig, i);
2451           if (XVEC (orig, i) != NULL)
2452             {
2453               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2454               for (j = 0; j < XVECLEN (copy, i); j++)
2455                 XVECEXP (copy, i, j)
2456                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
2457             }
2458           break;
2459
2460         case 'w':
2461           XWINT (copy, i) = XWINT (orig, i);
2462           break;
2463
2464         case 'n':
2465         case 'i':
2466           XINT (copy, i) = XINT (orig, i);
2467           break;
2468
2469         case 't':
2470           XTREE (copy, i) = XTREE (orig, i);
2471           break;
2472
2473         case 's':
2474         case 'S':
2475           XSTR (copy, i) = XSTR (orig, i);
2476           break;
2477
2478         case '0':
2479           X0ANY (copy, i) = X0ANY (orig, i);
2480           break;
2481
2482         default:
2483           abort ();
2484         }
2485     }
2486   return copy;
2487 }
2488
2489 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2490    Recursively does the same for subexpressions.  Uses
2491    copy_rtx_if_shared_1 to reduce stack space.  */
2492
2493 rtx
2494 copy_rtx_if_shared (rtx orig)
2495 {
2496   copy_rtx_if_shared_1 (&orig);
2497   return orig;
2498 }
2499
2500 /* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
2501    use.  Recursively does the same for subexpressions.  */
2502
2503 static void
2504 copy_rtx_if_shared_1 (rtx *orig1)
2505 {
2506   rtx x;
2507   int i;
2508   enum rtx_code code;
2509   rtx *last_ptr;
2510   const char *format_ptr;
2511   int copied = 0;
2512   int length;
2513
2514   /* Repeat is used to turn tail-recursion into iteration.  */
2515 repeat:
2516   x = *orig1;
2517
2518   if (x == 0)
2519     return;
2520
2521   code = GET_CODE (x);
2522
2523   /* These types may be freely shared.  */
2524
2525   switch (code)
2526     {
2527     case REG:
2528     case QUEUED:
2529     case CONST_INT:
2530     case CONST_DOUBLE:
2531     case CONST_VECTOR:
2532     case SYMBOL_REF:
2533     case LABEL_REF:
2534     case CODE_LABEL:
2535     case PC:
2536     case CC0:
2537     case SCRATCH:
2538       /* SCRATCH must be shared because they represent distinct values.  */
2539       return;
2540     case CLOBBER:
2541       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2542         return;
2543       break;
2544
2545     case CONST:
2546       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2547          a LABEL_REF, it isn't sharable.  */
2548       if (GET_CODE (XEXP (x, 0)) == PLUS
2549           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2550           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2551         return;
2552       break;
2553
2554     case INSN:
2555     case JUMP_INSN:
2556     case CALL_INSN:
2557     case NOTE:
2558     case BARRIER:
2559       /* The chain of insns is not being copied.  */
2560       return;
2561
2562     default:
2563       break;
2564     }
2565
2566   /* This rtx may not be shared.  If it has already been seen,
2567      replace it with a copy of itself.  */
2568
2569   if (RTX_FLAG (x, used))
2570     {
2571       rtx copy;
2572
2573       copy = rtx_alloc (code);
2574       memcpy (copy, x, RTX_SIZE (code));
2575       x = copy;
2576       copied = 1;
2577     }
2578   RTX_FLAG (x, used) = 1;
2579
2580   /* Now scan the subexpressions recursively.
2581      We can store any replaced subexpressions directly into X
2582      since we know X is not shared!  Any vectors in X
2583      must be copied if X was copied.  */
2584
2585   format_ptr = GET_RTX_FORMAT (code);
2586   length = GET_RTX_LENGTH (code);
2587   last_ptr = NULL;
2588   
2589   for (i = 0; i < length; i++)
2590     {
2591       switch (*format_ptr++)
2592         {
2593         case 'e':
2594           if (last_ptr)
2595             copy_rtx_if_shared_1 (last_ptr);
2596           last_ptr = &XEXP (x, i);
2597           break;
2598
2599         case 'E':
2600           if (XVEC (x, i) != NULL)
2601             {
2602               int j;
2603               int len = XVECLEN (x, i);
2604               
2605               /* Copy the vector iff I copied the rtx and the length
2606                  is nonzero.  */
2607               if (copied && len > 0)
2608                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2609               
2610               /* Call recursively on all inside the vector.  */
2611               for (j = 0; j < len; j++)
2612                 {
2613                   if (last_ptr)
2614                     copy_rtx_if_shared_1 (last_ptr);
2615                   last_ptr = &XVECEXP (x, i, j);
2616                 }
2617             }
2618           break;
2619         }
2620     }
2621   *orig1 = x;
2622   if (last_ptr)
2623     {
2624       orig1 = last_ptr;
2625       goto repeat;
2626     }
2627   return;
2628 }
2629
2630 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2631    to look for shared sub-parts.  */
2632
2633 void
2634 reset_used_flags (rtx x)
2635 {
2636   int i, j;
2637   enum rtx_code code;
2638   const char *format_ptr;
2639   int length;
2640
2641   /* Repeat is used to turn tail-recursion into iteration.  */
2642 repeat:
2643   if (x == 0)
2644     return;
2645
2646   code = GET_CODE (x);
2647
2648   /* These types may be freely shared so we needn't do any resetting
2649      for them.  */
2650
2651   switch (code)
2652     {
2653     case REG:
2654     case QUEUED:
2655     case CONST_INT:
2656     case CONST_DOUBLE:
2657     case CONST_VECTOR:
2658     case SYMBOL_REF:
2659     case CODE_LABEL:
2660     case PC:
2661     case CC0:
2662       return;
2663
2664     case INSN:
2665     case JUMP_INSN:
2666     case CALL_INSN:
2667     case NOTE:
2668     case LABEL_REF:
2669     case BARRIER:
2670       /* The chain of insns is not being copied.  */
2671       return;
2672
2673     default:
2674       break;
2675     }
2676
2677   RTX_FLAG (x, used) = 0;
2678
2679   format_ptr = GET_RTX_FORMAT (code);
2680   length = GET_RTX_LENGTH (code);
2681   
2682   for (i = 0; i < length; i++)
2683     {
2684       switch (*format_ptr++)
2685         {
2686         case 'e':
2687           if (i == length-1)
2688             {
2689               x = XEXP (x, i);
2690               goto repeat;
2691             }
2692           reset_used_flags (XEXP (x, i));
2693           break;
2694
2695         case 'E':
2696           for (j = 0; j < XVECLEN (x, i); j++)
2697             reset_used_flags (XVECEXP (x, i, j));
2698           break;
2699         }
2700     }
2701 }
2702
2703 /* Set all the USED bits in X to allow copy_rtx_if_shared to be used
2704    to look for shared sub-parts.  */
2705
2706 void
2707 set_used_flags (rtx x)
2708 {
2709   int i, j;
2710   enum rtx_code code;
2711   const char *format_ptr;
2712
2713   if (x == 0)
2714     return;
2715
2716   code = GET_CODE (x);
2717
2718   /* These types may be freely shared so we needn't do any resetting
2719      for them.  */
2720
2721   switch (code)
2722     {
2723     case REG:
2724     case QUEUED:
2725     case CONST_INT:
2726     case CONST_DOUBLE:
2727     case CONST_VECTOR:
2728     case SYMBOL_REF:
2729     case CODE_LABEL:
2730     case PC:
2731     case CC0:
2732       return;
2733
2734     case INSN:
2735     case JUMP_INSN:
2736     case CALL_INSN:
2737     case NOTE:
2738     case LABEL_REF:
2739     case BARRIER:
2740       /* The chain of insns is not being copied.  */
2741       return;
2742
2743     default:
2744       break;
2745     }
2746
2747   RTX_FLAG (x, used) = 1;
2748
2749   format_ptr = GET_RTX_FORMAT (code);
2750   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2751     {
2752       switch (*format_ptr++)
2753         {
2754         case 'e':
2755           set_used_flags (XEXP (x, i));
2756           break;
2757
2758         case 'E':
2759           for (j = 0; j < XVECLEN (x, i); j++)
2760             set_used_flags (XVECEXP (x, i, j));
2761           break;
2762         }
2763     }
2764 }
2765 \f
2766 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2767    Return X or the rtx for the pseudo reg the value of X was copied into.
2768    OTHER must be valid as a SET_DEST.  */
2769
2770 rtx
2771 make_safe_from (rtx x, rtx other)
2772 {
2773   while (1)
2774     switch (GET_CODE (other))
2775       {
2776       case SUBREG:
2777         other = SUBREG_REG (other);
2778         break;
2779       case STRICT_LOW_PART:
2780       case SIGN_EXTEND:
2781       case ZERO_EXTEND:
2782         other = XEXP (other, 0);
2783         break;
2784       default:
2785         goto done;
2786       }
2787  done:
2788   if ((MEM_P (other)
2789        && ! CONSTANT_P (x)
2790        && !REG_P (x)
2791        && GET_CODE (x) != SUBREG)
2792       || (REG_P (other)
2793           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2794               || reg_mentioned_p (other, x))))
2795     {
2796       rtx temp = gen_reg_rtx (GET_MODE (x));
2797       emit_move_insn (temp, x);
2798       return temp;
2799     }
2800   return x;
2801 }
2802 \f
2803 /* Emission of insns (adding them to the doubly-linked list).  */
2804
2805 /* Return the first insn of the current sequence or current function.  */
2806
2807 rtx
2808 get_insns (void)
2809 {
2810   return first_insn;
2811 }
2812
2813 /* Specify a new insn as the first in the chain.  */
2814
2815 void
2816 set_first_insn (rtx insn)
2817 {
2818   if (PREV_INSN (insn) != 0)
2819     abort ();
2820   first_insn = insn;
2821 }
2822
2823 /* Return the last insn emitted in current sequence or current function.  */
2824
2825 rtx
2826 get_last_insn (void)
2827 {
2828   return last_insn;
2829 }
2830
2831 /* Specify a new insn as the last in the chain.  */
2832
2833 void
2834 set_last_insn (rtx insn)
2835 {
2836   if (NEXT_INSN (insn) != 0)
2837     abort ();
2838   last_insn = insn;
2839 }
2840
2841 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2842
2843 rtx
2844 get_last_insn_anywhere (void)
2845 {
2846   struct sequence_stack *stack;
2847   if (last_insn)
2848     return last_insn;
2849   for (stack = seq_stack; stack; stack = stack->next)
2850     if (stack->last != 0)
2851       return stack->last;
2852   return 0;
2853 }
2854
2855 /* Return the first nonnote insn emitted in current sequence or current
2856    function.  This routine looks inside SEQUENCEs.  */
2857
2858 rtx
2859 get_first_nonnote_insn (void)
2860 {
2861   rtx insn = first_insn;
2862
2863   while (insn)
2864     {
2865       insn = next_insn (insn);
2866       if (insn == 0 || !NOTE_P (insn))
2867         break;
2868     }
2869
2870   return insn;
2871 }
2872
2873 /* Return the last nonnote insn emitted in current sequence or current
2874    function.  This routine looks inside SEQUENCEs.  */
2875
2876 rtx
2877 get_last_nonnote_insn (void)
2878 {
2879   rtx insn = last_insn;
2880
2881   while (insn)
2882     {
2883       insn = previous_insn (insn);
2884       if (insn == 0 || !NOTE_P (insn))
2885         break;
2886     }
2887
2888   return insn;
2889 }
2890
2891 /* Return a number larger than any instruction's uid in this function.  */
2892
2893 int
2894 get_max_uid (void)
2895 {
2896   return cur_insn_uid;
2897 }
2898
2899 /* Renumber instructions so that no instruction UIDs are wasted.  */
2900
2901 void
2902 renumber_insns (FILE *stream)
2903 {
2904   rtx insn;
2905
2906   /* If we're not supposed to renumber instructions, don't.  */
2907   if (!flag_renumber_insns)
2908     return;
2909
2910   /* If there aren't that many instructions, then it's not really
2911      worth renumbering them.  */
2912   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
2913     return;
2914
2915   cur_insn_uid = 1;
2916
2917   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2918     {
2919       if (stream)
2920         fprintf (stream, "Renumbering insn %d to %d\n",
2921                  INSN_UID (insn), cur_insn_uid);
2922       INSN_UID (insn) = cur_insn_uid++;
2923     }
2924 }
2925 \f
2926 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2927    of the sequence.  */
2928
2929 rtx
2930 next_insn (rtx insn)
2931 {
2932   if (insn)
2933     {
2934       insn = NEXT_INSN (insn);
2935       if (insn && NONJUMP_INSN_P (insn)
2936           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2937         insn = XVECEXP (PATTERN (insn), 0, 0);
2938     }
2939
2940   return insn;
2941 }
2942
2943 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2944    of the sequence.  */
2945
2946 rtx
2947 previous_insn (rtx insn)
2948 {
2949   if (insn)
2950     {
2951       insn = PREV_INSN (insn);
2952       if (insn && NONJUMP_INSN_P (insn)
2953           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2954         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2955     }
2956
2957   return insn;
2958 }
2959
2960 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2961    look inside SEQUENCEs.  */
2962
2963 rtx
2964 next_nonnote_insn (rtx insn)
2965 {
2966   while (insn)
2967     {
2968       insn = NEXT_INSN (insn);
2969       if (insn == 0 || !NOTE_P (insn))
2970         break;
2971     }
2972
2973   return insn;
2974 }
2975
2976 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2977    not look inside SEQUENCEs.  */
2978
2979 rtx
2980 prev_nonnote_insn (rtx insn)
2981 {
2982   while (insn)
2983     {
2984       insn = PREV_INSN (insn);
2985       if (insn == 0 || !NOTE_P (insn))
2986         break;
2987     }
2988
2989   return insn;
2990 }
2991
2992 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2993    or 0, if there is none.  This routine does not look inside
2994    SEQUENCEs.  */
2995
2996 rtx
2997 next_real_insn (rtx insn)
2998 {
2999   while (insn)
3000     {
3001       insn = NEXT_INSN (insn);
3002       if (insn == 0 || INSN_P (insn))
3003         break;
3004     }
3005
3006   return insn;
3007 }
3008
3009 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
3010    or 0, if there is none.  This routine does not look inside
3011    SEQUENCEs.  */
3012
3013 rtx
3014 prev_real_insn (rtx insn)
3015 {
3016   while (insn)
3017     {
3018       insn = PREV_INSN (insn);
3019       if (insn == 0 || INSN_P (insn))
3020         break;
3021     }
3022
3023   return insn;
3024 }
3025
3026 /* Return the last CALL_INSN in the current list, or 0 if there is none.
3027    This routine does not look inside SEQUENCEs.  */
3028
3029 rtx
3030 last_call_insn (void)
3031 {
3032   rtx insn;
3033
3034   for (insn = get_last_insn ();
3035        insn && !CALL_P (insn);
3036        insn = PREV_INSN (insn))
3037     ;
3038
3039   return insn;
3040 }
3041
3042 /* Find the next insn after INSN that really does something.  This routine
3043    does not look inside SEQUENCEs.  Until reload has completed, this is the
3044    same as next_real_insn.  */
3045
3046 int
3047 active_insn_p (rtx insn)
3048 {
3049   return (CALL_P (insn) || JUMP_P (insn)
3050           || (NONJUMP_INSN_P (insn)
3051               && (! reload_completed
3052                   || (GET_CODE (PATTERN (insn)) != USE
3053                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
3054 }
3055
3056 rtx
3057 next_active_insn (rtx insn)
3058 {
3059   while (insn)
3060     {
3061       insn = NEXT_INSN (insn);
3062       if (insn == 0 || active_insn_p (insn))
3063         break;
3064     }
3065
3066   return insn;
3067 }
3068
3069 /* Find the last insn before INSN that really does something.  This routine
3070    does not look inside SEQUENCEs.  Until reload has completed, this is the
3071    same as prev_real_insn.  */
3072
3073 rtx
3074 prev_active_insn (rtx insn)
3075 {
3076   while (insn)
3077     {
3078       insn = PREV_INSN (insn);
3079       if (insn == 0 || active_insn_p (insn))
3080         break;
3081     }
3082
3083   return insn;
3084 }
3085
3086 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
3087
3088 rtx
3089 next_label (rtx insn)
3090 {
3091   while (insn)
3092     {
3093       insn = NEXT_INSN (insn);
3094       if (insn == 0 || LABEL_P (insn))
3095         break;
3096     }
3097
3098   return insn;
3099 }
3100
3101 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
3102
3103 rtx
3104 prev_label (rtx insn)
3105 {
3106   while (insn)
3107     {
3108       insn = PREV_INSN (insn);
3109       if (insn == 0 || LABEL_P (insn))
3110         break;
3111     }
3112
3113   return insn;
3114 }
3115
3116 /* Return the last label to mark the same position as LABEL.  Return null
3117    if LABEL itself is null.  */
3118
3119 rtx
3120 skip_consecutive_labels (rtx label)
3121 {
3122   rtx insn;
3123
3124   for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
3125     if (LABEL_P (insn))
3126       label = insn;
3127
3128   return label;
3129 }
3130 \f
3131 #ifdef HAVE_cc0
3132 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
3133    and REG_CC_USER notes so we can find it.  */
3134
3135 void
3136 link_cc0_insns (rtx insn)
3137 {
3138   rtx user = next_nonnote_insn (insn);
3139
3140   if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
3141     user = XVECEXP (PATTERN (user), 0, 0);
3142
3143   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
3144                                         REG_NOTES (user));
3145   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
3146 }
3147
3148 /* Return the next insn that uses CC0 after INSN, which is assumed to
3149    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
3150    applied to the result of this function should yield INSN).
3151
3152    Normally, this is simply the next insn.  However, if a REG_CC_USER note
3153    is present, it contains the insn that uses CC0.
3154
3155    Return 0 if we can't find the insn.  */
3156
3157 rtx
3158 next_cc0_user (rtx insn)
3159 {
3160   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
3161
3162   if (note)
3163     return XEXP (note, 0);
3164
3165   insn = next_nonnote_insn (insn);
3166   if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
3167     insn = XVECEXP (PATTERN (insn), 0, 0);
3168
3169   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
3170     return insn;
3171
3172   return 0;
3173 }
3174
3175 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
3176    note, it is the previous insn.  */
3177
3178 rtx
3179 prev_cc0_setter (rtx insn)
3180 {
3181   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
3182
3183   if (note)
3184     return XEXP (note, 0);
3185
3186   insn = prev_nonnote_insn (insn);
3187   if (! sets_cc0_p (PATTERN (insn)))
3188     abort ();
3189
3190   return insn;
3191 }
3192 #endif
3193
3194 /* Increment the label uses for all labels present in rtx.  */
3195
3196 static void
3197 mark_label_nuses (rtx x)
3198 {
3199   enum rtx_code code;
3200   int i, j;
3201   const char *fmt;
3202
3203   code = GET_CODE (x);
3204   if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
3205     LABEL_NUSES (XEXP (x, 0))++;
3206
3207   fmt = GET_RTX_FORMAT (code);
3208   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3209     {
3210       if (fmt[i] == 'e')
3211         mark_label_nuses (XEXP (x, i));
3212       else if (fmt[i] == 'E')
3213         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3214           mark_label_nuses (XVECEXP (x, i, j));
3215     }
3216 }
3217
3218 \f
3219 /* Try splitting insns that can be split for better scheduling.
3220    PAT is the pattern which might split.
3221    TRIAL is the insn providing PAT.
3222    LAST is nonzero if we should return the last insn of the sequence produced.
3223
3224    If this routine succeeds in splitting, it returns the first or last
3225    replacement insn depending on the value of LAST.  Otherwise, it
3226    returns TRIAL.  If the insn to be returned can be split, it will be.  */
3227
3228 rtx
3229 try_split (rtx pat, rtx trial, int last)
3230 {
3231   rtx before = PREV_INSN (trial);
3232   rtx after = NEXT_INSN (trial);
3233   int has_barrier = 0;
3234   rtx tem;
3235   rtx note, seq;
3236   int probability;
3237   rtx insn_last, insn;
3238   int njumps = 0;
3239
3240   if (any_condjump_p (trial)
3241       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
3242     split_branch_probability = INTVAL (XEXP (note, 0));
3243   probability = split_branch_probability;
3244
3245   seq = split_insns (pat, trial);
3246
3247   split_branch_probability = -1;
3248
3249   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
3250      We may need to handle this specially.  */
3251   if (after && BARRIER_P (after))
3252     {
3253       has_barrier = 1;
3254       after = NEXT_INSN (after);
3255     }
3256
3257   if (!seq)
3258     return trial;
3259
3260   /* Avoid infinite loop if any insn of the result matches
3261      the original pattern.  */
3262   insn_last = seq;
3263   while (1)
3264     {
3265       if (INSN_P (insn_last)
3266           && rtx_equal_p (PATTERN (insn_last), pat))
3267         return trial;
3268       if (!NEXT_INSN (insn_last))
3269         break;
3270       insn_last = NEXT_INSN (insn_last);
3271     }
3272
3273   /* Mark labels.  */
3274   for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3275     {
3276       if (JUMP_P (insn))
3277         {
3278           mark_jump_label (PATTERN (insn), insn, 0);
3279           njumps++;
3280           if (probability != -1
3281               && any_condjump_p (insn)
3282               && !find_reg_note (insn, REG_BR_PROB, 0))
3283             {
3284               /* We can preserve the REG_BR_PROB notes only if exactly
3285                  one jump is created, otherwise the machine description
3286                  is responsible for this step using
3287                  split_branch_probability variable.  */
3288               if (njumps != 1)
3289                 abort ();
3290               REG_NOTES (insn)
3291                 = gen_rtx_EXPR_LIST (REG_BR_PROB,
3292                                      GEN_INT (probability),
3293                                      REG_NOTES (insn));
3294             }
3295         }
3296     }
3297
3298   /* If we are splitting a CALL_INSN, look for the CALL_INSN
3299      in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3300   if (CALL_P (trial))
3301     {
3302       for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3303         if (CALL_P (insn))
3304           {
3305             rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
3306             while (*p)
3307               p = &XEXP (*p, 1);
3308             *p = CALL_INSN_FUNCTION_USAGE (trial);
3309             SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
3310           }
3311     }
3312
3313   /* Copy notes, particularly those related to the CFG.  */
3314   for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
3315     {
3316       switch (REG_NOTE_KIND (note))
3317         {
3318         case REG_EH_REGION:
3319           insn = insn_last;
3320           while (insn != NULL_RTX)
3321             {
3322               if (CALL_P (insn)
3323                   || (flag_non_call_exceptions
3324                       && may_trap_p (PATTERN (insn))))
3325                 REG_NOTES (insn)
3326                   = gen_rtx_EXPR_LIST (REG_EH_REGION,
3327                                        XEXP (note, 0),
3328                                        REG_NOTES (insn));
3329               insn = PREV_INSN (insn);
3330             }
3331           break;
3332
3333         case REG_NORETURN:
3334         case REG_SETJMP:
3335         case REG_ALWAYS_RETURN:
3336           insn = insn_last;
3337           while (insn != NULL_RTX)
3338             {
3339               if (CALL_P (insn))
3340                 REG_NOTES (insn)
3341                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3342                                        XEXP (note, 0),
3343                                        REG_NOTES (insn));
3344               insn = PREV_INSN (insn);
3345             }
3346           break;
3347
3348         case REG_NON_LOCAL_GOTO:
3349           insn = insn_last;
3350           while (insn != NULL_RTX)
3351             {
3352               if (JUMP_P (insn))
3353                 REG_NOTES (insn)
3354                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3355                                        XEXP (note, 0),
3356                                        REG_NOTES (insn));
3357               insn = PREV_INSN (insn);
3358             }
3359           break;
3360
3361         default:
3362           break;
3363         }
3364     }
3365
3366   /* If there are LABELS inside the split insns increment the
3367      usage count so we don't delete the label.  */
3368   if (NONJUMP_INSN_P (trial))
3369     {
3370       insn = insn_last;
3371       while (insn != NULL_RTX)
3372         {
3373           if (NONJUMP_INSN_P (insn))
3374             mark_label_nuses (PATTERN (insn));
3375
3376           insn = PREV_INSN (insn);
3377         }
3378     }
3379
3380   tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));
3381
3382   delete_insn (trial);
3383   if (has_barrier)
3384     emit_barrier_after (tem);
3385
3386   /* Recursively call try_split for each new insn created; by the
3387      time control returns here that insn will be fully split, so
3388      set LAST and continue from the insn after the one returned.
3389      We can't use next_active_insn here since AFTER may be a note.
3390      Ignore deleted insns, which can be occur if not optimizing.  */
3391   for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3392     if (! INSN_DELETED_P (tem) && INSN_P (tem))
3393       tem = try_split (PATTERN (tem), tem, 1);
3394
3395   /* Return either the first or the last insn, depending on which was
3396      requested.  */
3397   return last
3398     ? (after ? PREV_INSN (after) : last_insn)
3399     : NEXT_INSN (before);
3400 }
3401 \f
3402 /* Make and return an INSN rtx, initializing all its slots.
3403    Store PATTERN in the pattern slots.  */
3404
3405 rtx
3406 make_insn_raw (rtx pattern)
3407 {
3408   rtx insn;
3409
3410   insn = rtx_alloc (INSN);
3411
3412   INSN_UID (insn) = cur_insn_uid++;
3413   PATTERN (insn) = pattern;
3414   INSN_CODE (insn) = -1;
3415   LOG_LINKS (insn) = NULL;
3416   REG_NOTES (insn) = NULL;
3417   INSN_LOCATOR (insn) = 0;
3418   BLOCK_FOR_INSN (insn) = NULL;
3419
3420 #ifdef ENABLE_RTL_CHECKING
3421   if (insn
3422       && INSN_P (insn)
3423       && (returnjump_p (insn)
3424           || (GET_CODE (insn) == SET
3425               && SET_DEST (insn) == pc_rtx)))
3426     {
3427       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
3428       debug_rtx (insn);
3429     }
3430 #endif
3431
3432   return insn;
3433 }
3434
3435 /* Like `make_insn_raw' but make a JUMP_INSN instead of an insn.  */
3436
3437 static rtx
3438 make_jump_insn_raw (rtx pattern)
3439 {
3440   rtx insn;
3441
3442   insn = rtx_alloc (JUMP_INSN);
3443   INSN_UID (insn) = cur_insn_uid++;
3444
3445   PATTERN (insn) = pattern;
3446   INSN_CODE (insn) = -1;
3447   LOG_LINKS (insn) = NULL;
3448   REG_NOTES (insn) = NULL;
3449   JUMP_LABEL (insn) = NULL;
3450   INSN_LOCATOR (insn) = 0;
3451   BLOCK_FOR_INSN (insn) = NULL;
3452
3453   return insn;
3454 }
3455
3456 /* Like `make_insn_raw' but make a CALL_INSN instead of an insn.  */
3457
3458 static rtx
3459 make_call_insn_raw (rtx pattern)
3460 {
3461   rtx insn;
3462
3463   insn = rtx_alloc (CALL_INSN);
3464   INSN_UID (insn) = cur_insn_uid++;
3465
3466   PATTERN (insn) = pattern;
3467   INSN_CODE (insn) = -1;
3468   LOG_LINKS (insn) = NULL;
3469   REG_NOTES (insn) = NULL;
3470   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3471   INSN_LOCATOR (insn) = 0;
3472   BLOCK_FOR_INSN (insn) = NULL;
3473
3474   return insn;
3475 }
3476 \f
3477 /* Add INSN to the end of the doubly-linked list.
3478    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3479
3480 void
3481 add_insn (rtx insn)
3482 {
3483   PREV_INSN (insn) = last_insn;
3484   NEXT_INSN (insn) = 0;
3485
3486   if (NULL != last_insn)
3487     NEXT_INSN (last_insn) = insn;
3488
3489   if (NULL == first_insn)
3490     first_insn = insn;
3491
3492   last_insn = insn;
3493 }
3494
3495 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3496    the next should be the only functions called to insert an insn once
3497    delay slots have been filled since only they know how to update a
3498    SEQUENCE.  */
3499
3500 void
3501 add_insn_after (rtx insn, rtx after)
3502 {
3503   rtx next = NEXT_INSN (after);
3504   basic_block bb;
3505
3506   if (optimize && INSN_DELETED_P (after))
3507     abort ();
3508
3509   NEXT_INSN (insn) = next;
3510   PREV_INSN (insn) = after;
3511
3512   if (next)
3513     {
3514       PREV_INSN (next) = insn;
3515       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3516         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3517     }
3518   else if (last_insn == after)
3519     last_insn = insn;
3520   else
3521     {
3522       struct sequence_stack *stack = seq_stack;
3523       /* Scan all pending sequences too.  */
3524       for (; stack; stack = stack->next)
3525         if (after == stack->last)
3526           {
3527             stack->last = insn;
3528             break;
3529           }
3530
3531       if (stack == 0)
3532         abort ();
3533     }
3534
3535   if (!BARRIER_P (after)
3536       && !BARRIER_P (insn)
3537       && (bb = BLOCK_FOR_INSN (after)))
3538     {
3539       set_block_for_insn (insn, bb);
3540       if (INSN_P (insn))
3541         bb->flags |= BB_DIRTY;
3542       /* Should not happen as first in the BB is always
3543          either NOTE or LABEL.  */
3544       if (BB_END (bb) == after
3545           /* Avoid clobbering of structure when creating new BB.  */
3546           && !BARRIER_P (insn)
3547           && (!NOTE_P (insn)
3548               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3549         BB_END (bb) = insn;
3550     }
3551
3552   NEXT_INSN (after) = insn;
3553   if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
3554     {
3555       rtx sequence = PATTERN (after);
3556       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3557     }
3558 }
3559
3560 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3561    the previous should be the only functions called to insert an insn once
3562    delay slots have been filled since only they know how to update a
3563    SEQUENCE.  */
3564
3565 void
3566 add_insn_before (rtx insn, rtx before)
3567 {
3568   rtx prev = PREV_INSN (before);
3569   basic_block bb;
3570
3571   if (optimize && INSN_DELETED_P (before))
3572     abort ();
3573
3574   PREV_INSN (insn) = prev;
3575   NEXT_INSN (insn) = before;
3576
3577   if (prev)
3578     {
3579       NEXT_INSN (prev) = insn;
3580       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3581         {
3582           rtx sequence = PATTERN (prev);
3583           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3584         }
3585     }
3586   else if (first_insn == before)
3587     first_insn = insn;
3588   else
3589     {
3590       struct sequence_stack *stack = seq_stack;
3591       /* Scan all pending sequences too.  */
3592       for (; stack; stack = stack->next)
3593         if (before == stack->first)
3594           {
3595             stack->first = insn;
3596             break;
3597           }
3598
3599       if (stack == 0)
3600         abort ();
3601     }
3602
3603   if (!BARRIER_P (before)
3604       && !BARRIER_P (insn)
3605       && (bb = BLOCK_FOR_INSN (before)))
3606     {
3607       set_block_for_insn (insn, bb);
3608       if (INSN_P (insn))
3609         bb->flags |= BB_DIRTY;
3610       /* Should not happen as first in the BB is always
3611          either NOTE or LABEl.  */
3612       if (BB_HEAD (bb) == insn
3613           /* Avoid clobbering of structure when creating new BB.  */
3614           && !BARRIER_P (insn)
3615           && (!NOTE_P (insn)
3616               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3617         abort ();
3618     }
3619
3620   PREV_INSN (before) = insn;
3621   if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
3622     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3623 }
3624
3625 /* Remove an insn from its doubly-linked list.  This function knows how
3626    to handle sequences.  */
3627 void
3628 remove_insn (rtx insn)
3629 {
3630   rtx next = NEXT_INSN (insn);
3631   rtx prev = PREV_INSN (insn);
3632   basic_block bb;
3633
3634   if (prev)
3635     {
3636       NEXT_INSN (prev) = next;
3637       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3638         {
3639           rtx sequence = PATTERN (prev);
3640           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3641         }
3642     }
3643   else if (first_insn == insn)
3644     first_insn = next;
3645   else
3646     {
3647       struct sequence_stack *stack = seq_stack;
3648       /* Scan all pending sequences too.  */
3649       for (; stack; stack = stack->next)
3650         if (insn == stack->first)
3651           {
3652             stack->first = next;
3653             break;
3654           }
3655
3656       if (stack == 0)
3657         abort ();
3658     }
3659
3660   if (next)
3661     {
3662       PREV_INSN (next) = prev;
3663       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3664         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3665     }
3666   else if (last_insn == insn)
3667     last_insn = prev;
3668   else
3669     {
3670       struct sequence_stack *stack = seq_stack;
3671       /* Scan all pending sequences too.  */
3672       for (; stack; stack = stack->next)
3673         if (insn == stack->last)
3674           {
3675             stack->last = prev;
3676             break;
3677           }
3678
3679       if (stack == 0)
3680         abort ();
3681     }
3682   if (!BARRIER_P (insn)
3683       && (bb = BLOCK_FOR_INSN (insn)))
3684     {
3685       if (INSN_P (insn))
3686         bb->flags |= BB_DIRTY;
3687       if (BB_HEAD (bb) == insn)
3688         {
3689           /* Never ever delete the basic block note without deleting whole
3690              basic block.  */
3691           if (NOTE_P (insn))
3692             abort ();
3693           BB_HEAD (bb) = next;
3694         }
3695       if (BB_END (bb) == insn)
3696         BB_END (bb) = prev;
3697     }
3698 }
3699
3700 /* Append CALL_FUSAGE to the CALL_INSN_FUNCTION_USAGE for CALL_INSN.  */
3701
3702 void
3703 add_function_usage_to (rtx call_insn, rtx call_fusage)
3704 {
3705   if (! call_insn || !CALL_P (call_insn))
3706     abort ();
3707
3708   /* Put the register usage information on the CALL.  If there is already
3709      some usage information, put ours at the end.  */
3710   if (CALL_INSN_FUNCTION_USAGE (call_insn))
3711     {
3712       rtx link;
3713
3714       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
3715            link = XEXP (link, 1))
3716         ;
3717
3718       XEXP (link, 1) = call_fusage;
3719     }
3720   else
3721     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
3722 }
3723
3724 /* Delete all insns made since FROM.
3725    FROM becomes the new last instruction.  */
3726
3727 void
3728 delete_insns_since (rtx from)
3729 {
3730   if (from == 0)
3731     first_insn = 0;
3732   else
3733     NEXT_INSN (from) = 0;
3734   last_insn = from;
3735 }
3736
3737 /* This function is deprecated, please use sequences instead.
3738
3739    Move a consecutive bunch of insns to a different place in the chain.
3740    The insns to be moved are those between FROM and TO.
3741    They are moved to a new position after the insn AFTER.
3742    AFTER must not be FROM or TO or any insn in between.
3743
3744    This function does not know about SEQUENCEs and hence should not be
3745    called after delay-slot filling has been done.  */
3746
3747 void
3748 reorder_insns_nobb (rtx from, rtx to, rtx after)
3749 {
3750   /* Splice this bunch out of where it is now.  */
3751   if (PREV_INSN (from))
3752     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
3753   if (NEXT_INSN (to))
3754     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
3755   if (last_insn == to)
3756     last_insn = PREV_INSN (from);
3757   if (first_insn == from)
3758     first_insn = NEXT_INSN (to);
3759
3760   /* Make the new neighbors point to it and it to them.  */
3761   if (NEXT_INSN (after))
3762     PREV_INSN (NEXT_INSN (after)) = to;
3763
3764   NEXT_INSN (to) = NEXT_INSN (after);
3765   PREV_INSN (from) = after;
3766   NEXT_INSN (after) = from;
3767   if (after == last_insn)
3768     last_insn = to;
3769 }
3770
3771 /* Same as function above, but take care to update BB boundaries.  */
3772 void
3773 reorder_insns (rtx from, rtx to, rtx after)
3774 {
3775   rtx prev = PREV_INSN (from);
3776   basic_block bb, bb2;
3777
3778   reorder_insns_nobb (from, to, after);
3779
3780   if (!BARRIER_P (after)
3781       && (bb = BLOCK_FOR_INSN (after)))
3782     {
3783       rtx x;
3784       bb->flags |= BB_DIRTY;
3785
3786       if (!BARRIER_P (from)
3787           && (bb2 = BLOCK_FOR_INSN (from)))
3788         {
3789           if (BB_END (bb2) == to)
3790             BB_END (bb2) = prev;
3791           bb2->flags |= BB_DIRTY;
3792         }
3793
3794       if (BB_END (bb) == after)
3795         BB_END (bb) = to;
3796
3797       for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
3798         set_block_for_insn (x, bb);
3799     }
3800 }
3801
3802 /* Return the line note insn preceding INSN.  */
3803
3804 static rtx
3805 find_line_note (rtx insn)
3806 {
3807   if (no_line_numbers)
3808     return 0;
3809
3810   for (; insn; insn = PREV_INSN (insn))
3811     if (NOTE_P (insn)
3812         && NOTE_LINE_NUMBER (insn) >= 0)
3813       break;
3814
3815   return insn;
3816 }
3817
3818 /* Remove unnecessary notes from the instruction stream.  */
3819
3820 void
3821 remove_unnecessary_notes (void)
3822 {
3823   rtx block_stack = NULL_RTX;
3824   rtx eh_stack = NULL_RTX;
3825   rtx insn;
3826   rtx next;
3827   rtx tmp;
3828
3829   /* We must not remove the first instruction in the function because
3830      the compiler depends on the first instruction being a note.  */
3831   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
3832     {
3833       /* Remember what's next.  */
3834       next = NEXT_INSN (insn);
3835
3836       /* We're only interested in notes.  */
3837       if (!NOTE_P (insn))
3838         continue;
3839
3840       switch (NOTE_LINE_NUMBER (insn))
3841         {
3842         case NOTE_INSN_DELETED:
3843         case NOTE_INSN_LOOP_END_TOP_COND:
3844           remove_insn (insn);
3845           break;
3846
3847         case NOTE_INSN_EH_REGION_BEG:
3848           eh_stack = alloc_INSN_LIST (insn, eh_stack);
3849           break;
3850
3851         case NOTE_INSN_EH_REGION_END:
3852           /* Too many end notes.  */
3853           if (eh_stack == NULL_RTX)
3854             abort ();
3855           /* Mismatched nesting.  */
3856           if (NOTE_EH_HANDLER (XEXP (eh_stack, 0)) != NOTE_EH_HANDLER (insn))
3857             abort ();
3858           tmp = eh_stack;
3859           eh_stack = XEXP (eh_stack, 1);
3860           free_INSN_LIST_node (tmp);
3861           break;
3862
3863         case NOTE_INSN_BLOCK_BEG:
3864           /* By now, all notes indicating lexical blocks should have
3865              NOTE_BLOCK filled in.  */
3866           if (NOTE_BLOCK (insn) == NULL_TREE)
3867             abort ();
3868           block_stack = alloc_INSN_LIST (insn, block_stack);
3869           break;
3870
3871         case NOTE_INSN_BLOCK_END:
3872           /* Too many end notes.  */
3873           if (block_stack == NULL_RTX)
3874             abort ();
3875           /* Mismatched nesting.  */
3876           if (NOTE_BLOCK (XEXP (block_stack, 0)) != NOTE_BLOCK (insn))
3877             abort ();
3878           tmp = block_stack;
3879           block_stack = XEXP (block_stack, 1);
3880           free_INSN_LIST_node (tmp);
3881
3882           /* Scan back to see if there are any non-note instructions
3883              between INSN and the beginning of this block.  If not,
3884              then there is no PC range in the generated code that will
3885              actually be in this block, so there's no point in
3886              remembering the existence of the block.  */
3887           for (tmp = PREV_INSN (insn); tmp; tmp = PREV_INSN (tmp))
3888             {
3889               /* This block contains a real instruction.  Note that we
3890                  don't include labels; if the only thing in the block
3891                  is a label, then there are still no PC values that
3892                  lie within the block.  */
3893               if (INSN_P (tmp))
3894                 break;
3895
3896               /* We're only interested in NOTEs.  */
3897               if (!NOTE_P (tmp))
3898                 continue;
3899
3900               if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_BEG)
3901                 {
3902                   /* We just verified that this BLOCK matches us with
3903                      the block_stack check above.  Never delete the
3904                      BLOCK for the outermost scope of the function; we
3905                      can refer to names from that scope even if the
3906                      block notes are messed up.  */
3907                   if (! is_body_block (NOTE_BLOCK (insn))
3908                       && (*debug_hooks->ignore_block) (NOTE_BLOCK (insn)))
3909                     {
3910                       remove_insn (tmp);
3911                       remove_insn (insn);
3912                     }
3913                   break;
3914                 }
3915               else if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_END)
3916                 /* There's a nested block.  We need to leave the
3917                    current block in place since otherwise the debugger
3918                    wouldn't be able to show symbols from our block in
3919                    the nested block.  */
3920                 break;
3921             }
3922         }
3923     }
3924
3925   /* Too many begin notes.  */
3926   if (block_stack || eh_stack)
3927     abort ();
3928 }
3929
3930 \f
3931 /* Emit insn(s) of given code and pattern
3932    at a specified place within the doubly-linked list.
3933
3934    All of the emit_foo global entry points accept an object
3935    X which is either an insn list or a PATTERN of a single
3936    instruction.
3937
3938    There are thus a few canonical ways to generate code and
3939    emit it at a specific place in the instruction stream.  For
3940    example, consider the instruction named SPOT and the fact that
3941    we would like to emit some instructions before SPOT.  We might
3942    do it like this:
3943
3944         start_sequence ();
3945         ... emit the new instructions ...
3946         insns_head = get_insns ();
3947         end_sequence ();
3948
3949         emit_insn_before (insns_head, SPOT);
3950
3951    It used to be common to generate SEQUENCE rtl instead, but that
3952    is a relic of the past which no longer occurs.  The reason is that
3953    SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
3954    generated would almost certainly die right after it was created.  */
3955
3956 /* Make X be output before the instruction BEFORE.  */
3957
3958 rtx
3959 emit_insn_before (rtx x, rtx before)
3960 {
3961   rtx last = before;
3962   rtx insn;
3963
3964 #ifdef ENABLE_RTL_CHECKING
3965   if (before == NULL_RTX)
3966     abort ();
3967 #endif
3968
3969   if (x == NULL_RTX)
3970     return last;
3971
3972   switch (GET_CODE (x))
3973     {
3974     case INSN:
3975     case JUMP_INSN:
3976     case CALL_INSN:
3977     case CODE_LABEL:
3978     case BARRIER:
3979     case NOTE:
3980       insn = x;
3981       while (insn)
3982         {
3983           rtx next = NEXT_INSN (insn);
3984           add_insn_before (insn, before);
3985           last = insn;
3986           insn = next;
3987         }
3988       break;
3989
3990 #ifdef ENABLE_RTL_CHECKING
3991     case SEQUENCE:
3992       abort ();
3993       break;
3994 #endif
3995
3996     default:
3997       last = make_insn_raw (x);
3998       add_insn_before (last, before);
3999       break;
4000     }
4001
4002   return last;
4003 }
4004
4005 /* Make an instruction with body X and code JUMP_INSN
4006    and output it before the instruction BEFORE.  */
4007
4008 rtx
4009 emit_jump_insn_before (rtx x, rtx before)
4010 {
4011   rtx insn, last = NULL_RTX;
4012
4013 #ifdef ENABLE_RTL_CHECKING
4014   if (before == NULL_RTX)
4015     abort ();
4016 #endif
4017
4018   switch (GET_CODE (x))
4019     {
4020     case INSN:
4021     case JUMP_INSN:
4022     case CALL_INSN:
4023     case CODE_LABEL:
4024     case BARRIER:
4025     case NOTE:
4026       insn = x;
4027       while (insn)
4028         {
4029           rtx next = NEXT_INSN (insn);
4030           add_insn_before (insn, before);
4031           last = insn;
4032           insn = next;
4033         }
4034       break;
4035
4036 #ifdef ENABLE_RTL_CHECKING
4037     case SEQUENCE:
4038       abort ();
4039       break;
4040 #endif
4041
4042     default:
4043       last = make_jump_insn_raw (x);
4044       add_insn_before (last, before);
4045       break;
4046     }
4047
4048   return last;
4049 }
4050
4051 /* Make an instruction with body X and code CALL_INSN
4052    and output it before the instruction BEFORE.  */
4053
4054 rtx
4055 emit_call_insn_before (rtx x, rtx before)
4056 {
4057   rtx last = NULL_RTX, insn;
4058
4059 #ifdef ENABLE_RTL_CHECKING
4060   if (before == NULL_RTX)
4061     abort ();
4062 #endif
4063
4064   switch (GET_CODE (x))
4065     {
4066     case INSN:
4067     case JUMP_INSN:
4068     case CALL_INSN:
4069     case CODE_LABEL:
4070     case BARRIER:
4071     case NOTE:
4072       insn = x;
4073       while (insn)
4074         {
4075           rtx next = NEXT_INSN (insn);
4076           add_insn_before (insn, before);
4077           last = insn;
4078           insn = next;
4079         }
4080       break;
4081
4082 #ifdef ENABLE_RTL_CHECKING
4083     case SEQUENCE:
4084       abort ();
4085       break;
4086 #endif
4087
4088     default:
4089       last = make_call_insn_raw (x);
4090       add_insn_before (last, before);
4091       break;
4092     }
4093
4094   return last;
4095 }
4096
4097 /* Make an insn of code BARRIER
4098    and output it before the insn BEFORE.  */
4099
4100 rtx
4101 emit_barrier_before (rtx before)
4102 {
4103   rtx insn = rtx_alloc (BARRIER);
4104
4105   INSN_UID (insn) = cur_insn_uid++;
4106
4107   add_insn_before (insn, before);
4108   return insn;
4109 }
4110
4111 /* Emit the label LABEL before the insn BEFORE.  */
4112
4113 rtx
4114 emit_label_before (rtx label, rtx before)
4115 {
4116   /* This can be called twice for the same label as a result of the
4117      confusion that follows a syntax error!  So make it harmless.  */
4118   if (INSN_UID (label) == 0)
4119     {
4120       INSN_UID (label) = cur_insn_uid++;
4121       add_insn_before (label, before);
4122     }
4123
4124   return label;
4125 }
4126
4127 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
4128
4129 rtx
4130 emit_note_before (int subtype, rtx before)
4131 {
4132   rtx note = rtx_alloc (NOTE);
4133   INSN_UID (note) = cur_insn_uid++;
4134 #ifndef USE_MAPPED_LOCATION
4135   NOTE_SOURCE_FILE (note) = 0;
4136 #endif
4137   NOTE_LINE_NUMBER (note) = subtype;
4138   BLOCK_FOR_INSN (note) = NULL;
4139
4140   add_insn_before (note, before);
4141   return note;
4142 }
4143 \f
4144 /* Helper for emit_insn_after, handles lists of instructions
4145    efficiently.  */
4146
4147 static rtx emit_insn_after_1 (rtx, rtx);
4148
4149 static rtx
4150 emit_insn_after_1 (rtx first, rtx after)
4151 {
4152   rtx last;
4153   rtx after_after;
4154   basic_block bb;
4155
4156   if (!BARRIER_P (after)
4157       && (bb = BLOCK_FOR_INSN (after)))
4158     {
4159       bb->flags |= BB_DIRTY;
4160       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4161         if (!BARRIER_P (last))
4162           set_block_for_insn (last, bb);
4163       if (!BARRIER_P (last))
4164         set_block_for_insn (last, bb);
4165       if (BB_END (bb) == after)
4166         BB_END (bb) = last;
4167     }
4168   else
4169     for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4170       continue;
4171
4172   after_after = NEXT_INSN (after);
4173
4174   NEXT_INSN (after) = first;
4175   PREV_INSN (first) = after;
4176   NEXT_INSN (last) = after_after;
4177   if (after_after)
4178     PREV_INSN (after_after) = last;
4179
4180   if (after == last_insn)
4181     last_insn = last;
4182   return last;
4183 }
4184
4185 /* Make X be output after the insn AFTER.  */
4186
4187 rtx
4188 emit_insn_after (rtx x, rtx after)
4189 {
4190   rtx last = after;
4191
4192 #ifdef ENABLE_RTL_CHECKING
4193   if (after == NULL_RTX)
4194     abort ();
4195 #endif
4196
4197   if (x == NULL_RTX)
4198     return last;
4199
4200   switch (GET_CODE (x))
4201     {
4202     case INSN:
4203     case JUMP_INSN:
4204     case CALL_INSN:
4205     case CODE_LABEL:
4206     case BARRIER:
4207     case NOTE:
4208       last = emit_insn_after_1 (x, after);
4209       break;
4210
4211 #ifdef ENABLE_RTL_CHECKING
4212     case SEQUENCE:
4213       abort ();
4214       break;
4215 #endif
4216
4217     default:
4218       last = make_insn_raw (x);
4219       add_insn_after (last, after);
4220       break;
4221     }
4222
4223   return last;
4224 }
4225
4226 /* Similar to emit_insn_after, except that line notes are to be inserted so
4227    as to act as if this insn were at FROM.  */
4228
4229 void
4230 emit_insn_after_with_line_notes (rtx x, rtx after, rtx from)
4231 {
4232   rtx from_line = find_line_note (from);
4233   rtx after_line = find_line_note (after);
4234   rtx insn = emit_insn_after (x, after);
4235
4236   if (from_line)
4237     emit_note_copy_after (from_line, after);
4238
4239   if (after_line)
4240     emit_note_copy_after (after_line, insn);
4241 }
4242
4243 /* Make an insn of code JUMP_INSN with body X
4244    and output it after the insn AFTER.  */
4245
4246 rtx
4247 emit_jump_insn_after (rtx x, rtx after)
4248 {
4249   rtx last;
4250
4251 #ifdef ENABLE_RTL_CHECKING
4252   if (after == NULL_RTX)
4253     abort ();
4254 #endif
4255
4256   switch (GET_CODE (x))
4257     {
4258     case INSN:
4259     case JUMP_INSN:
4260     case CALL_INSN:
4261     case CODE_LABEL:
4262     case BARRIER:
4263     case NOTE:
4264       last = emit_insn_after_1 (x, after);
4265       break;
4266
4267 #ifdef ENABLE_RTL_CHECKING
4268     case SEQUENCE:
4269       abort ();
4270       break;
4271 #endif
4272
4273     default:
4274       last = make_jump_insn_raw (x);
4275       add_insn_after (last, after);
4276       break;
4277     }
4278
4279   return last;
4280 }
4281
4282 /* Make an instruction with body X and code CALL_INSN
4283    and output it after the instruction AFTER.  */
4284
4285 rtx
4286 emit_call_insn_after (rtx x, rtx after)
4287 {
4288   rtx last;
4289
4290 #ifdef ENABLE_RTL_CHECKING
4291   if (after == NULL_RTX)
4292     abort ();
4293 #endif
4294
4295   switch (GET_CODE (x))
4296     {
4297     case INSN:
4298     case JUMP_INSN:
4299     case CALL_INSN:
4300     case CODE_LABEL:
4301     case BARRIER:
4302     case NOTE:
4303       last = emit_insn_after_1 (x, after);
4304       break;
4305
4306 #ifdef ENABLE_RTL_CHECKING
4307     case SEQUENCE:
4308       abort ();
4309       break;
4310 #endif
4311
4312     default:
4313       last = make_call_insn_raw (x);
4314       add_insn_after (last, after);
4315       break;
4316     }
4317
4318   return last;
4319 }
4320
4321 /* Make an insn of code BARRIER
4322    and output it after the insn AFTER.  */
4323
4324 rtx
4325 emit_barrier_after (rtx after)
4326 {
4327   rtx insn = rtx_alloc (BARRIER);
4328
4329   INSN_UID (insn) = cur_insn_uid++;
4330
4331   add_insn_after (insn, after);
4332   return insn;
4333 }
4334
4335 /* Emit the label LABEL after the insn AFTER.  */
4336
4337 rtx
4338 emit_label_after (rtx label, rtx after)
4339 {
4340   /* This can be called twice for the same label
4341      as a result of the confusion that follows a syntax error!
4342      So make it harmless.  */
4343   if (INSN_UID (label) == 0)
4344     {
4345       INSN_UID (label) = cur_insn_uid++;
4346       add_insn_after (label, after);
4347     }
4348
4349   return label;
4350 }
4351
4352 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
4353
4354 rtx
4355 emit_note_after (int subtype, rtx after)
4356 {
4357   rtx note = rtx_alloc (NOTE);
4358   INSN_UID (note) = cur_insn_uid++;
4359 #ifndef USE_MAPPED_LOCATION
4360   NOTE_SOURCE_FILE (note) = 0;
4361 #endif
4362   NOTE_LINE_NUMBER (note) = subtype;
4363   BLOCK_FOR_INSN (note) = NULL;
4364   add_insn_after (note, after);
4365   return note;
4366 }
4367
4368 /* Emit a copy of note ORIG after the insn AFTER.  */
4369
4370 rtx
4371 emit_note_copy_after (rtx orig, rtx after)
4372 {
4373   rtx note;
4374
4375   if (NOTE_LINE_NUMBER (orig) >= 0 && no_line_numbers)
4376     {
4377       cur_insn_uid++;
4378       return 0;
4379     }
4380
4381   note = rtx_alloc (NOTE);
4382   INSN_UID (note) = cur_insn_uid++;
4383   NOTE_LINE_NUMBER (note) = NOTE_LINE_NUMBER (orig);
4384   NOTE_DATA (note) = NOTE_DATA (orig);
4385   BLOCK_FOR_INSN (note) = NULL;
4386   add_insn_after (note, after);
4387   return note;
4388 }
4389 \f
4390 /* Like emit_insn_after, but set INSN_LOCATOR according to SCOPE.  */
4391 rtx
4392 emit_insn_after_setloc (rtx pattern, rtx after, int loc)
4393 {
4394   rtx last = emit_insn_after (pattern, after);
4395
4396   if (pattern == NULL_RTX)
4397     return last;
4398
4399   after = NEXT_INSN (after);