OSDN Git Service

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