OSDN Git Service

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