OSDN Git Service

1d33a0977b2fb164b6606b376b4fc2f58d3d2a93
[pf3gnuchains/gcc-fork.git] / gcc / regclass.c
1 /* Compute register class preferences for pseudo-registers.
2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996
3    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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 2, 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 COPYING.  If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA.  */
22
23
24 /* This file contains two passes of the compiler: reg_scan and reg_class.
25    It also defines some tables of information about the hardware registers
26    and a function init_reg_sets to initialize the tables.  */
27
28 #include "config.h"
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
32 #include "hard-reg-set.h"
33 #include "rtl.h"
34 #include "expr.h"
35 #include "tm_p.h"
36 #include "flags.h"
37 #include "basic-block.h"
38 #include "regs.h"
39 #include "function.h"
40 #include "insn-config.h"
41 #include "recog.h"
42 #include "reload.h"
43 #include "real.h"
44 #include "toplev.h"
45 #include "output.h"
46 #include "ggc.h"
47 #include "timevar.h"
48
49 static void init_reg_sets_1 (void);
50 static void init_reg_autoinc (void);
51
52 /* If we have auto-increment or auto-decrement and we can have secondary
53    reloads, we are not allowed to use classes requiring secondary
54    reloads for pseudos auto-incremented since reload can't handle it.  */
55
56 #ifdef AUTO_INC_DEC
57 #if defined(SECONDARY_INPUT_RELOAD_CLASS) || defined(SECONDARY_OUTPUT_RELOAD_CLASS)
58 #define FORBIDDEN_INC_DEC_CLASSES
59 #endif
60 #endif
61 \f
62 /* Register tables used by many passes.  */
63
64 /* Indexed by hard register number, contains 1 for registers
65    that are fixed use (stack pointer, pc, frame pointer, etc.).
66    These are the registers that cannot be used to allocate
67    a pseudo reg for general use.  */
68
69 char fixed_regs[FIRST_PSEUDO_REGISTER];
70
71 /* Same info as a HARD_REG_SET.  */
72
73 HARD_REG_SET fixed_reg_set;
74
75 /* Data for initializing the above.  */
76
77 static const char initial_fixed_regs[] = FIXED_REGISTERS;
78
79 /* Indexed by hard register number, contains 1 for registers
80    that are fixed use or are clobbered by function calls.
81    These are the registers that cannot be used to allocate
82    a pseudo reg whose life crosses calls unless we are able
83    to save/restore them across the calls.  */
84
85 char call_used_regs[FIRST_PSEUDO_REGISTER];
86
87 /* Same info as a HARD_REG_SET.  */
88
89 HARD_REG_SET call_used_reg_set;
90
91 /* HARD_REG_SET of registers we want to avoid caller saving.  */
92 HARD_REG_SET losing_caller_save_reg_set;
93
94 /* Data for initializing the above.  */
95
96 static const char initial_call_used_regs[] = CALL_USED_REGISTERS;
97
98 /* This is much like call_used_regs, except it doesn't have to
99    be a superset of FIXED_REGISTERS. This vector indicates
100    what is really call clobbered, and is used when defining
101    regs_invalidated_by_call.  */
102
103 #ifdef CALL_REALLY_USED_REGISTERS
104 char call_really_used_regs[] = CALL_REALLY_USED_REGISTERS;
105 #endif
106
107 #ifdef CALL_REALLY_USED_REGISTERS
108 #define CALL_REALLY_USED_REGNO_P(X)  call_really_used_regs[X]
109 #else
110 #define CALL_REALLY_USED_REGNO_P(X)  call_used_regs[X]
111 #endif
112
113
114 /* Indexed by hard register number, contains 1 for registers that are
115    fixed use or call used registers that cannot hold quantities across
116    calls even if we are willing to save and restore them.  call fixed
117    registers are a subset of call used registers.  */
118
119 char call_fixed_regs[FIRST_PSEUDO_REGISTER];
120
121 /* The same info as a HARD_REG_SET.  */
122
123 HARD_REG_SET call_fixed_reg_set;
124
125 /* Number of non-fixed registers.  */
126
127 int n_non_fixed_regs;
128
129 /* Indexed by hard register number, contains 1 for registers
130    that are being used for global register decls.
131    These must be exempt from ordinary flow analysis
132    and are also considered fixed.  */
133
134 char global_regs[FIRST_PSEUDO_REGISTER];
135
136 /* Contains 1 for registers that are set or clobbered by calls.  */
137 /* ??? Ideally, this would be just call_used_regs plus global_regs, but
138    for someone's bright idea to have call_used_regs strictly include
139    fixed_regs.  Which leaves us guessing as to the set of fixed_regs
140    that are actually preserved.  We know for sure that those associated
141    with the local stack frame are safe, but scant others.  */
142
143 HARD_REG_SET regs_invalidated_by_call;
144
145 /* Table of register numbers in the order in which to try to use them.  */
146 #ifdef REG_ALLOC_ORDER
147 int reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
148
149 /* The inverse of reg_alloc_order.  */
150 int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
151 #endif
152
153 /* For each reg class, a HARD_REG_SET saying which registers are in it.  */
154
155 HARD_REG_SET reg_class_contents[N_REG_CLASSES];
156
157 /* The same information, but as an array of unsigned ints.  We copy from
158    these unsigned ints to the table above.  We do this so the tm.h files
159    do not have to be aware of the wordsize for machines with <= 64 regs.
160    Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
161
162 #define N_REG_INTS  \
163   ((FIRST_PSEUDO_REGISTER + (32 - 1)) / 32)
164
165 static const unsigned int_reg_class_contents[N_REG_CLASSES][N_REG_INTS]
166   = REG_CLASS_CONTENTS;
167
168 /* For each reg class, number of regs it contains.  */
169
170 unsigned int reg_class_size[N_REG_CLASSES];
171
172 /* For each reg class, table listing all the containing classes.  */
173
174 enum reg_class reg_class_superclasses[N_REG_CLASSES][N_REG_CLASSES];
175
176 /* For each reg class, table listing all the classes contained in it.  */
177
178 enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
179
180 /* For each pair of reg classes,
181    a largest reg class contained in their union.  */
182
183 enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
184
185 /* For each pair of reg classes,
186    the smallest reg class containing their union.  */
187
188 enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
189
190 /* Array containing all of the register names.  */
191
192 const char * reg_names[] = REGISTER_NAMES;
193
194 /* For each hard register, the widest mode object that it can contain.
195    This will be a MODE_INT mode if the register can hold integers.  Otherwise
196    it will be a MODE_FLOAT or a MODE_CC mode, whichever is valid for the
197    register.  */
198
199 enum machine_mode reg_raw_mode[FIRST_PSEUDO_REGISTER];
200
201 /* 1 if there is a register of given mode.  */
202
203 bool have_regs_of_mode [MAX_MACHINE_MODE];
204
205 /* 1 if class does contain register of given mode.  */
206
207 static char contains_reg_of_mode [N_REG_CLASSES] [MAX_MACHINE_MODE];
208
209 /* Maximum cost of moving from a register in one class to a register in
210    another class.  Based on REGISTER_MOVE_COST.  */
211
212 static int move_cost[MAX_MACHINE_MODE][N_REG_CLASSES][N_REG_CLASSES];
213
214 /* Similar, but here we don't have to move if the first index is a subset
215    of the second so in that case the cost is zero.  */
216
217 static int may_move_in_cost[MAX_MACHINE_MODE][N_REG_CLASSES][N_REG_CLASSES];
218
219 /* Similar, but here we don't have to move if the first index is a superset
220    of the second so in that case the cost is zero.  */
221
222 static int may_move_out_cost[MAX_MACHINE_MODE][N_REG_CLASSES][N_REG_CLASSES];
223
224 #ifdef FORBIDDEN_INC_DEC_CLASSES
225
226 /* These are the classes that regs which are auto-incremented or decremented
227    cannot be put in.  */
228
229 static int forbidden_inc_dec_class[N_REG_CLASSES];
230
231 /* Indexed by n, is nonzero if (REG n) is used in an auto-inc or auto-dec
232    context.  */
233
234 static char *in_inc_dec;
235
236 #endif /* FORBIDDEN_INC_DEC_CLASSES */
237
238 #ifdef CANNOT_CHANGE_MODE_CLASS
239 /* All registers that have been subreged.  Indexed by regno * MAX_MACHINE_MODE
240    + mode.  */
241 bitmap_head subregs_of_mode;
242 #endif
243
244 /* Sample MEM values for use by memory_move_secondary_cost.  */
245
246 static GTY(()) rtx top_of_stack[MAX_MACHINE_MODE];
247
248 /* Linked list of reg_info structures allocated for reg_n_info array.
249    Grouping all of the allocated structures together in one lump
250    means only one call to bzero to clear them, rather than n smaller
251    calls.  */
252 struct reg_info_data {
253   struct reg_info_data *next;   /* next set of reg_info structures */
254   size_t min_index;             /* minimum index # */
255   size_t max_index;             /* maximum index # */
256   char used_p;                  /* nonzero if this has been used previously */
257   reg_info data[1];             /* beginning of the reg_info data */
258 };
259
260 static struct reg_info_data *reg_info_head;
261
262 /* No more global register variables may be declared; true once
263    regclass has been initialized.  */
264
265 static int no_global_reg_vars = 0;
266
267 /* Specify number of hard registers given machine mode occupy.  */
268 unsigned char hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
269
270 /* Function called only once to initialize the above data on reg usage.
271    Once this is done, various switches may override.  */
272
273 void
274 init_reg_sets (void)
275 {
276   int i, j;
277
278   /* First copy the register information from the initial int form into
279      the regsets.  */
280
281   for (i = 0; i < N_REG_CLASSES; i++)
282     {
283       CLEAR_HARD_REG_SET (reg_class_contents[i]);
284
285       /* Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
286       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
287         if (int_reg_class_contents[i][j / 32]
288             & ((unsigned) 1 << (j % 32)))
289           SET_HARD_REG_BIT (reg_class_contents[i], j);
290     }
291
292   /* Sanity check: make sure the target macros FIXED_REGISTERS and
293      CALL_USED_REGISTERS had the right number of initializers.  */
294   gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
295   gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
296
297   memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
298   memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
299   memset (global_regs, 0, sizeof global_regs);
300
301   /* Do any additional initialization regsets may need.  */
302   INIT_ONCE_REG_SET ();
303
304 #ifdef REG_ALLOC_ORDER
305   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
306     inv_reg_alloc_order[reg_alloc_order[i]] = i;
307 #endif
308 }
309
310 /* After switches have been processed, which perhaps alter
311    `fixed_regs' and `call_used_regs', convert them to HARD_REG_SETs.  */
312
313 static void
314 init_reg_sets_1 (void)
315 {
316   unsigned int i, j;
317   unsigned int /* enum machine_mode */ m;
318
319   /* This macro allows the fixed or call-used registers
320      and the register classes to depend on target flags.  */
321
322 #ifdef CONDITIONAL_REGISTER_USAGE
323   CONDITIONAL_REGISTER_USAGE;
324 #endif
325
326   /* Compute number of hard regs in each class.  */
327
328   memset (reg_class_size, 0, sizeof reg_class_size);
329   for (i = 0; i < N_REG_CLASSES; i++)
330     for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
331       if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
332         reg_class_size[i]++;
333
334   /* Initialize the table of subunions.
335      reg_class_subunion[I][J] gets the largest-numbered reg-class
336      that is contained in the union of classes I and J.  */
337
338   for (i = 0; i < N_REG_CLASSES; i++)
339     {
340       for (j = 0; j < N_REG_CLASSES; j++)
341         {
342           HARD_REG_SET c;
343           int k;
344
345           COPY_HARD_REG_SET (c, reg_class_contents[i]);
346           IOR_HARD_REG_SET (c, reg_class_contents[j]);
347           for (k = 0; k < N_REG_CLASSES; k++)
348             {
349               GO_IF_HARD_REG_SUBSET (reg_class_contents[k], c,
350                                      subclass1);
351               continue;
352
353             subclass1:
354               /* Keep the largest subclass.  */         /* SPEE 900308 */
355               GO_IF_HARD_REG_SUBSET (reg_class_contents[k],
356                                      reg_class_contents[(int) reg_class_subunion[i][j]],
357                                      subclass2);
358               reg_class_subunion[i][j] = (enum reg_class) k;
359             subclass2:
360               ;
361             }
362         }
363     }
364
365   /* Initialize the table of superunions.
366      reg_class_superunion[I][J] gets the smallest-numbered reg-class
367      containing the union of classes I and J.  */
368
369   for (i = 0; i < N_REG_CLASSES; i++)
370     {
371       for (j = 0; j < N_REG_CLASSES; j++)
372         {
373           HARD_REG_SET c;
374           int k;
375
376           COPY_HARD_REG_SET (c, reg_class_contents[i]);
377           IOR_HARD_REG_SET (c, reg_class_contents[j]);
378           for (k = 0; k < N_REG_CLASSES; k++)
379             GO_IF_HARD_REG_SUBSET (c, reg_class_contents[k], superclass);
380
381         superclass:
382           reg_class_superunion[i][j] = (enum reg_class) k;
383         }
384     }
385
386   /* Initialize the tables of subclasses and superclasses of each reg class.
387      First clear the whole table, then add the elements as they are found.  */
388
389   for (i = 0; i < N_REG_CLASSES; i++)
390     {
391       for (j = 0; j < N_REG_CLASSES; j++)
392         {
393           reg_class_superclasses[i][j] = LIM_REG_CLASSES;
394           reg_class_subclasses[i][j] = LIM_REG_CLASSES;
395         }
396     }
397
398   for (i = 0; i < N_REG_CLASSES; i++)
399     {
400       if (i == (int) NO_REGS)
401         continue;
402
403       for (j = i + 1; j < N_REG_CLASSES; j++)
404         {
405           enum reg_class *p;
406
407           GO_IF_HARD_REG_SUBSET (reg_class_contents[i], reg_class_contents[j],
408                                  subclass);
409           continue;
410         subclass:
411           /* Reg class I is a subclass of J.
412              Add J to the table of superclasses of I.  */
413           p = &reg_class_superclasses[i][0];
414           while (*p != LIM_REG_CLASSES) p++;
415           *p = (enum reg_class) j;
416           /* Add I to the table of superclasses of J.  */
417           p = &reg_class_subclasses[j][0];
418           while (*p != LIM_REG_CLASSES) p++;
419           *p = (enum reg_class) i;
420         }
421     }
422
423   /* Initialize "constant" tables.  */
424
425   CLEAR_HARD_REG_SET (fixed_reg_set);
426   CLEAR_HARD_REG_SET (call_used_reg_set);
427   CLEAR_HARD_REG_SET (call_fixed_reg_set);
428   CLEAR_HARD_REG_SET (regs_invalidated_by_call);
429
430   memcpy (call_fixed_regs, fixed_regs, sizeof call_fixed_regs);
431
432   n_non_fixed_regs = 0;
433
434   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
435     {
436       /* call_used_regs must include fixed_regs.  */
437       gcc_assert (!fixed_regs[i] || call_used_regs[i]);
438 #ifdef CALL_REALLY_USED_REGISTERS
439       /* call_used_regs must include call_really_used_regs.  */
440       gcc_assert (!call_really_used_regs[i] || call_used_regs[i]);
441 #endif
442
443       if (fixed_regs[i])
444         SET_HARD_REG_BIT (fixed_reg_set, i);
445       else
446         n_non_fixed_regs++;
447
448       if (call_used_regs[i])
449         SET_HARD_REG_BIT (call_used_reg_set, i);
450       if (call_fixed_regs[i])
451         SET_HARD_REG_BIT (call_fixed_reg_set, i);
452       if (CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (i)))
453         SET_HARD_REG_BIT (losing_caller_save_reg_set, i);
454
455       /* There are a couple of fixed registers that we know are safe to
456          exclude from being clobbered by calls:
457
458          The frame pointer is always preserved across calls.  The arg pointer
459          is if it is fixed.  The stack pointer usually is, unless
460          RETURN_POPS_ARGS, in which case an explicit CLOBBER will be present.
461          If we are generating PIC code, the PIC offset table register is
462          preserved across calls, though the target can override that.  */
463
464       if (i == STACK_POINTER_REGNUM)
465         ;
466       else if (global_regs[i])
467         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
468       else if (i == FRAME_POINTER_REGNUM)
469         ;
470 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
471       else if (i == HARD_FRAME_POINTER_REGNUM)
472         ;
473 #endif
474 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
475       else if (i == ARG_POINTER_REGNUM && fixed_regs[i])
476         ;
477 #endif
478 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
479       else if (i == (unsigned) PIC_OFFSET_TABLE_REGNUM && fixed_regs[i])
480         ;
481 #endif
482       else if (CALL_REALLY_USED_REGNO_P (i))
483         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
484     }
485
486   memset (have_regs_of_mode, 0, sizeof (have_regs_of_mode));
487   memset (contains_reg_of_mode, 0, sizeof (contains_reg_of_mode));
488   for (m = 0; m < (unsigned int) MAX_MACHINE_MODE; m++)
489     for (i = 0; i < N_REG_CLASSES; i++)
490       if ((unsigned) CLASS_MAX_NREGS (i, m) <= reg_class_size[i])
491         for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
492           if (!fixed_regs [j] && TEST_HARD_REG_BIT (reg_class_contents[i], j)
493               && HARD_REGNO_MODE_OK (j, m))
494              {
495                contains_reg_of_mode [i][m] = 1;
496                have_regs_of_mode [m] = 1;
497                break;
498              }
499
500   /* Initialize the move cost table.  Find every subset of each class
501      and take the maximum cost of moving any subset to any other.  */
502
503   for (m = 0; m < (unsigned int) MAX_MACHINE_MODE; m++)
504     if (have_regs_of_mode [m])
505       {
506         for (i = 0; i < N_REG_CLASSES; i++)
507           if (contains_reg_of_mode [i][m])
508             for (j = 0; j < N_REG_CLASSES; j++)
509               {
510                 int cost;
511                 enum reg_class *p1, *p2;
512
513                 if (!contains_reg_of_mode [j][m])
514                   {
515                     move_cost[m][i][j] = 65536;
516                     may_move_in_cost[m][i][j] = 65536;
517                     may_move_out_cost[m][i][j] = 65536;
518                   }
519                 else
520                   {
521                     cost = REGISTER_MOVE_COST (m, i, j);
522
523                     for (p2 = &reg_class_subclasses[j][0];
524                          *p2 != LIM_REG_CLASSES;
525                          p2++)
526                       if (*p2 != i && contains_reg_of_mode [*p2][m])
527                         cost = MAX (cost, move_cost [m][i][*p2]);
528
529                     for (p1 = &reg_class_subclasses[i][0];
530                          *p1 != LIM_REG_CLASSES;
531                          p1++)
532                       if (*p1 != j && contains_reg_of_mode [*p1][m])
533                         cost = MAX (cost, move_cost [m][*p1][j]);
534
535                     move_cost[m][i][j] = cost;
536
537                     if (reg_class_subset_p (i, j))
538                       may_move_in_cost[m][i][j] = 0;
539                     else
540                       may_move_in_cost[m][i][j] = cost;
541
542                     if (reg_class_subset_p (j, i))
543                       may_move_out_cost[m][i][j] = 0;
544                     else
545                       may_move_out_cost[m][i][j] = cost;
546                   }
547               }
548           else
549             for (j = 0; j < N_REG_CLASSES; j++)
550               {
551                 move_cost[m][i][j] = 65536;
552                 may_move_in_cost[m][i][j] = 65536;
553                 may_move_out_cost[m][i][j] = 65536;
554               }
555       }
556 }
557
558 /* Compute the table of register modes.
559    These values are used to record death information for individual registers
560    (as opposed to a multi-register mode).  */
561
562 void
563 init_reg_modes_once (void)
564 {
565   int i, j;
566
567   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
568     for (j = 0; j < MAX_MACHINE_MODE; j++)
569       hard_regno_nregs[i][j] = HARD_REGNO_NREGS(i, (enum machine_mode)j);
570
571   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
572     {
573       reg_raw_mode[i] = choose_hard_reg_mode (i, 1, false);
574
575       /* If we couldn't find a valid mode, just use the previous mode.
576          ??? One situation in which we need to do this is on the mips where
577          HARD_REGNO_NREGS (fpreg, [SD]Fmode) returns 2.  Ideally we'd like
578          to use DF mode for the even registers and VOIDmode for the odd
579          (for the cpu models where the odd ones are inaccessible).  */
580       if (reg_raw_mode[i] == VOIDmode)
581         reg_raw_mode[i] = i == 0 ? word_mode : reg_raw_mode[i-1];
582     }
583 }
584
585 /* Finish initializing the register sets and
586    initialize the register modes.  */
587
588 void
589 init_regs (void)
590 {
591   /* This finishes what was started by init_reg_sets, but couldn't be done
592      until after register usage was specified.  */
593   init_reg_sets_1 ();
594
595   init_reg_autoinc ();
596 }
597
598 /* Initialize some fake stack-frame MEM references for use in
599    memory_move_secondary_cost.  */
600
601 void
602 init_fake_stack_mems (void)
603 {
604 #ifdef HAVE_SECONDARY_RELOADS
605   {
606     int i;
607
608     for (i = 0; i < MAX_MACHINE_MODE; i++)
609       top_of_stack[i] = gen_rtx_MEM (i, stack_pointer_rtx);
610   }
611 #endif
612 }
613
614 #ifdef HAVE_SECONDARY_RELOADS
615
616 /* Compute extra cost of moving registers to/from memory due to reloads.
617    Only needed if secondary reloads are required for memory moves.  */
618
619 int
620 memory_move_secondary_cost (enum machine_mode mode, enum reg_class class, int in)
621 {
622   enum reg_class altclass;
623   int partial_cost = 0;
624   /* We need a memory reference to feed to SECONDARY... macros.  */
625   /* mem may be unused even if the SECONDARY_ macros are defined.  */
626   rtx mem ATTRIBUTE_UNUSED = top_of_stack[(int) mode];
627
628
629   if (in)
630     {
631 #ifdef SECONDARY_INPUT_RELOAD_CLASS
632       altclass = SECONDARY_INPUT_RELOAD_CLASS (class, mode, mem);
633 #else
634       altclass = NO_REGS;
635 #endif
636     }
637   else
638     {
639 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
640       altclass = SECONDARY_OUTPUT_RELOAD_CLASS (class, mode, mem);
641 #else
642       altclass = NO_REGS;
643 #endif
644     }
645
646   if (altclass == NO_REGS)
647     return 0;
648
649   if (in)
650     partial_cost = REGISTER_MOVE_COST (mode, altclass, class);
651   else
652     partial_cost = REGISTER_MOVE_COST (mode, class, altclass);
653
654   if (class == altclass)
655     /* This isn't simply a copy-to-temporary situation.  Can't guess
656        what it is, so MEMORY_MOVE_COST really ought not to be calling
657        here in that case.
658
659        I'm tempted to put in an assert here, but returning this will
660        probably only give poor estimates, which is what we would've
661        had before this code anyways.  */
662     return partial_cost;
663
664   /* Check if the secondary reload register will also need a
665      secondary reload.  */
666   return memory_move_secondary_cost (mode, altclass, in) + partial_cost;
667 }
668 #endif
669
670 /* Return a machine mode that is legitimate for hard reg REGNO and large
671    enough to save nregs.  If we can't find one, return VOIDmode.
672    If CALL_SAVED is true, only consider modes that are call saved.  */
673
674 enum machine_mode
675 choose_hard_reg_mode (unsigned int regno ATTRIBUTE_UNUSED,
676                       unsigned int nregs, bool call_saved)
677 {
678   unsigned int /* enum machine_mode */ m;
679   enum machine_mode found_mode = VOIDmode, mode;
680
681   /* We first look for the largest integer mode that can be validly
682      held in REGNO.  If none, we look for the largest floating-point mode.
683      If we still didn't find a valid mode, try CCmode.  */
684
685   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
686        mode != VOIDmode;
687        mode = GET_MODE_WIDER_MODE (mode))
688     if ((unsigned) hard_regno_nregs[regno][mode] == nregs
689         && HARD_REGNO_MODE_OK (regno, mode)
690         && (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
691       found_mode = mode;
692
693   if (found_mode != VOIDmode)
694     return found_mode;
695
696   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
697        mode != VOIDmode;
698        mode = GET_MODE_WIDER_MODE (mode))
699     if ((unsigned) hard_regno_nregs[regno][mode] == nregs
700         && HARD_REGNO_MODE_OK (regno, mode)
701         && (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
702       found_mode = mode;
703
704   if (found_mode != VOIDmode)
705     return found_mode;
706
707   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
708        mode != VOIDmode;
709        mode = GET_MODE_WIDER_MODE (mode))
710     if ((unsigned) hard_regno_nregs[regno][mode] == nregs
711         && HARD_REGNO_MODE_OK (regno, mode)
712         && (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
713       found_mode = mode;
714
715   if (found_mode != VOIDmode)
716     return found_mode;
717
718   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
719        mode != VOIDmode;
720        mode = GET_MODE_WIDER_MODE (mode))
721     if ((unsigned) hard_regno_nregs[regno][mode] == nregs
722         && HARD_REGNO_MODE_OK (regno, mode)
723         && (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
724       found_mode = mode;
725
726   if (found_mode != VOIDmode)
727     return found_mode;
728
729   /* Iterate over all of the CCmodes.  */
730   for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
731     {
732       mode = (enum machine_mode) m;
733       if ((unsigned) hard_regno_nregs[regno][mode] == nregs
734           && HARD_REGNO_MODE_OK (regno, mode)
735           && (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
736         return mode;
737     }
738
739   /* We can't find a mode valid for this register.  */
740   return VOIDmode;
741 }
742
743 /* Specify the usage characteristics of the register named NAME.
744    It should be a fixed register if FIXED and a
745    call-used register if CALL_USED.  */
746
747 void
748 fix_register (const char *name, int fixed, int call_used)
749 {
750   int i;
751
752   /* Decode the name and update the primary form of
753      the register info.  */
754
755   if ((i = decode_reg_name (name)) >= 0)
756     {
757       if ((i == STACK_POINTER_REGNUM
758 #ifdef HARD_FRAME_POINTER_REGNUM
759            || i == HARD_FRAME_POINTER_REGNUM
760 #else
761            || i == FRAME_POINTER_REGNUM
762 #endif
763            )
764           && (fixed == 0 || call_used == 0))
765         {
766           static const char * const what_option[2][2] = {
767             { "call-saved", "call-used" },
768             { "no-such-option", "fixed" }};
769
770           error ("can't use '%s' as a %s register", name,
771                  what_option[fixed][call_used]);
772         }
773       else
774         {
775           fixed_regs[i] = fixed;
776           call_used_regs[i] = call_used;
777 #ifdef CALL_REALLY_USED_REGISTERS
778           if (fixed == 0)
779             call_really_used_regs[i] = call_used;
780 #endif
781         }
782     }
783   else
784     {
785       warning ("unknown register name: %s", name);
786     }
787 }
788
789 /* Mark register number I as global.  */
790
791 void
792 globalize_reg (int i)
793 {
794   if (fixed_regs[i] == 0 && no_global_reg_vars)
795     error ("global register variable follows a function definition");
796
797   if (global_regs[i])
798     {
799       warning ("register used for two global register variables");
800       return;
801     }
802
803   if (call_used_regs[i] && ! fixed_regs[i])
804     warning ("call-clobbered register used for global register variable");
805
806   global_regs[i] = 1;
807
808   /* If we're globalizing the frame pointer, we need to set the
809      appropriate regs_invalidated_by_call bit, even if it's already
810      set in fixed_regs.  */
811   if (i != STACK_POINTER_REGNUM)
812     SET_HARD_REG_BIT (regs_invalidated_by_call, i);
813
814   /* If already fixed, nothing else to do.  */
815   if (fixed_regs[i])
816     return;
817
818   fixed_regs[i] = call_used_regs[i] = call_fixed_regs[i] = 1;
819 #ifdef CALL_REALLY_USED_REGISTERS
820   call_really_used_regs[i] = 1;
821 #endif
822   n_non_fixed_regs--;
823
824   SET_HARD_REG_BIT (fixed_reg_set, i);
825   SET_HARD_REG_BIT (call_used_reg_set, i);
826   SET_HARD_REG_BIT (call_fixed_reg_set, i);
827 }
828 \f
829 /* Now the data and code for the `regclass' pass, which happens
830    just before local-alloc.  */
831
832 /* The `costs' struct records the cost of using a hard register of each class
833    and of using memory for each pseudo.  We use this data to set up
834    register class preferences.  */
835
836 struct costs
837 {
838   int cost[N_REG_CLASSES];
839   int mem_cost;
840 };
841
842 /* Structure used to record preferences of given pseudo.  */
843 struct reg_pref
844 {
845   /* (enum reg_class) prefclass is the preferred class.  */
846   char prefclass;
847
848   /* altclass is a register class that we should use for allocating
849      pseudo if no register in the preferred class is available.
850      If no register in this class is available, memory is preferred.
851
852      It might appear to be more general to have a bitmask of classes here,
853      but since it is recommended that there be a class corresponding to the
854      union of most major pair of classes, that generality is not required.  */
855   char altclass;
856 };
857
858 /* Record the cost of each class for each pseudo.  */
859
860 static struct costs *costs;
861
862 /* Initialized once, and used to initialize cost values for each insn.  */
863
864 static struct costs init_cost;
865
866 /* Record preferences of each pseudo.
867    This is available after `regclass' is run.  */
868
869 static struct reg_pref *reg_pref;
870
871 /* Allocated buffers for reg_pref.  */
872
873 static struct reg_pref *reg_pref_buffer;
874
875 /* Frequency of executions of current insn.  */
876
877 static int frequency;
878
879 static rtx scan_one_insn (rtx, int);
880 static void record_operand_costs (rtx, struct costs *, struct reg_pref *);
881 static void dump_regclass (FILE *);
882 static void record_reg_classes (int, int, rtx *, enum machine_mode *,
883                                 const char **, rtx, struct costs *,
884                                 struct reg_pref *);
885 static int copy_cost (rtx, enum machine_mode, enum reg_class, int);
886 static void record_address_regs (rtx, enum reg_class, int);
887 #ifdef FORBIDDEN_INC_DEC_CLASSES
888 static int auto_inc_dec_reg_p (rtx, enum machine_mode);
889 #endif
890 static void reg_scan_mark_refs (rtx, rtx, int, unsigned int);
891
892 /* Return the reg_class in which pseudo reg number REGNO is best allocated.
893    This function is sometimes called before the info has been computed.
894    When that happens, just return GENERAL_REGS, which is innocuous.  */
895
896 enum reg_class
897 reg_preferred_class (int regno)
898 {
899   if (reg_pref == 0)
900     return GENERAL_REGS;
901   return (enum reg_class) reg_pref[regno].prefclass;
902 }
903
904 enum reg_class
905 reg_alternate_class (int regno)
906 {
907   if (reg_pref == 0)
908     return ALL_REGS;
909
910   return (enum reg_class) reg_pref[regno].altclass;
911 }
912
913 /* Initialize some global data for this pass.  */
914
915 void
916 regclass_init (void)
917 {
918   int i;
919
920   init_cost.mem_cost = 10000;
921   for (i = 0; i < N_REG_CLASSES; i++)
922     init_cost.cost[i] = 10000;
923
924   /* This prevents dump_flow_info from losing if called
925      before regclass is run.  */
926   reg_pref = NULL;
927
928   /* No more global register variables may be declared.  */
929   no_global_reg_vars = 1;
930 }
931 \f
932 /* Dump register costs.  */
933 static void
934 dump_regclass (FILE *dump)
935 {
936   static const char *const reg_class_names[] = REG_CLASS_NAMES;
937   int i;
938   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
939     {
940       int /* enum reg_class */ class;
941       if (REG_N_REFS (i))
942         {
943           fprintf (dump, "  Register %i costs:", i);
944           for (class = 0; class < (int) N_REG_CLASSES; class++)
945             if (contains_reg_of_mode [(enum reg_class) class][PSEUDO_REGNO_MODE (i)]
946 #ifdef FORBIDDEN_INC_DEC_CLASSES
947                 && (!in_inc_dec[i]
948                     || !forbidden_inc_dec_class[(enum reg_class) class])
949 #endif
950 #ifdef CANNOT_CHANGE_MODE_CLASS
951                 && ! invalid_mode_change_p (i, (enum reg_class) class,
952                                             PSEUDO_REGNO_MODE (i))
953 #endif
954                 )
955             fprintf (dump, " %s:%i", reg_class_names[class],
956                      costs[i].cost[(enum reg_class) class]);
957           fprintf (dump, " MEM:%i\n", costs[i].mem_cost);
958         }
959     }
960 }
961 \f
962
963 /* Calculate the costs of insn operands.  */
964
965 static void
966 record_operand_costs (rtx insn, struct costs *op_costs,
967                       struct reg_pref *reg_pref)
968 {
969   const char *constraints[MAX_RECOG_OPERANDS];
970   enum machine_mode modes[MAX_RECOG_OPERANDS];
971   int i;
972
973   for (i = 0; i < recog_data.n_operands; i++)
974     {
975       constraints[i] = recog_data.constraints[i];
976       modes[i] = recog_data.operand_mode[i];
977     }
978
979   /* If we get here, we are set up to record the costs of all the
980      operands for this insn.  Start by initializing the costs.
981      Then handle any address registers.  Finally record the desired
982      classes for any pseudos, doing it twice if some pair of
983      operands are commutative.  */
984
985   for (i = 0; i < recog_data.n_operands; i++)
986     {
987       op_costs[i] = init_cost;
988
989       if (GET_CODE (recog_data.operand[i]) == SUBREG)
990         recog_data.operand[i] = SUBREG_REG (recog_data.operand[i]);
991
992       if (MEM_P (recog_data.operand[i]))
993         record_address_regs (XEXP (recog_data.operand[i], 0),
994                              MODE_BASE_REG_CLASS (modes[i]), frequency * 2);
995       else if (constraints[i][0] == 'p'
996                || EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
997         record_address_regs (recog_data.operand[i],
998                              MODE_BASE_REG_CLASS (modes[i]), frequency * 2);
999     }
1000
1001   /* Check for commutative in a separate loop so everything will
1002      have been initialized.  We must do this even if one operand
1003      is a constant--see addsi3 in m68k.md.  */
1004
1005   for (i = 0; i < (int) recog_data.n_operands - 1; i++)
1006     if (constraints[i][0] == '%')
1007       {
1008         const char *xconstraints[MAX_RECOG_OPERANDS];
1009         int j;
1010
1011         /* Handle commutative operands by swapping the constraints.
1012            We assume the modes are the same.  */
1013
1014         for (j = 0; j < recog_data.n_operands; j++)
1015           xconstraints[j] = constraints[j];
1016
1017         xconstraints[i] = constraints[i+1];
1018         xconstraints[i+1] = constraints[i];
1019         record_reg_classes (recog_data.n_alternatives, recog_data.n_operands,
1020                             recog_data.operand, modes,
1021                             xconstraints, insn, op_costs, reg_pref);
1022       }
1023
1024   record_reg_classes (recog_data.n_alternatives, recog_data.n_operands,
1025                       recog_data.operand, modes,
1026                       constraints, insn, op_costs, reg_pref);
1027 }
1028 \f
1029 /* Subroutine of regclass, processes one insn INSN.  Scan it and record each
1030    time it would save code to put a certain register in a certain class.
1031    PASS, when nonzero, inhibits some optimizations which need only be done
1032    once.
1033    Return the last insn processed, so that the scan can be continued from
1034    there.  */
1035
1036 static rtx
1037 scan_one_insn (rtx insn, int pass)
1038 {
1039   enum rtx_code pat_code;
1040   rtx set, note;
1041   int i, j;
1042   struct costs op_costs[MAX_RECOG_OPERANDS];
1043
1044   if (!INSN_P (insn))
1045     return insn;
1046
1047   pat_code = GET_CODE (PATTERN (insn));
1048   if (pat_code == USE
1049       || pat_code == CLOBBER
1050       || pat_code == ASM_INPUT
1051       || pat_code == ADDR_VEC
1052       || pat_code == ADDR_DIFF_VEC)
1053     return insn;
1054
1055   set = single_set (insn);
1056   extract_insn (insn);
1057
1058   /* If this insn loads a parameter from its stack slot, then
1059      it represents a savings, rather than a cost, if the
1060      parameter is stored in memory.  Record this fact.  */
1061
1062   if (set != 0 && REG_P (SET_DEST (set))
1063       && MEM_P (SET_SRC (set))
1064       && (note = find_reg_note (insn, REG_EQUIV,
1065                                 NULL_RTX)) != 0
1066       && MEM_P (XEXP (note, 0)))
1067     {
1068       costs[REGNO (SET_DEST (set))].mem_cost
1069         -= (MEMORY_MOVE_COST (GET_MODE (SET_DEST (set)),
1070                               GENERAL_REGS, 1)
1071             * frequency);
1072       record_address_regs (XEXP (SET_SRC (set), 0),
1073                            MODE_BASE_REG_CLASS (VOIDmode), frequency * 2);
1074       return insn;
1075     }
1076
1077   /* Improve handling of two-address insns such as
1078      (set X (ashift CONST Y)) where CONST must be made to
1079      match X. Change it into two insns: (set X CONST)
1080      (set X (ashift X Y)).  If we left this for reloading, it
1081      would probably get three insns because X and Y might go
1082      in the same place. This prevents X and Y from receiving
1083      the same hard reg.
1084
1085      We can only do this if the modes of operands 0 and 1
1086      (which might not be the same) are tieable and we only need
1087      do this during our first pass.  */
1088
1089   if (pass == 0 && optimize
1090       && recog_data.n_operands >= 3
1091       && recog_data.constraints[1][0] == '0'
1092       && recog_data.constraints[1][1] == 0
1093       && CONSTANT_P (recog_data.operand[1])
1094       && ! rtx_equal_p (recog_data.operand[0], recog_data.operand[1])
1095       && ! rtx_equal_p (recog_data.operand[0], recog_data.operand[2])
1096       && REG_P (recog_data.operand[0])
1097       && MODES_TIEABLE_P (GET_MODE (recog_data.operand[0]),
1098                           recog_data.operand_mode[1]))
1099     {
1100       rtx previnsn = prev_real_insn (insn);
1101       rtx dest
1102         = gen_lowpart (recog_data.operand_mode[1],
1103                        recog_data.operand[0]);
1104       rtx newinsn
1105         = emit_insn_before (gen_move_insn (dest, recog_data.operand[1]), insn);
1106
1107       /* If this insn was the start of a basic block,
1108          include the new insn in that block.
1109          We need not check for code_label here;
1110          while a basic block can start with a code_label,
1111          INSN could not be at the beginning of that block.  */
1112       if (previnsn == 0 || JUMP_P (previnsn))
1113         {
1114           basic_block b;
1115           FOR_EACH_BB (b)
1116             if (insn == BB_HEAD (b))
1117               BB_HEAD (b) = newinsn;
1118         }
1119
1120       /* This makes one more setting of new insns's dest.  */
1121       REG_N_SETS (REGNO (recog_data.operand[0]))++;
1122       REG_N_REFS (REGNO (recog_data.operand[0]))++;
1123       REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
1124
1125       *recog_data.operand_loc[1] = recog_data.operand[0];
1126       REG_N_REFS (REGNO (recog_data.operand[0]))++;
1127       REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
1128       for (i = recog_data.n_dups - 1; i >= 0; i--)
1129         if (recog_data.dup_num[i] == 1)
1130           {
1131             *recog_data.dup_loc[i] = recog_data.operand[0];
1132             REG_N_REFS (REGNO (recog_data.operand[0]))++;
1133             REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
1134           }
1135
1136       return PREV_INSN (newinsn);
1137     }
1138
1139   record_operand_costs (insn, op_costs, reg_pref);
1140
1141   /* Now add the cost for each operand to the total costs for
1142      its register.  */
1143
1144   for (i = 0; i < recog_data.n_operands; i++)
1145     if (REG_P (recog_data.operand[i])
1146         && REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER)
1147       {
1148         int regno = REGNO (recog_data.operand[i]);
1149         struct costs *p = &costs[regno], *q = &op_costs[i];
1150
1151         p->mem_cost += q->mem_cost * frequency;
1152         for (j = 0; j < N_REG_CLASSES; j++)
1153           p->cost[j] += q->cost[j] * frequency;
1154       }
1155
1156   return insn;
1157 }
1158
1159 /* Initialize information about which register classes can be used for
1160    pseudos that are auto-incremented or auto-decremented.  */
1161
1162 static void
1163 init_reg_autoinc (void)
1164 {
1165 #ifdef FORBIDDEN_INC_DEC_CLASSES
1166   int i;
1167
1168   for (i = 0; i < N_REG_CLASSES; i++)
1169     {
1170       rtx r = gen_rtx_raw_REG (VOIDmode, 0);
1171       enum machine_mode m;
1172       int j;
1173
1174       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
1175         if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
1176           {
1177             REGNO (r) = j;
1178
1179             for (m = VOIDmode; (int) m < (int) MAX_MACHINE_MODE;
1180                  m = (enum machine_mode) ((int) m + 1))
1181               if (HARD_REGNO_MODE_OK (j, m))
1182                 {
1183                   PUT_MODE (r, m);
1184
1185                   /* If a register is not directly suitable for an
1186                      auto-increment or decrement addressing mode and
1187                      requires secondary reloads, disallow its class from
1188                      being used in such addresses.  */
1189
1190                   if ((0
1191 #ifdef SECONDARY_RELOAD_CLASS
1192                        || (SECONDARY_RELOAD_CLASS (MODE_BASE_REG_CLASS (VOIDmode), m, r)
1193                            != NO_REGS)
1194 #else
1195 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1196                        || (SECONDARY_INPUT_RELOAD_CLASS (MODE_BASE_REG_CLASS (VOIDmode), m, r)
1197                            != NO_REGS)
1198 #endif
1199 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1200                        || (SECONDARY_OUTPUT_RELOAD_CLASS (MODE_BASE_REG_CLASS (VOIDmode), m, r)
1201                            != NO_REGS)
1202 #endif
1203 #endif
1204                        )
1205                       && ! auto_inc_dec_reg_p (r, m))
1206                     forbidden_inc_dec_class[i] = 1;
1207                 }
1208           }
1209     }
1210 #endif /* FORBIDDEN_INC_DEC_CLASSES */
1211 }
1212
1213 /* This is a pass of the compiler that scans all instructions
1214    and calculates the preferred class for each pseudo-register.
1215    This information can be accessed later by calling `reg_preferred_class'.
1216    This pass comes just before local register allocation.  */
1217
1218 void
1219 regclass (rtx f, int nregs, FILE *dump)
1220 {
1221   rtx insn;
1222   int i;
1223   int pass;
1224
1225   init_recog ();
1226
1227   costs = xmalloc (nregs * sizeof (struct costs));
1228
1229 #ifdef FORBIDDEN_INC_DEC_CLASSES
1230
1231   in_inc_dec = xmalloc (nregs);
1232
1233 #endif /* FORBIDDEN_INC_DEC_CLASSES */
1234
1235   /* Normally we scan the insns once and determine the best class to use for
1236      each register.  However, if -fexpensive_optimizations are on, we do so
1237      twice, the second time using the tentative best classes to guide the
1238      selection.  */
1239
1240   for (pass = 0; pass <= flag_expensive_optimizations; pass++)
1241     {
1242       basic_block bb;
1243
1244       if (dump)
1245         fprintf (dump, "\n\nPass %i\n\n",pass);
1246       /* Zero out our accumulation of the cost of each class for each reg.  */
1247
1248       memset (costs, 0, nregs * sizeof (struct costs));
1249
1250 #ifdef FORBIDDEN_INC_DEC_CLASSES
1251       memset (in_inc_dec, 0, nregs);
1252 #endif
1253
1254       /* Scan the instructions and record each time it would
1255          save code to put a certain register in a certain class.  */
1256
1257       if (!optimize)
1258         {
1259           frequency = REG_FREQ_MAX;
1260           for (insn = f; insn; insn = NEXT_INSN (insn))
1261             insn = scan_one_insn (insn, pass);
1262         }
1263       else
1264         FOR_EACH_BB (bb)
1265           {
1266             /* Show that an insn inside a loop is likely to be executed three
1267                times more than insns outside a loop.  This is much more
1268                aggressive than the assumptions made elsewhere and is being
1269                tried as an experiment.  */
1270             frequency = REG_FREQ_FROM_BB (bb);
1271             for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
1272               {
1273                 insn = scan_one_insn (insn, pass);
1274                 if (insn == BB_END (bb))
1275                   break;
1276               }
1277           }
1278
1279       /* Now for each register look at how desirable each class is
1280          and find which class is preferred.  Store that in
1281          `prefclass'.  Record in `altclass' the largest register
1282          class any of whose registers is better than memory.  */
1283
1284       if (pass == 0)
1285         reg_pref = reg_pref_buffer;
1286
1287       if (dump)
1288         {
1289           dump_regclass (dump);
1290           fprintf (dump,"\n");
1291         }
1292       for (i = FIRST_PSEUDO_REGISTER; i < nregs; i++)
1293         {
1294           int best_cost = (1 << (HOST_BITS_PER_INT - 2)) - 1;
1295           enum reg_class best = ALL_REGS, alt = NO_REGS;
1296           /* This is an enum reg_class, but we call it an int
1297              to save lots of casts.  */
1298           int class;
1299           struct costs *p = &costs[i];
1300
1301           /* In non-optimizing compilation REG_N_REFS is not initialized
1302              yet.  */
1303           if (optimize && !REG_N_REFS (i) && !REG_N_SETS (i))
1304             continue;
1305
1306           for (class = (int) ALL_REGS - 1; class > 0; class--)
1307             {
1308               /* Ignore classes that are too small for this operand or
1309                  invalid for an operand that was auto-incremented.  */
1310               if (!contains_reg_of_mode [class][PSEUDO_REGNO_MODE (i)]
1311 #ifdef FORBIDDEN_INC_DEC_CLASSES
1312                   || (in_inc_dec[i] && forbidden_inc_dec_class[class])
1313 #endif
1314 #ifdef CANNOT_CHANGE_MODE_CLASS
1315                   || invalid_mode_change_p (i, (enum reg_class) class,
1316                                             PSEUDO_REGNO_MODE (i))
1317 #endif
1318                   )
1319                 ;
1320               else if (p->cost[class] < best_cost)
1321                 {
1322                   best_cost = p->cost[class];
1323                   best = (enum reg_class) class;
1324                 }
1325               else if (p->cost[class] == best_cost)
1326                 best = reg_class_subunion[(int) best][class];
1327             }
1328
1329           /* Record the alternate register class; i.e., a class for which
1330              every register in it is better than using memory.  If adding a
1331              class would make a smaller class (i.e., no union of just those
1332              classes exists), skip that class.  The major unions of classes
1333              should be provided as a register class.  Don't do this if we
1334              will be doing it again later.  */
1335
1336           if ((pass == 1  || dump) || ! flag_expensive_optimizations)
1337             for (class = 0; class < N_REG_CLASSES; class++)
1338               if (p->cost[class] < p->mem_cost
1339                   && (reg_class_size[(int) reg_class_subunion[(int) alt][class]]
1340                       > reg_class_size[(int) alt])
1341 #ifdef FORBIDDEN_INC_DEC_CLASSES
1342                   && ! (in_inc_dec[i] && forbidden_inc_dec_class[class])
1343 #endif
1344 #ifdef CANNOT_CHANGE_MODE_CLASS
1345                   && ! invalid_mode_change_p (i, (enum reg_class) class,
1346                                               PSEUDO_REGNO_MODE (i))
1347 #endif
1348                   )
1349                 alt = reg_class_subunion[(int) alt][class];
1350
1351           /* If we don't add any classes, nothing to try.  */
1352           if (alt == best)
1353             alt = NO_REGS;
1354
1355           if (dump
1356               && (reg_pref[i].prefclass != (int) best
1357                   || reg_pref[i].altclass != (int) alt))
1358             {
1359               static const char *const reg_class_names[] = REG_CLASS_NAMES;
1360               fprintf (dump, "  Register %i", i);
1361               if (alt == ALL_REGS || best == ALL_REGS)
1362                 fprintf (dump, " pref %s\n", reg_class_names[(int) best]);
1363               else if (alt == NO_REGS)
1364                 fprintf (dump, " pref %s or none\n", reg_class_names[(int) best]);
1365               else
1366                 fprintf (dump, " pref %s, else %s\n",
1367                          reg_class_names[(int) best],
1368                          reg_class_names[(int) alt]);
1369             }
1370
1371           /* We cast to (int) because (char) hits bugs in some compilers.  */
1372           reg_pref[i].prefclass = (int) best;
1373           reg_pref[i].altclass = (int) alt;
1374         }
1375     }
1376
1377 #ifdef FORBIDDEN_INC_DEC_CLASSES
1378   free (in_inc_dec);
1379 #endif
1380   free (costs);
1381 }
1382 \f
1383 /* Record the cost of using memory or registers of various classes for
1384    the operands in INSN.
1385
1386    N_ALTS is the number of alternatives.
1387
1388    N_OPS is the number of operands.
1389
1390    OPS is an array of the operands.
1391
1392    MODES are the modes of the operands, in case any are VOIDmode.
1393
1394    CONSTRAINTS are the constraints to use for the operands.  This array
1395    is modified by this procedure.
1396
1397    This procedure works alternative by alternative.  For each alternative
1398    we assume that we will be able to allocate all pseudos to their ideal
1399    register class and calculate the cost of using that alternative.  Then
1400    we compute for each operand that is a pseudo-register, the cost of
1401    having the pseudo allocated to each register class and using it in that
1402    alternative.  To this cost is added the cost of the alternative.
1403
1404    The cost of each class for this insn is its lowest cost among all the
1405    alternatives.  */
1406
1407 static void
1408 record_reg_classes (int n_alts, int n_ops, rtx *ops,
1409                     enum machine_mode *modes, const char **constraints,
1410                     rtx insn, struct costs *op_costs,
1411                     struct reg_pref *reg_pref)
1412 {
1413   int alt;
1414   int i, j;
1415   rtx set;
1416
1417   /* Process each alternative, each time minimizing an operand's cost with
1418      the cost for each operand in that alternative.  */
1419
1420   for (alt = 0; alt < n_alts; alt++)
1421     {
1422       struct costs this_op_costs[MAX_RECOG_OPERANDS];
1423       int alt_fail = 0;
1424       int alt_cost = 0;
1425       enum reg_class classes[MAX_RECOG_OPERANDS];
1426       int allows_mem[MAX_RECOG_OPERANDS];
1427       int class;
1428
1429       for (i = 0; i < n_ops; i++)
1430         {
1431           const char *p = constraints[i];
1432           rtx op = ops[i];
1433           enum machine_mode mode = modes[i];
1434           int allows_addr = 0;
1435           int win = 0;
1436           unsigned char c;
1437
1438           /* Initially show we know nothing about the register class.  */
1439           classes[i] = NO_REGS;
1440           allows_mem[i] = 0;
1441
1442           /* If this operand has no constraints at all, we can conclude
1443              nothing about it since anything is valid.  */
1444
1445           if (*p == 0)
1446             {
1447               if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
1448                 memset (&this_op_costs[i], 0, sizeof this_op_costs[i]);
1449
1450               continue;
1451             }
1452
1453           /* If this alternative is only relevant when this operand
1454              matches a previous operand, we do different things depending
1455              on whether this operand is a pseudo-reg or not.  We must process
1456              any modifiers for the operand before we can make this test.  */
1457
1458           while (*p == '%' || *p == '=' || *p == '+' || *p == '&')
1459             p++;
1460
1461           if (p[0] >= '0' && p[0] <= '0' + i && (p[1] == ',' || p[1] == 0))
1462             {
1463               /* Copy class and whether memory is allowed from the matching
1464                  alternative.  Then perform any needed cost computations
1465                  and/or adjustments.  */
1466               j = p[0] - '0';
1467               classes[i] = classes[j];
1468               allows_mem[i] = allows_mem[j];
1469
1470               if (!REG_P (op) || REGNO (op) < FIRST_PSEUDO_REGISTER)
1471                 {
1472                   /* If this matches the other operand, we have no added
1473                      cost and we win.  */
1474                   if (rtx_equal_p (ops[j], op))
1475                     win = 1;
1476
1477                   /* If we can put the other operand into a register, add to
1478                      the cost of this alternative the cost to copy this
1479                      operand to the register used for the other operand.  */
1480
1481                   else if (classes[j] != NO_REGS)
1482                     alt_cost += copy_cost (op, mode, classes[j], 1), win = 1;
1483                 }
1484               else if (!REG_P (ops[j])
1485                        || REGNO (ops[j]) < FIRST_PSEUDO_REGISTER)
1486                 {
1487                   /* This op is a pseudo but the one it matches is not.  */
1488
1489                   /* If we can't put the other operand into a register, this
1490                      alternative can't be used.  */
1491
1492                   if (classes[j] == NO_REGS)
1493                     alt_fail = 1;
1494
1495                   /* Otherwise, add to the cost of this alternative the cost
1496                      to copy the other operand to the register used for this
1497                      operand.  */
1498
1499                   else
1500                     alt_cost += copy_cost (ops[j], mode, classes[j], 1);
1501                 }
1502               else
1503                 {
1504                   /* The costs of this operand are not the same as the other
1505                      operand since move costs are not symmetric.  Moreover,
1506                      if we cannot tie them, this alternative needs to do a
1507                      copy, which is one instruction.  */
1508
1509                   struct costs *pp = &this_op_costs[i];
1510
1511                   for (class = 0; class < N_REG_CLASSES; class++)
1512                     pp->cost[class]
1513                       = ((recog_data.operand_type[i] != OP_OUT
1514                           ? may_move_in_cost[mode][class][(int) classes[i]]
1515                           : 0)
1516                          + (recog_data.operand_type[i] != OP_IN
1517                             ? may_move_out_cost[mode][(int) classes[i]][class]
1518                             : 0));
1519
1520                   /* If the alternative actually allows memory, make things
1521                      a bit cheaper since we won't need an extra insn to
1522                      load it.  */
1523
1524                   pp->mem_cost
1525                     = ((recog_data.operand_type[i] != OP_IN
1526                         ? MEMORY_MOVE_COST (mode, classes[i], 0)
1527                         : 0)
1528                        + (recog_data.operand_type[i] != OP_OUT
1529                           ? MEMORY_MOVE_COST (mode, classes[i], 1)
1530                           : 0) - allows_mem[i]);
1531
1532                   /* If we have assigned a class to this register in our
1533                      first pass, add a cost to this alternative corresponding
1534                      to what we would add if this register were not in the
1535                      appropriate class.  */
1536
1537                   if (reg_pref)
1538                     alt_cost
1539                       += (may_move_in_cost[mode]
1540                           [(unsigned char) reg_pref[REGNO (op)].prefclass]
1541                           [(int) classes[i]]);
1542
1543                   if (REGNO (ops[i]) != REGNO (ops[j])
1544                       && ! find_reg_note (insn, REG_DEAD, op))
1545                     alt_cost += 2;
1546
1547                   /* This is in place of ordinary cost computation
1548                      for this operand, so skip to the end of the
1549                      alternative (should be just one character).  */
1550                   while (*p && *p++ != ',')
1551                     ;
1552
1553                   constraints[i] = p;
1554                   continue;
1555                 }
1556             }
1557
1558           /* Scan all the constraint letters.  See if the operand matches
1559              any of the constraints.  Collect the valid register classes
1560              and see if this operand accepts memory.  */
1561
1562           while ((c = *p))
1563             {
1564               switch (c)
1565                 {
1566                 case ',':
1567                   break;
1568                 case '*':
1569                   /* Ignore the next letter for this pass.  */
1570                   c = *++p;
1571                   break;
1572
1573                 case '?':
1574                   alt_cost += 2;
1575                 case '!':  case '#':  case '&':
1576                 case '0':  case '1':  case '2':  case '3':  case '4':
1577                 case '5':  case '6':  case '7':  case '8':  case '9':
1578                   break;
1579
1580                 case 'p':
1581                   allows_addr = 1;
1582                   win = address_operand (op, GET_MODE (op));
1583                   /* We know this operand is an address, so we want it to be
1584                      allocated to a register that can be the base of an
1585                      address, i.e. BASE_REG_CLASS.  */
1586                   classes[i]
1587                     = reg_class_subunion[(int) classes[i]]
1588                       [(int) MODE_BASE_REG_CLASS (VOIDmode)];
1589                   break;
1590
1591                 case 'm':  case 'o':  case 'V':
1592                   /* It doesn't seem worth distinguishing between offsettable
1593                      and non-offsettable addresses here.  */
1594                   allows_mem[i] = 1;
1595                   if (MEM_P (op))
1596                     win = 1;
1597                   break;
1598
1599                 case '<':
1600                   if (MEM_P (op)
1601                       && (GET_CODE (XEXP (op, 0)) == PRE_DEC
1602                           || GET_CODE (XEXP (op, 0)) == POST_DEC))
1603                     win = 1;
1604                   break;
1605
1606                 case '>':
1607                   if (MEM_P (op)
1608                       && (GET_CODE (XEXP (op, 0)) == PRE_INC
1609                           || GET_CODE (XEXP (op, 0)) == POST_INC))
1610                     win = 1;
1611                   break;
1612
1613                 case 'E':
1614                 case 'F':
1615                   if (GET_CODE (op) == CONST_DOUBLE
1616                       || (GET_CODE (op) == CONST_VECTOR
1617                           && (GET_MODE_CLASS (GET_MODE (op))
1618                               == MODE_VECTOR_FLOAT)))
1619                     win = 1;
1620                   break;
1621
1622                 case 'G':
1623                 case 'H':
1624                   if (GET_CODE (op) == CONST_DOUBLE
1625                       && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
1626                     win = 1;
1627                   break;
1628
1629                 case 's':
1630                   if (GET_CODE (op) == CONST_INT
1631                       || (GET_CODE (op) == CONST_DOUBLE
1632                           && GET_MODE (op) == VOIDmode))
1633                     break;
1634                 case 'i':
1635                   if (CONSTANT_P (op)
1636                       && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op)))
1637                     win = 1;
1638                   break;
1639
1640                 case 'n':
1641                   if (GET_CODE (op) == CONST_INT
1642                       || (GET_CODE (op) == CONST_DOUBLE
1643                           && GET_MODE (op) == VOIDmode))
1644                     win = 1;
1645                   break;
1646
1647                 case 'I':
1648                 case 'J':
1649                 case 'K':
1650                 case 'L':
1651                 case 'M':
1652                 case 'N':
1653                 case 'O':
1654                 case 'P':
1655                   if (GET_CODE (op) == CONST_INT
1656                       && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), c, p))
1657                     win = 1;
1658                   break;
1659
1660                 case 'X':
1661                   win = 1;
1662                   break;
1663
1664                 case 'g':
1665                   if (MEM_P (op)
1666                       || (CONSTANT_P (op)
1667                           && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))))
1668                     win = 1;
1669                   allows_mem[i] = 1;
1670                 case 'r':
1671                   classes[i]
1672                     = reg_class_subunion[(int) classes[i]][(int) GENERAL_REGS];
1673                   break;
1674
1675                 default:
1676                   if (REG_CLASS_FROM_CONSTRAINT (c, p) != NO_REGS)
1677                     classes[i]
1678                       = reg_class_subunion[(int) classes[i]]
1679                         [(int) REG_CLASS_FROM_CONSTRAINT (c, p)];
1680 #ifdef EXTRA_CONSTRAINT_STR
1681                   else if (EXTRA_CONSTRAINT_STR (op, c, p))
1682                     win = 1;
1683
1684                   if (EXTRA_MEMORY_CONSTRAINT (c, p))
1685                     {
1686                       /* Every MEM can be reloaded to fit.  */
1687                       allows_mem[i] = 1;
1688                       if (MEM_P (op))
1689                         win = 1;
1690                     }
1691                   if (EXTRA_ADDRESS_CONSTRAINT (c, p))
1692                     {
1693                       /* Every address can be reloaded to fit.  */
1694                       allows_addr = 1;
1695                       if (address_operand (op, GET_MODE (op)))
1696                         win = 1;
1697                       /* We know this operand is an address, so we want it to
1698                          be allocated to a register that can be the base of an
1699                          address, i.e. BASE_REG_CLASS.  */
1700                       classes[i]
1701                         = reg_class_subunion[(int) classes[i]]
1702                           [(int) MODE_BASE_REG_CLASS (VOIDmode)];
1703                     }
1704 #endif
1705                   break;
1706                 }
1707               p += CONSTRAINT_LEN (c, p);
1708               if (c == ',')
1709                 break;
1710             }
1711
1712           constraints[i] = p;
1713
1714           /* How we account for this operand now depends on whether it is  a
1715              pseudo register or not.  If it is, we first check if any
1716              register classes are valid.  If not, we ignore this alternative,
1717              since we want to assume that all pseudos get allocated for
1718              register preferencing.  If some register class is valid, compute
1719              the costs of moving the pseudo into that class.  */
1720
1721           if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
1722             {
1723               if (classes[i] == NO_REGS)
1724                 {
1725                   /* We must always fail if the operand is a REG, but
1726                      we did not find a suitable class.
1727
1728                      Otherwise we may perform an uninitialized read
1729                      from this_op_costs after the `continue' statement
1730                      below.  */
1731                   alt_fail = 1;
1732                 }
1733               else
1734                 {
1735                   struct costs *pp = &this_op_costs[i];
1736
1737                   for (class = 0; class < N_REG_CLASSES; class++)
1738                     pp->cost[class]
1739                       = ((recog_data.operand_type[i] != OP_OUT
1740                           ? may_move_in_cost[mode][class][(int) classes[i]]
1741                           : 0)
1742                          + (recog_data.operand_type[i] != OP_IN
1743                             ? may_move_out_cost[mode][(int) classes[i]][class]
1744                             : 0));
1745
1746                   /* If the alternative actually allows memory, make things
1747                      a bit cheaper since we won't need an extra insn to
1748                      load it.  */
1749
1750                   pp->mem_cost
1751                     = ((recog_data.operand_type[i] != OP_IN
1752                         ? MEMORY_MOVE_COST (mode, classes[i], 0)
1753                         : 0)
1754                        + (recog_data.operand_type[i] != OP_OUT
1755                           ? MEMORY_MOVE_COST (mode, classes[i], 1)
1756                           : 0) - allows_mem[i]);
1757
1758                   /* If we have assigned a class to this register in our
1759                      first pass, add a cost to this alternative corresponding
1760                      to what we would add if this register were not in the
1761                      appropriate class.  */
1762
1763                   if (reg_pref)
1764                     alt_cost
1765                       += (may_move_in_cost[mode]
1766                           [(unsigned char) reg_pref[REGNO (op)].prefclass]
1767                           [(int) classes[i]]);
1768                 }
1769             }
1770
1771           /* Otherwise, if this alternative wins, either because we
1772              have already determined that or if we have a hard register of
1773              the proper class, there is no cost for this alternative.  */
1774
1775           else if (win
1776                    || (REG_P (op)
1777                        && reg_fits_class_p (op, classes[i], 0, GET_MODE (op))))
1778             ;
1779
1780           /* If registers are valid, the cost of this alternative includes
1781              copying the object to and/or from a register.  */
1782
1783           else if (classes[i] != NO_REGS)
1784             {
1785               if (recog_data.operand_type[i] != OP_OUT)
1786                 alt_cost += copy_cost (op, mode, classes[i], 1);
1787
1788               if (recog_data.operand_type[i] != OP_IN)
1789                 alt_cost += copy_cost (op, mode, classes[i], 0);
1790             }
1791
1792           /* The only other way this alternative can be used is if this is a
1793              constant that could be placed into memory.  */
1794
1795           else if (CONSTANT_P (op) && (allows_addr || allows_mem[i]))
1796             alt_cost += MEMORY_MOVE_COST (mode, classes[i], 1);
1797           else
1798             alt_fail = 1;
1799         }
1800
1801       if (alt_fail)
1802         continue;
1803
1804       /* Finally, update the costs with the information we've calculated
1805          about this alternative.  */
1806
1807       for (i = 0; i < n_ops; i++)
1808         if (REG_P (ops[i])
1809             && REGNO (ops[i]) >= FIRST_PSEUDO_REGISTER)
1810           {
1811             struct costs *pp = &op_costs[i], *qq = &this_op_costs[i];
1812             int scale = 1 + (recog_data.operand_type[i] == OP_INOUT);
1813
1814             pp->mem_cost = MIN (pp->mem_cost,
1815                                 (qq->mem_cost + alt_cost) * scale);
1816
1817             for (class = 0; class < N_REG_CLASSES; class++)
1818               pp->cost[class] = MIN (pp->cost[class],
1819                                      (qq->cost[class] + alt_cost) * scale);
1820           }
1821     }
1822
1823   /* If this insn is a single set copying operand 1 to operand 0
1824      and one operand is a pseudo with the other a hard reg or a pseudo
1825      that prefers a register that is in its own register class then
1826      we may want to adjust the cost of that register class to -1.
1827
1828      Avoid the adjustment if the source does not die to avoid stressing of
1829      register allocator by preferrencing two colliding registers into single
1830      class.
1831
1832      Also avoid the adjustment if a copy between registers of the class
1833      is expensive (ten times the cost of a default copy is considered
1834      arbitrarily expensive).  This avoids losing when the preferred class
1835      is very expensive as the source of a copy instruction.  */
1836
1837   if ((set = single_set (insn)) != 0
1838       && ops[0] == SET_DEST (set) && ops[1] == SET_SRC (set)
1839       && REG_P (ops[0]) && REG_P (ops[1])
1840       && find_regno_note (insn, REG_DEAD, REGNO (ops[1])))
1841     for (i = 0; i <= 1; i++)
1842       if (REGNO (ops[i]) >= FIRST_PSEUDO_REGISTER)
1843         {
1844           unsigned int regno = REGNO (ops[!i]);
1845           enum machine_mode mode = GET_MODE (ops[!i]);
1846           int class;
1847           unsigned int nr;
1848
1849           if (regno >= FIRST_PSEUDO_REGISTER && reg_pref != 0)
1850             {
1851               enum reg_class pref = reg_pref[regno].prefclass;
1852
1853               if ((reg_class_size[(unsigned char) pref]
1854                    == (unsigned) CLASS_MAX_NREGS (pref, mode))
1855                   && REGISTER_MOVE_COST (mode, pref, pref) < 10 * 2)
1856                 op_costs[i].cost[(unsigned char) pref] = -1;
1857             }
1858           else if (regno < FIRST_PSEUDO_REGISTER)
1859             for (class = 0; class < N_REG_CLASSES; class++)
1860               if (TEST_HARD_REG_BIT (reg_class_contents[class], regno)
1861                   && reg_class_size[class] == (unsigned) CLASS_MAX_NREGS (class, mode))
1862                 {
1863                   if (reg_class_size[class] == 1)
1864                     op_costs[i].cost[class] = -1;
1865                   else
1866                     {
1867                       for (nr = 0; nr < (unsigned) hard_regno_nregs[regno][mode]; nr++)
1868                         {
1869                           if (! TEST_HARD_REG_BIT (reg_class_contents[class],
1870                                                    regno + nr))
1871                             break;
1872                         }
1873
1874                       if (nr == (unsigned) hard_regno_nregs[regno][mode])
1875                         op_costs[i].cost[class] = -1;
1876                     }
1877                 }
1878         }
1879 }
1880 \f
1881 /* Compute the cost of loading X into (if TO_P is nonzero) or from (if
1882    TO_P is zero) a register of class CLASS in mode MODE.
1883
1884    X must not be a pseudo.  */
1885
1886 static int
1887 copy_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
1888            enum reg_class class, int to_p ATTRIBUTE_UNUSED)
1889 {
1890 #ifdef HAVE_SECONDARY_RELOADS
1891   enum reg_class secondary_class = NO_REGS;
1892 #endif
1893
1894   /* If X is a SCRATCH, there is actually nothing to move since we are
1895      assuming optimal allocation.  */
1896
1897   if (GET_CODE (x) == SCRATCH)
1898     return 0;
1899
1900   /* Get the class we will actually use for a reload.  */
1901   class = PREFERRED_RELOAD_CLASS (x, class);
1902
1903 #ifdef HAVE_SECONDARY_RELOADS
1904   /* If we need a secondary reload (we assume here that we are using
1905      the secondary reload as an intermediate, not a scratch register), the
1906      cost is that to load the input into the intermediate register, then
1907      to copy them.  We use a special value of TO_P to avoid recursion.  */
1908
1909 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1910   if (to_p == 1)
1911     secondary_class = SECONDARY_INPUT_RELOAD_CLASS (class, mode, x);
1912 #endif
1913
1914 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1915   if (! to_p)
1916     secondary_class = SECONDARY_OUTPUT_RELOAD_CLASS (class, mode, x);
1917 #endif
1918
1919   if (secondary_class != NO_REGS)
1920     return (move_cost[mode][(int) secondary_class][(int) class]
1921             + copy_cost (x, mode, secondary_class, 2));
1922 #endif  /* HAVE_SECONDARY_RELOADS */
1923
1924   /* For memory, use the memory move cost, for (hard) registers, use the
1925      cost to move between the register classes, and use 2 for everything
1926      else (constants).  */
1927
1928   if (MEM_P (x) || class == NO_REGS)
1929     return MEMORY_MOVE_COST (mode, class, to_p);
1930
1931   else if (REG_P (x))
1932     return move_cost[mode][(int) REGNO_REG_CLASS (REGNO (x))][(int) class];
1933
1934   else
1935     /* If this is a constant, we may eventually want to call rtx_cost here.  */
1936     return COSTS_N_INSNS (1);
1937 }
1938 \f
1939 /* Record the pseudo registers we must reload into hard registers
1940    in a subexpression of a memory address, X.
1941
1942    CLASS is the class that the register needs to be in and is either
1943    BASE_REG_CLASS or INDEX_REG_CLASS.
1944
1945    SCALE is twice the amount to multiply the cost by (it is twice so we
1946    can represent half-cost adjustments).  */
1947
1948 static void
1949 record_address_regs (rtx x, enum reg_class class, int scale)
1950 {
1951   enum rtx_code code = GET_CODE (x);
1952
1953   switch (code)
1954     {
1955     case CONST_INT:
1956     case CONST:
1957     case CC0:
1958     case PC:
1959     case SYMBOL_REF:
1960     case LABEL_REF:
1961       return;
1962
1963     case PLUS:
1964       /* When we have an address that is a sum,
1965          we must determine whether registers are "base" or "index" regs.
1966          If there is a sum of two registers, we must choose one to be
1967          the "base".  Luckily, we can use the REG_POINTER to make a good
1968          choice most of the time.  We only need to do this on machines
1969          that can have two registers in an address and where the base
1970          and index register classes are different.
1971
1972          ??? This code used to set REGNO_POINTER_FLAG in some cases, but
1973          that seems bogus since it should only be set when we are sure
1974          the register is being used as a pointer.  */
1975
1976       {
1977         rtx arg0 = XEXP (x, 0);
1978         rtx arg1 = XEXP (x, 1);
1979         enum rtx_code code0 = GET_CODE (arg0);
1980         enum rtx_code code1 = GET_CODE (arg1);
1981
1982         /* Look inside subregs.  */
1983         if (code0 == SUBREG)
1984           arg0 = SUBREG_REG (arg0), code0 = GET_CODE (arg0);
1985         if (code1 == SUBREG)
1986           arg1 = SUBREG_REG (arg1), code1 = GET_CODE (arg1);
1987
1988         /* If this machine only allows one register per address, it must
1989            be in the first operand.  */
1990
1991         if (MAX_REGS_PER_ADDRESS == 1)
1992           record_address_regs (arg0, class, scale);
1993
1994         /* If index and base registers are the same on this machine, just
1995            record registers in any non-constant operands.  We assume here,
1996            as well as in the tests below, that all addresses are in
1997            canonical form.  */
1998
1999         else if (INDEX_REG_CLASS == MODE_BASE_REG_CLASS (VOIDmode))
2000           {
2001             record_address_regs (arg0, class, scale);
2002             if (! CONSTANT_P (arg1))
2003               record_address_regs (arg1, class, scale);
2004           }
2005
2006         /* If the second operand is a constant integer, it doesn't change
2007            what class the first operand must be.  */
2008
2009         else if (code1 == CONST_INT || code1 == CONST_DOUBLE)
2010           record_address_regs (arg0, class, scale);
2011
2012         /* If the second operand is a symbolic constant, the first operand
2013            must be an index register.  */
2014
2015         else if (code1 == SYMBOL_REF || code1 == CONST || code1 == LABEL_REF)
2016           record_address_regs (arg0, INDEX_REG_CLASS, scale);
2017
2018         /* If both operands are registers but one is already a hard register
2019            of index or base class, give the other the class that the hard
2020            register is not.  */
2021
2022 #ifdef REG_OK_FOR_BASE_P
2023         else if (code0 == REG && code1 == REG
2024                  && REGNO (arg0) < FIRST_PSEUDO_REGISTER
2025                  && (REG_OK_FOR_BASE_P (arg0) || REG_OK_FOR_INDEX_P (arg0)))
2026           record_address_regs (arg1,
2027                                REG_OK_FOR_BASE_P (arg0)
2028                                ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (VOIDmode),
2029                                scale);
2030         else if (code0 == REG && code1 == REG
2031                  && REGNO (arg1) < FIRST_PSEUDO_REGISTER
2032                  && (REG_OK_FOR_BASE_P (arg1) || REG_OK_FOR_INDEX_P (arg1)))
2033           record_address_regs (arg0,
2034                                REG_OK_FOR_BASE_P (arg1)
2035                                ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (VOIDmode),
2036                                scale);
2037 #endif
2038
2039         /* If one operand is known to be a pointer, it must be the base
2040            with the other operand the index.  Likewise if the other operand
2041            is a MULT.  */
2042
2043         else if ((code0 == REG && REG_POINTER (arg0))
2044                  || code1 == MULT)
2045           {
2046             record_address_regs (arg0, MODE_BASE_REG_CLASS (VOIDmode), scale);
2047             record_address_regs (arg1, INDEX_REG_CLASS, scale);
2048           }
2049         else if ((code1 == REG && REG_POINTER (arg1))
2050                  || code0 == MULT)
2051           {
2052             record_address_regs (arg0, INDEX_REG_CLASS, scale);
2053             record_address_regs (arg1, MODE_BASE_REG_CLASS (VOIDmode), scale);
2054           }
2055
2056         /* Otherwise, count equal chances that each might be a base
2057            or index register.  This case should be rare.  */
2058
2059         else
2060           {
2061             record_address_regs (arg0, MODE_BASE_REG_CLASS (VOIDmode),
2062                                  scale / 2);
2063             record_address_regs (arg0, INDEX_REG_CLASS, scale / 2);
2064             record_address_regs (arg1, MODE_BASE_REG_CLASS (VOIDmode),
2065                                  scale / 2);
2066             record_address_regs (arg1, INDEX_REG_CLASS, scale / 2);
2067           }
2068       }
2069       break;
2070
2071       /* Double the importance of a pseudo register that is incremented
2072          or decremented, since it would take two extra insns
2073          if it ends up in the wrong place.  */
2074     case POST_MODIFY:
2075     case PRE_MODIFY:
2076       record_address_regs (XEXP (x, 0), MODE_BASE_REG_CLASS (VOIDmode),
2077                            2 * scale);
2078       if (REG_P (XEXP (XEXP (x, 1), 1)))
2079         record_address_regs (XEXP (XEXP (x, 1), 1),
2080                              INDEX_REG_CLASS, 2 * scale);
2081       break;
2082
2083     case POST_INC:
2084     case PRE_INC:
2085     case POST_DEC:
2086     case PRE_DEC:
2087       /* Double the importance of a pseudo register that is incremented
2088          or decremented, since it would take two extra insns
2089          if it ends up in the wrong place.  If the operand is a pseudo,
2090          show it is being used in an INC_DEC context.  */
2091
2092 #ifdef FORBIDDEN_INC_DEC_CLASSES
2093       if (REG_P (XEXP (x, 0))
2094           && REGNO (XEXP (x, 0)) >= FIRST_PSEUDO_REGISTER)
2095         in_inc_dec[REGNO (XEXP (x, 0))] = 1;
2096 #endif
2097
2098       record_address_regs (XEXP (x, 0), class, 2 * scale);
2099       break;
2100
2101     case REG:
2102       {
2103         struct costs *pp = &costs[REGNO (x)];
2104         int i;
2105
2106         pp->mem_cost += (MEMORY_MOVE_COST (Pmode, class, 1) * scale) / 2;
2107
2108         for (i = 0; i < N_REG_CLASSES; i++)
2109           pp->cost[i] += (may_move_in_cost[Pmode][i][(int) class] * scale) / 2;
2110       }
2111       break;
2112
2113     default:
2114       {
2115         const char *fmt = GET_RTX_FORMAT (code);
2116         int i;
2117         for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2118           if (fmt[i] == 'e')
2119             record_address_regs (XEXP (x, i), class, scale);
2120       }
2121     }
2122 }
2123 \f
2124 #ifdef FORBIDDEN_INC_DEC_CLASSES
2125
2126 /* Return 1 if REG is valid as an auto-increment memory reference
2127    to an object of MODE.  */
2128
2129 static int
2130 auto_inc_dec_reg_p (rtx reg, enum machine_mode mode)
2131 {
2132   if (HAVE_POST_INCREMENT
2133       && memory_address_p (mode, gen_rtx_POST_INC (Pmode, reg)))
2134     return 1;
2135
2136   if (HAVE_POST_DECREMENT
2137       && memory_address_p (mode, gen_rtx_POST_DEC (Pmode, reg)))
2138     return 1;
2139
2140   if (HAVE_PRE_INCREMENT
2141       && memory_address_p (mode, gen_rtx_PRE_INC (Pmode, reg)))
2142     return 1;
2143
2144   if (HAVE_PRE_DECREMENT
2145       && memory_address_p (mode, gen_rtx_PRE_DEC (Pmode, reg)))
2146     return 1;
2147
2148   return 0;
2149 }
2150 #endif
2151 \f
2152 static short *renumber;
2153 static size_t regno_allocated;
2154 static unsigned int reg_n_max;
2155
2156 /* Allocate enough space to hold NUM_REGS registers for the tables used for
2157    reg_scan and flow_analysis that are indexed by the register number.  If
2158    NEW_P is nonzero, initialize all of the registers, otherwise only
2159    initialize the new registers allocated.  The same table is kept from
2160    function to function, only reallocating it when we need more room.  If
2161    RENUMBER_P is nonzero, allocate the reg_renumber array also.  */
2162
2163 void
2164 allocate_reg_info (size_t num_regs, int new_p, int renumber_p)
2165 {
2166   size_t size_info;
2167   size_t size_renumber;
2168   size_t min = (new_p) ? 0 : reg_n_max;
2169   struct reg_info_data *reg_data;
2170
2171   if (num_regs > regno_allocated)
2172     {
2173       size_t old_allocated = regno_allocated;
2174
2175       regno_allocated = num_regs + (num_regs / 20);     /* Add some slop space.  */
2176       size_renumber = regno_allocated * sizeof (short);
2177
2178       if (!reg_n_info)
2179         {
2180           VARRAY_REG_INIT (reg_n_info, regno_allocated, "reg_n_info");
2181           renumber = xmalloc (size_renumber);
2182           reg_pref_buffer = xmalloc (regno_allocated
2183                                      * sizeof (struct reg_pref));
2184         }
2185
2186       else
2187         {
2188           VARRAY_GROW (reg_n_info, regno_allocated);
2189
2190           if (new_p)            /* If we're zapping everything, no need to realloc.  */
2191             {
2192               free ((char *) renumber);
2193               free ((char *) reg_pref);
2194               renumber = xmalloc (size_renumber);
2195               reg_pref_buffer = xmalloc (regno_allocated
2196                                          * sizeof (struct reg_pref));
2197             }
2198
2199           else
2200             {
2201               renumber = xrealloc (renumber, size_renumber);
2202               reg_pref_buffer = xrealloc (reg_pref_buffer,
2203                                           regno_allocated
2204                                           * sizeof (struct reg_pref));
2205             }
2206         }
2207
2208       size_info = (regno_allocated - old_allocated) * sizeof (reg_info)
2209         + sizeof (struct reg_info_data) - sizeof (reg_info);
2210       reg_data = xcalloc (size_info, 1);
2211       reg_data->min_index = old_allocated;
2212       reg_data->max_index = regno_allocated - 1;
2213       reg_data->next = reg_info_head;
2214       reg_info_head = reg_data;
2215     }
2216
2217   reg_n_max = num_regs;
2218   if (min < num_regs)
2219     {
2220       /* Loop through each of the segments allocated for the actual
2221          reg_info pages, and set up the pointers, zero the pages, etc.  */
2222       for (reg_data = reg_info_head;
2223            reg_data && reg_data->max_index >= min;
2224            reg_data = reg_data->next)
2225         {
2226           size_t min_index = reg_data->min_index;
2227           size_t max_index = reg_data->max_index;
2228           size_t max = MIN (max_index, num_regs);
2229           size_t local_min = min - min_index;
2230           size_t i;
2231
2232           if (reg_data->min_index > num_regs)
2233             continue;
2234
2235           if (min < min_index)
2236             local_min = 0;
2237           if (!reg_data->used_p)        /* page just allocated with calloc */
2238             reg_data->used_p = 1;       /* no need to zero */
2239           else
2240             memset (&reg_data->data[local_min], 0,
2241                     sizeof (reg_info) * (max - min_index - local_min + 1));
2242
2243           for (i = min_index+local_min; i <= max; i++)
2244             {
2245               VARRAY_REG (reg_n_info, i) = &reg_data->data[i-min_index];
2246               REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;
2247               renumber[i] = -1;
2248               reg_pref_buffer[i].prefclass = (char) NO_REGS;
2249               reg_pref_buffer[i].altclass = (char) NO_REGS;
2250             }
2251         }
2252     }
2253
2254   /* If {pref,alt}class have already been allocated, update the pointers to
2255      the newly realloced ones.  */
2256   if (reg_pref)
2257     reg_pref = reg_pref_buffer;
2258
2259   if (renumber_p)
2260     reg_renumber = renumber;
2261
2262   /* Tell the regset code about the new number of registers.  */
2263   MAX_REGNO_REG_SET (num_regs, new_p, renumber_p);
2264 }
2265
2266 /* Free up the space allocated by allocate_reg_info.  */
2267 void
2268 free_reg_info (void)
2269 {
2270   if (reg_n_info)
2271     {
2272       struct reg_info_data *reg_data;
2273       struct reg_info_data *reg_next;
2274
2275       VARRAY_FREE (reg_n_info);
2276       for (reg_data = reg_info_head; reg_data; reg_data = reg_next)
2277         {
2278           reg_next = reg_data->next;
2279           free ((char *) reg_data);
2280         }
2281
2282       free (reg_pref_buffer);
2283       reg_pref_buffer = (struct reg_pref *) 0;
2284       reg_info_head = (struct reg_info_data *) 0;
2285       renumber = (short *) 0;
2286     }
2287   regno_allocated = 0;
2288   reg_n_max = 0;
2289 }
2290 \f
2291 /* This is the `regscan' pass of the compiler, run just before cse
2292    and again just before loop.
2293
2294    It finds the first and last use of each pseudo-register
2295    and records them in the vectors regno_first_uid, regno_last_uid
2296    and counts the number of sets in the vector reg_n_sets.
2297
2298    REPEAT is nonzero the second time this is called.  */
2299
2300 /* Maximum number of parallel sets and clobbers in any insn in this fn.
2301    Always at least 3, since the combiner could put that many together
2302    and we want this to remain correct for all the remaining passes.
2303    This corresponds to the maximum number of times note_stores will call
2304    a function for any insn.  */
2305
2306 int max_parallel;
2307
2308 /* Used as a temporary to record the largest number of registers in
2309    PARALLEL in a SET_DEST.  This is added to max_parallel.  */
2310
2311 static int max_set_parallel;
2312
2313 void
2314 reg_scan (rtx f, unsigned int nregs, int repeat ATTRIBUTE_UNUSED)
2315 {
2316   rtx insn;
2317
2318   timevar_push (TV_REG_SCAN);
2319
2320   allocate_reg_info (nregs, TRUE, FALSE);
2321   max_parallel = 3;
2322   max_set_parallel = 0;
2323
2324   for (insn = f; insn; insn = NEXT_INSN (insn))
2325     if (INSN_P (insn))
2326       {
2327         rtx pat = PATTERN (insn);
2328         if (GET_CODE (pat) == PARALLEL
2329             && XVECLEN (pat, 0) > max_parallel)
2330           max_parallel = XVECLEN (pat, 0);
2331         reg_scan_mark_refs (pat, insn, 0, 0);
2332
2333         if (REG_NOTES (insn))
2334           reg_scan_mark_refs (REG_NOTES (insn), insn, 1, 0);
2335       }
2336
2337   max_parallel += max_set_parallel;
2338
2339   timevar_pop (TV_REG_SCAN);
2340 }
2341
2342 /* Update 'regscan' information by looking at the insns
2343    from FIRST to LAST.  Some new REGs have been created,
2344    and any REG with number greater than OLD_MAX_REGNO is
2345    such a REG.  We only update information for those.  */
2346
2347 void
2348 reg_scan_update (rtx first, rtx last, unsigned int old_max_regno)
2349 {
2350   rtx insn;
2351
2352   allocate_reg_info (max_reg_num (), FALSE, FALSE);
2353
2354   for (insn = first; insn != last; insn = NEXT_INSN (insn))
2355     if (INSN_P (insn))
2356       {
2357         rtx pat = PATTERN (insn);
2358         if (GET_CODE (pat) == PARALLEL
2359             && XVECLEN (pat, 0) > max_parallel)
2360           max_parallel = XVECLEN (pat, 0);
2361         reg_scan_mark_refs (pat, insn, 0, old_max_regno);
2362
2363         if (REG_NOTES (insn))
2364           reg_scan_mark_refs (REG_NOTES (insn), insn, 1, old_max_regno);
2365       }
2366 }
2367
2368 /* X is the expression to scan.  INSN is the insn it appears in.
2369    NOTE_FLAG is nonzero if X is from INSN's notes rather than its body.
2370    We should only record information for REGs with numbers
2371    greater than or equal to MIN_REGNO.  */
2372
2373 static void
2374 reg_scan_mark_refs (rtx x, rtx insn, int note_flag, unsigned int min_regno)
2375 {
2376   enum rtx_code code;
2377   rtx dest;
2378   rtx note;
2379
2380   if (!x)
2381     return;
2382   code = GET_CODE (x);
2383   switch (code)
2384     {
2385     case CONST:
2386     case CONST_INT:
2387     case CONST_DOUBLE:
2388     case CONST_VECTOR:
2389     case CC0:
2390     case PC:
2391     case SYMBOL_REF:
2392     case LABEL_REF:
2393     case ADDR_VEC:
2394     case ADDR_DIFF_VEC:
2395       return;
2396
2397     case REG:
2398       {
2399         unsigned int regno = REGNO (x);
2400
2401         if (regno >= min_regno)
2402           {
2403             REGNO_LAST_NOTE_UID (regno) = INSN_UID (insn);
2404             if (!note_flag)
2405               REGNO_LAST_UID (regno) = INSN_UID (insn);
2406             if (REGNO_FIRST_UID (regno) == 0)
2407               REGNO_FIRST_UID (regno) = INSN_UID (insn);
2408             /* If we are called by reg_scan_update() (indicated by min_regno
2409                being set), we also need to update the reference count.  */
2410             if (min_regno)
2411               REG_N_REFS (regno)++;
2412           }
2413       }
2414       break;
2415
2416     case EXPR_LIST:
2417       if (XEXP (x, 0))
2418         reg_scan_mark_refs (XEXP (x, 0), insn, note_flag, min_regno);
2419       if (XEXP (x, 1))
2420         reg_scan_mark_refs (XEXP (x, 1), insn, note_flag, min_regno);
2421       break;
2422
2423     case INSN_LIST:
2424       if (XEXP (x, 1))
2425         reg_scan_mark_refs (XEXP (x, 1), insn, note_flag, min_regno);
2426       break;
2427
2428     case CLOBBER:
2429       {
2430         rtx reg = XEXP (x, 0);
2431         if (REG_P (reg)
2432             && REGNO (reg) >= min_regno)
2433           {
2434             REG_N_SETS (REGNO (reg))++;
2435             REG_N_REFS (REGNO (reg))++;
2436           }
2437         else if (MEM_P (reg))
2438           reg_scan_mark_refs (XEXP (reg, 0), insn, note_flag, min_regno);
2439       }
2440       break;
2441
2442     case SET:
2443       /* Count a set of the destination if it is a register.  */
2444       for (dest = SET_DEST (x);
2445            GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
2446            || GET_CODE (dest) == ZERO_EXTEND;
2447            dest = XEXP (dest, 0))
2448         ;
2449
2450       /* For a PARALLEL, record the number of things (less the usual one for a
2451          SET) that are set.  */
2452       if (GET_CODE (dest) == PARALLEL)
2453         max_set_parallel = MAX (max_set_parallel, XVECLEN (dest, 0) - 1);
2454
2455       if (REG_P (dest)
2456           && REGNO (dest) >= min_regno)
2457         {
2458           REG_N_SETS (REGNO (dest))++;
2459           REG_N_REFS (REGNO (dest))++;
2460         }
2461
2462       /* If this is setting a pseudo from another pseudo or the sum of a
2463          pseudo and a constant integer and the other pseudo is known to be
2464          a pointer, set the destination to be a pointer as well.
2465
2466          Likewise if it is setting the destination from an address or from a
2467          value equivalent to an address or to the sum of an address and
2468          something else.
2469
2470          But don't do any of this if the pseudo corresponds to a user
2471          variable since it should have already been set as a pointer based
2472          on the type.  */
2473
2474       if (REG_P (SET_DEST (x))
2475           && REGNO (SET_DEST (x)) >= FIRST_PSEUDO_REGISTER
2476           && REGNO (SET_DEST (x)) >= min_regno
2477           /* If the destination pseudo is set more than once, then other
2478              sets might not be to a pointer value (consider access to a
2479              union in two threads of control in the presence of global
2480              optimizations).  So only set REG_POINTER on the destination
2481              pseudo if this is the only set of that pseudo.  */
2482           && REG_N_SETS (REGNO (SET_DEST (x))) == 1
2483           && ! REG_USERVAR_P (SET_DEST (x))
2484           && ! REG_POINTER (SET_DEST (x))
2485           && ((REG_P (SET_SRC (x))
2486                && REG_POINTER (SET_SRC (x)))
2487               || ((GET_CODE (SET_SRC (x)) == PLUS
2488                    || GET_CODE (SET_SRC (x)) == LO_SUM)
2489                   && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
2490                   && REG_P (XEXP (SET_SRC (x), 0))
2491                   && REG_POINTER (XEXP (SET_SRC (x), 0)))
2492               || GET_CODE (SET_SRC (x)) == CONST
2493               || GET_CODE (SET_SRC (x)) == SYMBOL_REF
2494               || GET_CODE (SET_SRC (x)) == LABEL_REF
2495               || (GET_CODE (SET_SRC (x)) == HIGH
2496                   && (GET_CODE (XEXP (SET_SRC (x), 0)) == CONST
2497                       || GET_CODE (XEXP (SET_SRC (x), 0)) == SYMBOL_REF
2498                       || GET_CODE (XEXP (SET_SRC (x), 0)) == LABEL_REF))
2499               || ((GET_CODE (SET_SRC (x)) == PLUS
2500                    || GET_CODE (SET_SRC (x)) == LO_SUM)
2501                   && (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST
2502                       || GET_CODE (XEXP (SET_SRC (x), 1)) == SYMBOL_REF
2503                       || GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF))
2504               || ((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
2505                   && (GET_CODE (XEXP (note, 0)) == CONST
2506                       || GET_CODE (XEXP (note, 0)) == SYMBOL_REF
2507                       || GET_CODE (XEXP (note, 0)) == LABEL_REF))))
2508         REG_POINTER (SET_DEST (x)) = 1;
2509
2510       /* If this is setting a register from a register or from a simple
2511          conversion of a register, propagate REG_EXPR.  */
2512       if (REG_P (dest))
2513         {
2514           rtx src = SET_SRC (x);
2515
2516           while (GET_CODE (src) == SIGN_EXTEND
2517                  || GET_CODE (src) == ZERO_EXTEND
2518                  || GET_CODE (src) == TRUNCATE
2519                  || (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)))
2520             src = XEXP (src, 0);
2521
2522           if (!REG_ATTRS (dest) && REG_P (src))
2523             REG_ATTRS (dest) = REG_ATTRS (src);
2524           if (!REG_ATTRS (dest) && MEM_P (src))
2525             set_reg_attrs_from_mem (dest, src);
2526         }
2527
2528       /* ... fall through ...  */
2529
2530     default:
2531       {
2532         const char *fmt = GET_RTX_FORMAT (code);
2533         int i;
2534         for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2535           {
2536             if (fmt[i] == 'e')
2537               reg_scan_mark_refs (XEXP (x, i), insn, note_flag, min_regno);
2538             else if (fmt[i] == 'E' && XVEC (x, i) != 0)
2539               {
2540                 int j;
2541                 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2542                   reg_scan_mark_refs (XVECEXP (x, i, j), insn, note_flag, min_regno);
2543               }
2544           }
2545       }
2546     }
2547 }
2548 \f
2549 /* Return nonzero if C1 is a subset of C2, i.e., if every register in C1
2550    is also in C2.  */
2551
2552 int
2553 reg_class_subset_p (enum reg_class c1, enum reg_class c2)
2554 {
2555   if (c1 == c2) return 1;
2556
2557   if (c2 == ALL_REGS)
2558   win:
2559     return 1;
2560   GO_IF_HARD_REG_SUBSET (reg_class_contents[(int) c1],
2561                          reg_class_contents[(int) c2],
2562                          win);
2563   return 0;
2564 }
2565
2566 /* Return nonzero if there is a register that is in both C1 and C2.  */
2567
2568 int
2569 reg_classes_intersect_p (enum reg_class c1, enum reg_class c2)
2570 {
2571   HARD_REG_SET c;
2572
2573   if (c1 == c2) return 1;
2574
2575   if (c1 == ALL_REGS || c2 == ALL_REGS)
2576     return 1;
2577
2578   COPY_HARD_REG_SET (c, reg_class_contents[(int) c1]);
2579   AND_HARD_REG_SET (c, reg_class_contents[(int) c2]);
2580
2581   GO_IF_HARD_REG_SUBSET (c, reg_class_contents[(int) NO_REGS], lose);
2582   return 1;
2583
2584  lose:
2585   return 0;
2586 }
2587
2588 /* Release any memory allocated by register sets.  */
2589
2590 void
2591 regset_release_memory (void)
2592 {
2593   bitmap_release_memory ();
2594 }
2595
2596 #ifdef CANNOT_CHANGE_MODE_CLASS
2597 /* Set bits in *USED which correspond to registers which can't change
2598    their mode from FROM to any mode in which REGNO was encountered.  */
2599
2600 void
2601 cannot_change_mode_set_regs (HARD_REG_SET *used, enum machine_mode from,
2602                              unsigned int regno)
2603 {
2604   enum machine_mode to;
2605   int n, i;
2606   int start = regno * MAX_MACHINE_MODE;
2607
2608   EXECUTE_IF_SET_IN_BITMAP (&subregs_of_mode, start, n,
2609     if (n >= MAX_MACHINE_MODE + start)
2610       return;
2611     to = n - start;
2612     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2613       if (! TEST_HARD_REG_BIT (*used, i)
2614           && REG_CANNOT_CHANGE_MODE_P (i, from, to))
2615         SET_HARD_REG_BIT (*used, i);
2616   );
2617 }
2618
2619 /* Return 1 if REGNO has had an invalid mode change in CLASS from FROM
2620    mode.  */
2621
2622 bool
2623 invalid_mode_change_p (unsigned int regno, enum reg_class class,
2624                        enum machine_mode from_mode)
2625 {
2626   enum machine_mode to_mode;
2627   int n;
2628   int start = regno * MAX_MACHINE_MODE;
2629
2630   EXECUTE_IF_SET_IN_BITMAP (&subregs_of_mode, start, n,
2631     if (n >= MAX_MACHINE_MODE + start)
2632       return 0;
2633     to_mode = n - start;
2634     if (CANNOT_CHANGE_MODE_CLASS (from_mode, to_mode, class))
2635       return 1;
2636   );
2637   return 0;
2638 }
2639 #endif /* CANNOT_CHANGE_MODE_CLASS */
2640
2641 #include "gt-regclass.h"