OSDN Git Service

418da241b667da35b9946238247a438cddedd961
[pf3gnuchains/gcc-fork.git] / gcc / emit-rtl.c
1 /* Emit RTL for the GCC expander.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22
23 /* Middle-to-low level generation of rtx code and insns.
24
25    This file contains support functions for creating rtl expressions
26    and manipulating them in the doubly-linked chain of insns.
27
28    The patterns of the insns are created by machine-dependent
29    routines in insn-emit.c, which is generated automatically from
30    the machine description.  These routines make the individual rtx's
31    of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch],
32    which are automatically generated from rtl.def; what is machine
33    dependent is the kind of rtx's they make and what arguments they
34    use.  */
35
36 #include "config.h"
37 #include "system.h"
38 #include "coretypes.h"
39 #include "tm.h"
40 #include "toplev.h"
41 #include "rtl.h"
42 #include "tree.h"
43 #include "tm_p.h"
44 #include "flags.h"
45 #include "function.h"
46 #include "expr.h"
47 #include "regs.h"
48 #include "hard-reg-set.h"
49 #include "hashtab.h"
50 #include "insn-config.h"
51 #include "recog.h"
52 #include "real.h"
53 #include "fixed-value.h"
54 #include "bitmap.h"
55 #include "basic-block.h"
56 #include "ggc.h"
57 #include "debug.h"
58 #include "langhooks.h"
59 #include "tree-pass.h"
60 #include "df.h"
61
62 /* Commonly used modes.  */
63
64 enum machine_mode byte_mode;    /* Mode whose width is BITS_PER_UNIT.  */
65 enum machine_mode word_mode;    /* Mode whose width is BITS_PER_WORD.  */
66 enum machine_mode double_mode;  /* Mode whose width is DOUBLE_TYPE_SIZE.  */
67 enum machine_mode ptr_mode;     /* Mode whose width is POINTER_SIZE.  */
68
69 /* Datastructures maintained for currently processed function in RTL form.  */
70
71 struct rtl_data x_rtl;
72
73 /* Indexed by pseudo register number, gives the rtx for that pseudo.
74    Allocated in parallel with regno_pointer_align.  
75    FIXME: We could put it into emit_status struct, but gengtype is not able to deal
76    with length attribute nested in top level structures.  */
77
78 rtx * regno_reg_rtx;
79
80 /* This is *not* reset after each function.  It gives each CODE_LABEL
81    in the entire compilation a unique label number.  */
82
83 static GTY(()) int label_num = 1;
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 dconsthalf;
115
116 /* Record fixed-point constant 0 and 1.  */
117 FIXED_VALUE_TYPE fconst0[MAX_FCONST0];
118 FIXED_VALUE_TYPE fconst1[MAX_FCONST1];
119
120 /* All references to the following fixed hard registers go through
121    these unique rtl objects.  On machines where the frame-pointer and
122    arg-pointer are the same register, they use the same unique object.
123
124    After register allocation, other rtl objects which used to be pseudo-regs
125    may be clobbered to refer to the frame-pointer register.
126    But references that were originally to the frame-pointer can be
127    distinguished from the others because they contain frame_pointer_rtx.
128
129    When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
130    tricky: until register elimination has taken place hard_frame_pointer_rtx
131    should be used if it is being set, and frame_pointer_rtx otherwise.  After
132    register elimination hard_frame_pointer_rtx should always be used.
133    On machines where the two registers are same (most) then these are the
134    same.
135
136    In an inline procedure, the stack and frame pointer rtxs may not be
137    used for anything else.  */
138 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
139 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
140 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
141
142 /* This is used to implement __builtin_return_address for some machines.
143    See for instance the MIPS port.  */
144 rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
145
146 /* We make one copy of (const_int C) where C is in
147    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
148    to save space during the compilation and simplify comparisons of
149    integers.  */
150
151 rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
152
153 /* A hash table storing CONST_INTs whose absolute value is greater
154    than MAX_SAVED_CONST_INT.  */
155
156 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
157      htab_t const_int_htab;
158
159 /* A hash table storing memory attribute structures.  */
160 static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
161      htab_t mem_attrs_htab;
162
163 /* A hash table storing register attribute structures.  */
164 static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
165      htab_t reg_attrs_htab;
166
167 /* A hash table storing all CONST_DOUBLEs.  */
168 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
169      htab_t const_double_htab;
170
171 /* A hash table storing all CONST_FIXEDs.  */
172 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
173      htab_t const_fixed_htab;
174
175 #define first_insn (crtl->emit.x_first_insn)
176 #define last_insn (crtl->emit.x_last_insn)
177 #define cur_insn_uid (crtl->emit.x_cur_insn_uid)
178 #define last_location (crtl->emit.x_last_location)
179 #define first_label_num (crtl->emit.x_first_label_num)
180
181 static rtx make_call_insn_raw (rtx);
182 static rtx change_address_1 (rtx, enum machine_mode, rtx, int);
183 static void set_used_decls (tree);
184 static void mark_label_nuses (rtx);
185 static hashval_t const_int_htab_hash (const void *);
186 static int const_int_htab_eq (const void *, const void *);
187 static hashval_t const_double_htab_hash (const void *);
188 static int const_double_htab_eq (const void *, const void *);
189 static rtx lookup_const_double (rtx);
190 static hashval_t const_fixed_htab_hash (const void *);
191 static int const_fixed_htab_eq (const void *, const void *);
192 static rtx lookup_const_fixed (rtx);
193 static hashval_t mem_attrs_htab_hash (const void *);
194 static int mem_attrs_htab_eq (const void *, const void *);
195 static mem_attrs *get_mem_attrs (alias_set_type, tree, rtx, rtx, unsigned int,
196                                  enum machine_mode);
197 static hashval_t reg_attrs_htab_hash (const void *);
198 static int reg_attrs_htab_eq (const void *, const void *);
199 static reg_attrs *get_reg_attrs (tree, int);
200 static tree component_ref_for_mem_expr (tree);
201 static rtx gen_const_vector (enum machine_mode, int);
202 static void copy_rtx_if_shared_1 (rtx *orig);
203
204 /* Probability of the conditional branch currently proceeded by try_split.
205    Set to -1 otherwise.  */
206 int split_branch_probability = -1;
207 \f
208 /* Returns a hash code for X (which is a really a CONST_INT).  */
209
210 static hashval_t
211 const_int_htab_hash (const void *x)
212 {
213   return (hashval_t) INTVAL ((const_rtx) x);
214 }
215
216 /* Returns nonzero if the value represented by X (which is really a
217    CONST_INT) is the same as that given by Y (which is really a
218    HOST_WIDE_INT *).  */
219
220 static int
221 const_int_htab_eq (const void *x, const void *y)
222 {
223   return (INTVAL ((const_rtx) x) == *((const HOST_WIDE_INT *) y));
224 }
225
226 /* Returns a hash code for X (which is really a CONST_DOUBLE).  */
227 static hashval_t
228 const_double_htab_hash (const void *x)
229 {
230   const_rtx const value = (const_rtx) x;
231   hashval_t h;
232
233   if (GET_MODE (value) == VOIDmode)
234     h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
235   else
236     {
237       h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
238       /* MODE is used in the comparison, so it should be in the hash.  */
239       h ^= GET_MODE (value);
240     }
241   return h;
242 }
243
244 /* Returns nonzero if the value represented by X (really a ...)
245    is the same as that represented by Y (really a ...) */
246 static int
247 const_double_htab_eq (const void *x, const void *y)
248 {
249   const_rtx const a = (const_rtx)x, b = (const_rtx)y;
250
251   if (GET_MODE (a) != GET_MODE (b))
252     return 0;
253   if (GET_MODE (a) == VOIDmode)
254     return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
255             && CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
256   else
257     return real_identical (CONST_DOUBLE_REAL_VALUE (a),
258                            CONST_DOUBLE_REAL_VALUE (b));
259 }
260
261 /* Returns a hash code for X (which is really a CONST_FIXED).  */
262
263 static hashval_t
264 const_fixed_htab_hash (const void *x)
265 {
266   const_rtx const value = (const_rtx) x;
267   hashval_t h;
268
269   h = fixed_hash (CONST_FIXED_VALUE (value));
270   /* MODE is used in the comparison, so it should be in the hash.  */
271   h ^= GET_MODE (value);
272   return h;
273 }
274
275 /* Returns nonzero if the value represented by X (really a ...)
276    is the same as that represented by Y (really a ...).  */
277
278 static int
279 const_fixed_htab_eq (const void *x, const void *y)
280 {
281   const_rtx const a = (const_rtx) x, b = (const_rtx) y;
282
283   if (GET_MODE (a) != GET_MODE (b))
284     return 0;
285   return fixed_identical (CONST_FIXED_VALUE (a), CONST_FIXED_VALUE (b));
286 }
287
288 /* Returns a hash code for X (which is a really a mem_attrs *).  */
289
290 static hashval_t
291 mem_attrs_htab_hash (const void *x)
292 {
293   const mem_attrs *const p = (const mem_attrs *) x;
294
295   return (p->alias ^ (p->align * 1000)
296           ^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
297           ^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
298           ^ (size_t) iterative_hash_expr (p->expr, 0));
299 }
300
301 /* Returns nonzero if the value represented by X (which is really a
302    mem_attrs *) is the same as that given by Y (which is also really a
303    mem_attrs *).  */
304
305 static int
306 mem_attrs_htab_eq (const void *x, const void *y)
307 {
308   const mem_attrs *const p = (const mem_attrs *) x;
309   const mem_attrs *const q = (const mem_attrs *) y;
310
311   return (p->alias == q->alias && p->offset == q->offset
312           && p->size == q->size && p->align == q->align
313           && (p->expr == q->expr
314               || (p->expr != NULL_TREE && q->expr != NULL_TREE
315                   && operand_equal_p (p->expr, q->expr, 0))));
316 }
317
318 /* Allocate a new mem_attrs structure and insert it into the hash table if
319    one identical to it is not already in the table.  We are doing this for
320    MEM of mode MODE.  */
321
322 static mem_attrs *
323 get_mem_attrs (alias_set_type alias, tree expr, rtx offset, rtx size,
324                unsigned int align, enum machine_mode mode)
325 {
326   mem_attrs attrs;
327   void **slot;
328
329   /* If everything is the default, we can just return zero.
330      This must match what the corresponding MEM_* macros return when the
331      field is not present.  */
332   if (alias == 0 && expr == 0 && offset == 0
333       && (size == 0
334           || (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
335       && (STRICT_ALIGNMENT && mode != BLKmode
336           ? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
337     return 0;
338
339   attrs.alias = alias;
340   attrs.expr = expr;
341   attrs.offset = offset;
342   attrs.size = size;
343   attrs.align = align;
344
345   slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
346   if (*slot == 0)
347     {
348       *slot = ggc_alloc (sizeof (mem_attrs));
349       memcpy (*slot, &attrs, sizeof (mem_attrs));
350     }
351
352   return (mem_attrs *) *slot;
353 }
354
355 /* Returns a hash code for X (which is a really a reg_attrs *).  */
356
357 static hashval_t
358 reg_attrs_htab_hash (const void *x)
359 {
360   const reg_attrs *const p = (const reg_attrs *) x;
361
362   return ((p->offset * 1000) ^ (long) p->decl);
363 }
364
365 /* Returns nonzero if the value represented by X (which is really a
366    reg_attrs *) is the same as that given by Y (which is also really a
367    reg_attrs *).  */
368
369 static int
370 reg_attrs_htab_eq (const void *x, const void *y)
371 {
372   const reg_attrs *const p = (const reg_attrs *) x;
373   const reg_attrs *const q = (const reg_attrs *) y;
374
375   return (p->decl == q->decl && p->offset == q->offset);
376 }
377 /* Allocate a new reg_attrs structure and insert it into the hash table if
378    one identical to it is not already in the table.  We are doing this for
379    MEM of mode MODE.  */
380
381 static reg_attrs *
382 get_reg_attrs (tree decl, int offset)
383 {
384   reg_attrs attrs;
385   void **slot;
386
387   /* If everything is the default, we can just return zero.  */
388   if (decl == 0 && offset == 0)
389     return 0;
390
391   attrs.decl = decl;
392   attrs.offset = offset;
393
394   slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
395   if (*slot == 0)
396     {
397       *slot = ggc_alloc (sizeof (reg_attrs));
398       memcpy (*slot, &attrs, sizeof (reg_attrs));
399     }
400
401   return (reg_attrs *) *slot;
402 }
403
404
405 #if !HAVE_blockage
406 /* Generate an empty ASM_INPUT, which is used to block attempts to schedule
407    across this insn. */
408
409 rtx
410 gen_blockage (void)
411 {
412   rtx x = gen_rtx_ASM_INPUT (VOIDmode, "");
413   MEM_VOLATILE_P (x) = true;
414   return x;
415 }
416 #endif
417
418
419 /* Generate a new REG rtx.  Make sure ORIGINAL_REGNO is set properly, and
420    don't attempt to share with the various global pieces of rtl (such as
421    frame_pointer_rtx).  */
422
423 rtx
424 gen_raw_REG (enum machine_mode mode, int regno)
425 {
426   rtx x = gen_rtx_raw_REG (mode, regno);
427   ORIGINAL_REGNO (x) = regno;
428   return x;
429 }
430
431 /* There are some RTL codes that require special attention; the generation
432    functions do the raw handling.  If you add to this list, modify
433    special_rtx in gengenrtl.c as well.  */
434
435 rtx
436 gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
437 {
438   void **slot;
439
440   if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
441     return const_int_rtx[arg + MAX_SAVED_CONST_INT];
442
443 #if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
444   if (const_true_rtx && arg == STORE_FLAG_VALUE)
445     return const_true_rtx;
446 #endif
447
448   /* Look up the CONST_INT in the hash table.  */
449   slot = htab_find_slot_with_hash (const_int_htab, &arg,
450                                    (hashval_t) arg, INSERT);
451   if (*slot == 0)
452     *slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
453
454   return (rtx) *slot;
455 }
456
457 rtx
458 gen_int_mode (HOST_WIDE_INT c, enum machine_mode mode)
459 {
460   return GEN_INT (trunc_int_for_mode (c, mode));
461 }
462
463 /* CONST_DOUBLEs might be created from pairs of integers, or from
464    REAL_VALUE_TYPEs.  Also, their length is known only at run time,
465    so we cannot use gen_rtx_raw_CONST_DOUBLE.  */
466
467 /* Determine whether REAL, a CONST_DOUBLE, already exists in the
468    hash table.  If so, return its counterpart; otherwise add it
469    to the hash table and return it.  */
470 static rtx
471 lookup_const_double (rtx real)
472 {
473   void **slot = htab_find_slot (const_double_htab, real, INSERT);
474   if (*slot == 0)
475     *slot = real;
476
477   return (rtx) *slot;
478 }
479
480 /* Return a CONST_DOUBLE rtx for a floating-point value specified by
481    VALUE in mode MODE.  */
482 rtx
483 const_double_from_real_value (REAL_VALUE_TYPE value, enum machine_mode mode)
484 {
485   rtx real = rtx_alloc (CONST_DOUBLE);
486   PUT_MODE (real, mode);
487
488   real->u.rv = value;
489
490   return lookup_const_double (real);
491 }
492
493 /* Determine whether FIXED, a CONST_FIXED, already exists in the
494    hash table.  If so, return its counterpart; otherwise add it
495    to the hash table and return it.  */
496
497 static rtx
498 lookup_const_fixed (rtx fixed)
499 {
500   void **slot = htab_find_slot (const_fixed_htab, fixed, INSERT);
501   if (*slot == 0)
502     *slot = fixed;
503
504   return (rtx) *slot;
505 }
506
507 /* Return a CONST_FIXED rtx for a fixed-point value specified by
508    VALUE in mode MODE.  */
509
510 rtx
511 const_fixed_from_fixed_value (FIXED_VALUE_TYPE value, enum machine_mode mode)
512 {
513   rtx fixed = rtx_alloc (CONST_FIXED);
514   PUT_MODE (fixed, mode);
515
516   fixed->u.fv = value;
517
518   return lookup_const_fixed (fixed);
519 }
520
521 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
522    of ints: I0 is the low-order word and I1 is the high-order word.
523    Do not use this routine for non-integer modes; convert to
524    REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE.  */
525
526 rtx
527 immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
528 {
529   rtx value;
530   unsigned int i;
531
532   /* There are the following cases (note that there are no modes with
533      HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < 2 * HOST_BITS_PER_WIDE_INT):
534
535      1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use
536         gen_int_mode.
537      2) GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT, but the value of
538         the integer fits into HOST_WIDE_INT anyway (i.e., i1 consists only
539         from copies of the sign bit, and sign of i0 and i1 are the same),  then 
540         we return a CONST_INT for i0.
541      3) Otherwise, we create a CONST_DOUBLE for i0 and i1.  */
542   if (mode != VOIDmode)
543     {
544       gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
545                   || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT
546                   /* We can get a 0 for an error mark.  */
547                   || GET_MODE_CLASS (mode) == MODE_VECTOR_INT
548                   || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);
549
550       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
551         return gen_int_mode (i0, mode);
552
553       gcc_assert (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT);
554     }
555
556   /* If this integer fits in one word, return a CONST_INT.  */
557   if ((i1 == 0 && i0 >= 0) || (i1 == ~0 && i0 < 0))
558     return GEN_INT (i0);
559
560   /* We use VOIDmode for integers.  */
561   value = rtx_alloc (CONST_DOUBLE);
562   PUT_MODE (value, VOIDmode);
563
564   CONST_DOUBLE_LOW (value) = i0;
565   CONST_DOUBLE_HIGH (value) = i1;
566
567   for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
568     XWINT (value, i) = 0;
569
570   return lookup_const_double (value);
571 }
572
573 rtx
574 gen_rtx_REG (enum machine_mode mode, unsigned int regno)
575 {
576   /* In case the MD file explicitly references the frame pointer, have
577      all such references point to the same frame pointer.  This is
578      used during frame pointer elimination to distinguish the explicit
579      references to these registers from pseudos that happened to be
580      assigned to them.
581
582      If we have eliminated the frame pointer or arg pointer, we will
583      be using it as a normal register, for example as a spill
584      register.  In such cases, we might be accessing it in a mode that
585      is not Pmode and therefore cannot use the pre-allocated rtx.
586
587      Also don't do this when we are making new REGs in reload, since
588      we don't want to get confused with the real pointers.  */
589
590   if (mode == Pmode && !reload_in_progress)
591     {
592       if (regno == FRAME_POINTER_REGNUM
593           && (!reload_completed || frame_pointer_needed))
594         return frame_pointer_rtx;
595 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
596       if (regno == HARD_FRAME_POINTER_REGNUM
597           && (!reload_completed || frame_pointer_needed))
598         return hard_frame_pointer_rtx;
599 #endif
600 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
601       if (regno == ARG_POINTER_REGNUM)
602         return arg_pointer_rtx;
603 #endif
604 #ifdef RETURN_ADDRESS_POINTER_REGNUM
605       if (regno == RETURN_ADDRESS_POINTER_REGNUM)
606         return return_address_pointer_rtx;
607 #endif
608       if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
609           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
610         return pic_offset_table_rtx;
611       if (regno == STACK_POINTER_REGNUM)
612         return stack_pointer_rtx;
613     }
614
615 #if 0
616   /* If the per-function register table has been set up, try to re-use
617      an existing entry in that table to avoid useless generation of RTL.
618
619      This code is disabled for now until we can fix the various backends
620      which depend on having non-shared hard registers in some cases.   Long
621      term we want to re-enable this code as it can significantly cut down
622      on the amount of useless RTL that gets generated.
623
624      We'll also need to fix some code that runs after reload that wants to
625      set ORIGINAL_REGNO.  */
626
627   if (cfun
628       && cfun->emit
629       && regno_reg_rtx
630       && regno < FIRST_PSEUDO_REGISTER
631       && reg_raw_mode[regno] == mode)
632     return regno_reg_rtx[regno];
633 #endif
634
635   return gen_raw_REG (mode, regno);
636 }
637
638 rtx
639 gen_rtx_MEM (enum machine_mode mode, rtx addr)
640 {
641   rtx rt = gen_rtx_raw_MEM (mode, addr);
642
643   /* This field is not cleared by the mere allocation of the rtx, so
644      we clear it here.  */
645   MEM_ATTRS (rt) = 0;
646
647   return rt;
648 }
649
650 /* Generate a memory referring to non-trapping constant memory.  */
651
652 rtx
653 gen_const_mem (enum machine_mode mode, rtx addr)
654 {
655   rtx mem = gen_rtx_MEM (mode, addr);
656   MEM_READONLY_P (mem) = 1;
657   MEM_NOTRAP_P (mem) = 1;
658   return mem;
659 }
660
661 /* Generate a MEM referring to fixed portions of the frame, e.g., register
662    save areas.  */
663
664 rtx
665 gen_frame_mem (enum machine_mode mode, rtx addr)
666 {
667   rtx mem = gen_rtx_MEM (mode, addr);
668   MEM_NOTRAP_P (mem) = 1;
669   set_mem_alias_set (mem, get_frame_alias_set ());
670   return mem;
671 }
672
673 /* Generate a MEM referring to a temporary use of the stack, not part
674     of the fixed stack frame.  For example, something which is pushed
675     by a target splitter.  */
676 rtx
677 gen_tmp_stack_mem (enum machine_mode mode, rtx addr)
678 {
679   rtx mem = gen_rtx_MEM (mode, addr);
680   MEM_NOTRAP_P (mem) = 1;
681   if (!cfun->calls_alloca)
682     set_mem_alias_set (mem, get_frame_alias_set ());
683   return mem;
684 }
685
686 /* We want to create (subreg:OMODE (obj:IMODE) OFFSET).  Return true if
687    this construct would be valid, and false otherwise.  */
688
689 bool
690 validate_subreg (enum machine_mode omode, enum machine_mode imode,
691                  const_rtx reg, unsigned int offset)
692 {
693   unsigned int isize = GET_MODE_SIZE (imode);
694   unsigned int osize = GET_MODE_SIZE (omode);
695
696   /* All subregs must be aligned.  */
697   if (offset % osize != 0)
698     return false;
699
700   /* The subreg offset cannot be outside the inner object.  */
701   if (offset >= isize)
702     return false;
703
704   /* ??? This should not be here.  Temporarily continue to allow word_mode
705      subregs of anything.  The most common offender is (subreg:SI (reg:DF)).
706      Generally, backends are doing something sketchy but it'll take time to
707      fix them all.  */
708   if (omode == word_mode)
709     ;
710   /* ??? Similarly, e.g. with (subreg:DF (reg:TI)).  Though store_bit_field
711      is the culprit here, and not the backends.  */
712   else if (osize >= UNITS_PER_WORD && isize >= osize)
713     ;
714   /* Allow component subregs of complex and vector.  Though given the below
715      extraction rules, it's not always clear what that means.  */
716   else if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
717            && GET_MODE_INNER (imode) == omode)
718     ;
719   /* ??? x86 sse code makes heavy use of *paradoxical* vector subregs,
720      i.e. (subreg:V4SF (reg:SF) 0).  This surely isn't the cleanest way to
721      represent this.  It's questionable if this ought to be represented at
722      all -- why can't this all be hidden in post-reload splitters that make
723      arbitrarily mode changes to the registers themselves.  */
724   else if (VECTOR_MODE_P (omode) && GET_MODE_INNER (omode) == imode)
725     ;
726   /* Subregs involving floating point modes are not allowed to
727      change size.  Therefore (subreg:DI (reg:DF) 0) is fine, but
728      (subreg:SI (reg:DF) 0) isn't.  */
729   else if (FLOAT_MODE_P (imode) || FLOAT_MODE_P (omode))
730     {
731       if (isize != osize)
732         return false;
733     }
734
735   /* Paradoxical subregs must have offset zero.  */
736   if (osize > isize)
737     return offset == 0;
738
739   /* This is a normal subreg.  Verify that the offset is representable.  */
740
741   /* For hard registers, we already have most of these rules collected in
742      subreg_offset_representable_p.  */
743   if (reg && REG_P (reg) && HARD_REGISTER_P (reg))
744     {
745       unsigned int regno = REGNO (reg);
746
747 #ifdef CANNOT_CHANGE_MODE_CLASS
748       if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
749           && GET_MODE_INNER (imode) == omode)
750         ;
751       else if (REG_CANNOT_CHANGE_MODE_P (regno, imode, omode))
752         return false;
753 #endif
754
755       return subreg_offset_representable_p (regno, imode, offset, omode);
756     }
757
758   /* For pseudo registers, we want most of the same checks.  Namely:
759      If the register no larger than a word, the subreg must be lowpart.
760      If the register is larger than a word, the subreg must be the lowpart
761      of a subword.  A subreg does *not* perform arbitrary bit extraction.
762      Given that we've already checked mode/offset alignment, we only have
763      to check subword subregs here.  */
764   if (osize < UNITS_PER_WORD)
765     {
766       enum machine_mode wmode = isize > UNITS_PER_WORD ? word_mode : imode;
767       unsigned int low_off = subreg_lowpart_offset (omode, wmode);
768       if (offset % UNITS_PER_WORD != low_off)
769         return false;
770     }
771   return true;
772 }
773
774 rtx
775 gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
776 {
777   gcc_assert (validate_subreg (mode, GET_MODE (reg), reg, offset));
778   return gen_rtx_raw_SUBREG (mode, reg, offset);
779 }
780
781 /* Generate a SUBREG representing the least-significant part of REG if MODE
782    is smaller than mode of REG, otherwise paradoxical SUBREG.  */
783
784 rtx
785 gen_lowpart_SUBREG (enum machine_mode mode, rtx reg)
786 {
787   enum machine_mode inmode;
788
789   inmode = GET_MODE (reg);
790   if (inmode == VOIDmode)
791     inmode = mode;
792   return gen_rtx_SUBREG (mode, reg,
793                          subreg_lowpart_offset (mode, inmode));
794 }
795 \f
796 /* gen_rtvec (n, [rt1, ..., rtn])
797 **
798 **          This routine creates an rtvec and stores within it the
799 **      pointers to rtx's which are its arguments.
800 */
801
802 /*VARARGS1*/
803 rtvec
804 gen_rtvec (int n, ...)
805 {
806   int i, save_n;
807   rtx *vector;
808   va_list p;
809
810   va_start (p, n);
811
812   if (n == 0)
813     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
814
815   vector = XALLOCAVEC (rtx, n);
816
817   for (i = 0; i < n; i++)
818     vector[i] = va_arg (p, rtx);
819
820   /* The definition of VA_* in K&R C causes `n' to go out of scope.  */
821   save_n = n;
822   va_end (p);
823
824   return gen_rtvec_v (save_n, vector);
825 }
826
827 rtvec
828 gen_rtvec_v (int n, rtx *argp)
829 {
830   int i;
831   rtvec rt_val;
832
833   if (n == 0)
834     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
835
836   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
837
838   for (i = 0; i < n; i++)
839     rt_val->elem[i] = *argp++;
840
841   return rt_val;
842 }
843 \f
844 /* Return the number of bytes between the start of an OUTER_MODE
845    in-memory value and the start of an INNER_MODE in-memory value,
846    given that the former is a lowpart of the latter.  It may be a
847    paradoxical lowpart, in which case the offset will be negative
848    on big-endian targets.  */
849
850 int
851 byte_lowpart_offset (enum machine_mode outer_mode,
852                      enum machine_mode inner_mode)
853 {
854   if (GET_MODE_SIZE (outer_mode) < GET_MODE_SIZE (inner_mode))
855     return subreg_lowpart_offset (outer_mode, inner_mode);
856   else
857     return -subreg_lowpart_offset (inner_mode, outer_mode);
858 }
859 \f
860 /* Generate a REG rtx for a new pseudo register of mode MODE.
861    This pseudo is assigned the next sequential register number.  */
862
863 rtx
864 gen_reg_rtx (enum machine_mode mode)
865 {
866   rtx val;
867
868   gcc_assert (can_create_pseudo_p ());
869
870   if (generating_concat_p
871       && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
872           || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
873     {
874       /* For complex modes, don't make a single pseudo.
875          Instead, make a CONCAT of two pseudos.
876          This allows noncontiguous allocation of the real and imaginary parts,
877          which makes much better code.  Besides, allocating DCmode
878          pseudos overstrains reload on some machines like the 386.  */
879       rtx realpart, imagpart;
880       enum machine_mode partmode = GET_MODE_INNER (mode);
881
882       realpart = gen_reg_rtx (partmode);
883       imagpart = gen_reg_rtx (partmode);
884       return gen_rtx_CONCAT (mode, realpart, imagpart);
885     }
886
887   /* Make sure regno_pointer_align, and regno_reg_rtx are large
888      enough to have an element for this pseudo reg number.  */
889
890   if (reg_rtx_no == crtl->emit.regno_pointer_align_length)
891     {
892       int old_size = crtl->emit.regno_pointer_align_length;
893       char *new;
894       rtx *new1;
895
896       new = XRESIZEVEC (char, crtl->emit.regno_pointer_align, old_size * 2);
897       memset (new + old_size, 0, old_size);
898       crtl->emit.regno_pointer_align = (unsigned char *) new;
899
900       new1 = GGC_RESIZEVEC (rtx, regno_reg_rtx, old_size * 2);
901       memset (new1 + old_size, 0, old_size * sizeof (rtx));
902       regno_reg_rtx = new1;
903
904       crtl->emit.regno_pointer_align_length = old_size * 2;
905     }
906
907   val = gen_raw_REG (mode, reg_rtx_no);
908   regno_reg_rtx[reg_rtx_no++] = val;
909   return val;
910 }
911
912 /* Update NEW with the same attributes as REG, but with OFFSET added
913    to the REG_OFFSET.  */
914
915 static void
916 update_reg_offset (rtx new, rtx reg, int offset)
917 {
918   REG_ATTRS (new) = get_reg_attrs (REG_EXPR (reg),
919                                    REG_OFFSET (reg) + offset);
920 }
921
922 /* Generate a register with same attributes as REG, but with OFFSET
923    added to the REG_OFFSET.  */
924
925 rtx
926 gen_rtx_REG_offset (rtx reg, enum machine_mode mode, unsigned int regno,
927                     int offset)
928 {
929   rtx new = gen_rtx_REG (mode, regno);
930
931   update_reg_offset (new, reg, offset);
932   return new;
933 }
934
935 /* Generate a new pseudo-register with the same attributes as REG, but
936    with OFFSET added to the REG_OFFSET.  */
937
938 rtx
939 gen_reg_rtx_offset (rtx reg, enum machine_mode mode, int offset)
940 {
941   rtx new = gen_reg_rtx (mode);
942
943   update_reg_offset (new, reg, offset);
944   return new;
945 }
946
947 /* Adjust REG in-place so that it has mode MODE.  It is assumed that the
948    new register is a (possibly paradoxical) lowpart of the old one.  */
949
950 void
951 adjust_reg_mode (rtx reg, enum machine_mode mode)
952 {
953   update_reg_offset (reg, reg, byte_lowpart_offset (mode, GET_MODE (reg)));
954   PUT_MODE (reg, mode);
955 }
956
957 /* Copy REG's attributes from X, if X has any attributes.  If REG and X
958    have different modes, REG is a (possibly paradoxical) lowpart of X.  */
959
960 void
961 set_reg_attrs_from_value (rtx reg, rtx x)
962 {
963   int offset;
964
965   /* Hard registers can be reused for multiple purposes within the same
966      function, so setting REG_ATTRS, REG_POINTER and REG_POINTER_ALIGN
967      on them is wrong.  */
968   if (HARD_REGISTER_P (reg))
969     return;
970
971   offset = byte_lowpart_offset (GET_MODE (reg), GET_MODE (x));
972   if (MEM_P (x))
973     {
974       if (MEM_OFFSET (x) && GET_CODE (MEM_OFFSET (x)) == CONST_INT)
975         REG_ATTRS (reg)
976           = get_reg_attrs (MEM_EXPR (x), INTVAL (MEM_OFFSET (x)) + offset);
977       if (MEM_POINTER (x))
978         mark_reg_pointer (reg, MEM_ALIGN (x));
979     }
980   else if (REG_P (x))
981     {
982       if (REG_ATTRS (x))
983         update_reg_offset (reg, x, offset);
984       if (REG_POINTER (x))
985         mark_reg_pointer (reg, REGNO_POINTER_ALIGN (REGNO (x)));
986     }
987 }
988
989 /* Generate a REG rtx for a new pseudo register, copying the mode
990    and attributes from X.  */
991
992 rtx
993 gen_reg_rtx_and_attrs (rtx x)
994 {
995   rtx reg = gen_reg_rtx (GET_MODE (x));
996   set_reg_attrs_from_value (reg, x);
997   return reg;
998 }
999
1000 /* Set the register attributes for registers contained in PARM_RTX.
1001    Use needed values from memory attributes of MEM.  */
1002
1003 void
1004 set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
1005 {
1006   if (REG_P (parm_rtx))
1007     set_reg_attrs_from_value (parm_rtx, mem);
1008   else if (GET_CODE (parm_rtx) == PARALLEL)
1009     {
1010       /* Check for a NULL entry in the first slot, used to indicate that the
1011          parameter goes both on the stack and in registers.  */
1012       int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
1013       for (; i < XVECLEN (parm_rtx, 0); i++)
1014         {
1015           rtx x = XVECEXP (parm_rtx, 0, i);
1016           if (REG_P (XEXP (x, 0)))
1017             REG_ATTRS (XEXP (x, 0))
1018               = get_reg_attrs (MEM_EXPR (mem),
1019                                INTVAL (XEXP (x, 1)));
1020         }
1021     }
1022 }
1023
1024 /* Set the REG_ATTRS for registers in value X, given that X represents
1025    decl T.  */
1026
1027 static void
1028 set_reg_attrs_for_decl_rtl (tree t, rtx x)
1029 {
1030   if (GET_CODE (x) == SUBREG)
1031     {
1032       gcc_assert (subreg_lowpart_p (x));
1033       x = SUBREG_REG (x);
1034     }
1035   if (REG_P (x))
1036     REG_ATTRS (x)
1037       = get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
1038                                                DECL_MODE (t)));
1039   if (GET_CODE (x) == CONCAT)
1040     {
1041       if (REG_P (XEXP (x, 0)))
1042         REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
1043       if (REG_P (XEXP (x, 1)))
1044         REG_ATTRS (XEXP (x, 1))
1045           = get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
1046     }
1047   if (GET_CODE (x) == PARALLEL)
1048     {
1049       int i, start;
1050
1051       /* Check for a NULL entry, used to indicate that the parameter goes
1052          both on the stack and in registers.  */
1053       if (XEXP (XVECEXP (x, 0, 0), 0))
1054         start = 0;
1055       else
1056         start = 1;
1057
1058       for (i = start; i < XVECLEN (x, 0); i++)
1059         {
1060           rtx y = XVECEXP (x, 0, i);
1061           if (REG_P (XEXP (y, 0)))
1062             REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
1063         }
1064     }
1065 }
1066
1067 /* Assign the RTX X to declaration T.  */
1068
1069 void
1070 set_decl_rtl (tree t, rtx x)
1071 {
1072   DECL_WRTL_CHECK (t)->decl_with_rtl.rtl = x;
1073   if (x)
1074     set_reg_attrs_for_decl_rtl (t, x);
1075 }
1076
1077 /* Assign the RTX X to parameter declaration T.  BY_REFERENCE_P is true
1078    if the ABI requires the parameter to be passed by reference.  */
1079
1080 void
1081 set_decl_incoming_rtl (tree t, rtx x, bool by_reference_p)
1082 {
1083   DECL_INCOMING_RTL (t) = x;
1084   if (x && !by_reference_p)
1085     set_reg_attrs_for_decl_rtl (t, x);
1086 }
1087
1088 /* Identify REG (which may be a CONCAT) as a user register.  */
1089
1090 void
1091 mark_user_reg (rtx reg)
1092 {
1093   if (GET_CODE (reg) == CONCAT)
1094     {
1095       REG_USERVAR_P (XEXP (reg, 0)) = 1;
1096       REG_USERVAR_P (XEXP (reg, 1)) = 1;
1097     }
1098   else
1099     {
1100       gcc_assert (REG_P (reg));
1101       REG_USERVAR_P (reg) = 1;
1102     }
1103 }
1104
1105 /* Identify REG as a probable pointer register and show its alignment
1106    as ALIGN, if nonzero.  */
1107
1108 void
1109 mark_reg_pointer (rtx reg, int align)
1110 {
1111   if (! REG_POINTER (reg))
1112     {
1113       REG_POINTER (reg) = 1;
1114
1115       if (align)
1116         REGNO_POINTER_ALIGN (REGNO (reg)) = align;
1117     }
1118   else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
1119     /* We can no-longer be sure just how aligned this pointer is.  */
1120     REGNO_POINTER_ALIGN (REGNO (reg)) = align;
1121 }
1122
1123 /* Return 1 plus largest pseudo reg number used in the current function.  */
1124
1125 int
1126 max_reg_num (void)
1127 {
1128   return reg_rtx_no;
1129 }
1130
1131 /* Return 1 + the largest label number used so far in the current function.  */
1132
1133 int
1134 max_label_num (void)
1135 {
1136   return label_num;
1137 }
1138
1139 /* Return first label number used in this function (if any were used).  */
1140
1141 int
1142 get_first_label_num (void)
1143 {
1144   return first_label_num;
1145 }
1146
1147 /* If the rtx for label was created during the expansion of a nested
1148    function, then first_label_num won't include this label number.
1149    Fix this now so that array indices work later.  */
1150
1151 void
1152 maybe_set_first_label_num (rtx x)
1153 {
1154   if (CODE_LABEL_NUMBER (x) < first_label_num)
1155     first_label_num = CODE_LABEL_NUMBER (x);
1156 }
1157 \f
1158 /* Return a value representing some low-order bits of X, where the number
1159    of low-order bits is given by MODE.  Note that no conversion is done
1160    between floating-point and fixed-point values, rather, the bit
1161    representation is returned.
1162
1163    This function handles the cases in common between gen_lowpart, below,
1164    and two variants in cse.c and combine.c.  These are the cases that can
1165    be safely handled at all points in the compilation.
1166
1167    If this is not a case we can handle, return 0.  */
1168
1169 rtx
1170 gen_lowpart_common (enum machine_mode mode, rtx x)
1171 {
1172   int msize = GET_MODE_SIZE (mode);
1173   int xsize;
1174   int offset = 0;
1175   enum machine_mode innermode;
1176
1177   /* Unfortunately, this routine doesn't take a parameter for the mode of X,
1178      so we have to make one up.  Yuk.  */
1179   innermode = GET_MODE (x);
1180   if (GET_CODE (x) == CONST_INT
1181       && msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT)
1182     innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
1183   else if (innermode == VOIDmode)
1184     innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0);
1185   
1186   xsize = GET_MODE_SIZE (innermode);
1187
1188   gcc_assert (innermode != VOIDmode && innermode != BLKmode);
1189
1190   if (innermode == mode)
1191     return x;
1192
1193   /* MODE must occupy no more words than the mode of X.  */
1194   if ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
1195       > ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
1196     return 0;
1197
1198   /* Don't allow generating paradoxical FLOAT_MODE subregs.  */
1199   if (SCALAR_FLOAT_MODE_P (mode) && msize > xsize)
1200     return 0;
1201
1202   offset = subreg_lowpart_offset (mode, innermode);
1203
1204   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
1205       && (GET_MODE_CLASS (mode) == MODE_INT
1206           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
1207     {
1208       /* If we are getting the low-order part of something that has been
1209          sign- or zero-extended, we can either just use the object being
1210          extended or make a narrower extension.  If we want an even smaller
1211          piece than the size of the object being extended, call ourselves
1212          recursively.
1213
1214          This case is used mostly by combine and cse.  */
1215
1216       if (GET_MODE (XEXP (x, 0)) == mode)
1217         return XEXP (x, 0);
1218       else if (msize < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
1219         return gen_lowpart_common (mode, XEXP (x, 0));
1220       else if (msize < xsize)
1221         return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
1222     }
1223   else if (GET_CODE (x) == SUBREG || REG_P (x)
1224            || GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
1225            || GET_CODE (x) == CONST_DOUBLE || GET_CODE (x) == CONST_INT)
1226     return simplify_gen_subreg (mode, x, innermode, offset);
1227
1228   /* Otherwise, we can't do this.  */
1229   return 0;
1230 }
1231 \f
1232 rtx
1233 gen_highpart (enum machine_mode mode, rtx x)
1234 {
1235   unsigned int msize = GET_MODE_SIZE (mode);
1236   rtx result;
1237
1238   /* This case loses if X is a subreg.  To catch bugs early,
1239      complain if an invalid MODE is used even in other cases.  */
1240   gcc_assert (msize <= UNITS_PER_WORD
1241               || msize == (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)));
1242
1243   result = simplify_gen_subreg (mode, x, GET_MODE (x),
1244                                 subreg_highpart_offset (mode, GET_MODE (x)));
1245   gcc_assert (result);
1246   
1247   /* simplify_gen_subreg is not guaranteed to return a valid operand for
1248      the target if we have a MEM.  gen_highpart must return a valid operand,
1249      emitting code if necessary to do so.  */
1250   if (MEM_P (result))
1251     {
1252       result = validize_mem (result);
1253       gcc_assert (result);
1254     }
1255   
1256   return result;
1257 }
1258
1259 /* Like gen_highpart, but accept mode of EXP operand in case EXP can
1260    be VOIDmode constant.  */
1261 rtx
1262 gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx exp)
1263 {
1264   if (GET_MODE (exp) != VOIDmode)
1265     {
1266       gcc_assert (GET_MODE (exp) == innermode);
1267       return gen_highpart (outermode, exp);
1268     }
1269   return simplify_gen_subreg (outermode, exp, innermode,
1270                               subreg_highpart_offset (outermode, innermode));
1271 }
1272
1273 /* Return the SUBREG_BYTE for an OUTERMODE lowpart of an INNERMODE value.  */
1274
1275 unsigned int
1276 subreg_lowpart_offset (enum machine_mode outermode, enum machine_mode innermode)
1277 {
1278   unsigned int offset = 0;
1279   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1280
1281   if (difference > 0)
1282     {
1283       if (WORDS_BIG_ENDIAN)
1284         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1285       if (BYTES_BIG_ENDIAN)
1286         offset += difference % UNITS_PER_WORD;
1287     }
1288
1289   return offset;
1290 }
1291
1292 /* Return offset in bytes to get OUTERMODE high part
1293    of the value in mode INNERMODE stored in memory in target format.  */
1294 unsigned int
1295 subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode)
1296 {
1297   unsigned int offset = 0;
1298   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1299
1300   gcc_assert (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode));
1301
1302   if (difference > 0)
1303     {
1304       if (! WORDS_BIG_ENDIAN)
1305         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1306       if (! BYTES_BIG_ENDIAN)
1307         offset += difference % UNITS_PER_WORD;
1308     }
1309
1310   return offset;
1311 }
1312
1313 /* Return 1 iff X, assumed to be a SUBREG,
1314    refers to the least significant part of its containing reg.
1315    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1316
1317 int
1318 subreg_lowpart_p (const_rtx x)
1319 {
1320   if (GET_CODE (x) != SUBREG)
1321     return 1;
1322   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1323     return 0;
1324
1325   return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
1326           == SUBREG_BYTE (x));
1327 }
1328 \f
1329 /* Return subword OFFSET of operand OP.
1330    The word number, OFFSET, is interpreted as the word number starting
1331    at the low-order address.  OFFSET 0 is the low-order word if not
1332    WORDS_BIG_ENDIAN, otherwise it is the high-order word.
1333
1334    If we cannot extract the required word, we return zero.  Otherwise,
1335    an rtx corresponding to the requested word will be returned.
1336
1337    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1338    reload has completed, a valid address will always be returned.  After
1339    reload, if a valid address cannot be returned, we return zero.
1340
1341    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1342    it is the responsibility of the caller.
1343
1344    MODE is the mode of OP in case it is a CONST_INT.
1345
1346    ??? This is still rather broken for some cases.  The problem for the
1347    moment is that all callers of this thing provide no 'goal mode' to
1348    tell us to work with.  This exists because all callers were written
1349    in a word based SUBREG world.
1350    Now use of this function can be deprecated by simplify_subreg in most
1351    cases.
1352  */
1353
1354 rtx
1355 operand_subword (rtx op, unsigned int offset, int validate_address, enum machine_mode mode)
1356 {
1357   if (mode == VOIDmode)
1358     mode = GET_MODE (op);
1359
1360   gcc_assert (mode != VOIDmode);
1361
1362   /* If OP is narrower than a word, fail.  */
1363   if (mode != BLKmode
1364       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1365     return 0;
1366
1367   /* If we want a word outside OP, return zero.  */
1368   if (mode != BLKmode
1369       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1370     return const0_rtx;
1371
1372   /* Form a new MEM at the requested address.  */
1373   if (MEM_P (op))
1374     {
1375       rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1376
1377       if (! validate_address)
1378         return new;
1379
1380       else if (reload_completed)
1381         {
1382           if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
1383             return 0;
1384         }
1385       else
1386         return replace_equiv_address (new, XEXP (new, 0));
1387     }
1388
1389   /* Rest can be handled by simplify_subreg.  */
1390   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1391 }
1392
1393 /* Similar to `operand_subword', but never return 0.  If we can't
1394    extract the required subword, put OP into a register and try again.
1395    The second attempt must succeed.  We always validate the address in
1396    this case.
1397
1398    MODE is the mode of OP, in case it is CONST_INT.  */
1399
1400 rtx
1401 operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
1402 {
1403   rtx result = operand_subword (op, offset, 1, mode);
1404
1405   if (result)
1406     return result;
1407
1408   if (mode != BLKmode && mode != VOIDmode)
1409     {
1410       /* If this is a register which can not be accessed by words, copy it
1411          to a pseudo register.  */
1412       if (REG_P (op))
1413         op = copy_to_reg (op);
1414       else
1415         op = force_reg (mode, op);
1416     }
1417
1418   result = operand_subword (op, offset, 1, mode);
1419   gcc_assert (result);
1420
1421   return result;
1422 }
1423 \f
1424 /* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
1425    or (2) a component ref of something variable.  Represent the later with
1426    a NULL expression.  */
1427
1428 static tree
1429 component_ref_for_mem_expr (tree ref)
1430 {
1431   tree inner = TREE_OPERAND (ref, 0);
1432
1433   if (TREE_CODE (inner) == COMPONENT_REF)
1434     inner = component_ref_for_mem_expr (inner);
1435   else
1436     {
1437       /* Now remove any conversions: they don't change what the underlying
1438          object is.  Likewise for SAVE_EXPR.  */
1439       while (CONVERT_EXPR_P (inner)
1440              || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1441              || TREE_CODE (inner) == SAVE_EXPR)
1442         inner = TREE_OPERAND (inner, 0);
1443
1444       if (! DECL_P (inner))
1445         inner = NULL_TREE;
1446     }
1447
1448   if (inner == TREE_OPERAND (ref, 0))
1449     return ref;
1450   else
1451     return build3 (COMPONENT_REF, TREE_TYPE (ref), inner,
1452                    TREE_OPERAND (ref, 1), NULL_TREE);
1453 }
1454
1455 /* Returns 1 if both MEM_EXPR can be considered equal
1456    and 0 otherwise.  */
1457
1458 int
1459 mem_expr_equal_p (const_tree expr1, const_tree expr2)
1460 {
1461   if (expr1 == expr2)
1462     return 1;
1463
1464   if (! expr1 || ! expr2)
1465     return 0;
1466
1467   if (TREE_CODE (expr1) != TREE_CODE (expr2))
1468     return 0;
1469
1470   if (TREE_CODE (expr1) == COMPONENT_REF)
1471     return 
1472       mem_expr_equal_p (TREE_OPERAND (expr1, 0),
1473                         TREE_OPERAND (expr2, 0))
1474       && mem_expr_equal_p (TREE_OPERAND (expr1, 1), /* field decl */
1475                            TREE_OPERAND (expr2, 1));
1476   
1477   if (INDIRECT_REF_P (expr1))
1478     return mem_expr_equal_p (TREE_OPERAND (expr1, 0),
1479                              TREE_OPERAND (expr2, 0));
1480
1481   /* ARRAY_REFs, ARRAY_RANGE_REFs and BIT_FIELD_REFs should already
1482               have been resolved here.  */
1483   gcc_assert (DECL_P (expr1));
1484   
1485   /* Decls with different pointers can't be equal.  */
1486   return 0;
1487 }
1488
1489 /* Given REF, a MEM, and T, either the type of X or the expression
1490    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
1491    if we are making a new object of this type.  BITPOS is nonzero if
1492    there is an offset outstanding on T that will be applied later.  */
1493
1494 void
1495 set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
1496                                  HOST_WIDE_INT bitpos)
1497 {
1498   alias_set_type alias = MEM_ALIAS_SET (ref);
1499   tree expr = MEM_EXPR (ref);
1500   rtx offset = MEM_OFFSET (ref);
1501   rtx size = MEM_SIZE (ref);
1502   unsigned int align = MEM_ALIGN (ref);
1503   HOST_WIDE_INT apply_bitpos = 0;
1504   tree type;
1505
1506   /* It can happen that type_for_mode was given a mode for which there
1507      is no language-level type.  In which case it returns NULL, which
1508      we can see here.  */
1509   if (t == NULL_TREE)
1510     return;
1511
1512   type = TYPE_P (t) ? t : TREE_TYPE (t);
1513   if (type == error_mark_node)
1514     return;
1515
1516   /* If we have already set DECL_RTL = ref, get_alias_set will get the
1517      wrong answer, as it assumes that DECL_RTL already has the right alias
1518      info.  Callers should not set DECL_RTL until after the call to
1519      set_mem_attributes.  */
1520   gcc_assert (!DECL_P (t) || ref != DECL_RTL_IF_SET (t));
1521
1522   /* Get the alias set from the expression or type (perhaps using a
1523      front-end routine) and use it.  */
1524   alias = get_alias_set (t);
1525
1526   MEM_VOLATILE_P (ref) |= TYPE_VOLATILE (type);
1527   MEM_IN_STRUCT_P (ref)
1528     = AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE;
1529   MEM_POINTER (ref) = POINTER_TYPE_P (type);
1530
1531   /* If we are making an object of this type, or if this is a DECL, we know
1532      that it is a scalar if the type is not an aggregate.  */
1533   if ((objectp || DECL_P (t))
1534       && ! AGGREGATE_TYPE_P (type)
1535       && TREE_CODE (type) != COMPLEX_TYPE)
1536     MEM_SCALAR_P (ref) = 1;
1537
1538   /* We can set the alignment from the type if we are making an object,
1539      this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
1540   if (objectp || TREE_CODE (t) == INDIRECT_REF 
1541       || TREE_CODE (t) == ALIGN_INDIRECT_REF 
1542       || TYPE_ALIGN_OK (type))
1543     align = MAX (align, TYPE_ALIGN (type));
1544   else 
1545     if (TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
1546       {
1547         if (integer_zerop (TREE_OPERAND (t, 1)))
1548           /* We don't know anything about the alignment.  */
1549           align = BITS_PER_UNIT;
1550         else
1551           align = tree_low_cst (TREE_OPERAND (t, 1), 1);
1552       }
1553
1554   /* If the size is known, we can set that.  */
1555   if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
1556     size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
1557
1558   /* If T is not a type, we may be able to deduce some more information about
1559      the expression.  */
1560   if (! TYPE_P (t))
1561     {
1562       tree base;
1563
1564       if (TREE_THIS_VOLATILE (t))
1565         MEM_VOLATILE_P (ref) = 1;
1566
1567       /* Now remove any conversions: they don't change what the underlying
1568          object is.  Likewise for SAVE_EXPR.  */
1569       while (CONVERT_EXPR_P (t)
1570              || TREE_CODE (t) == VIEW_CONVERT_EXPR
1571              || TREE_CODE (t) == SAVE_EXPR)
1572         t = TREE_OPERAND (t, 0);
1573
1574       /* We may look through structure-like accesses for the purposes of
1575          examining TREE_THIS_NOTRAP, but not array-like accesses.  */
1576       base = t;
1577       while (TREE_CODE (base) == COMPONENT_REF
1578              || TREE_CODE (base) == REALPART_EXPR
1579              || TREE_CODE (base) == IMAGPART_EXPR
1580              || TREE_CODE (base) == BIT_FIELD_REF)
1581         base = TREE_OPERAND (base, 0);
1582
1583       if (DECL_P (base))
1584         {
1585           if (CODE_CONTAINS_STRUCT (TREE_CODE (base), TS_DECL_WITH_VIS))
1586             MEM_NOTRAP_P (ref) = !DECL_WEAK (base);
1587           else
1588             MEM_NOTRAP_P (ref) = 1;
1589         }
1590       else
1591         MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (base);
1592
1593       base = get_base_address (base);
1594       if (base && DECL_P (base)
1595           && TREE_READONLY (base)
1596           && (TREE_STATIC (base) || DECL_EXTERNAL (base)))
1597         {
1598           tree base_type = TREE_TYPE (base);
1599           gcc_assert (!(base_type && TYPE_NEEDS_CONSTRUCTING (base_type))
1600                       || DECL_ARTIFICIAL (base));
1601           MEM_READONLY_P (ref) = 1;
1602         }
1603
1604       /* If this expression uses it's parent's alias set, mark it such
1605          that we won't change it.  */
1606       if (component_uses_parent_alias_set (t))
1607         MEM_KEEP_ALIAS_SET_P (ref) = 1;
1608
1609       /* If this is a decl, set the attributes of the MEM from it.  */
1610       if (DECL_P (t))
1611         {
1612           expr = t;
1613           offset = const0_rtx;
1614           apply_bitpos = bitpos;
1615           size = (DECL_SIZE_UNIT (t)
1616                   && host_integerp (DECL_SIZE_UNIT (t), 1)
1617                   ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
1618           align = DECL_ALIGN (t);
1619         }
1620
1621       /* If this is a constant, we know the alignment.  */
1622       else if (CONSTANT_CLASS_P (t))
1623         {
1624           align = TYPE_ALIGN (type);
1625 #ifdef CONSTANT_ALIGNMENT
1626           align = CONSTANT_ALIGNMENT (t, align);
1627 #endif
1628         }
1629
1630       /* If this is a field reference and not a bit-field, record it.  */
1631       /* ??? There is some information that can be gleaned from bit-fields,
1632          such as the word offset in the structure that might be modified.
1633          But skip it for now.  */
1634       else if (TREE_CODE (t) == COMPONENT_REF
1635                && ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
1636         {
1637           expr = component_ref_for_mem_expr (t);
1638           offset = const0_rtx;
1639           apply_bitpos = bitpos;
1640           /* ??? Any reason the field size would be different than
1641              the size we got from the type?  */
1642         }
1643
1644       /* If this is an array reference, look for an outer field reference.  */
1645       else if (TREE_CODE (t) == ARRAY_REF)
1646         {
1647           tree off_tree = size_zero_node;
1648           /* We can't modify t, because we use it at the end of the
1649              function.  */
1650           tree t2 = t;
1651
1652           do
1653             {
1654               tree index = TREE_OPERAND (t2, 1);
1655               tree low_bound = array_ref_low_bound (t2);
1656               tree unit_size = array_ref_element_size (t2);
1657
1658               /* We assume all arrays have sizes that are a multiple of a byte.
1659                  First subtract the lower bound, if any, in the type of the
1660                  index, then convert to sizetype and multiply by the size of
1661                  the array element.  */
1662               if (! integer_zerop (low_bound))
1663                 index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
1664                                      index, low_bound);
1665
1666               off_tree = size_binop (PLUS_EXPR,
1667                                      size_binop (MULT_EXPR,
1668                                                  fold_convert (sizetype,
1669                                                                index),
1670                                                  unit_size),
1671                                      off_tree);
1672               t2 = TREE_OPERAND (t2, 0);
1673             }
1674           while (TREE_CODE (t2) == ARRAY_REF);
1675
1676           if (DECL_P (t2))
1677             {
1678               expr = t2;
1679               offset = NULL;
1680               if (host_integerp (off_tree, 1))
1681                 {
1682                   HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
1683                   HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
1684                   align = DECL_ALIGN (t2);
1685                   if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
1686                     align = aoff;
1687                   offset = GEN_INT (ioff);
1688                   apply_bitpos = bitpos;
1689                 }
1690             }
1691           else if (TREE_CODE (t2) == COMPONENT_REF)
1692             {
1693               expr = component_ref_for_mem_expr (t2);
1694               if (host_integerp (off_tree, 1))
1695                 {
1696                   offset = GEN_INT (tree_low_cst (off_tree, 1));
1697                   apply_bitpos = bitpos;
1698                 }
1699               /* ??? Any reason the field size would be different than
1700                  the size we got from the type?  */
1701             }
1702           else if (flag_argument_noalias > 1
1703                    && (INDIRECT_REF_P (t2))
1704                    && TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
1705             {
1706               expr = t2;
1707               offset = NULL;
1708             }
1709         }
1710
1711       /* If this is a Fortran indirect argument reference, record the
1712          parameter decl.  */
1713       else if (flag_argument_noalias > 1
1714                && (INDIRECT_REF_P (t))
1715                && TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
1716         {
1717           expr = t;
1718           offset = NULL;
1719         }
1720     }
1721
1722   /* If we modified OFFSET based on T, then subtract the outstanding
1723      bit position offset.  Similarly, increase the size of the accessed
1724      object to contain the negative offset.  */
1725   if (apply_bitpos)
1726     {
1727       offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
1728       if (size)
1729         size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
1730     }
1731
1732   if (TREE_CODE (t) == ALIGN_INDIRECT_REF)
1733     {
1734       /* Force EXPR and OFFSET to NULL, since we don't know exactly what
1735          we're overlapping.  */
1736       offset = NULL;
1737       expr = NULL;
1738     }
1739
1740   /* Now set the attributes we computed above.  */
1741   MEM_ATTRS (ref)
1742     = get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));
1743
1744   /* If this is already known to be a scalar or aggregate, we are done.  */
1745   if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
1746     return;
1747
1748   /* If it is a reference into an aggregate, this is part of an aggregate.
1749      Otherwise we don't know.  */
1750   else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
1751            || TREE_CODE (t) == ARRAY_RANGE_REF
1752            || TREE_CODE (t) == BIT_FIELD_REF)
1753     MEM_IN_STRUCT_P (ref) = 1;
1754 }
1755
1756 void
1757 set_mem_attributes (rtx ref, tree t, int objectp)
1758 {
1759   set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
1760 }
1761
1762 /* Set MEM to the decl that REG refers to.  */
1763
1764 void
1765 set_mem_attrs_from_reg (rtx mem, rtx reg)
1766 {
1767   MEM_ATTRS (mem)
1768     = get_mem_attrs (MEM_ALIAS_SET (mem), REG_EXPR (reg),
1769                      GEN_INT (REG_OFFSET (reg)),
1770                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1771 }
1772
1773 /* Set the alias set of MEM to SET.  */
1774
1775 void
1776 set_mem_alias_set (rtx mem, alias_set_type set)
1777 {
1778 #ifdef ENABLE_CHECKING
1779   /* If the new and old alias sets don't conflict, something is wrong.  */
1780   gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
1781 #endif
1782
1783   MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
1784                                    MEM_SIZE (mem), MEM_ALIGN (mem),
1785                                    GET_MODE (mem));
1786 }
1787
1788 /* Set the alignment of MEM to ALIGN bits.  */
1789
1790 void
1791 set_mem_align (rtx mem, unsigned int align)
1792 {
1793   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1794                                    MEM_OFFSET (mem), MEM_SIZE (mem), align,
1795                                    GET_MODE (mem));
1796 }
1797
1798 /* Set the expr for MEM to EXPR.  */
1799
1800 void
1801 set_mem_expr (rtx mem, tree expr)
1802 {
1803   MEM_ATTRS (mem)
1804     = get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
1805                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1806 }
1807
1808 /* Set the offset of MEM to OFFSET.  */
1809
1810 void
1811 set_mem_offset (rtx mem, rtx offset)
1812 {
1813   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1814                                    offset, MEM_SIZE (mem), MEM_ALIGN (mem),
1815                                    GET_MODE (mem));
1816 }
1817
1818 /* Set the size of MEM to SIZE.  */
1819
1820 void
1821 set_mem_size (rtx mem, rtx size)
1822 {
1823   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1824                                    MEM_OFFSET (mem), size, MEM_ALIGN (mem),
1825                                    GET_MODE (mem));
1826 }
1827 \f
1828 /* Return a memory reference like MEMREF, but with its mode changed to MODE
1829    and its address changed to ADDR.  (VOIDmode means don't change the mode.
1830    NULL for ADDR means don't change the address.)  VALIDATE is nonzero if the
1831    returned memory location is required to be valid.  The memory
1832    attributes are not changed.  */
1833
1834 static rtx
1835 change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
1836 {
1837   rtx new;
1838
1839   gcc_assert (MEM_P (memref));
1840   if (mode == VOIDmode)
1841     mode = GET_MODE (memref);
1842   if (addr == 0)
1843     addr = XEXP (memref, 0);
1844   if (mode == GET_MODE (memref) && addr == XEXP (memref, 0)
1845       && (!validate || memory_address_p (mode, addr)))
1846     return memref;
1847
1848   if (validate)
1849     {
1850       if (reload_in_progress || reload_completed)
1851         gcc_assert (memory_address_p (mode, addr));
1852       else
1853         addr = memory_address (mode, addr);
1854     }
1855
1856   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
1857     return memref;
1858
1859   new = gen_rtx_MEM (mode, addr);
1860   MEM_COPY_ATTRIBUTES (new, memref);
1861   return new;
1862 }
1863
1864 /* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
1865    way we are changing MEMREF, so we only preserve the alias set.  */
1866
1867 rtx
1868 change_address (rtx memref, enum machine_mode mode, rtx addr)
1869 {
1870   rtx new = change_address_1 (memref, mode, addr, 1), size;
1871   enum machine_mode mmode = GET_MODE (new);
1872   unsigned int align;
1873
1874   size = mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode));
1875   align = mmode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mmode);
1876
1877   /* If there are no changes, just return the original memory reference.  */
1878   if (new == memref)
1879     {
1880       if (MEM_ATTRS (memref) == 0
1881           || (MEM_EXPR (memref) == NULL
1882               && MEM_OFFSET (memref) == NULL
1883               && MEM_SIZE (memref) == size
1884               && MEM_ALIGN (memref) == align))
1885         return new;
1886
1887       new = gen_rtx_MEM (mmode, XEXP (memref, 0));
1888       MEM_COPY_ATTRIBUTES (new, memref);
1889     }
1890
1891   MEM_ATTRS (new)
1892     = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0, size, align, mmode);
1893
1894   return new;
1895 }
1896
1897 /* Return a memory reference like MEMREF, but with its mode changed
1898    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
1899    nonzero, the memory address is forced to be valid.
1900    If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
1901    and caller is responsible for adjusting MEMREF base register.  */
1902
1903 rtx
1904 adjust_address_1 (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset,
1905                   int validate, int adjust)
1906 {
1907   rtx addr = XEXP (memref, 0);
1908   rtx new;
1909   rtx memoffset = MEM_OFFSET (memref);
1910   rtx size = 0;
1911   unsigned int memalign = MEM_ALIGN (memref);
1912
1913   /* If there are no changes, just return the original memory reference.  */
1914   if (mode == GET_MODE (memref) && !offset
1915       && (!validate || memory_address_p (mode, addr)))
1916     return memref;
1917
1918   /* ??? Prefer to create garbage instead of creating shared rtl.
1919      This may happen even if offset is nonzero -- consider
1920      (plus (plus reg reg) const_int) -- so do this always.  */
1921   addr = copy_rtx (addr);
1922
1923   if (adjust)
1924     {
1925       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
1926          object, we can merge it into the LO_SUM.  */
1927       if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
1928           && offset >= 0
1929           && (unsigned HOST_WIDE_INT) offset
1930               < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
1931         addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
1932                                plus_constant (XEXP (addr, 1), offset));
1933       else
1934         addr = plus_constant (addr, offset);
1935     }
1936
1937   new = change_address_1 (memref, mode, addr, validate);
1938
1939   /* Compute the new values of the memory attributes due to this adjustment.
1940      We add the offsets and update the alignment.  */
1941   if (memoffset)
1942     memoffset = GEN_INT (offset + INTVAL (memoffset));
1943
1944   /* Compute the new alignment by taking the MIN of the alignment and the
1945      lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
1946      if zero.  */
1947   if (offset != 0)
1948     memalign
1949       = MIN (memalign,
1950              (unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
1951
1952   /* We can compute the size in a number of ways.  */
1953   if (GET_MODE (new) != BLKmode)
1954     size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
1955   else if (MEM_SIZE (memref))
1956     size = plus_constant (MEM_SIZE (memref), -offset);
1957
1958   MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
1959                                    memoffset, size, memalign, GET_MODE (new));
1960
1961   /* At some point, we should validate that this offset is within the object,
1962      if all the appropriate values are known.  */
1963   return new;
1964 }
1965
1966 /* Return a memory reference like MEMREF, but with its mode changed
1967    to MODE and its address changed to ADDR, which is assumed to be
1968    MEMREF offset by OFFSET bytes.  If VALIDATE is
1969    nonzero, the memory address is forced to be valid.  */
1970
1971 rtx
1972 adjust_automodify_address_1 (rtx memref, enum machine_mode mode, rtx addr,
1973                              HOST_WIDE_INT offset, int validate)
1974 {
1975   memref = change_address_1 (memref, VOIDmode, addr, validate);
1976   return adjust_address_1 (memref, mode, offset, validate, 0);
1977 }
1978
1979 /* Return a memory reference like MEMREF, but whose address is changed by
1980    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
1981    known to be in OFFSET (possibly 1).  */
1982
1983 rtx
1984 offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
1985 {
1986   rtx new, addr = XEXP (memref, 0);
1987
1988   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1989
1990   /* At this point we don't know _why_ the address is invalid.  It
1991      could have secondary memory references, multiplies or anything.
1992
1993      However, if we did go and rearrange things, we can wind up not
1994      being able to recognize the magic around pic_offset_table_rtx.
1995      This stuff is fragile, and is yet another example of why it is
1996      bad to expose PIC machinery too early.  */
1997   if (! memory_address_p (GET_MODE (memref), new)
1998       && GET_CODE (addr) == PLUS
1999       && XEXP (addr, 0) == pic_offset_table_rtx)
2000     {
2001       addr = force_reg (GET_MODE (addr), addr);
2002       new = simplify_gen_binary (PLUS, Pmode, addr, offset);
2003     }
2004
2005   update_temp_slot_address (XEXP (memref, 0), new);
2006   new = change_address_1 (memref, VOIDmode, new, 1);
2007
2008   /* If there are no changes, just return the original memory reference.  */
2009   if (new == memref)
2010     return new;
2011
2012   /* Update the alignment to reflect the offset.  Reset the offset, which
2013      we don't know.  */
2014   MEM_ATTRS (new)
2015     = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
2016                      MIN (MEM_ALIGN (memref), pow2 * BITS_PER_UNIT),
2017                      GET_MODE (new));
2018   return new;
2019 }
2020
2021 /* Return a memory reference like MEMREF, but with its address changed to
2022    ADDR.  The caller is asserting that the actual piece of memory pointed
2023    to is the same, just the form of the address is being changed, such as
2024    by putting something into a register.  */
2025
2026 rtx
2027 replace_equiv_address (rtx memref, rtx addr)
2028 {
2029   /* change_address_1 copies the memory attribute structure without change
2030      and that's exactly what we want here.  */
2031   update_temp_slot_address (XEXP (memref, 0), addr);
2032   return change_address_1 (memref, VOIDmode, addr, 1);
2033 }
2034
2035 /* Likewise, but the reference is not required to be valid.  */
2036
2037 rtx
2038 replace_equiv_address_nv (rtx memref, rtx addr)
2039 {
2040   return change_address_1 (memref, VOIDmode, addr, 0);
2041 }
2042
2043 /* Return a memory reference like MEMREF, but with its mode widened to
2044    MODE and offset by OFFSET.  This would be used by targets that e.g.
2045    cannot issue QImode memory operations and have to use SImode memory
2046    operations plus masking logic.  */
2047
2048 rtx
2049 widen_memory_access (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset)
2050 {
2051   rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
2052   tree expr = MEM_EXPR (new);
2053   rtx memoffset = MEM_OFFSET (new);
2054   unsigned int size = GET_MODE_SIZE (mode);
2055
2056   /* If there are no changes, just return the original memory reference.  */
2057   if (new == memref)
2058     return new;
2059
2060   /* If we don't know what offset we were at within the expression, then
2061      we can't know if we've overstepped the bounds.  */
2062   if (! memoffset)
2063     expr = NULL_TREE;
2064
2065   while (expr)
2066     {
2067       if (TREE_CODE (expr) == COMPONENT_REF)
2068         {
2069           tree field = TREE_OPERAND (expr, 1);
2070           tree offset = component_ref_field_offset (expr);
2071
2072           if (! DECL_SIZE_UNIT (field))
2073             {
2074               expr = NULL_TREE;
2075               break;
2076             }
2077
2078           /* Is the field at least as large as the access?  If so, ok,
2079              otherwise strip back to the containing structure.  */
2080           if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
2081               && compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
2082               && INTVAL (memoffset) >= 0)
2083             break;
2084
2085           if (! host_integerp (offset, 1))
2086             {
2087               expr = NULL_TREE;
2088               break;
2089             }
2090
2091           expr = TREE_OPERAND (expr, 0);
2092           memoffset
2093             = (GEN_INT (INTVAL (memoffset)
2094                         + tree_low_cst (offset, 1)
2095                         + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
2096                            / BITS_PER_UNIT)));
2097         }
2098       /* Similarly for the decl.  */
2099       else if (DECL_P (expr)
2100                && DECL_SIZE_UNIT (expr)
2101                && TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
2102                && compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
2103                && (! memoffset || INTVAL (memoffset) >= 0))
2104         break;
2105       else
2106         {
2107           /* The widened memory access overflows the expression, which means
2108              that it could alias another expression.  Zap it.  */
2109           expr = NULL_TREE;
2110           break;
2111         }
2112     }
2113
2114   if (! expr)
2115     memoffset = NULL_RTX;
2116
2117   /* The widened memory may alias other stuff, so zap the alias set.  */
2118   /* ??? Maybe use get_alias_set on any remaining expression.  */
2119
2120   MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
2121                                    MEM_ALIGN (new), mode);
2122
2123   return new;
2124 }
2125 \f
2126 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
2127
2128 rtx
2129 gen_label_rtx (void)
2130 {
2131   return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
2132                              NULL, label_num++, NULL);
2133 }
2134 \f
2135 /* For procedure integration.  */
2136
2137 /* Install new pointers to the first and last insns in the chain.
2138    Also, set cur_insn_uid to one higher than the last in use.
2139    Used for an inline-procedure after copying the insn chain.  */
2140
2141 void
2142 set_new_first_and_last_insn (rtx first, rtx last)
2143 {
2144   rtx insn;
2145
2146   first_insn = first;
2147   last_insn = last;
2148   cur_insn_uid = 0;
2149
2150   for (insn = first; insn; insn = NEXT_INSN (insn))
2151     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
2152
2153   cur_insn_uid++;
2154 }
2155 \f
2156 /* Go through all the RTL insn bodies and copy any invalid shared
2157    structure.  This routine should only be called once.  */
2158
2159 static void
2160 unshare_all_rtl_1 (rtx insn)
2161 {
2162   /* Unshare just about everything else.  */
2163   unshare_all_rtl_in_chain (insn);
2164
2165   /* Make sure the addresses of stack slots found outside the insn chain
2166      (such as, in DECL_RTL of a variable) are not shared
2167      with the insn chain.
2168
2169      This special care is necessary when the stack slot MEM does not
2170      actually appear in the insn chain.  If it does appear, its address
2171      is unshared from all else at that point.  */
2172   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
2173 }
2174
2175 /* Go through all the RTL insn bodies and copy any invalid shared
2176    structure, again.  This is a fairly expensive thing to do so it
2177    should be done sparingly.  */
2178
2179 void
2180 unshare_all_rtl_again (rtx insn)
2181 {
2182   rtx p;
2183   tree decl;
2184
2185   for (p = insn; p; p = NEXT_INSN (p))
2186     if (INSN_P (p))
2187       {
2188         reset_used_flags (PATTERN (p));
2189         reset_used_flags (REG_NOTES (p));
2190       }
2191
2192   /* Make sure that virtual stack slots are not shared.  */
2193   set_used_decls (DECL_INITIAL (cfun->decl));
2194
2195   /* Make sure that virtual parameters are not shared.  */
2196   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
2197     set_used_flags (DECL_RTL (decl));
2198
2199   reset_used_flags (stack_slot_list);
2200
2201   unshare_all_rtl_1 (insn);
2202 }
2203
2204 unsigned int
2205 unshare_all_rtl (void)
2206 {
2207   unshare_all_rtl_1 (get_insns ());
2208   return 0;
2209 }
2210
2211 struct rtl_opt_pass pass_unshare_all_rtl =
2212 {
2213  {
2214   RTL_PASS,
2215   "unshare",                            /* name */
2216   NULL,                                 /* gate */
2217   unshare_all_rtl,                      /* execute */
2218   NULL,                                 /* sub */
2219   NULL,                                 /* next */
2220   0,                                    /* static_pass_number */
2221   0,                                    /* tv_id */
2222   0,                                    /* properties_required */
2223   0,                                    /* properties_provided */
2224   0,                                    /* properties_destroyed */
2225   0,                                    /* todo_flags_start */
2226   TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */
2227  }
2228 };
2229
2230
2231 /* Check that ORIG is not marked when it should not be and mark ORIG as in use,
2232    Recursively does the same for subexpressions.  */
2233
2234 static void
2235 verify_rtx_sharing (rtx orig, rtx insn)
2236 {
2237   rtx x = orig;
2238   int i;
2239   enum rtx_code code;
2240   const char *format_ptr;
2241
2242   if (x == 0)
2243     return;
2244
2245   code = GET_CODE (x);
2246
2247   /* These types may be freely shared.  */
2248
2249   switch (code)
2250     {
2251     case REG:
2252     case CONST_INT:
2253     case CONST_DOUBLE:
2254     case CONST_FIXED:
2255     case CONST_VECTOR:
2256     case SYMBOL_REF:
2257     case LABEL_REF:
2258     case CODE_LABEL:
2259     case PC:
2260     case CC0:
2261     case SCRATCH:
2262       return;
2263       /* SCRATCH must be shared because they represent distinct values.  */
2264     case CLOBBER:
2265       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2266         return;
2267       break;
2268
2269     case CONST:
2270       if (shared_const_p (orig))
2271         return;
2272       break;
2273
2274     case MEM:
2275       /* A MEM is allowed to be shared if its address is constant.  */
2276       if (CONSTANT_ADDRESS_P (XEXP (x, 0))
2277           || reload_completed || reload_in_progress)
2278         return;
2279
2280       break;
2281
2282     default:
2283       break;
2284     }
2285
2286   /* This rtx may not be shared.  If it has already been seen,
2287      replace it with a copy of itself.  */
2288 #ifdef ENABLE_CHECKING
2289   if (RTX_FLAG (x, used))
2290     {
2291       error ("invalid rtl sharing found in the insn");
2292       debug_rtx (insn);
2293       error ("shared rtx");
2294       debug_rtx (x);
2295       internal_error ("internal consistency failure");
2296     }
2297 #endif
2298   gcc_assert (!RTX_FLAG (x, used));
2299   
2300   RTX_FLAG (x, used) = 1;
2301
2302   /* Now scan the subexpressions recursively.  */
2303
2304   format_ptr = GET_RTX_FORMAT (code);
2305
2306   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2307     {
2308       switch (*format_ptr++)
2309         {
2310         case 'e':
2311           verify_rtx_sharing (XEXP (x, i), insn);
2312           break;
2313
2314         case 'E':
2315           if (XVEC (x, i) != NULL)
2316             {
2317               int j;
2318               int len = XVECLEN (x, i);
2319
2320               for (j = 0; j < len; j++)
2321                 {
2322                   /* We allow sharing of ASM_OPERANDS inside single
2323                      instruction.  */
2324                   if (j && GET_CODE (XVECEXP (x, i, j)) == SET
2325                       && (GET_CODE (SET_SRC (XVECEXP (x, i, j)))
2326                           == ASM_OPERANDS))
2327                     verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
2328                   else
2329                     verify_rtx_sharing (XVECEXP (x, i, j), insn);
2330                 }
2331             }
2332           break;
2333         }
2334     }
2335   return;
2336 }
2337
2338 /* Go through all the RTL insn bodies and check that there is no unexpected
2339    sharing in between the subexpressions.  */
2340
2341 void
2342 verify_rtl_sharing (void)
2343 {
2344   rtx p;
2345
2346   for (p = get_insns (); p; p = NEXT_INSN (p))
2347     if (INSN_P (p))
2348       {
2349         reset_used_flags (PATTERN (p));
2350         reset_used_flags (REG_NOTES (p));
2351         if (GET_CODE (PATTERN (p)) == SEQUENCE)
2352           {
2353             int i;
2354             rtx q, sequence = PATTERN (p);
2355
2356             for (i = 0; i < XVECLEN (sequence, 0); i++)
2357               {
2358                 q = XVECEXP (sequence, 0, i);
2359                 gcc_assert (INSN_P (q));
2360                 reset_used_flags (PATTERN (q));
2361                 reset_used_flags (REG_NOTES (q));
2362               }
2363           }
2364       }
2365
2366   for (p = get_insns (); p; p = NEXT_INSN (p))
2367     if (INSN_P (p))
2368       {
2369         verify_rtx_sharing (PATTERN (p), p);
2370         verify_rtx_sharing (REG_NOTES (p), p);
2371       }
2372 }
2373
2374 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2375    Assumes the mark bits are cleared at entry.  */
2376
2377 void
2378 unshare_all_rtl_in_chain (rtx insn)
2379 {
2380   for (; insn; insn = NEXT_INSN (insn))
2381     if (INSN_P (insn))
2382       {
2383         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2384         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2385       }
2386 }
2387
2388 /* Go through all virtual stack slots of a function and mark them as
2389    shared.  We never replace the DECL_RTLs themselves with a copy,
2390    but expressions mentioned into a DECL_RTL cannot be shared with
2391    expressions in the instruction stream.
2392
2393    Note that reload may convert pseudo registers into memories in-place.
2394    Pseudo registers are always shared, but MEMs never are.  Thus if we
2395    reset the used flags on MEMs in the instruction stream, we must set
2396    them again on MEMs that appear in DECL_RTLs.  */
2397
2398 static void
2399 set_used_decls (tree blk)
2400 {
2401   tree t;
2402
2403   /* Mark decls.  */
2404   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2405     if (DECL_RTL_SET_P (t))
2406       set_used_flags (DECL_RTL (t));
2407
2408   /* Now process sub-blocks.  */
2409   for (t = BLOCK_SUBBLOCKS (blk); t; t = BLOCK_CHAIN (t))
2410     set_used_decls (t);
2411 }
2412
2413 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2414    Recursively does the same for subexpressions.  Uses
2415    copy_rtx_if_shared_1 to reduce stack space.  */
2416
2417 rtx
2418 copy_rtx_if_shared (rtx orig)
2419 {
2420   copy_rtx_if_shared_1 (&orig);
2421   return orig;
2422 }
2423
2424 /* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
2425    use.  Recursively does the same for subexpressions.  */
2426
2427 static void
2428 copy_rtx_if_shared_1 (rtx *orig1)
2429 {
2430   rtx x;
2431   int i;
2432   enum rtx_code code;
2433   rtx *last_ptr;
2434   const char *format_ptr;
2435   int copied = 0;
2436   int length;
2437
2438   /* Repeat is used to turn tail-recursion into iteration.  */
2439 repeat:
2440   x = *orig1;
2441
2442   if (x == 0)
2443     return;
2444
2445   code = GET_CODE (x);
2446
2447   /* These types may be freely shared.  */
2448
2449   switch (code)
2450     {
2451     case REG:
2452     case CONST_INT:
2453     case CONST_DOUBLE:
2454     case CONST_FIXED:
2455     case CONST_VECTOR:
2456     case SYMBOL_REF:
2457     case LABEL_REF:
2458     case CODE_LABEL:
2459     case PC:
2460     case CC0:
2461     case SCRATCH:
2462       /* SCRATCH must be shared because they represent distinct values.  */
2463       return;
2464     case CLOBBER:
2465       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2466         return;
2467       break;
2468
2469     case CONST:
2470       if (shared_const_p (x))
2471         return;
2472       break;
2473
2474     case INSN:
2475     case JUMP_INSN:
2476     case CALL_INSN:
2477     case NOTE:
2478     case BARRIER:
2479       /* The chain of insns is not being copied.  */
2480       return;
2481
2482     default:
2483       break;
2484     }
2485
2486   /* This rtx may not be shared.  If it has already been seen,
2487      replace it with a copy of itself.  */
2488
2489   if (RTX_FLAG (x, used))
2490     {
2491       x = shallow_copy_rtx (x);
2492       copied = 1;
2493     }
2494   RTX_FLAG (x, used) = 1;
2495
2496   /* Now scan the subexpressions recursively.
2497      We can store any replaced subexpressions directly into X
2498      since we know X is not shared!  Any vectors in X
2499      must be copied if X was copied.  */
2500
2501   format_ptr = GET_RTX_FORMAT (code);
2502   length = GET_RTX_LENGTH (code);
2503   last_ptr = NULL;
2504   
2505   for (i = 0; i < length; i++)
2506     {
2507       switch (*format_ptr++)
2508         {
2509         case 'e':
2510           if (last_ptr)
2511             copy_rtx_if_shared_1 (last_ptr);
2512           last_ptr = &XEXP (x, i);
2513           break;
2514
2515         case 'E':
2516           if (XVEC (x, i) != NULL)
2517             {
2518               int j;
2519               int len = XVECLEN (x, i);
2520               
2521               /* Copy the vector iff I copied the rtx and the length
2522                  is nonzero.  */
2523               if (copied && len > 0)
2524                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2525               
2526               /* Call recursively on all inside the vector.  */
2527               for (j = 0; j < len; j++)
2528                 {
2529                   if (last_ptr)
2530                     copy_rtx_if_shared_1 (last_ptr);
2531                   last_ptr = &XVECEXP (x, i, j);
2532                 }
2533             }
2534           break;
2535         }
2536     }
2537   *orig1 = x;
2538   if (last_ptr)
2539     {
2540       orig1 = last_ptr;
2541       goto repeat;
2542     }
2543   return;
2544 }
2545
2546 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2547    to look for shared sub-parts.  */
2548
2549 void
2550 reset_used_flags (rtx x)
2551 {
2552   int i, j;
2553   enum rtx_code code;
2554   const char *format_ptr;
2555   int length;
2556
2557   /* Repeat is used to turn tail-recursion into iteration.  */
2558 repeat:
2559   if (x == 0)
2560     return;
2561
2562   code = GET_CODE (x);
2563
2564   /* These types may be freely shared so we needn't do any resetting
2565      for them.  */
2566
2567   switch (code)
2568     {
2569     case REG:
2570     case CONST_INT:
2571     case CONST_DOUBLE:
2572     case CONST_FIXED:
2573     case CONST_VECTOR:
2574     case SYMBOL_REF:
2575     case CODE_LABEL:
2576     case PC:
2577     case CC0:
2578       return;
2579
2580     case INSN:
2581     case JUMP_INSN:
2582     case CALL_INSN:
2583     case NOTE:
2584     case LABEL_REF:
2585     case BARRIER:
2586       /* The chain of insns is not being copied.  */
2587       return;
2588
2589     default:
2590       break;
2591     }
2592
2593   RTX_FLAG (x, used) = 0;
2594
2595   format_ptr = GET_RTX_FORMAT (code);
2596   length = GET_RTX_LENGTH (code);
2597   
2598   for (i = 0; i < length; i++)
2599     {
2600       switch (*format_ptr++)
2601         {
2602         case 'e':
2603           if (i == length-1)
2604             {
2605               x = XEXP (x, i);
2606               goto repeat;
2607             }
2608           reset_used_flags (XEXP (x, i));
2609           break;
2610
2611         case 'E':
2612           for (j = 0; j < XVECLEN (x, i); j++)
2613             reset_used_flags (XVECEXP (x, i, j));
2614           break;
2615         }
2616     }
2617 }
2618
2619 /* Set all the USED bits in X to allow copy_rtx_if_shared to be used
2620    to look for shared sub-parts.  */
2621
2622 void
2623 set_used_flags (rtx x)
2624 {
2625   int i, j;
2626   enum rtx_code code;
2627   const char *format_ptr;
2628
2629   if (x == 0)
2630     return;
2631
2632   code = GET_CODE (x);
2633
2634   /* These types may be freely shared so we needn't do any resetting
2635      for them.  */
2636
2637   switch (code)
2638     {
2639     case REG:
2640     case CONST_INT:
2641     case CONST_DOUBLE:
2642     case CONST_FIXED:
2643     case CONST_VECTOR:
2644     case SYMBOL_REF:
2645     case CODE_LABEL:
2646     case PC:
2647     case CC0:
2648       return;
2649
2650     case INSN:
2651     case JUMP_INSN:
2652     case CALL_INSN:
2653     case NOTE:
2654     case LABEL_REF:
2655     case BARRIER:
2656       /* The chain of insns is not being copied.  */
2657       return;
2658
2659     default:
2660       break;
2661     }
2662
2663   RTX_FLAG (x, used) = 1;
2664
2665   format_ptr = GET_RTX_FORMAT (code);
2666   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2667     {
2668       switch (*format_ptr++)
2669         {
2670         case 'e':
2671           set_used_flags (XEXP (x, i));
2672           break;
2673
2674         case 'E':
2675           for (j = 0; j < XVECLEN (x, i); j++)
2676             set_used_flags (XVECEXP (x, i, j));
2677           break;
2678         }
2679     }
2680 }
2681 \f
2682 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2683    Return X or the rtx for the pseudo reg the value of X was copied into.
2684    OTHER must be valid as a SET_DEST.  */
2685
2686 rtx
2687 make_safe_from (rtx x, rtx other)
2688 {
2689   while (1)
2690     switch (GET_CODE (other))
2691       {
2692       case SUBREG:
2693         other = SUBREG_REG (other);
2694         break;
2695       case STRICT_LOW_PART:
2696       case SIGN_EXTEND:
2697       case ZERO_EXTEND:
2698         other = XEXP (other, 0);
2699         break;
2700       default:
2701         goto done;
2702       }
2703  done:
2704   if ((MEM_P (other)
2705        && ! CONSTANT_P (x)
2706        && !REG_P (x)
2707        && GET_CODE (x) != SUBREG)
2708       || (REG_P (other)
2709           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2710               || reg_mentioned_p (other, x))))
2711     {
2712       rtx temp = gen_reg_rtx (GET_MODE (x));
2713       emit_move_insn (temp, x);
2714       return temp;
2715     }
2716   return x;
2717 }
2718 \f
2719 /* Emission of insns (adding them to the doubly-linked list).  */
2720
2721 /* Return the first insn of the current sequence or current function.  */
2722
2723 rtx
2724 get_insns (void)
2725 {
2726   return first_insn;
2727 }
2728
2729 /* Specify a new insn as the first in the chain.  */
2730
2731 void
2732 set_first_insn (rtx insn)
2733 {
2734   gcc_assert (!PREV_INSN (insn));
2735   first_insn = insn;
2736 }
2737
2738 /* Return the last insn emitted in current sequence or current function.  */
2739
2740 rtx
2741 get_last_insn (void)
2742 {
2743   return last_insn;
2744 }
2745
2746 /* Specify a new insn as the last in the chain.  */
2747
2748 void
2749 set_last_insn (rtx insn)
2750 {
2751   gcc_assert (!NEXT_INSN (insn));
2752   last_insn = insn;
2753 }
2754
2755 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2756
2757 rtx
2758 get_last_insn_anywhere (void)
2759 {
2760   struct sequence_stack *stack;
2761   if (last_insn)
2762     return last_insn;
2763   for (stack = seq_stack; stack; stack = stack->next)
2764     if (stack->last != 0)
2765       return stack->last;
2766   return 0;
2767 }
2768
2769 /* Return the first nonnote insn emitted in current sequence or current
2770    function.  This routine looks inside SEQUENCEs.  */
2771
2772 rtx
2773 get_first_nonnote_insn (void)
2774 {
2775   rtx insn = first_insn;
2776
2777   if (insn)
2778     {
2779       if (NOTE_P (insn))
2780         for (insn = next_insn (insn);
2781              insn && NOTE_P (insn);
2782              insn = next_insn (insn))
2783           continue;
2784       else
2785         {
2786           if (NONJUMP_INSN_P (insn)
2787               && GET_CODE (PATTERN (insn)) == SEQUENCE)
2788             insn = XVECEXP (PATTERN (insn), 0, 0);
2789         }
2790     }
2791
2792   return insn;
2793 }
2794
2795 /* Return the last nonnote insn emitted in current sequence or current
2796    function.  This routine looks inside SEQUENCEs.  */
2797
2798 rtx
2799 get_last_nonnote_insn (void)
2800 {
2801   rtx insn = last_insn;
2802
2803   if (insn)
2804     {
2805       if (NOTE_P (insn))
2806         for (insn = previous_insn (insn);
2807              insn && NOTE_P (insn);
2808              insn = previous_insn (insn))
2809           continue;
2810       else
2811         {
2812           if (NONJUMP_INSN_P (insn)
2813               && GET_CODE (PATTERN (insn)) == SEQUENCE)
2814             insn = XVECEXP (PATTERN (insn), 0,
2815                             XVECLEN (PATTERN (insn), 0) - 1);
2816         }
2817     }
2818
2819   return insn;
2820 }
2821
2822 /* Return a number larger than any instruction's uid in this function.  */
2823
2824 int
2825 get_max_uid (void)
2826 {
2827   return cur_insn_uid;
2828 }
2829 \f
2830 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2831    of the sequence.  */
2832
2833 rtx
2834 next_insn (rtx insn)
2835 {
2836   if (insn)
2837     {
2838       insn = NEXT_INSN (insn);
2839       if (insn && NONJUMP_INSN_P (insn)
2840           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2841         insn = XVECEXP (PATTERN (insn), 0, 0);
2842     }
2843
2844   return insn;
2845 }
2846
2847 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2848    of the sequence.  */
2849
2850 rtx
2851 previous_insn (rtx insn)
2852 {
2853   if (insn)
2854     {
2855       insn = PREV_INSN (insn);
2856       if (insn && NONJUMP_INSN_P (insn)
2857           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2858         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2859     }
2860
2861   return insn;
2862 }
2863
2864 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2865    look inside SEQUENCEs.  */
2866
2867 rtx
2868 next_nonnote_insn (rtx insn)
2869 {
2870   while (insn)
2871     {
2872       insn = NEXT_INSN (insn);
2873       if (insn == 0 || !NOTE_P (insn))
2874         break;
2875     }
2876
2877   return insn;
2878 }
2879
2880 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2881    not look inside SEQUENCEs.  */
2882
2883 rtx
2884 prev_nonnote_insn (rtx insn)
2885 {
2886   while (insn)
2887     {
2888       insn = PREV_INSN (insn);
2889       if (insn == 0 || !NOTE_P (insn))
2890         break;
2891     }
2892
2893   return insn;
2894 }
2895
2896 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2897    or 0, if there is none.  This routine does not look inside
2898    SEQUENCEs.  */
2899
2900 rtx
2901 next_real_insn (rtx insn)
2902 {
2903   while (insn)
2904     {
2905       insn = NEXT_INSN (insn);
2906       if (insn == 0 || INSN_P (insn))
2907         break;
2908     }
2909
2910   return insn;
2911 }
2912
2913 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
2914    or 0, if there is none.  This routine does not look inside
2915    SEQUENCEs.  */
2916
2917 rtx
2918 prev_real_insn (rtx insn)
2919 {
2920   while (insn)
2921     {
2922       insn = PREV_INSN (insn);
2923       if (insn == 0 || INSN_P (insn))
2924         break;
2925     }
2926
2927   return insn;
2928 }
2929
2930 /* Return the last CALL_INSN in the current list, or 0 if there is none.
2931    This routine does not look inside SEQUENCEs.  */
2932
2933 rtx
2934 last_call_insn (void)
2935 {
2936   rtx insn;
2937
2938   for (insn = get_last_insn ();
2939        insn && !CALL_P (insn);
2940        insn = PREV_INSN (insn))
2941     ;
2942
2943   return insn;
2944 }
2945
2946 /* Find the next insn after INSN that really does something.  This routine
2947    does not look inside SEQUENCEs.  Until reload has completed, this is the
2948    same as next_real_insn.  */
2949
2950 int
2951 active_insn_p (const_rtx insn)
2952 {
2953   return (CALL_P (insn) || JUMP_P (insn)
2954           || (NONJUMP_INSN_P (insn)
2955               && (! reload_completed
2956                   || (GET_CODE (PATTERN (insn)) != USE
2957                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
2958 }
2959
2960 rtx
2961 next_active_insn (rtx insn)
2962 {
2963   while (insn)
2964     {
2965       insn = NEXT_INSN (insn);
2966       if (insn == 0 || active_insn_p (insn))
2967         break;
2968     }
2969
2970   return insn;
2971 }
2972
2973 /* Find the last insn before INSN that really does something.  This routine
2974    does not look inside SEQUENCEs.  Until reload has completed, this is the
2975    same as prev_real_insn.  */
2976
2977 rtx
2978 prev_active_insn (rtx insn)
2979 {
2980   while (insn)
2981     {
2982       insn = PREV_INSN (insn);
2983       if (insn == 0 || active_insn_p (insn))
2984         break;
2985     }
2986
2987   return insn;
2988 }
2989
2990 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
2991
2992 rtx
2993 next_label (rtx insn)
2994 {
2995   while (insn)
2996     {
2997       insn = NEXT_INSN (insn);
2998       if (insn == 0 || LABEL_P (insn))
2999         break;
3000     }
3001
3002   return insn;
3003 }
3004
3005 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
3006
3007 rtx
3008 prev_label (rtx insn)
3009 {
3010   while (insn)
3011     {
3012       insn = PREV_INSN (insn);
3013       if (insn == 0 || LABEL_P (insn))
3014         break;
3015     }
3016
3017   return insn;
3018 }
3019
3020 /* Return the last label to mark the same position as LABEL.  Return null
3021    if LABEL itself is null.  */
3022
3023 rtx
3024 skip_consecutive_labels (rtx label)
3025 {
3026   rtx insn;
3027
3028   for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
3029     if (LABEL_P (insn))
3030       label = insn;
3031
3032   return label;
3033 }
3034 \f
3035 #ifdef HAVE_cc0
3036 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
3037    and REG_CC_USER notes so we can find it.  */
3038
3039 void
3040 link_cc0_insns (rtx insn)
3041 {
3042   rtx user = next_nonnote_insn (insn);
3043
3044   if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
3045     user = XVECEXP (PATTERN (user), 0, 0);
3046
3047   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
3048                                         REG_NOTES (user));
3049   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
3050 }
3051
3052 /* Return the next insn that uses CC0 after INSN, which is assumed to
3053    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
3054    applied to the result of this function should yield INSN).
3055
3056    Normally, this is simply the next insn.  However, if a REG_CC_USER note
3057    is present, it contains the insn that uses CC0.
3058
3059    Return 0 if we can't find the insn.  */
3060
3061 rtx
3062 next_cc0_user (rtx insn)
3063 {
3064   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
3065
3066   if (note)
3067     return XEXP (note, 0);
3068
3069   insn = next_nonnote_insn (insn);
3070   if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
3071     insn = XVECEXP (PATTERN (insn), 0, 0);
3072
3073   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
3074     return insn;
3075
3076   return 0;
3077 }
3078
3079 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
3080    note, it is the previous insn.  */
3081
3082 rtx
3083 prev_cc0_setter (rtx insn)
3084 {
3085   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
3086
3087   if (note)
3088     return XEXP (note, 0);
3089
3090   insn = prev_nonnote_insn (insn);
3091   gcc_assert (sets_cc0_p (PATTERN (insn)));
3092
3093   return insn;
3094 }
3095 #endif
3096
3097 #ifdef AUTO_INC_DEC
3098 /* Find a RTX_AUTOINC class rtx which matches DATA.  */
3099
3100 static int
3101 find_auto_inc (rtx *xp, void *data)
3102 {
3103   rtx x = *xp;
3104   rtx reg = (rtx) data;
3105
3106   if (GET_RTX_CLASS (GET_CODE (x)) != RTX_AUTOINC)
3107     return 0;
3108
3109   switch (GET_CODE (x))
3110     {
3111       case PRE_DEC:
3112       case PRE_INC:
3113       case POST_DEC:
3114       case POST_INC:
3115       case PRE_MODIFY:
3116       case POST_MODIFY:
3117         if (rtx_equal_p (reg, XEXP (x, 0)))
3118           return 1;
3119         break;
3120
3121       default:
3122         gcc_unreachable ();
3123     }
3124   return -1;
3125 }
3126 #endif
3127
3128 /* Increment the label uses for all labels present in rtx.  */
3129
3130 static void
3131 mark_label_nuses (rtx x)
3132 {
3133   enum rtx_code code;
3134   int i, j;
3135   const char *fmt;
3136
3137   code = GET_CODE (x);
3138   if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
3139     LABEL_NUSES (XEXP (x, 0))++;
3140
3141   fmt = GET_RTX_FORMAT (code);
3142   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3143     {
3144       if (fmt[i] == 'e')
3145         mark_label_nuses (XEXP (x, i));
3146       else if (fmt[i] == 'E')
3147         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3148           mark_label_nuses (XVECEXP (x, i, j));
3149     }
3150 }
3151
3152 \f
3153 /* Try splitting insns that can be split for better scheduling.
3154    PAT is the pattern which might split.
3155    TRIAL is the insn providing PAT.
3156    LAST is nonzero if we should return the last insn of the sequence produced.
3157
3158    If this routine succeeds in splitting, it returns the first or last
3159    replacement insn depending on the value of LAST.  Otherwise, it
3160    returns TRIAL.  If the insn to be returned can be split, it will be.  */
3161
3162 rtx
3163 try_split (rtx pat, rtx trial, int last)
3164 {
3165   rtx before = PREV_INSN (trial);
3166   rtx after = NEXT_INSN (trial);
3167   int has_barrier = 0;
3168   rtx note, seq, tem;
3169   int probability;
3170   rtx insn_last, insn;
3171   int njumps = 0;
3172
3173   if (any_condjump_p (trial)
3174       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
3175     split_branch_probability = INTVAL (XEXP (note, 0));
3176   probability = split_branch_probability;
3177
3178   seq = split_insns (pat, trial);
3179
3180   split_branch_probability = -1;
3181
3182   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
3183      We may need to handle this specially.  */
3184   if (after && BARRIER_P (after))
3185     {
3186       has_barrier = 1;
3187       after = NEXT_INSN (after);
3188     }
3189
3190   if (!seq)
3191     return trial;
3192
3193   /* Avoid infinite loop if any insn of the result matches
3194      the original pattern.  */
3195   insn_last = seq;
3196   while (1)
3197     {
3198       if (INSN_P (insn_last)
3199           && rtx_equal_p (PATTERN (insn_last), pat))
3200         return trial;
3201       if (!NEXT_INSN (insn_last))
3202         break;
3203       insn_last = NEXT_INSN (insn_last);
3204     }
3205
3206   /* We will be adding the new sequence to the function.  The splitters
3207      may have introduced invalid RTL sharing, so unshare the sequence now.  */
3208   unshare_all_rtl_in_chain (seq);
3209
3210   /* Mark labels.  */
3211   for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3212     {
3213       if (JUMP_P (insn))
3214         {
3215           mark_jump_label (PATTERN (insn), insn, 0);
3216           njumps++;
3217           if (probability != -1
3218               && any_condjump_p (insn)
3219               && !find_reg_note (insn, REG_BR_PROB, 0))
3220             {
3221               /* We can preserve the REG_BR_PROB notes only if exactly
3222                  one jump is created, otherwise the machine description
3223                  is responsible for this step using
3224                  split_branch_probability variable.  */
3225               gcc_assert (njumps == 1);
3226               REG_NOTES (insn)
3227                 = gen_rtx_EXPR_LIST (REG_BR_PROB,
3228                                      GEN_INT (probability),
3229                                      REG_NOTES (insn));
3230             }
3231         }
3232     }
3233
3234   /* If we are splitting a CALL_INSN, look for the CALL_INSN
3235      in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3236   if (CALL_P (trial))
3237     {
3238       for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3239         if (CALL_P (insn))
3240           {
3241             rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
3242             while (*p)
3243               p = &XEXP (*p, 1);
3244             *p = CALL_INSN_FUNCTION_USAGE (trial);
3245             SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
3246           }
3247     }
3248
3249   /* Copy notes, particularly those related to the CFG.  */
3250   for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
3251     {
3252       switch (REG_NOTE_KIND (note))
3253         {
3254         case REG_EH_REGION:
3255           for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
3256             {
3257               if (CALL_P (insn)
3258                   || (flag_non_call_exceptions && INSN_P (insn)
3259                       && may_trap_p (PATTERN (insn))))
3260                 REG_NOTES (insn)
3261                   = gen_rtx_EXPR_LIST (REG_EH_REGION,
3262                                        XEXP (note, 0),
3263                                        REG_NOTES (insn));
3264             }
3265           break;
3266
3267         case REG_NORETURN:
3268         case REG_SETJMP:
3269           for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
3270             {
3271               if (CALL_P (insn))
3272                 REG_NOTES (insn)
3273                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3274                                        XEXP (note, 0),
3275                                        REG_NOTES (insn));
3276             }
3277           break;
3278
3279         case REG_NON_LOCAL_GOTO:
3280           for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
3281             {
3282               if (JUMP_P (insn))
3283                 REG_NOTES (insn)
3284                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3285                                        XEXP (note, 0),
3286                                        REG_NOTES (insn));
3287             }
3288           break;
3289
3290 #ifdef AUTO_INC_DEC
3291         case REG_INC:
3292           for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
3293             {
3294               rtx reg = XEXP (note, 0);
3295               if (!FIND_REG_INC_NOTE (insn, reg)
3296                   && for_each_rtx (&PATTERN (insn), find_auto_inc, reg) > 0)
3297                 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_INC, reg,
3298                                                       REG_NOTES (insn));
3299             }
3300           break;
3301 #endif
3302
3303         default:
3304           break;
3305         }
3306     }
3307
3308   /* If there are LABELS inside the split insns increment the
3309      usage count so we don't delete the label.  */
3310   if (INSN_P (trial))
3311     {
3312       insn = insn_last;
3313       while (insn != NULL_RTX)
3314         {
3315           /* JUMP_P insns have already been "marked" above.  */
3316           if (NONJUMP_INSN_P (insn))
3317             mark_label_nuses (PATTERN (insn));
3318
3319           insn = PREV_INSN (insn);
3320         }
3321     }
3322
3323   tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));
3324
3325   delete_insn (trial);
3326   if (has_barrier)
3327     emit_barrier_after (tem);
3328
3329   /* Recursively call try_split for each new insn created; by the
3330      time control returns here that insn will be fully split, so
3331      set LAST and continue from the insn after the one returned.
3332      We can't use next_active_insn here since AFTER may be a note.
3333      Ignore deleted insns, which can be occur if not optimizing.  */
3334   for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3335     if (! INSN_DELETED_P (tem) && INSN_P (tem))
3336       tem = try_split (PATTERN (tem), tem, 1);
3337
3338   /* Return either the first or the last insn, depending on which was
3339      requested.  */
3340   return last
3341     ? (after ? PREV_INSN (after) : last_insn)
3342     : NEXT_INSN (before);
3343 }
3344 \f
3345 /* Make and return an INSN rtx, initializing all its slots.
3346    Store PATTERN in the pattern slots.  */
3347
3348 rtx
3349 make_insn_raw (rtx pattern)
3350 {
3351   rtx insn;
3352
3353   insn = rtx_alloc (INSN);
3354
3355   INSN_UID (insn) = cur_insn_uid++;
3356   PATTERN (insn) = pattern;
3357   INSN_CODE (insn) = -1;
3358   REG_NOTES (insn) = NULL;
3359   INSN_LOCATOR (insn) = curr_insn_locator ();
3360   BLOCK_FOR_INSN (insn) = NULL;
3361
3362 #ifdef ENABLE_RTL_CHECKING
3363   if (insn
3364       && INSN_P (insn)
3365       && (returnjump_p (insn)
3366           || (GET_CODE (insn) == SET
3367               && SET_DEST (insn) == pc_rtx)))
3368     {
3369       warning (0, "ICE: emit_insn used where emit_jump_insn needed:\n");
3370       debug_rtx (insn);
3371     }
3372 #endif
3373
3374   return insn;
3375 }
3376
3377 /* Like `make_insn_raw' but make a JUMP_INSN instead of an insn.  */
3378
3379 rtx
3380 make_jump_insn_raw (rtx pattern)
3381 {
3382   rtx insn;
3383
3384   insn = rtx_alloc (JUMP_INSN);
3385   INSN_UID (insn) = cur_insn_uid++;
3386
3387   PATTERN (insn) = pattern;
3388   INSN_CODE (insn) = -1;
3389   REG_NOTES (insn) = NULL;
3390   JUMP_LABEL (insn) = NULL;
3391   INSN_LOCATOR (insn) = curr_insn_locator ();
3392   BLOCK_FOR_INSN (insn) = NULL;
3393
3394   return insn;
3395 }
3396
3397 /* Like `make_insn_raw' but make a CALL_INSN instead of an insn.  */
3398
3399 static rtx
3400 make_call_insn_raw (rtx pattern)
3401 {
3402   rtx insn;
3403
3404   insn = rtx_alloc (CALL_INSN);
3405   INSN_UID (insn) = cur_insn_uid++;
3406
3407   PATTERN (insn) = pattern;
3408   INSN_CODE (insn) = -1;
3409   REG_NOTES (insn) = NULL;
3410   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3411   INSN_LOCATOR (insn) = curr_insn_locator ();
3412   BLOCK_FOR_INSN (insn) = NULL;
3413
3414   return insn;
3415 }
3416 \f
3417 /* Add INSN to the end of the doubly-linked list.
3418    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3419
3420 void
3421 add_insn (rtx insn)
3422 {
3423   PREV_INSN (insn) = last_insn;
3424   NEXT_INSN (insn) = 0;
3425
3426   if (NULL != last_insn)
3427     NEXT_INSN (last_insn) = insn;
3428
3429   if (NULL == first_insn)
3430     first_insn = insn;
3431
3432   last_insn = insn;
3433 }
3434
3435 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3436    the next should be the only functions called to insert an insn once
3437    delay slots have been filled since only they know how to update a
3438    SEQUENCE.  */
3439
3440 void
3441 add_insn_after (rtx insn, rtx after, basic_block bb)
3442 {
3443   rtx next = NEXT_INSN (after);
3444
3445   gcc_assert (!optimize || !INSN_DELETED_P (after));
3446
3447   NEXT_INSN (insn) = next;
3448   PREV_INSN (insn) = after;
3449
3450   if (next)
3451     {
3452       PREV_INSN (next) = insn;
3453       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3454         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3455     }
3456   else if (last_insn == after)
3457     last_insn = insn;
3458   else
3459     {
3460       struct sequence_stack *stack = seq_stack;
3461       /* Scan all pending sequences too.  */
3462       for (; stack; stack = stack->next)
3463         if (after == stack->last)
3464           {
3465             stack->last = insn;
3466             break;
3467           }
3468
3469       gcc_assert (stack);
3470     }
3471
3472   if (!BARRIER_P (after)
3473       && !BARRIER_P (insn)
3474       && (bb = BLOCK_FOR_INSN (after)))
3475     {
3476       set_block_for_insn (insn, bb);
3477       if (INSN_P (insn))
3478         df_insn_rescan (insn);
3479       /* Should not happen as first in the BB is always
3480          either NOTE or LABEL.  */
3481       if (BB_END (bb) == after
3482           /* Avoid clobbering of structure when creating new BB.  */
3483           && !BARRIER_P (insn)
3484           && !NOTE_INSN_BASIC_BLOCK_P (insn))
3485         BB_END (bb) = insn;
3486     }
3487
3488   NEXT_INSN (after) = insn;
3489   if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
3490     {
3491       rtx sequence = PATTERN (after);
3492       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3493     }
3494 }
3495
3496 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3497    the previous should be the only functions called to insert an insn
3498    once delay slots have been filled since only they know how to
3499    update a SEQUENCE.  If BB is NULL, an attempt is made to infer the
3500    bb from before.  */
3501
3502 void
3503 add_insn_before (rtx insn, rtx before, basic_block bb)
3504 {
3505   rtx prev = PREV_INSN (before);
3506
3507   gcc_assert (!optimize || !INSN_DELETED_P (before));
3508
3509   PREV_INSN (insn) = prev;
3510   NEXT_INSN (insn) = before;
3511
3512   if (prev)
3513     {
3514       NEXT_INSN (prev) = insn;
3515       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3516         {
3517           rtx sequence = PATTERN (prev);
3518           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3519         }
3520     }
3521   else if (first_insn == before)
3522     first_insn = insn;
3523   else
3524     {
3525       struct sequence_stack *stack = seq_stack;
3526       /* Scan all pending sequences too.  */
3527       for (; stack; stack = stack->next)
3528         if (before == stack->first)
3529           {
3530             stack->first = insn;
3531             break;
3532           }
3533
3534       gcc_assert (stack);
3535     }
3536
3537   if (!bb 
3538       && !BARRIER_P (before)
3539       && !BARRIER_P (insn))
3540     bb = BLOCK_FOR_INSN (before);
3541
3542   if (bb)
3543     {
3544       set_block_for_insn (insn, bb);
3545       if (INSN_P (insn))
3546         df_insn_rescan (insn);
3547       /* Should not happen as first in the BB is always either NOTE or
3548          LABEL.  */
3549       gcc_assert (BB_HEAD (bb) != insn
3550                   /* Avoid clobbering of structure when creating new BB.  */
3551                   || BARRIER_P (insn)
3552                   || NOTE_INSN_BASIC_BLOCK_P (insn));
3553     }
3554
3555   PREV_INSN (before) = insn;
3556   if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
3557     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3558 }
3559
3560
3561 /* Replace insn with an deleted instruction note.  */
3562
3563 void set_insn_deleted (rtx insn)
3564 {
3565   df_insn_delete (BLOCK_FOR_INSN (insn), INSN_UID (insn));
3566   PUT_CODE (insn, NOTE);
3567   NOTE_KIND (insn) = NOTE_INSN_DELETED;
3568 }
3569
3570
3571 /* Remove an insn from its doubly-linked list.  This function knows how
3572    to handle sequences.  */
3573 void
3574 remove_insn (rtx insn)
3575 {
3576   rtx next = NEXT_INSN (insn);
3577   rtx prev = PREV_INSN (insn);
3578   basic_block bb;
3579
3580   /* Later in the code, the block will be marked dirty.  */
3581   df_insn_delete (NULL, INSN_UID (insn));
3582
3583   if (prev)
3584     {
3585       NEXT_INSN (prev) = next;
3586       if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
3587         {
3588           rtx sequence = PATTERN (prev);
3589           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3590         }
3591     }
3592   else if (first_insn == insn)
3593     first_insn = next;
3594   else
3595     {
3596       struct sequence_stack *stack = seq_stack;
3597       /* Scan all pending sequences too.  */
3598       for (; stack; stack = stack->next)
3599         if (insn == stack->first)
3600           {
3601             stack->first = next;
3602             break;
3603           }
3604
3605       gcc_assert (stack);
3606     }
3607
3608   if (next)
3609     {
3610       PREV_INSN (next) = prev;
3611       if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
3612         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3613     }
3614   else if (last_insn == insn)
3615     last_insn = prev;
3616   else
3617     {
3618       struct sequence_stack *stack = seq_stack;
3619       /* Scan all pending sequences too.  */
3620       for (; stack; stack = stack->next)
3621         if (insn == stack->last)
3622           {
3623             stack->last = prev;
3624             break;
3625           }
3626
3627       gcc_assert (stack);
3628     }
3629   if (!BARRIER_P (insn)
3630       && (bb = BLOCK_FOR_INSN (insn)))
3631     {
3632       if (INSN_P (insn))
3633         df_set_bb_dirty (bb);
3634       if (BB_HEAD (bb) == insn)
3635         {
3636           /* Never ever delete the basic block note without deleting whole
3637              basic block.  */
3638           gcc_assert (!NOTE_P (insn));
3639           BB_HEAD (bb) = next;
3640         }
3641       if (BB_END (bb) == insn)
3642         BB_END (bb) = prev;
3643     }
3644 }
3645
3646 /* Append CALL_FUSAGE to the CALL_INSN_FUNCTION_USAGE for CALL_INSN.  */
3647
3648 void
3649 add_function_usage_to (rtx call_insn, rtx call_fusage)
3650 {
3651   gcc_assert (call_insn && CALL_P (call_insn));
3652
3653   /* Put the register usage information on the CALL.  If there is already
3654      some usage information, put ours at the end.  */
3655   if (CALL_INSN_FUNCTION_USAGE (call_insn))
3656     {
3657       rtx link;
3658
3659       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
3660            link = XEXP (link, 1))
3661         ;
3662
3663       XEXP (link, 1) = call_fusage;
3664     }
3665   else
3666     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
3667 }
3668
3669 /* Delete all insns made since FROM.
3670    FROM becomes the new last instruction.  */
3671
3672 void
3673 delete_insns_since (rtx from)
3674 {
3675   if (from == 0)
3676     first_insn = 0;
3677   else
3678     NEXT_INSN (from) = 0;
3679   last_insn = from;
3680 }
3681
3682 /* This function is deprecated, please use sequences instead.
3683
3684    Move a consecutive bunch of insns to a different place in the chain.
3685    The insns to be moved are those between FROM and TO.
3686    They are moved to a new position after the insn AFTER.
3687    AFTER must not be FROM or TO or any insn in between.
3688
3689    This function does not know about SEQUENCEs and hence should not be
3690    called after delay-slot filling has been done.  */
3691
3692 void
3693 reorder_insns_nobb (rtx from, rtx to, rtx after)
3694 {
3695   /* Splice this bunch out of where it is now.  */
3696   if (PREV_INSN (from))
3697     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
3698   if (NEXT_INSN (to))
3699     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
3700   if (last_insn == to)
3701     last_insn = PREV_INSN (from);
3702   if (first_insn == from)
3703     first_insn = NEXT_INSN (to);
3704
3705   /* Make the new neighbors point to it and it to them.  */
3706   if (NEXT_INSN (after))
3707     PREV_INSN (NEXT_INSN (after)) = to;
3708
3709   NEXT_INSN (to) = NEXT_INSN (after);
3710   PREV_INSN (from) = after;
3711   NEXT_INSN (after) = from;
3712   if (after == last_insn)
3713     last_insn = to;
3714 }
3715
3716 /* Same as function above, but take care to update BB boundaries.  */
3717 void
3718 reorder_insns (rtx from, rtx to, rtx after)
3719 {
3720   rtx prev = PREV_INSN (from);
3721   basic_block bb, bb2;
3722
3723   reorder_insns_nobb (from, to, after);
3724
3725   if (!BARRIER_P (after)
3726       && (bb = BLOCK_FOR_INSN (after)))
3727     {
3728       rtx x;
3729       df_set_bb_dirty (bb);
3730
3731       if (!BARRIER_P (from)
3732           && (bb2 = BLOCK_FOR_INSN (from)))
3733         {
3734           if (BB_END (bb2) == to)
3735             BB_END (bb2) = prev;
3736           df_set_bb_dirty (bb2);
3737         }
3738
3739       if (BB_END (bb) == after)
3740         BB_END (bb) = to;
3741
3742       for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
3743         if (!BARRIER_P (x))
3744           df_insn_change_bb (x, bb);
3745     }
3746 }
3747
3748 \f
3749 /* Emit insn(s) of given code and pattern
3750    at a specified place within the doubly-linked list.
3751
3752    All of the emit_foo global entry points accept an object
3753    X which is either an insn list or a PATTERN of a single
3754    instruction.
3755
3756    There are thus a few canonical ways to generate code and
3757    emit it at a specific place in the instruction stream.  For
3758    example, consider the instruction named SPOT and the fact that
3759    we would like to emit some instructions before SPOT.  We might
3760    do it like this:
3761
3762         start_sequence ();
3763         ... emit the new instructions ...
3764         insns_head = get_insns ();
3765         end_sequence ();
3766
3767         emit_insn_before (insns_head, SPOT);
3768
3769    It used to be common to generate SEQUENCE rtl instead, but that
3770    is a relic of the past which no longer occurs.  The reason is that
3771    SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
3772    generated would almost certainly die right after it was created.  */
3773
3774 /* Make X be output before the instruction BEFORE.  */
3775
3776 rtx
3777 emit_insn_before_noloc (rtx x, rtx before, basic_block bb)
3778 {
3779   rtx last = before;
3780   rtx insn;
3781
3782   gcc_assert (before);
3783
3784   if (x == NULL_RTX)
3785     return last;
3786
3787   switch (GET_CODE (x))
3788     {
3789     case INSN:
3790     case JUMP_INSN:
3791     case CALL_INSN:
3792     case CODE_LABEL:
3793     case BARRIER:
3794     case NOTE:
3795       insn = x;
3796       while (insn)
3797         {
3798           rtx next = NEXT_INSN (insn);
3799           add_insn_before (insn, before, bb);
3800           last = insn;
3801           insn = next;
3802         }
3803       break;
3804
3805 #ifdef ENABLE_RTL_CHECKING
3806     case SEQUENCE:
3807       gcc_unreachable ();
3808       break;
3809 #endif
3810
3811     default:
3812       last = make_insn_raw (x);
3813       add_insn_before (last, before, bb);
3814       break;
3815     }
3816
3817   return last;
3818 }
3819
3820 /* Make an instruction with body X and code JUMP_INSN
3821    and output it before the instruction BEFORE.  */
3822
3823 rtx
3824 emit_jump_insn_before_noloc (rtx x, rtx before)
3825 {
3826   rtx insn, last = NULL_RTX;
3827
3828   gcc_assert (before);
3829
3830   switch (GET_CODE (x))
3831     {
3832     case INSN:
3833     case JUMP_INSN:
3834     case CALL_INSN:
3835     case CODE_LABEL:
3836     case BARRIER:
3837     case NOTE:
3838       insn = x;
3839       while (insn)
3840         {
3841           rtx next = NEXT_INSN (insn);
3842           add_insn_before (insn, before, NULL);
3843           last = insn;
3844           insn = next;
3845         }
3846       break;
3847
3848 #ifdef ENABLE_RTL_CHECKING
3849     case SEQUENCE:
3850       gcc_unreachable ();
3851       break;
3852 #endif
3853
3854     default:
3855       last = make_jump_insn_raw (x);
3856       add_insn_before (last, before, NULL);
3857       break;
3858     }
3859
3860   return last;
3861 }
3862
3863 /* Make an instruction with body X and code CALL_INSN
3864    and output it before the instruction BEFORE.  */
3865
3866 rtx
3867 emit_call_insn_before_noloc (rtx x, rtx before)
3868 {
3869   rtx last = NULL_RTX, insn;
3870
3871   gcc_assert (before);
3872
3873   switch (GET_CODE (x))
3874     {
3875     case INSN:
3876     case JUMP_INSN:
3877     case CALL_INSN:
3878     case CODE_LABEL:
3879     case BARRIER:
3880     case NOTE:
3881       insn = x;
3882       while (insn)
3883         {
3884           rtx next = NEXT_INSN (insn);
3885           add_insn_before (insn, before, NULL);
3886           last = insn;
3887           insn = next;
3888         }
3889       break;
3890
3891 #ifdef ENABLE_RTL_CHECKING
3892     case SEQUENCE:
3893       gcc_unreachable ();
3894       break;
3895 #endif
3896
3897     default:
3898       last = make_call_insn_raw (x);
3899       add_insn_before (last, before, NULL);
3900       break;
3901     }
3902
3903   return last;
3904 }
3905
3906 /* Make an insn of code BARRIER
3907    and output it before the insn BEFORE.  */
3908
3909 rtx
3910 emit_barrier_before (rtx before)
3911 {
3912   rtx insn = rtx_alloc (BARRIER);
3913
3914   INSN_UID (insn) = cur_insn_uid++;
3915
3916   add_insn_before (insn, before, NULL);
3917   return insn;
3918 }
3919
3920 /* Emit the label LABEL before the insn BEFORE.  */
3921
3922 rtx
3923 emit_label_before (rtx label, rtx before)
3924 {
3925   /* This can be called twice for the same label as a result of the
3926      confusion that follows a syntax error!  So make it harmless.  */
3927   if (INSN_UID (label) == 0)
3928     {
3929       INSN_UID (label) = cur_insn_uid++;
3930       add_insn_before (label, before, NULL);
3931     }
3932
3933   return label;
3934 }
3935
3936 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
3937
3938 rtx
3939 emit_note_before (enum insn_note subtype, rtx before)
3940 {
3941   rtx note = rtx_alloc (NOTE);
3942   INSN_UID (note) = cur_insn_uid++;
3943   NOTE_KIND (note) = subtype;
3944   BLOCK_FOR_INSN (note) = NULL;
3945   memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
3946
3947   add_insn_before (note, before, NULL);
3948   return note;
3949 }
3950 \f
3951 /* Helper for emit_insn_after, handles lists of instructions
3952    efficiently.  */
3953
3954 static rtx
3955 emit_insn_after_1 (rtx first, rtx after, basic_block bb)
3956 {
3957   rtx last;
3958   rtx after_after;
3959   if (!bb && !BARRIER_P (after))
3960     bb = BLOCK_FOR_INSN (after);
3961
3962   if (bb)
3963     {
3964       df_set_bb_dirty (bb);
3965       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
3966         if (!BARRIER_P (last))
3967           {
3968             set_block_for_insn (last, bb);
3969             df_insn_rescan (last);
3970           }
3971       if (!BARRIER_P (last))
3972         {
3973           set_block_for_insn (last, bb);
3974           df_insn_rescan (last);
3975         }
3976       if (BB_END (bb) == after)
3977         BB_END (bb) = last;
3978     }
3979   else
3980     for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
3981       continue;
3982
3983   after_after = NEXT_INSN (after);
3984
3985   NEXT_INSN (after) = first;
3986   PREV_INSN (first) = after;
3987   NEXT_INSN (last) = after_after;
3988   if (after_after)
3989     PREV_INSN (after_after) = last;
3990
3991   if (after == last_insn)
3992     last_insn = last;
3993   return last;
3994 }
3995
3996 /* Make X be output after the insn AFTER and set the BB of insn.  If
3997    BB is NULL, an attempt is made to infer the BB from AFTER.  */
3998
3999 rtx
4000 emit_insn_after_noloc (rtx x, rtx after, basic_block bb)
4001 {
4002   rtx last = after;
4003
4004   gcc_assert (after);
4005
4006   if (x == NULL_RTX)
4007     return last;
4008
4009   switch (GET_CODE (x))
4010     {
4011     case INSN:
4012     case JUMP_INSN:
4013     case CALL_INSN:
4014     case CODE_LABEL:
4015     case BARRIER:
4016     case NOTE:
4017       last = emit_insn_after_1 (x, after, bb);
4018       break;
4019
4020 #ifdef ENABLE_RTL_CHECKING
4021     case SEQUENCE:
4022       gcc_unreachable ();
4023       break;
4024 #endif
4025
4026     default:
4027       last = make_insn_raw (x);
4028       add_insn_after (last, after, bb);
4029       break;
4030     }
4031
4032   return last;
4033 }
4034
4035
4036 /* Make an insn of code JUMP_INSN with body X
4037    and output it after the insn AFTER.  */
4038
4039 rtx
4040 emit_jump_insn_after_noloc (rtx x, rtx after)
4041 {
4042   rtx last;
4043
4044   gcc_assert (after);
4045
4046   switch (GET_CODE (x))
4047     {
4048     case INSN:
4049     case JUMP_INSN:
4050     case CALL_INSN:
4051     case CODE_LABEL:
4052     case BARRIER:
4053     case NOTE:
4054       last = emit_insn_after_1 (x, after, NULL);
4055       break;
4056
4057 #ifdef ENABLE_RTL_CHECKING
4058     case SEQUENCE:
4059       gcc_unreachable ();
4060       break;
4061 #endif
4062
4063     default:
4064       last = make_jump_insn_raw (x);
4065       add_insn_after (last, after, NULL);
4066       break;
4067     }
4068
4069   return last;
4070 }
4071
4072 /* Make an instruction with body X and code CALL_INSN
4073    and output it after the instruction AFTER.  */
4074
4075 rtx
4076 emit_call_insn_after_noloc (rtx x, rtx after)
4077 {
4078   rtx last;
4079
4080   gcc_assert (after);
4081
4082   switch (GET_CODE (x))
4083     {
4084     case INSN:
4085     case JUMP_INSN:
4086     case CALL_INSN:
4087     case CODE_LABEL:
4088     case BARRIER:
4089     case NOTE:
4090       last = emit_insn_after_1 (x, after, NULL);
4091       break;
4092
4093 #ifdef ENABLE_RTL_CHECKING
4094     case SEQUENCE:
4095       gcc_unreachable ();
4096       break;
4097 #endif
4098
4099     default:
4100       last = make_call_insn_raw (x);
4101       add_insn_after (last, after, NULL);
4102       break;
4103     }
4104
4105   return last;
4106 }
4107
4108 /* Make an insn of code BARRIER
4109    and output it after the insn AFTER.  */
4110
4111 rtx
4112 emit_barrier_after (rtx after)
4113 {
4114   rtx insn = rtx_alloc (BARRIER);
4115
4116   INSN_UID (insn) = cur_insn_uid++;
4117
4118   add_insn_after (insn, after, NULL);
4119   return insn;
4120 }
4121
4122 /* Emit the label LABEL after the insn AFTER.  */
4123
4124 rtx
4125 emit_label_after (rtx label, rtx after)
4126 {
4127   /* This can be called twice for the same label
4128      as a result of the confusion that follows a syntax error!
4129      So make it harmless.  */
4130   if (INSN_UID (label) == 0)
4131     {
4132       INSN_UID (label) = cur_insn_uid++;
4133       add_insn_after (label, after, NULL);
4134     }
4135
4136   return label;
4137 }
4138
4139 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
4140
4141 rtx
4142 emit_note_after (enum insn_note subtype, rtx after)
4143 {
4144   rtx note = rtx_alloc (NOTE);
4145   INSN_UID (note) = cur_insn_uid++;
4146   NOTE_KIND (note) = subtype;
4147   BLOCK_FOR_INSN (note) = NULL;
4148   memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
4149   add_insn_after (note, after, NULL);
4150   return note;
4151 }
4152 \f
4153 /* Like emit_insn_after_noloc, but set INSN_LOCATOR according to SCOPE.  */
4154 rtx
4155 emit_insn_after_setloc (rtx pattern, rtx after, int loc)
4156 {
4157   rtx last = emit_insn_after_noloc (pattern, after, NULL);
4158
4159   if (pattern == NULL_RTX || !loc)
4160     return last;
4161
4162   after = NEXT_INSN (after);
4163   while (1)
4164     {
4165       if (active_insn_p (after) && !INSN_LOCATOR (after))
4166         INSN_LOCATOR (after) = loc;
4167       if (after == last)
4168         break;
4169       after = NEXT_INSN (after);
4170     }
4171   return last;
4172 }
4173
4174 /* Like emit_insn_after_noloc, but set INSN_LOCATOR according to AFTER.  */
4175 rtx
4176 emit_insn_after (rtx pattern, rtx after)
4177 {
4178   if (INSN_P (after))
4179     return emit_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4180   else
4181     return emit_insn_after_noloc (pattern, after, NULL);
4182 }
4183
4184 /* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to SCOPE.  */
4185 rtx
4186 emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc)
4187 {
4188   rtx last = emit_jump_insn_after_noloc (pattern, after);
4189
4190   if (pattern == NULL_RTX || !loc)
4191     return last;
4192
4193   after = NEXT_INSN (after);
4194   while (1)
4195     {
4196       if (active_insn_p (after) && !INSN_LOCATOR (after))
4197         INSN_LOCATOR (after) = loc;
4198       if (after == last)
4199         break;
4200       after = NEXT_INSN (after);
4201     }
4202   return last;
4203 }
4204
4205 /* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to AFTER.  */
4206 rtx
4207 emit_jump_insn_after (rtx pattern, rtx after)
4208 {
4209   if (INSN_P (after))
4210     return emit_jump_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4211   else
4212     return emit_jump_insn_after_noloc (pattern, after);
4213 }
4214
4215 /* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to SCOPE.  */
4216 rtx
4217 emit_call_insn_after_setloc (rtx pattern, rtx after, int loc)
4218 {
4219   rtx last = emit_call_insn_after_noloc (pattern, after);
4220
4221   if (pattern == NULL_RTX || !loc)
4222     return last;
4223
4224   after = NEXT_INSN (after);
4225   while (1)
4226     {
4227       if (active_insn_p (after) && !INSN_LOCATOR (after))
4228         INSN_LOCATOR (after) = loc;
4229       if (after == last)
4230         break;
4231       after = NEXT_INSN (after);
4232     }
4233   return last;
4234 }
4235
4236 /* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to AFTER.  */
4237 rtx
4238 emit_call_insn_after (rtx pattern, rtx after)
4239 {
4240   if (INSN_P (after))
4241     return emit_call_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4242   else
4243     return emit_call_insn_after_noloc (pattern, after);
4244 }
4245
4246 /* Like emit_insn_before_noloc, but set INSN_LOCATOR according to SCOPE.  */
4247 rtx
4248 emit_insn_before_setloc (rtx pattern, rtx before, int loc)
4249 {
4250   rtx first = PREV_INSN (before);
4251   rtx last = emit_insn_before_noloc (pattern, before, NULL);
4252
4253   if (pattern == NULL_RTX || !loc)
4254     return last;
4255
4256   if (!first)
4257     first = get_insns ();
4258   else
4259     first = NEXT_INSN (first);
4260   while (1)
4261     {
4262       if (active_insn_p (first) && !INSN_LOCATOR (first))
4263         INSN_LOCATOR (first) = loc;
4264       if (first == last)
4265         break;
4266       first = NEXT_INSN (first);
4267     }
4268   return last;
4269 }
4270
4271 /* Like emit_insn_before_noloc, but set INSN_LOCATOR according to BEFORE.  */
4272 rtx
4273 emit_insn_before (rtx pattern, rtx before)
4274 {
4275   if (INSN_P (before))
4276     return emit_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
4277   else
4278     return emit_insn_before_noloc (pattern, before, NULL);
4279 }
4280
4281 /* like emit_insn_before_noloc, but set insn_locator according to scope.  */
4282 rtx
4283 emit_jump_insn_before_setloc (rtx pattern, rtx before, int loc)
4284 {
4285   rtx first = PREV_INSN (before);
4286   rtx last = emit_jump_insn_before_noloc (pattern, before);
4287
4288   if (pattern == NULL_RTX)
4289     return last;
4290
4291   first = NEXT_INSN (first);
4292   while (1)
4293     {
4294       if (active_insn_p (first) && !INSN_LOCATOR (first))
4295         INSN_LOCATOR (first) = loc;
4296       if (first == last)
4297         break;
4298       first = NEXT_INSN (first);
4299     }
4300   return last;
4301 }
4302
4303 /* Like emit_jump_insn_before_noloc, but set INSN_LOCATOR according to BEFORE.  */
4304 rtx
4305 emit_jump_insn_before (rtx pattern, rtx before)
4306 {
4307   if (INSN_P (before))
4308     return emit_jump_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
4309   else
4310     return emit_jump_insn_before_noloc (pattern, before);
4311 }
4312
4313 /* like emit_insn_before_noloc, but set insn_locator according to scope.  */
4314 rtx
4315 emit_call_insn_before_setloc (rtx pattern, rtx before, int loc)
4316 {
4317   rtx first = PREV_INSN (before);
4318   rtx last = emit_call_insn_before_noloc (pattern, before);
4319
4320   if (pattern == NULL_RTX)
4321     return last;
4322
4323   first = NEXT_INSN (first);
4324   while (1)
4325     {
4326       if (active_insn_p (first) && !INSN_LOCATOR (first))
4327         INSN_LOCATOR (first) = loc;
4328       if (first == last)
4329         break;
4330       first = NEXT_INSN (first);
4331     }
4332   return last;
4333 }
4334
4335 /* like emit_call_insn_before_noloc,
4336    but set insn_locator according to before.  */
4337 rtx
4338 emit_call_insn_before (rtx pattern, rtx before)
4339 {
4340   if (INSN_P (before))
4341     return emit_call_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
4342   else
4343     return emit_call_insn_before_noloc (pattern, before);
4344 }
4345 \f
4346 /* Take X and emit it at the end of the doubly-linked
4347    INSN list.
4348
4349    Returns the last insn emitted.  */
4350
4351 rtx
4352 emit_insn (rtx x)
4353 {
4354   rtx last = last_insn;
4355   rtx insn;
4356
4357   if (x == NULL_RTX)
4358     return last;
4359
4360   switch (GET_CODE (x))
4361     {
4362     case INSN:
4363     case JUMP_INSN:
4364     case CALL_INSN:
4365     case CODE_LABEL:
4366     case BARRIER:
4367     case NOTE:
4368       insn = x;
4369       while (insn)
4370         {
4371           rtx next = NEXT_INSN (insn);
4372           add_insn (insn);
4373           last = insn;
4374           insn = next;
4375         }
4376       break;
4377
4378 #ifdef ENABLE_RTL_CHECKING
4379     case SEQUENCE:
4380       gcc_unreachable ();
4381       break;
4382 #endif
4383
4384     default:
4385       last = make_insn_raw (x);
4386       add_insn (last);
4387       break;
4388     }
4389
4390   return last;
4391 }
4392
4393 /* Make an insn of code JUMP_INSN with pattern X
4394    and add it to the end of the doubly-linked list.  */
4395
4396 rtx
4397 emit_jump_insn (rtx x)
4398 {
4399   rtx last = NULL_RTX, insn;
4400
4401   switch (GET_CODE (x))
4402     {
4403     case INSN:
4404     case JUMP_INSN:
4405     case CALL_INSN:
4406     case CODE_LABEL:
4407     case BARRIER:
4408     case NOTE:
4409       insn = x;
4410       while (insn)
4411         {
4412           rtx next = NEXT_INSN (insn);
4413           add_insn (insn);
4414           last = insn;
4415           insn = next;
4416         }
4417       break;
4418
4419 #ifdef ENABLE_RTL_CHECKING
4420     case SEQUENCE:
4421       gcc_unreachable ();
4422       break;
4423 #endif
4424
4425     default:
4426       last = make_jump_insn_raw (x);
4427       add_insn (last);
4428       break;
4429     }
4430
4431   return last;
4432 }
4433