OSDN Git Service

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