OSDN Git Service

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