OSDN Git Service

f180075194d9b328751ef6fcd05326b7f1ca6e88
[pf3gnuchains/gcc-fork.git] / gcc / cse.c
1 /* Common subexpression elimination for GNU compiler.
2    Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc.
3
4 This file is part of GNU CC.
5
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21
22 #include "config.h"
23 /* Must precede rtl.h for FFS.  */
24 #include <stdio.h>
25
26 #include "rtl.h"
27 #include "regs.h"
28 #include "hard-reg-set.h"
29 #include "flags.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "recog.h"
33
34 #include <setjmp.h>
35
36 /* The basic idea of common subexpression elimination is to go
37    through the code, keeping a record of expressions that would
38    have the same value at the current scan point, and replacing
39    expressions encountered with the cheapest equivalent expression.
40
41    It is too complicated to keep track of the different possibilities
42    when control paths merge; so, at each label, we forget all that is
43    known and start fresh.  This can be described as processing each
44    basic block separately.  Note, however, that these are not quite
45    the same as the basic blocks found by a later pass and used for
46    data flow analysis and register packing.  We do not need to start fresh
47    after a conditional jump instruction if there is no label there.
48
49    We use two data structures to record the equivalent expressions:
50    a hash table for most expressions, and several vectors together
51    with "quantity numbers" to record equivalent (pseudo) registers.
52
53    The use of the special data structure for registers is desirable
54    because it is faster.  It is possible because registers references
55    contain a fairly small number, the register number, taken from
56    a contiguously allocated series, and two register references are
57    identical if they have the same number.  General expressions
58    do not have any such thing, so the only way to retrieve the
59    information recorded on an expression other than a register
60    is to keep it in a hash table.
61
62 Registers and "quantity numbers":
63    
64    At the start of each basic block, all of the (hardware and pseudo)
65    registers used in the function are given distinct quantity
66    numbers to indicate their contents.  During scan, when the code
67    copies one register into another, we copy the quantity number.
68    When a register is loaded in any other way, we allocate a new
69    quantity number to describe the value generated by this operation.
70    `reg_qty' records what quantity a register is currently thought
71    of as containing.
72
73    All real quantity numbers are greater than or equal to `max_reg'.
74    If register N has not been assigned a quantity, reg_qty[N] will equal N.
75
76    Quantity numbers below `max_reg' do not exist and none of the `qty_...'
77    variables should be referenced with an index below `max_reg'.
78
79    We also maintain a bidirectional chain of registers for each
80    quantity number.  `qty_first_reg', `qty_last_reg',
81    `reg_next_eqv' and `reg_prev_eqv' hold these chains.
82
83    The first register in a chain is the one whose lifespan is least local.
84    Among equals, it is the one that was seen first.
85    We replace any equivalent register with that one.
86
87    If two registers have the same quantity number, it must be true that
88    REG expressions with `qty_mode' must be in the hash table for both
89    registers and must be in the same class.
90
91    The converse is not true.  Since hard registers may be referenced in
92    any mode, two REG expressions might be equivalent in the hash table
93    but not have the same quantity number if the quantity number of one
94    of the registers is not the same mode as those expressions.
95    
96 Constants and quantity numbers
97
98    When a quantity has a known constant value, that value is stored
99    in the appropriate element of qty_const.  This is in addition to
100    putting the constant in the hash table as is usual for non-regs.
101
102    Whether a reg or a constant is preferred is determined by the configuration
103    macro CONST_COSTS and will often depend on the constant value.  In any
104    event, expressions containing constants can be simplified, by fold_rtx.
105
106    When a quantity has a known nearly constant value (such as an address
107    of a stack slot), that value is stored in the appropriate element
108    of qty_const.
109
110    Integer constants don't have a machine mode.  However, cse
111    determines the intended machine mode from the destination
112    of the instruction that moves the constant.  The machine mode
113    is recorded in the hash table along with the actual RTL
114    constant expression so that different modes are kept separate.
115
116 Other expressions:
117
118    To record known equivalences among expressions in general
119    we use a hash table called `table'.  It has a fixed number of buckets
120    that contain chains of `struct table_elt' elements for expressions.
121    These chains connect the elements whose expressions have the same
122    hash codes.
123
124    Other chains through the same elements connect the elements which
125    currently have equivalent values.
126
127    Register references in an expression are canonicalized before hashing
128    the expression.  This is done using `reg_qty' and `qty_first_reg'.
129    The hash code of a register reference is computed using the quantity
130    number, not the register number.
131
132    When the value of an expression changes, it is necessary to remove from the
133    hash table not just that expression but all expressions whose values
134    could be different as a result.
135
136      1. If the value changing is in memory, except in special cases
137      ANYTHING referring to memory could be changed.  That is because
138      nobody knows where a pointer does not point.
139      The function `invalidate_memory' removes what is necessary.
140
141      The special cases are when the address is constant or is
142      a constant plus a fixed register such as the frame pointer
143      or a static chain pointer.  When such addresses are stored in,
144      we can tell exactly which other such addresses must be invalidated
145      due to overlap.  `invalidate' does this.
146      All expressions that refer to non-constant
147      memory addresses are also invalidated.  `invalidate_memory' does this.
148
149      2. If the value changing is a register, all expressions
150      containing references to that register, and only those,
151      must be removed.
152
153    Because searching the entire hash table for expressions that contain
154    a register is very slow, we try to figure out when it isn't necessary.
155    Precisely, this is necessary only when expressions have been
156    entered in the hash table using this register, and then the value has
157    changed, and then another expression wants to be added to refer to
158    the register's new value.  This sequence of circumstances is rare
159    within any one basic block.
160
161    The vectors `reg_tick' and `reg_in_table' are used to detect this case.
162    reg_tick[i] is incremented whenever a value is stored in register i.
163    reg_in_table[i] holds -1 if no references to register i have been
164    entered in the table; otherwise, it contains the value reg_tick[i] had
165    when the references were entered.  If we want to enter a reference
166    and reg_in_table[i] != reg_tick[i], we must scan and remove old references.
167    Until we want to enter a new entry, the mere fact that the two vectors
168    don't match makes the entries be ignored if anyone tries to match them.
169
170    Registers themselves are entered in the hash table as well as in
171    the equivalent-register chains.  However, the vectors `reg_tick'
172    and `reg_in_table' do not apply to expressions which are simple
173    register references.  These expressions are removed from the table
174    immediately when they become invalid, and this can be done even if
175    we do not immediately search for all the expressions that refer to
176    the register.
177
178    A CLOBBER rtx in an instruction invalidates its operand for further
179    reuse.  A CLOBBER or SET rtx whose operand is a MEM:BLK
180    invalidates everything that resides in memory.
181
182 Related expressions:
183
184    Constant expressions that differ only by an additive integer
185    are called related.  When a constant expression is put in
186    the table, the related expression with no constant term
187    is also entered.  These are made to point at each other
188    so that it is possible to find out if there exists any
189    register equivalent to an expression related to a given expression.  */
190    
191 /* One plus largest register number used in this function.  */
192
193 static int max_reg;
194
195 /* Length of vectors indexed by quantity number.
196    We know in advance we will not need a quantity number this big.  */
197
198 static int max_qty;
199
200 /* Next quantity number to be allocated.
201    This is 1 + the largest number needed so far.  */
202
203 static int next_qty;
204
205 /* Indexed by quantity number, gives the first (or last) (pseudo) register 
206    in the chain of registers that currently contain this quantity.  */
207
208 static int *qty_first_reg;
209 static int *qty_last_reg;
210
211 /* Index by quantity number, gives the mode of the quantity.  */
212
213 static enum machine_mode *qty_mode;
214
215 /* Indexed by quantity number, gives the rtx of the constant value of the
216    quantity, or zero if it does not have a known value.
217    A sum of the frame pointer (or arg pointer) plus a constant
218    can also be entered here.  */
219
220 static rtx *qty_const;
221
222 /* Indexed by qty number, gives the insn that stored the constant value
223    recorded in `qty_const'.  */
224
225 static rtx *qty_const_insn;
226
227 /* The next three variables are used to track when a comparison between a
228    quantity and some constant or register has been passed.  In that case, we
229    know the results of the comparison in case we see it again.  These variables
230    record a comparison that is known to be true.  */
231
232 /* Indexed by qty number, gives the rtx code of a comparison with a known
233    result involving this quantity.  If none, it is UNKNOWN.  */
234 static enum rtx_code *qty_comparison_code;
235
236 /* Indexed by qty number, gives the constant being compared against in a
237    comparison of known result.  If no such comparison, it is undefined.
238    If the comparison is not with a constant, it is zero.  */
239
240 static rtx *qty_comparison_const;
241
242 /* Indexed by qty number, gives the quantity being compared against in a
243    comparison of known result.  If no such comparison, if it undefined.
244    If the comparison is not with a register, it is -1.  */
245
246 static int *qty_comparison_qty;
247
248 #ifdef HAVE_cc0
249 /* For machines that have a CC0, we do not record its value in the hash
250    table since its use is guaranteed to be the insn immediately following
251    its definition and any other insn is presumed to invalidate it.
252
253    Instead, we store below the value last assigned to CC0.  If it should
254    happen to be a constant, it is stored in preference to the actual
255    assigned value.  In case it is a constant, we store the mode in which
256    the constant should be interpreted.  */
257
258 static rtx prev_insn_cc0;
259 static enum machine_mode prev_insn_cc0_mode;
260 #endif
261
262 /* Previous actual insn.  0 if at first insn of basic block.  */
263
264 static rtx prev_insn;
265
266 /* Insn being scanned.  */
267
268 static rtx this_insn;
269
270 /* Index by (pseudo) register number, gives the quantity number
271    of the register's current contents.  */
272
273 static int *reg_qty;
274
275 /* Index by (pseudo) register number, gives the number of the next (or
276    previous) (pseudo) register in the chain of registers sharing the same
277    value.
278
279    Or -1 if this register is at the end of the chain.
280
281    If reg_qty[N] == N, reg_next_eqv[N] is undefined.  */
282
283 static int *reg_next_eqv;
284 static int *reg_prev_eqv;
285
286 /* Index by (pseudo) register number, gives the number of times
287    that register has been altered in the current basic block.  */
288
289 static int *reg_tick;
290
291 /* Index by (pseudo) register number, gives the reg_tick value at which
292    rtx's containing this register are valid in the hash table.
293    If this does not equal the current reg_tick value, such expressions
294    existing in the hash table are invalid.
295    If this is -1, no expressions containing this register have been
296    entered in the table.  */
297
298 static int *reg_in_table;
299
300 /* A HARD_REG_SET containing all the hard registers for which there is 
301    currently a REG expression in the hash table.  Note the difference
302    from the above variables, which indicate if the REG is mentioned in some
303    expression in the table.  */
304
305 static HARD_REG_SET hard_regs_in_table;
306
307 /* A HARD_REG_SET containing all the hard registers that are invalidated
308    by a CALL_INSN.  */
309
310 static HARD_REG_SET regs_invalidated_by_call;
311
312 /* Two vectors of ints:
313    one containing max_reg -1's; the other max_reg + 500 (an approximation
314    for max_qty) elements where element i contains i.
315    These are used to initialize various other vectors fast.  */
316
317 static int *all_minus_one;
318 static int *consec_ints;
319
320 /* CUID of insn that starts the basic block currently being cse-processed.  */
321
322 static int cse_basic_block_start;
323
324 /* CUID of insn that ends the basic block currently being cse-processed.  */
325
326 static int cse_basic_block_end;
327
328 /* Vector mapping INSN_UIDs to cuids.
329    The cuids are like uids but increase monotonically always.
330    We use them to see whether a reg is used outside a given basic block.  */
331
332 static int *uid_cuid;
333
334 /* Highest UID in UID_CUID.  */
335 static int max_uid;
336
337 /* Get the cuid of an insn.  */
338
339 #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
340
341 /* Nonzero if cse has altered conditional jump insns
342    in such a way that jump optimization should be redone.  */
343
344 static int cse_jumps_altered;
345
346 /* Nonzero if we put a LABEL_REF into the hash table.  Since we may have put
347    it into an INSN without a REG_LABEL, we have to rerun jump after CSE
348    to put in the note.  */
349 static int recorded_label_ref;
350
351 /* canon_hash stores 1 in do_not_record
352    if it notices a reference to CC0, PC, or some other volatile
353    subexpression.  */
354
355 static int do_not_record;
356
357 #ifdef LOAD_EXTEND_OP
358
359 /* Scratch rtl used when looking for load-extended copy of a MEM.  */
360 static rtx memory_extend_rtx;
361 #endif
362
363 /* canon_hash stores 1 in hash_arg_in_memory
364    if it notices a reference to memory within the expression being hashed.  */
365
366 static int hash_arg_in_memory;
367
368 /* canon_hash stores 1 in hash_arg_in_struct
369    if it notices a reference to memory that's part of a structure.  */
370
371 static int hash_arg_in_struct;
372
373 /* The hash table contains buckets which are chains of `struct table_elt's,
374    each recording one expression's information.
375    That expression is in the `exp' field.
376
377    Those elements with the same hash code are chained in both directions
378    through the `next_same_hash' and `prev_same_hash' fields.
379
380    Each set of expressions with equivalent values
381    are on a two-way chain through the `next_same_value'
382    and `prev_same_value' fields, and all point with
383    the `first_same_value' field at the first element in
384    that chain.  The chain is in order of increasing cost.
385    Each element's cost value is in its `cost' field.
386
387    The `in_memory' field is nonzero for elements that
388    involve any reference to memory.  These elements are removed
389    whenever a write is done to an unidentified location in memory.
390    To be safe, we assume that a memory address is unidentified unless
391    the address is either a symbol constant or a constant plus
392    the frame pointer or argument pointer.
393
394    The `in_struct' field is nonzero for elements that
395    involve any reference to memory inside a structure or array.
396
397    The `related_value' field is used to connect related expressions
398    (that differ by adding an integer).
399    The related expressions are chained in a circular fashion.
400    `related_value' is zero for expressions for which this
401    chain is not useful.
402
403    The `cost' field stores the cost of this element's expression.
404
405    The `is_const' flag is set if the element is a constant (including
406    a fixed address).
407
408    The `flag' field is used as a temporary during some search routines.
409
410    The `mode' field is usually the same as GET_MODE (`exp'), but
411    if `exp' is a CONST_INT and has no machine mode then the `mode'
412    field is the mode it was being used as.  Each constant is
413    recorded separately for each mode it is used with.  */
414
415
416 struct table_elt
417 {
418   rtx exp;
419   struct table_elt *next_same_hash;
420   struct table_elt *prev_same_hash;
421   struct table_elt *next_same_value;
422   struct table_elt *prev_same_value;
423   struct table_elt *first_same_value;
424   struct table_elt *related_value;
425   int cost;
426   enum machine_mode mode;
427   char in_memory;
428   char in_struct;
429   char is_const;
430   char flag;
431 };
432
433 /* We don't want a lot of buckets, because we rarely have very many
434    things stored in the hash table, and a lot of buckets slows
435    down a lot of loops that happen frequently.  */
436 #define NBUCKETS 31
437
438 /* Compute hash code of X in mode M.  Special-case case where X is a pseudo
439    register (hard registers may require `do_not_record' to be set).  */
440
441 #define HASH(X, M)      \
442  (GET_CODE (X) == REG && REGNO (X) >= FIRST_PSEUDO_REGISTER     \
443   ? (((unsigned) REG << 7) + (unsigned) reg_qty[REGNO (X)]) % NBUCKETS  \
444   : canon_hash (X, M) % NBUCKETS)
445
446 /* Determine whether register number N is considered a fixed register for CSE.
447    It is desirable to replace other regs with fixed regs, to reduce need for
448    non-fixed hard regs.
449    A reg wins if it is either the frame pointer or designated as fixed,
450    but not if it is an overlapping register.  */
451 #ifdef OVERLAPPING_REGNO_P
452 #define FIXED_REGNO_P(N)  \
453   (((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
454     || fixed_regs[N] || global_regs[N])   \
455    && ! OVERLAPPING_REGNO_P ((N)))
456 #else
457 #define FIXED_REGNO_P(N)  \
458   ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
459    || fixed_regs[N] || global_regs[N])
460 #endif
461
462 /* Compute cost of X, as stored in the `cost' field of a table_elt.  Fixed
463    hard registers and pointers into the frame are the cheapest with a cost
464    of 0.  Next come pseudos with a cost of one and other hard registers with
465    a cost of 2.  Aside from these special cases, call `rtx_cost'.  */
466
467 #define CHEAP_REGNO(N) \
468   ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM      \
469    || (N) == STACK_POINTER_REGNUM || (N) == ARG_POINTER_REGNUM          \
470    || ((N) >= FIRST_VIRTUAL_REGISTER && (N) <= LAST_VIRTUAL_REGISTER)   \
471    || ((N) < FIRST_PSEUDO_REGISTER                                      \
472        && FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS))
473
474 /* A register is cheap if it is a user variable assigned to the register
475    or if its register number always corresponds to a cheap register.  */
476
477 #define CHEAP_REG(N) \
478   ((REG_USERVAR_P (N) && REGNO (N) < FIRST_PSEUDO_REGISTER)     \
479    || CHEAP_REGNO (REGNO (N)))
480
481 #define COST(X)                                                         \
482   (GET_CODE (X) == REG                                                  \
483    ? (CHEAP_REG (X) ? 0                                                 \
484       : REGNO (X) >= FIRST_PSEUDO_REGISTER ? 1                          \
485       : 2)                                                              \
486    : ((GET_CODE (X) == SUBREG                                           \
487        && GET_CODE (SUBREG_REG (X)) == REG                              \
488        && GET_MODE_CLASS (GET_MODE (X)) == MODE_INT                     \
489        && GET_MODE_CLASS (GET_MODE (SUBREG_REG (X))) == MODE_INT        \
490        && (GET_MODE_SIZE (GET_MODE (X))                                 \
491            < GET_MODE_SIZE (GET_MODE (SUBREG_REG (X))))                 \
492        && subreg_lowpart_p (X)                                          \
493        && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (GET_MODE (X)),       \
494                                  GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (X))))) \
495       ? (CHEAP_REG (SUBREG_REG (X)) ? 0                                 \
496          : REGNO (SUBREG_REG (X)) >= FIRST_PSEUDO_REGISTER ? 1          \
497          : 2)                                                           \
498       : rtx_cost (X, SET) * 2))
499
500 /* Determine if the quantity number for register X represents a valid index
501    into the `qty_...' variables.  */
502
503 #define REGNO_QTY_VALID_P(N) (reg_qty[N] != (N))
504
505 static struct table_elt *table[NBUCKETS];
506
507 /* Chain of `struct table_elt's made so far for this function
508    but currently removed from the table.  */
509
510 static struct table_elt *free_element_chain;
511
512 /* Number of `struct table_elt' structures made so far for this function.  */
513
514 static int n_elements_made;
515
516 /* Maximum value `n_elements_made' has had so far in this compilation
517    for functions previously processed.  */
518
519 static int max_elements_made;
520
521 /* Surviving equivalence class when two equivalence classes are merged 
522    by recording the effects of a jump in the last insn.  Zero if the
523    last insn was not a conditional jump.  */
524
525 static struct table_elt *last_jump_equiv_class;
526
527 /* Set to the cost of a constant pool reference if one was found for a
528    symbolic constant.  If this was found, it means we should try to
529    convert constants into constant pool entries if they don't fit in
530    the insn.  */
531
532 static int constant_pool_entries_cost;
533
534 /* Bits describing what kind of values in memory must be invalidated
535    for a particular instruction.  If all three bits are zero,
536    no memory refs need to be invalidated.  Each bit is more powerful
537    than the preceding ones, and if a bit is set then the preceding
538    bits are also set.
539
540    Here is how the bits are set:
541    Pushing onto the stack invalidates only the stack pointer,
542    writing at a fixed address invalidates only variable addresses,
543    writing in a structure element at variable address
544      invalidates all but scalar variables,
545    and writing in anything else at variable address invalidates everything.  */
546
547 struct write_data
548 {
549   int sp : 1;                   /* Invalidate stack pointer.  */
550   int var : 1;                  /* Invalidate variable addresses.  */
551   int nonscalar : 1;            /* Invalidate all but scalar variables.  */
552   int all : 1;                  /* Invalidate all memory refs.  */
553 };
554
555 /* Define maximum length of a branch path.  */
556
557 #define PATHLENGTH      10
558
559 /* This data describes a block that will be processed by cse_basic_block.  */
560
561 struct cse_basic_block_data {
562   /* Lowest CUID value of insns in block.  */
563   int low_cuid;
564   /* Highest CUID value of insns in block.  */
565   int high_cuid;
566   /* Total number of SETs in block.  */
567   int nsets;
568   /* Last insn in the block.  */
569   rtx last;
570   /* Size of current branch path, if any.  */
571   int path_size;
572   /* Current branch path, indicating which branches will be taken.  */
573   struct branch_path {
574     /* The branch insn.  */
575     rtx branch;
576     /* Whether it should be taken or not.  AROUND is the same as taken
577        except that it is used when the destination label is not preceded
578        by a BARRIER.  */
579     enum taken {TAKEN, NOT_TAKEN, AROUND} status;
580   } path[PATHLENGTH];
581 };
582
583 /* Nonzero if X has the form (PLUS frame-pointer integer).  We check for
584    virtual regs here because the simplify_*_operation routines are called
585    by integrate.c, which is called before virtual register instantiation.  */
586
587 #define FIXED_BASE_PLUS_P(X)                                    \
588   ((X) == frame_pointer_rtx || (X) == hard_frame_pointer_rtx    \
589    || (X) == arg_pointer_rtx                                    \
590    || (X) == virtual_stack_vars_rtx                             \
591    || (X) == virtual_incoming_args_rtx                          \
592    || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
593        && (XEXP (X, 0) == frame_pointer_rtx                     \
594            || XEXP (X, 0) == hard_frame_pointer_rtx             \
595            || XEXP (X, 0) == arg_pointer_rtx                    \
596            || XEXP (X, 0) == virtual_stack_vars_rtx             \
597            || XEXP (X, 0) == virtual_incoming_args_rtx)))
598
599 /* Similar, but also allows reference to the stack pointer.
600
601    This used to include FIXED_BASE_PLUS_P, however, we can't assume that
602    arg_pointer_rtx by itself is nonzero, because on at least one machine,
603    the i960, the arg pointer is zero when it is unused.  */
604
605 #define NONZERO_BASE_PLUS_P(X)                                  \
606   ((X) == frame_pointer_rtx || (X) == hard_frame_pointer_rtx    \
607    || (X) == virtual_stack_vars_rtx                             \
608    || (X) == virtual_incoming_args_rtx                          \
609    || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
610        && (XEXP (X, 0) == frame_pointer_rtx                     \
611            || XEXP (X, 0) == hard_frame_pointer_rtx             \
612            || XEXP (X, 0) == arg_pointer_rtx                    \
613            || XEXP (X, 0) == virtual_stack_vars_rtx             \
614            || XEXP (X, 0) == virtual_incoming_args_rtx))        \
615    || (X) == stack_pointer_rtx                                  \
616    || (X) == virtual_stack_dynamic_rtx                          \
617    || (X) == virtual_outgoing_args_rtx                          \
618    || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
619        && (XEXP (X, 0) == stack_pointer_rtx                     \
620            || XEXP (X, 0) == virtual_stack_dynamic_rtx          \
621            || XEXP (X, 0) == virtual_outgoing_args_rtx)))
622
623 static void new_basic_block     PROTO((void));
624 static void make_new_qty        PROTO((int));
625 static void make_regs_eqv       PROTO((int, int));
626 static void delete_reg_equiv    PROTO((int));
627 static int mention_regs         PROTO((rtx));
628 static int insert_regs          PROTO((rtx, struct table_elt *, int));
629 static void free_element        PROTO((struct table_elt *));
630 static void remove_from_table   PROTO((struct table_elt *, unsigned));
631 static struct table_elt *get_element PROTO((void));
632 static struct table_elt *lookup PROTO((rtx, unsigned, enum machine_mode)),
633        *lookup_for_remove PROTO((rtx, unsigned, enum machine_mode));
634 static rtx lookup_as_function   PROTO((rtx, enum rtx_code));
635 static struct table_elt *insert PROTO((rtx, struct table_elt *, unsigned,
636                                        enum machine_mode));
637 static void merge_equiv_classes PROTO((struct table_elt *,
638                                        struct table_elt *));
639 static void invalidate          PROTO((rtx, enum machine_mode));
640 static void remove_invalid_refs PROTO((int));
641 static void rehash_using_reg    PROTO((rtx));
642 static void invalidate_memory   PROTO((struct write_data *));
643 static void invalidate_for_call PROTO((void));
644 static rtx use_related_value    PROTO((rtx, struct table_elt *));
645 static unsigned canon_hash      PROTO((rtx, enum machine_mode));
646 static unsigned safe_hash       PROTO((rtx, enum machine_mode));
647 static int exp_equiv_p          PROTO((rtx, rtx, int, int));
648 static void set_nonvarying_address_components PROTO((rtx, int, rtx *,
649                                                      HOST_WIDE_INT *,
650                                                      HOST_WIDE_INT *));
651 static int refers_to_p          PROTO((rtx, rtx));
652 static int refers_to_mem_p      PROTO((rtx, rtx, HOST_WIDE_INT,
653                                        HOST_WIDE_INT));
654 static int cse_rtx_addr_varies_p PROTO((rtx));
655 static rtx canon_reg            PROTO((rtx, rtx));
656 static void find_best_addr      PROTO((rtx, rtx *));
657 static enum rtx_code find_comparison_args PROTO((enum rtx_code, rtx *, rtx *,
658                                                  enum machine_mode *,
659                                                  enum machine_mode *));
660 static rtx cse_gen_binary       PROTO((enum rtx_code, enum machine_mode,
661                                        rtx, rtx));
662 static rtx simplify_plus_minus  PROTO((enum rtx_code, enum machine_mode,
663                                        rtx, rtx));
664 static rtx fold_rtx             PROTO((rtx, rtx));
665 static rtx equiv_constant       PROTO((rtx));
666 static void record_jump_equiv   PROTO((rtx, int));
667 static void record_jump_cond    PROTO((enum rtx_code, enum machine_mode,
668                                        rtx, rtx, int));
669 static void cse_insn            PROTO((rtx, int));
670 static void note_mem_written    PROTO((rtx, struct write_data *));
671 static void invalidate_from_clobbers PROTO((struct write_data *, rtx));
672 static rtx cse_process_notes    PROTO((rtx, rtx));
673 static void cse_around_loop     PROTO((rtx));
674 static void invalidate_skipped_set PROTO((rtx, rtx));
675 static void invalidate_skipped_block PROTO((rtx));
676 static void cse_check_loop_start PROTO((rtx, rtx));
677 static void cse_set_around_loop PROTO((rtx, rtx, rtx));
678 static rtx cse_basic_block      PROTO((rtx, rtx, struct branch_path *, int));
679 static void count_reg_usage     PROTO((rtx, int *, rtx, int));
680
681 extern int rtx_equal_function_value_matters;
682 \f
683 /* Return an estimate of the cost of computing rtx X.
684    One use is in cse, to decide which expression to keep in the hash table.
685    Another is in rtl generation, to pick the cheapest way to multiply.
686    Other uses like the latter are expected in the future.  */
687
688 /* Return the right cost to give to an operation
689    to make the cost of the corresponding register-to-register instruction
690    N times that of a fast register-to-register instruction.  */
691
692 #define COSTS_N_INSNS(N) ((N) * 4 - 2)
693
694 int
695 rtx_cost (x, outer_code)
696      rtx x;
697      enum rtx_code outer_code;
698 {
699   register int i, j;
700   register enum rtx_code code;
701   register char *fmt;
702   register int total;
703
704   if (x == 0)
705     return 0;
706
707   /* Compute the default costs of certain things.
708      Note that RTX_COSTS can override the defaults.  */
709
710   code = GET_CODE (x);
711   switch (code)
712     {
713     case MULT:
714       /* Count multiplication by 2**n as a shift,
715          because if we are considering it, we would output it as a shift.  */
716       if (GET_CODE (XEXP (x, 1)) == CONST_INT
717           && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
718         total = 2;
719       else
720         total = COSTS_N_INSNS (5);
721       break;
722     case DIV:
723     case UDIV:
724     case MOD:
725     case UMOD:
726       total = COSTS_N_INSNS (7);
727       break;
728     case USE:
729       /* Used in loop.c and combine.c as a marker.  */
730       total = 0;
731       break;
732     case ASM_OPERANDS:
733       /* We don't want these to be used in substitutions because
734          we have no way of validating the resulting insn.  So assign
735          anything containing an ASM_OPERANDS a very high cost.  */
736       total = 1000;
737       break;
738     default:
739       total = 2;
740     }
741
742   switch (code)
743     {
744     case REG:
745       return ! CHEAP_REG (x);
746
747     case SUBREG:
748       /* If we can't tie these modes, make this expensive.  The larger
749          the mode, the more expensive it is.  */
750       if (! MODES_TIEABLE_P (GET_MODE (x), GET_MODE (SUBREG_REG (x))))
751         return COSTS_N_INSNS (2
752                               + GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD);
753       return 2;
754 #ifdef RTX_COSTS
755       RTX_COSTS (x, code, outer_code);
756 #endif 
757       CONST_COSTS (x, code, outer_code);
758     }
759
760   /* Sum the costs of the sub-rtx's, plus cost of this operation,
761      which is already in total.  */
762
763   fmt = GET_RTX_FORMAT (code);
764   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
765     if (fmt[i] == 'e')
766       total += rtx_cost (XEXP (x, i), code);
767     else if (fmt[i] == 'E')
768       for (j = 0; j < XVECLEN (x, i); j++)
769         total += rtx_cost (XVECEXP (x, i, j), code);
770
771   return total;
772 }
773 \f
774 /* Clear the hash table and initialize each register with its own quantity,
775    for a new basic block.  */
776
777 static void
778 new_basic_block ()
779 {
780   register int i;
781
782   next_qty = max_reg;
783
784   bzero ((char *) reg_tick, max_reg * sizeof (int));
785
786   bcopy ((char *) all_minus_one, (char *) reg_in_table,
787          max_reg * sizeof (int));
788   bcopy ((char *) consec_ints, (char *) reg_qty, max_reg * sizeof (int));
789   CLEAR_HARD_REG_SET (hard_regs_in_table);
790
791   /* The per-quantity values used to be initialized here, but it is
792      much faster to initialize each as it is made in `make_new_qty'.  */
793
794   for (i = 0; i < NBUCKETS; i++)
795     {
796       register struct table_elt *this, *next;
797       for (this = table[i]; this; this = next)
798         {
799           next = this->next_same_hash;
800           free_element (this);
801         }
802     }
803
804   bzero ((char *) table, sizeof table);
805
806   prev_insn = 0;
807
808 #ifdef HAVE_cc0
809   prev_insn_cc0 = 0;
810 #endif
811 }
812
813 /* Say that register REG contains a quantity not in any register before
814    and initialize that quantity.  */
815
816 static void
817 make_new_qty (reg)
818      register int reg;
819 {
820   register int q;
821
822   if (next_qty >= max_qty)
823     abort ();
824
825   q = reg_qty[reg] = next_qty++;
826   qty_first_reg[q] = reg;
827   qty_last_reg[q] = reg;
828   qty_const[q] = qty_const_insn[q] = 0;
829   qty_comparison_code[q] = UNKNOWN;
830
831   reg_next_eqv[reg] = reg_prev_eqv[reg] = -1;
832 }
833
834 /* Make reg NEW equivalent to reg OLD.
835    OLD is not changing; NEW is.  */
836
837 static void
838 make_regs_eqv (new, old)
839      register int new, old;
840 {
841   register int lastr, firstr;
842   register int q = reg_qty[old];
843
844   /* Nothing should become eqv until it has a "non-invalid" qty number.  */
845   if (! REGNO_QTY_VALID_P (old))
846     abort ();
847
848   reg_qty[new] = q;
849   firstr = qty_first_reg[q];
850   lastr = qty_last_reg[q];
851
852   /* Prefer fixed hard registers to anything.  Prefer pseudo regs to other
853      hard regs.  Among pseudos, if NEW will live longer than any other reg
854      of the same qty, and that is beyond the current basic block,
855      make it the new canonical replacement for this qty.  */
856   if (! (firstr < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (firstr))
857       /* Certain fixed registers might be of the class NO_REGS.  This means
858          that not only can they not be allocated by the compiler, but
859          they cannot be used in substitutions or canonicalizations
860          either.  */
861       && (new >= FIRST_PSEUDO_REGISTER || REGNO_REG_CLASS (new) != NO_REGS)
862       && ((new < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (new))
863           || (new >= FIRST_PSEUDO_REGISTER
864               && (firstr < FIRST_PSEUDO_REGISTER
865                   || ((uid_cuid[regno_last_uid[new]] > cse_basic_block_end
866                        || (uid_cuid[regno_first_uid[new]]
867                            < cse_basic_block_start))
868                       && (uid_cuid[regno_last_uid[new]]
869                           > uid_cuid[regno_last_uid[firstr]]))))))
870     {
871       reg_prev_eqv[firstr] = new;
872       reg_next_eqv[new] = firstr;
873       reg_prev_eqv[new] = -1;
874       qty_first_reg[q] = new;
875     }
876   else
877     {
878       /* If NEW is a hard reg (known to be non-fixed), insert at end.
879          Otherwise, insert before any non-fixed hard regs that are at the
880          end.  Registers of class NO_REGS cannot be used as an
881          equivalent for anything.  */
882       while (lastr < FIRST_PSEUDO_REGISTER && reg_prev_eqv[lastr] >= 0
883              && (REGNO_REG_CLASS (lastr) == NO_REGS || ! FIXED_REGNO_P (lastr))
884              && new >= FIRST_PSEUDO_REGISTER)
885         lastr = reg_prev_eqv[lastr];
886       reg_next_eqv[new] = reg_next_eqv[lastr];
887       if (reg_next_eqv[lastr] >= 0)
888         reg_prev_eqv[reg_next_eqv[lastr]] = new;
889       else
890         qty_last_reg[q] = new;
891       reg_next_eqv[lastr] = new;
892       reg_prev_eqv[new] = lastr;
893     }
894 }
895
896 /* Remove REG from its equivalence class.  */
897
898 static void
899 delete_reg_equiv (reg)
900      register int reg;
901 {
902   register int q = reg_qty[reg];
903   register int p, n;
904
905   /* If invalid, do nothing.  */
906   if (q == reg)
907     return;
908
909   p = reg_prev_eqv[reg];
910   n = reg_next_eqv[reg];
911
912   if (n != -1)
913     reg_prev_eqv[n] = p;
914   else
915     qty_last_reg[q] = p;
916   if (p != -1)
917     reg_next_eqv[p] = n;
918   else
919     qty_first_reg[q] = n;
920
921   reg_qty[reg] = reg;
922 }
923
924 /* Remove any invalid expressions from the hash table
925    that refer to any of the registers contained in expression X.
926
927    Make sure that newly inserted references to those registers
928    as subexpressions will be considered valid.
929
930    mention_regs is not called when a register itself
931    is being stored in the table.
932
933    Return 1 if we have done something that may have changed the hash code
934    of X.  */
935
936 static int
937 mention_regs (x)
938      rtx x;
939 {
940   register enum rtx_code code;
941   register int i, j;
942   register char *fmt;
943   register int changed = 0;
944
945   if (x == 0)
946     return 0;
947
948   code = GET_CODE (x);
949   if (code == REG)
950     {
951       register int regno = REGNO (x);
952       register int endregno
953         = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
954                    : HARD_REGNO_NREGS (regno, GET_MODE (x)));
955       int i;
956
957       for (i = regno; i < endregno; i++)
958         {
959           if (reg_in_table[i] >= 0 && reg_in_table[i] != reg_tick[i])
960             remove_invalid_refs (i);
961
962           reg_in_table[i] = reg_tick[i];
963         }
964
965       return 0;
966     }
967
968   /* If X is a comparison or a COMPARE and either operand is a register
969      that does not have a quantity, give it one.  This is so that a later
970      call to record_jump_equiv won't cause X to be assigned a different
971      hash code and not found in the table after that call.
972
973      It is not necessary to do this here, since rehash_using_reg can
974      fix up the table later, but doing this here eliminates the need to
975      call that expensive function in the most common case where the only
976      use of the register is in the comparison.  */
977
978   if (code == COMPARE || GET_RTX_CLASS (code) == '<')
979     {
980       if (GET_CODE (XEXP (x, 0)) == REG
981           && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))))
982         if (insert_regs (XEXP (x, 0), NULL_PTR, 0))
983           {
984             rehash_using_reg (XEXP (x, 0));
985             changed = 1;
986           }
987
988       if (GET_CODE (XEXP (x, 1)) == REG
989           && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 1))))
990         if (insert_regs (XEXP (x, 1), NULL_PTR, 0))
991           {
992             rehash_using_reg (XEXP (x, 1));
993             changed = 1;
994           }
995     }
996
997   fmt = GET_RTX_FORMAT (code);
998   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
999     if (fmt[i] == 'e')
1000       changed |= mention_regs (XEXP (x, i));
1001     else if (fmt[i] == 'E')
1002       for (j = 0; j < XVECLEN (x, i); j++)
1003         changed |= mention_regs (XVECEXP (x, i, j));
1004
1005   return changed;
1006 }
1007
1008 /* Update the register quantities for inserting X into the hash table
1009    with a value equivalent to CLASSP.
1010    (If the class does not contain a REG, it is irrelevant.)
1011    If MODIFIED is nonzero, X is a destination; it is being modified.
1012    Note that delete_reg_equiv should be called on a register
1013    before insert_regs is done on that register with MODIFIED != 0.
1014
1015    Nonzero value means that elements of reg_qty have changed
1016    so X's hash code may be different.  */
1017
1018 static int
1019 insert_regs (x, classp, modified)
1020      rtx x;
1021      struct table_elt *classp;
1022      int modified;
1023 {
1024   if (GET_CODE (x) == REG)
1025     {
1026       register int regno = REGNO (x);
1027
1028       /* If REGNO is in the equivalence table already but is of the
1029          wrong mode for that equivalence, don't do anything here.  */
1030
1031       if (REGNO_QTY_VALID_P (regno)
1032           && qty_mode[reg_qty[regno]] != GET_MODE (x))
1033         return 0;
1034
1035       if (modified || ! REGNO_QTY_VALID_P (regno))
1036         {
1037           if (classp)
1038             for (classp = classp->first_same_value;
1039                  classp != 0;
1040                  classp = classp->next_same_value)
1041               if (GET_CODE (classp->exp) == REG
1042                   && GET_MODE (classp->exp) == GET_MODE (x))
1043                 {
1044                   make_regs_eqv (regno, REGNO (classp->exp));
1045                   return 1;
1046                 }
1047
1048           make_new_qty (regno);
1049           qty_mode[reg_qty[regno]] = GET_MODE (x);
1050           return 1;
1051         }
1052
1053       return 0;
1054     }
1055
1056   /* If X is a SUBREG, we will likely be inserting the inner register in the
1057      table.  If that register doesn't have an assigned quantity number at
1058      this point but does later, the insertion that we will be doing now will
1059      not be accessible because its hash code will have changed.  So assign
1060      a quantity number now.  */
1061
1062   else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
1063            && ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
1064     {
1065       insert_regs (SUBREG_REG (x), NULL_PTR, 0);
1066       mention_regs (SUBREG_REG (x));
1067       return 1;
1068     }
1069   else
1070     return mention_regs (x);
1071 }
1072 \f
1073 /* Look in or update the hash table.  */
1074
1075 /* Put the element ELT on the list of free elements.  */
1076
1077 static void
1078 free_element (elt)
1079      struct table_elt *elt;
1080 {
1081   elt->next_same_hash = free_element_chain;
1082   free_element_chain = elt;
1083 }
1084
1085 /* Return an element that is free for use.  */
1086
1087 static struct table_elt *
1088 get_element ()
1089 {
1090   struct table_elt *elt = free_element_chain;
1091   if (elt)
1092     {
1093       free_element_chain = elt->next_same_hash;
1094       return elt;
1095     }
1096   n_elements_made++;
1097   return (struct table_elt *) oballoc (sizeof (struct table_elt));
1098 }
1099
1100 /* Remove table element ELT from use in the table.
1101    HASH is its hash code, made using the HASH macro.
1102    It's an argument because often that is known in advance
1103    and we save much time not recomputing it.  */
1104
1105 static void
1106 remove_from_table (elt, hash)
1107      register struct table_elt *elt;
1108      unsigned hash;
1109 {
1110   if (elt == 0)
1111     return;
1112
1113   /* Mark this element as removed.  See cse_insn.  */
1114   elt->first_same_value = 0;
1115
1116   /* Remove the table element from its equivalence class.  */
1117      
1118   {
1119     register struct table_elt *prev = elt->prev_same_value;
1120     register struct table_elt *next = elt->next_same_value;
1121
1122     if (next) next->prev_same_value = prev;
1123
1124     if (prev)
1125       prev->next_same_value = next;
1126     else
1127       {
1128         register struct table_elt *newfirst = next;
1129         while (next)
1130           {
1131             next->first_same_value = newfirst;
1132             next = next->next_same_value;
1133           }
1134       }
1135   }
1136
1137   /* Remove the table element from its hash bucket.  */
1138
1139   {
1140     register struct table_elt *prev = elt->prev_same_hash;
1141     register struct table_elt *next = elt->next_same_hash;
1142
1143     if (next) next->prev_same_hash = prev;
1144
1145     if (prev)
1146       prev->next_same_hash = next;
1147     else if (table[hash] == elt)
1148       table[hash] = next;
1149     else
1150       {
1151         /* This entry is not in the proper hash bucket.  This can happen
1152            when two classes were merged by `merge_equiv_classes'.  Search
1153            for the hash bucket that it heads.  This happens only very
1154            rarely, so the cost is acceptable.  */
1155         for (hash = 0; hash < NBUCKETS; hash++)
1156           if (table[hash] == elt)
1157             table[hash] = next;
1158       }
1159   }
1160
1161   /* Remove the table element from its related-value circular chain.  */
1162
1163   if (elt->related_value != 0 && elt->related_value != elt)
1164     {
1165       register struct table_elt *p = elt->related_value;
1166       while (p->related_value != elt)
1167         p = p->related_value;
1168       p->related_value = elt->related_value;
1169       if (p->related_value == p)
1170         p->related_value = 0;
1171     }
1172
1173   free_element (elt);
1174 }
1175
1176 /* Look up X in the hash table and return its table element,
1177    or 0 if X is not in the table.
1178
1179    MODE is the machine-mode of X, or if X is an integer constant
1180    with VOIDmode then MODE is the mode with which X will be used.
1181
1182    Here we are satisfied to find an expression whose tree structure
1183    looks like X.  */
1184
1185 static struct table_elt *
1186 lookup (x, hash, mode)
1187      rtx x;
1188      unsigned hash;
1189      enum machine_mode mode;
1190 {
1191   register struct table_elt *p;
1192
1193   for (p = table[hash]; p; p = p->next_same_hash)
1194     if (mode == p->mode && ((x == p->exp && GET_CODE (x) == REG)
1195                             || exp_equiv_p (x, p->exp, GET_CODE (x) != REG, 0)))
1196       return p;
1197
1198   return 0;
1199 }
1200
1201 /* Like `lookup' but don't care whether the table element uses invalid regs.
1202    Also ignore discrepancies in the machine mode of a register.  */
1203
1204 static struct table_elt *
1205 lookup_for_remove (x, hash, mode)
1206      rtx x;
1207      unsigned hash;
1208      enum machine_mode mode;
1209 {
1210   register struct table_elt *p;
1211
1212   if (GET_CODE (x) == REG)
1213     {
1214       int regno = REGNO (x);
1215       /* Don't check the machine mode when comparing registers;
1216          invalidating (REG:SI 0) also invalidates (REG:DF 0).  */
1217       for (p = table[hash]; p; p = p->next_same_hash)
1218         if (GET_CODE (p->exp) == REG
1219             && REGNO (p->exp) == regno)
1220           return p;
1221     }
1222   else
1223     {
1224       for (p = table[hash]; p; p = p->next_same_hash)
1225         if (mode == p->mode && (x == p->exp || exp_equiv_p (x, p->exp, 0, 0)))
1226           return p;
1227     }
1228
1229   return 0;
1230 }
1231
1232 /* Look for an expression equivalent to X and with code CODE.
1233    If one is found, return that expression.  */
1234
1235 static rtx
1236 lookup_as_function (x, code)
1237      rtx x;
1238      enum rtx_code code;
1239 {
1240   register struct table_elt *p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS,
1241                                          GET_MODE (x));
1242   if (p == 0)
1243     return 0;
1244
1245   for (p = p->first_same_value; p; p = p->next_same_value)
1246     {
1247       if (GET_CODE (p->exp) == code
1248           /* Make sure this is a valid entry in the table.  */
1249           && exp_equiv_p (p->exp, p->exp, 1, 0))
1250         return p->exp;
1251     }
1252   
1253   return 0;
1254 }
1255
1256 /* Insert X in the hash table, assuming HASH is its hash code
1257    and CLASSP is an element of the class it should go in
1258    (or 0 if a new class should be made).
1259    It is inserted at the proper position to keep the class in
1260    the order cheapest first.
1261
1262    MODE is the machine-mode of X, or if X is an integer constant
1263    with VOIDmode then MODE is the mode with which X will be used.
1264
1265    For elements of equal cheapness, the most recent one
1266    goes in front, except that the first element in the list
1267    remains first unless a cheaper element is added.  The order of
1268    pseudo-registers does not matter, as canon_reg will be called to
1269    find the cheapest when a register is retrieved from the table.
1270
1271    The in_memory field in the hash table element is set to 0.
1272    The caller must set it nonzero if appropriate.
1273
1274    You should call insert_regs (X, CLASSP, MODIFY) before calling here,
1275    and if insert_regs returns a nonzero value
1276    you must then recompute its hash code before calling here.
1277
1278    If necessary, update table showing constant values of quantities.  */
1279
1280 #define CHEAPER(X,Y)   ((X)->cost < (Y)->cost)
1281
1282 static struct table_elt *
1283 insert (x, classp, hash, mode)
1284      register rtx x;
1285      register struct table_elt *classp;
1286      unsigned hash;
1287      enum machine_mode mode;
1288 {
1289   register struct table_elt *elt;
1290
1291   /* If X is a register and we haven't made a quantity for it,
1292      something is wrong.  */
1293   if (GET_CODE (x) == REG && ! REGNO_QTY_VALID_P (REGNO (x)))
1294     abort ();
1295
1296   /* If X is a hard register, show it is being put in the table.  */
1297   if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
1298     {
1299       int regno = REGNO (x);
1300       int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
1301       int i;
1302
1303       for (i = regno; i < endregno; i++)
1304             SET_HARD_REG_BIT (hard_regs_in_table, i);
1305     }
1306
1307   /* If X is a label, show we recorded it.  */
1308   if (GET_CODE (x) == LABEL_REF
1309       || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
1310           && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF))
1311     recorded_label_ref = 1;
1312
1313   /* Put an element for X into the right hash bucket.  */
1314
1315   elt = get_element ();
1316   elt->exp = x;
1317   elt->cost = COST (x);
1318   elt->next_same_value = 0;
1319   elt->prev_same_value = 0;
1320   elt->next_same_hash = table[hash];
1321   elt->prev_same_hash = 0;
1322   elt->related_value = 0;
1323   elt->in_memory = 0;
1324   elt->mode = mode;
1325   elt->is_const = (CONSTANT_P (x)
1326                    /* GNU C++ takes advantage of this for `this'
1327                       (and other const values).  */
1328                    || (RTX_UNCHANGING_P (x)
1329                        && GET_CODE (x) == REG
1330                        && REGNO (x) >= FIRST_PSEUDO_REGISTER)
1331                    || FIXED_BASE_PLUS_P (x));
1332
1333   if (table[hash])
1334     table[hash]->prev_same_hash = elt;
1335   table[hash] = elt;
1336
1337   /* Put it into the proper value-class.  */
1338   if (classp)
1339     {
1340       classp = classp->first_same_value;
1341       if (CHEAPER (elt, classp))
1342         /* Insert at the head of the class */
1343         {
1344           register struct table_elt *p;
1345           elt->next_same_value = classp;
1346           classp->prev_same_value = elt;
1347           elt->first_same_value = elt;
1348
1349           for (p = classp; p; p = p->next_same_value)
1350             p->first_same_value = elt;
1351         }
1352       else
1353         {
1354           /* Insert not at head of the class.  */
1355           /* Put it after the last element cheaper than X.  */
1356           register struct table_elt *p, *next;
1357           for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt);
1358                p = next);
1359           /* Put it after P and before NEXT.  */
1360           elt->next_same_value = next;
1361           if (next)
1362             next->prev_same_value = elt;
1363           elt->prev_same_value = p;
1364           p->next_same_value = elt;
1365           elt->first_same_value = classp;
1366         }
1367     }
1368   else
1369     elt->first_same_value = elt;
1370
1371   /* If this is a constant being set equivalent to a register or a register
1372      being set equivalent to a constant, note the constant equivalence.
1373
1374      If this is a constant, it cannot be equivalent to a different constant,
1375      and a constant is the only thing that can be cheaper than a register.  So
1376      we know the register is the head of the class (before the constant was
1377      inserted).
1378
1379      If this is a register that is not already known equivalent to a
1380      constant, we must check the entire class.
1381
1382      If this is a register that is already known equivalent to an insn,
1383      update `qty_const_insn' to show that `this_insn' is the latest
1384      insn making that quantity equivalent to the constant.  */
1385
1386   if (elt->is_const && classp && GET_CODE (classp->exp) == REG
1387       && GET_CODE (x) != REG)
1388     {
1389       qty_const[reg_qty[REGNO (classp->exp)]]
1390         = gen_lowpart_if_possible (qty_mode[reg_qty[REGNO (classp->exp)]], x);
1391       qty_const_insn[reg_qty[REGNO (classp->exp)]] = this_insn;
1392     }
1393
1394   else if (GET_CODE (x) == REG && classp && ! qty_const[reg_qty[REGNO (x)]]
1395            && ! elt->is_const)
1396     {
1397       register struct table_elt *p;
1398
1399       for (p = classp; p != 0; p = p->next_same_value)
1400         {
1401           if (p->is_const && GET_CODE (p->exp) != REG)
1402             {
1403               qty_const[reg_qty[REGNO (x)]]
1404                 = gen_lowpart_if_possible (GET_MODE (x), p->exp);
1405               qty_const_insn[reg_qty[REGNO (x)]] = this_insn;
1406               break;
1407             }
1408         }
1409     }
1410
1411   else if (GET_CODE (x) == REG && qty_const[reg_qty[REGNO (x)]]
1412            && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]])
1413     qty_const_insn[reg_qty[REGNO (x)]] = this_insn;
1414
1415   /* If this is a constant with symbolic value,
1416      and it has a term with an explicit integer value,
1417      link it up with related expressions.  */
1418   if (GET_CODE (x) == CONST)
1419     {
1420       rtx subexp = get_related_value (x);
1421       unsigned subhash;
1422       struct table_elt *subelt, *subelt_prev;
1423
1424       if (subexp != 0)
1425         {
1426           /* Get the integer-free subexpression in the hash table.  */
1427           subhash = safe_hash (subexp, mode) % NBUCKETS;
1428           subelt = lookup (subexp, subhash, mode);
1429           if (subelt == 0)
1430             subelt = insert (subexp, NULL_PTR, subhash, mode);
1431           /* Initialize SUBELT's circular chain if it has none.  */
1432           if (subelt->related_value == 0)
1433             subelt->related_value = subelt;
1434           /* Find the element in the circular chain that precedes SUBELT.  */
1435           subelt_prev = subelt;
1436           while (subelt_prev->related_value != subelt)
1437             subelt_prev = subelt_prev->related_value;
1438           /* Put new ELT into SUBELT's circular chain just before SUBELT.
1439              This way the element that follows SUBELT is the oldest one.  */
1440           elt->related_value = subelt_prev->related_value;
1441           subelt_prev->related_value = elt;
1442         }
1443     }
1444
1445   return elt;
1446 }
1447 \f
1448 /* Given two equivalence classes, CLASS1 and CLASS2, put all the entries from
1449    CLASS2 into CLASS1.  This is done when we have reached an insn which makes
1450    the two classes equivalent.
1451
1452    CLASS1 will be the surviving class; CLASS2 should not be used after this
1453    call.
1454
1455    Any invalid entries in CLASS2 will not be copied.  */
1456
1457 static void
1458 merge_equiv_classes (class1, class2)
1459      struct table_elt *class1, *class2;
1460 {
1461   struct table_elt *elt, *next, *new;
1462
1463   /* Ensure we start with the head of the classes.  */
1464   class1 = class1->first_same_value;
1465   class2 = class2->first_same_value;
1466
1467   /* If they were already equal, forget it.  */
1468   if (class1 == class2)
1469     return;
1470
1471   for (elt = class2; elt; elt = next)
1472     {
1473       unsigned hash;
1474       rtx exp = elt->exp;
1475       enum machine_mode mode = elt->mode;
1476
1477       next = elt->next_same_value;
1478
1479       /* Remove old entry, make a new one in CLASS1's class.
1480          Don't do this for invalid entries as we cannot find their
1481          hash code (it also isn't necessary).  */
1482       if (GET_CODE (exp) == REG || exp_equiv_p (exp, exp, 1, 0))
1483         {
1484           hash_arg_in_memory = 0;
1485           hash_arg_in_struct = 0;
1486           hash = HASH (exp, mode);
1487               
1488           if (GET_CODE (exp) == REG)
1489             delete_reg_equiv (REGNO (exp));
1490               
1491           remove_from_table (elt, hash);
1492
1493           if (insert_regs (exp, class1, 0))
1494             {
1495               rehash_using_reg (exp);
1496               hash = HASH (exp, mode);
1497             }
1498           new = insert (exp, class1, hash, mode);
1499           new->in_memory = hash_arg_in_memory;
1500           new->in_struct = hash_arg_in_struct;
1501         }
1502     }
1503 }
1504 \f
1505 /* Remove from the hash table, or mark as invalid,
1506    all expressions whose values could be altered by storing in X.
1507    X is a register, a subreg, or a memory reference with nonvarying address
1508    (because, when a memory reference with a varying address is stored in,
1509    all memory references are removed by invalidate_memory
1510    so specific invalidation is superfluous).
1511    FULL_MODE, if not VOIDmode, indicates that this much should be invalidated
1512    instead of just the amount indicated by the mode of X.  This is only used
1513    for bitfield stores into memory.
1514
1515    A nonvarying address may be just a register or just
1516    a symbol reference, or it may be either of those plus
1517    a numeric offset.  */
1518
1519 static void
1520 invalidate (x, full_mode)
1521      rtx x;
1522      enum machine_mode full_mode;
1523 {
1524   register int i;
1525   register struct table_elt *p;
1526   rtx base;
1527   HOST_WIDE_INT start, end;
1528
1529   /* If X is a register, dependencies on its contents
1530      are recorded through the qty number mechanism.
1531      Just change the qty number of the register,
1532      mark it as invalid for expressions that refer to it,
1533      and remove it itself.  */
1534
1535   if (GET_CODE (x) == REG)
1536     {
1537       register int regno = REGNO (x);
1538       register unsigned hash = HASH (x, GET_MODE (x));
1539
1540       /* Remove REGNO from any quantity list it might be on and indicate
1541          that it's value might have changed.  If it is a pseudo, remove its
1542          entry from the hash table.
1543
1544          For a hard register, we do the first two actions above for any
1545          additional hard registers corresponding to X.  Then, if any of these
1546          registers are in the table, we must remove any REG entries that
1547          overlap these registers.  */
1548
1549       delete_reg_equiv (regno);
1550       reg_tick[regno]++;
1551
1552       if (regno >= FIRST_PSEUDO_REGISTER)
1553         {
1554           /* Because a register can be referenced in more than one mode,
1555              we might have to remove more than one table entry.  */
1556
1557           struct table_elt *elt;
1558
1559           while (elt = lookup_for_remove (x, hash, GET_MODE (x)))
1560             remove_from_table (elt, hash);
1561         }
1562       else
1563         {
1564           HOST_WIDE_INT in_table
1565             = TEST_HARD_REG_BIT (hard_regs_in_table, regno);
1566           int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
1567           int tregno, tendregno;
1568           register struct table_elt *p, *next;
1569
1570           CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
1571
1572           for (i = regno + 1; i < endregno; i++)
1573             {
1574               in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, i);
1575               CLEAR_HARD_REG_BIT (hard_regs_in_table, i);
1576               delete_reg_equiv (i);
1577               reg_tick[i]++;
1578             }
1579
1580           if (in_table)
1581             for (hash = 0; hash < NBUCKETS; hash++)
1582               for (p = table[hash]; p; p = next)
1583                 {
1584                   next = p->next_same_hash;
1585
1586                   if (GET_CODE (p->exp) != REG
1587                       || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
1588                     continue;
1589
1590                   tregno = REGNO (p->exp);
1591                   tendregno
1592                     = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (p->exp));
1593                   if (tendregno > regno && tregno < endregno)
1594                   remove_from_table (p, hash);
1595                 }
1596         }
1597
1598       return;
1599     }
1600
1601   if (GET_CODE (x) == SUBREG)
1602     {
1603       if (GET_CODE (SUBREG_REG (x)) != REG)
1604         abort ();
1605       invalidate (SUBREG_REG (x), VOIDmode);
1606       return;
1607     }
1608
1609   /* X is not a register; it must be a memory reference with
1610      a nonvarying address.  Remove all hash table elements
1611      that refer to overlapping pieces of memory.  */
1612
1613   if (GET_CODE (x) != MEM)
1614     abort ();
1615
1616   if (full_mode == VOIDmode)
1617     full_mode = GET_MODE (x);
1618
1619   set_nonvarying_address_components (XEXP (x, 0), GET_MODE_SIZE (full_mode),
1620                                      &base, &start, &end);
1621
1622   for (i = 0; i < NBUCKETS; i++)
1623     {
1624       register struct table_elt *next;
1625       for (p = table[i]; p; p = next)
1626         {
1627           next = p->next_same_hash;
1628           if (refers_to_mem_p (p->exp, base, start, end))
1629             remove_from_table (p, i);
1630         }
1631     }
1632 }
1633
1634 /* Remove all expressions that refer to register REGNO,
1635    since they are already invalid, and we are about to
1636    mark that register valid again and don't want the old
1637    expressions to reappear as valid.  */
1638
1639 static void
1640 remove_invalid_refs (regno)
1641      int regno;
1642 {
1643   register int i;
1644   register struct table_elt *p, *next;
1645
1646   for (i = 0; i < NBUCKETS; i++)
1647     for (p = table[i]; p; p = next)
1648       {
1649         next = p->next_same_hash;
1650         if (GET_CODE (p->exp) != REG
1651             && refers_to_regno_p (regno, regno + 1, p->exp, NULL_PTR))
1652           remove_from_table (p, i);
1653       }
1654 }
1655 \f
1656 /* Recompute the hash codes of any valid entries in the hash table that
1657    reference X, if X is a register, or SUBREG_REG (X) if X is a SUBREG.
1658
1659    This is called when we make a jump equivalence.  */
1660
1661 static void
1662 rehash_using_reg (x)
1663      rtx x;
1664 {
1665   int i;
1666   struct table_elt *p, *next;
1667   unsigned hash;
1668
1669   if (GET_CODE (x) == SUBREG)
1670     x = SUBREG_REG (x);
1671
1672   /* If X is not a register or if the register is known not to be in any
1673      valid entries in the table, we have no work to do.  */
1674
1675   if (GET_CODE (x) != REG
1676       || reg_in_table[REGNO (x)] < 0
1677       || reg_in_table[REGNO (x)] != reg_tick[REGNO (x)])
1678     return;
1679
1680   /* Scan all hash chains looking for valid entries that mention X.
1681      If we find one and it is in the wrong hash chain, move it.  We can skip
1682      objects that are registers, since they are handled specially.  */
1683
1684   for (i = 0; i < NBUCKETS; i++)
1685     for (p = table[i]; p; p = next)
1686       {
1687         next = p->next_same_hash;
1688         if (GET_CODE (p->exp) != REG && reg_mentioned_p (x, p->exp)
1689             && exp_equiv_p (p->exp, p->exp, 1, 0)
1690             && i != (hash = safe_hash (p->exp, p->mode) % NBUCKETS))
1691           {
1692             if (p->next_same_hash)
1693               p->next_same_hash->prev_same_hash = p->prev_same_hash;
1694
1695             if (p->prev_same_hash)
1696               p->prev_same_hash->next_same_hash = p->next_same_hash;
1697             else
1698               table[i] = p->next_same_hash;
1699
1700             p->next_same_hash = table[hash];
1701             p->prev_same_hash = 0;
1702             if (table[hash])
1703               table[hash]->prev_same_hash = p;
1704             table[hash] = p;
1705           }
1706       }
1707 }
1708 \f
1709 /* Remove from the hash table all expressions that reference memory,
1710    or some of them as specified by *WRITES.  */
1711
1712 static void
1713 invalidate_memory (writes)
1714      struct write_data *writes;
1715 {
1716   register int i;
1717   register struct table_elt *p, *next;
1718   int all = writes->all;
1719   int nonscalar = writes->nonscalar;
1720
1721   for (i = 0; i < NBUCKETS; i++)
1722     for (p = table[i]; p; p = next)
1723       {
1724         next = p->next_same_hash;
1725         if (p->in_memory
1726             && (all
1727                 || (nonscalar && p->in_struct)
1728                 || cse_rtx_addr_varies_p (p->exp)))
1729           remove_from_table (p, i);
1730       }
1731 }
1732 \f
1733 /* Remove from the hash table any expression that is a call-clobbered
1734    register.  Also update their TICK values.  */
1735
1736 static void
1737 invalidate_for_call ()
1738 {
1739   int regno, endregno;
1740   int i;
1741   unsigned hash;
1742   struct table_elt *p, *next;
1743   int in_table = 0;
1744
1745   /* Go through all the hard registers.  For each that is clobbered in
1746      a CALL_INSN, remove the register from quantity chains and update
1747      reg_tick if defined.  Also see if any of these registers is currently
1748      in the table.  */
1749
1750   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1751     if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
1752       {
1753         delete_reg_equiv (regno);
1754         if (reg_tick[regno] >= 0)
1755           reg_tick[regno]++;
1756
1757         in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0);
1758       }
1759
1760   /* In the case where we have no call-clobbered hard registers in the
1761      table, we are done.  Otherwise, scan the table and remove any
1762      entry that overlaps a call-clobbered register.  */
1763
1764   if (in_table)
1765     for (hash = 0; hash < NBUCKETS; hash++)
1766       for (p = table[hash]; p; p = next)
1767         {
1768           next = p->next_same_hash;
1769
1770           if (GET_CODE (p->exp) != REG
1771               || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
1772             continue;
1773
1774           regno = REGNO (p->exp);
1775           endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (p->exp));
1776
1777           for (i = regno; i < endregno; i++)
1778             if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
1779               {
1780                 remove_from_table (p, hash);
1781                 break;
1782               }
1783         }
1784 }
1785 \f
1786 /* Given an expression X of type CONST,
1787    and ELT which is its table entry (or 0 if it
1788    is not in the hash table),
1789    return an alternate expression for X as a register plus integer.
1790    If none can be found, return 0.  */
1791
1792 static rtx
1793 use_related_value (x, elt)
1794      rtx x;
1795      struct table_elt *elt;
1796 {
1797   register struct table_elt *relt = 0;
1798   register struct table_elt *p, *q;
1799   HOST_WIDE_INT offset;
1800
1801   /* First, is there anything related known?
1802      If we have a table element, we can tell from that.
1803      Otherwise, must look it up.  */
1804
1805   if (elt != 0 && elt->related_value != 0)
1806     relt = elt;
1807   else if (elt == 0 && GET_CODE (x) == CONST)
1808     {
1809       rtx subexp = get_related_value (x);
1810       if (subexp != 0)
1811         relt = lookup (subexp,
1812                        safe_hash (subexp, GET_MODE (subexp)) % NBUCKETS,
1813                        GET_MODE (subexp));
1814     }
1815
1816   if (relt == 0)
1817     return 0;
1818
1819   /* Search all related table entries for one that has an
1820      equivalent register.  */
1821
1822   p = relt;
1823   while (1)
1824     {
1825       /* This loop is strange in that it is executed in two different cases.
1826          The first is when X is already in the table.  Then it is searching
1827          the RELATED_VALUE list of X's class (RELT).  The second case is when
1828          X is not in the table.  Then RELT points to a class for the related
1829          value.
1830
1831          Ensure that, whatever case we are in, that we ignore classes that have
1832          the same value as X.  */
1833
1834       if (rtx_equal_p (x, p->exp))
1835         q = 0;
1836       else
1837         for (q = p->first_same_value; q; q = q->next_same_value)
1838           if (GET_CODE (q->exp) == REG)
1839             break;
1840
1841       if (q)
1842         break;
1843
1844       p = p->related_value;
1845
1846       /* We went all the way around, so there is nothing to be found.
1847          Alternatively, perhaps RELT was in the table for some other reason
1848          and it has no related values recorded.  */
1849       if (p == relt || p == 0)
1850         break;
1851     }
1852
1853   if (q == 0)
1854     return 0;
1855
1856   offset = (get_integer_term (x) - get_integer_term (p->exp));
1857   /* Note: OFFSET may be 0 if P->xexp and X are related by commutativity.  */
1858   return plus_constant (q->exp, offset);
1859 }
1860 \f
1861 /* Hash an rtx.  We are careful to make sure the value is never negative.
1862    Equivalent registers hash identically.
1863    MODE is used in hashing for CONST_INTs only;
1864    otherwise the mode of X is used.
1865
1866    Store 1 in do_not_record if any subexpression is volatile.
1867
1868    Store 1 in hash_arg_in_memory if X contains a MEM rtx
1869    which does not have the RTX_UNCHANGING_P bit set.
1870    In this case, also store 1 in hash_arg_in_struct
1871    if there is a MEM rtx which has the MEM_IN_STRUCT_P bit set.
1872
1873    Note that cse_insn knows that the hash code of a MEM expression
1874    is just (int) MEM plus the hash code of the address.  */
1875
1876 static unsigned
1877 canon_hash (x, mode)
1878      rtx x;
1879      enum machine_mode mode;
1880 {
1881   register int i, j;
1882   register unsigned hash = 0;
1883   register enum rtx_code code;
1884   register char *fmt;
1885
1886   /* repeat is used to turn tail-recursion into iteration.  */
1887  repeat:
1888   if (x == 0)
1889     return hash;
1890
1891   code = GET_CODE (x);
1892   switch (code)
1893     {
1894     case REG:
1895       {
1896         register int regno = REGNO (x);
1897
1898         /* On some machines, we can't record any non-fixed hard register,
1899            because extending its life will cause reload problems.  We
1900            consider ap, fp, and sp to be fixed for this purpose.
1901            On all machines, we can't record any global registers.  */
1902
1903         if (regno < FIRST_PSEUDO_REGISTER
1904             && (global_regs[regno]
1905 #ifdef SMALL_REGISTER_CLASSES
1906                 || (SMALL_REGISTER_CLASSES
1907                     && ! fixed_regs[regno]
1908                     && regno != FRAME_POINTER_REGNUM
1909                     && regno != HARD_FRAME_POINTER_REGNUM
1910                     && regno != ARG_POINTER_REGNUM
1911                     && regno != STACK_POINTER_REGNUM)
1912 #endif
1913                 ))
1914           {
1915             do_not_record = 1;
1916             return 0;
1917           }
1918         hash += ((unsigned) REG << 7) + (unsigned) reg_qty[regno];
1919         return hash;
1920       }
1921
1922     case CONST_INT:
1923       {
1924         unsigned HOST_WIDE_INT tem = INTVAL (x);
1925         hash += ((unsigned) CONST_INT << 7) + (unsigned) mode + tem;
1926         return hash;
1927       }
1928
1929     case CONST_DOUBLE:
1930       /* This is like the general case, except that it only counts
1931          the integers representing the constant.  */
1932       hash += (unsigned) code + (unsigned) GET_MODE (x);
1933       if (GET_MODE (x) != VOIDmode)
1934         for (i = 2; i < GET_RTX_LENGTH (CONST_DOUBLE); i++)
1935           {
1936             unsigned tem = XINT (x, i);
1937             hash += tem;
1938           }
1939       else
1940         hash += ((unsigned) CONST_DOUBLE_LOW (x)
1941                  + (unsigned) CONST_DOUBLE_HIGH (x));
1942       return hash;
1943
1944       /* Assume there is only one rtx object for any given label.  */
1945     case LABEL_REF:
1946       hash
1947         += ((unsigned) LABEL_REF << 7) + (unsigned HOST_WIDE_INT) XEXP (x, 0);
1948       return hash;
1949
1950     case SYMBOL_REF:
1951       hash
1952         += ((unsigned) SYMBOL_REF << 7) + (unsigned HOST_WIDE_INT) XSTR (x, 0);
1953       return hash;
1954
1955     case MEM:
1956       if (MEM_VOLATILE_P (x))
1957         {
1958           do_not_record = 1;
1959           return 0;
1960         }
1961       if (! RTX_UNCHANGING_P (x) || FIXED_BASE_PLUS_P (XEXP (x, 0)))
1962         {
1963           hash_arg_in_memory = 1;
1964           if (MEM_IN_STRUCT_P (x)) hash_arg_in_struct = 1;
1965         }
1966       /* Now that we have already found this special case,
1967          might as well speed it up as much as possible.  */
1968       hash += (unsigned) MEM;
1969       x = XEXP (x, 0);
1970       goto repeat;
1971
1972     case PRE_DEC:
1973     case PRE_INC:
1974     case POST_DEC:
1975     case POST_INC:
1976     case PC:
1977     case CC0:
1978     case CALL:
1979     case UNSPEC_VOLATILE:
1980       do_not_record = 1;
1981       return 0;
1982
1983     case ASM_OPERANDS:
1984       if (MEM_VOLATILE_P (x))
1985         {
1986           do_not_record = 1;
1987           return 0;
1988         }
1989     }
1990
1991   i = GET_RTX_LENGTH (code) - 1;
1992   hash += (unsigned) code + (unsigned) GET_MODE (x);
1993   fmt = GET_RTX_FORMAT (code);
1994   for (; i >= 0; i--)
1995     {
1996       if (fmt[i] == 'e')
1997         {
1998           rtx tem = XEXP (x, i);
1999
2000           /* If we are about to do the last recursive call
2001              needed at this level, change it into iteration.
2002              This function  is called enough to be worth it.  */
2003           if (i == 0)
2004             {
2005               x = tem;
2006               goto repeat;
2007             }
2008           hash += canon_hash (tem, 0);
2009         }
2010       else if (fmt[i] == 'E')
2011         for (j = 0; j < XVECLEN (x, i); j++)
2012           hash += canon_hash (XVECEXP (x, i, j), 0);
2013       else if (fmt[i] == 's')
2014         {
2015           register unsigned char *p = (unsigned char *) XSTR (x, i);
2016           if (p)
2017             while (*p)
2018               hash += *p++;
2019         }
2020       else if (fmt[i] == 'i')
2021         {
2022           register unsigned tem = XINT (x, i);
2023           hash += tem;
2024         }
2025       else
2026         abort ();
2027     }
2028   return hash;
2029 }
2030
2031 /* Like canon_hash but with no side effects.  */
2032
2033 static unsigned
2034 safe_hash (x, mode)
2035      rtx x;
2036      enum machine_mode mode;
2037 {
2038   int save_do_not_record = do_not_record;
2039   int save_hash_arg_in_memory = hash_arg_in_memory;
2040   int save_hash_arg_in_struct = hash_arg_in_struct;
2041   unsigned hash = canon_hash (x, mode);
2042   hash_arg_in_memory = save_hash_arg_in_memory;
2043   hash_arg_in_struct = save_hash_arg_in_struct;
2044   do_not_record = save_do_not_record;
2045   return hash;
2046 }
2047 \f
2048 /* Return 1 iff X and Y would canonicalize into the same thing,
2049    without actually constructing the canonicalization of either one.
2050    If VALIDATE is nonzero,
2051    we assume X is an expression being processed from the rtl
2052    and Y was found in the hash table.  We check register refs
2053    in Y for being marked as valid.
2054
2055    If EQUAL_VALUES is nonzero, we allow a register to match a constant value
2056    that is known to be in the register.  Ordinarily, we don't allow them
2057    to match, because letting them match would cause unpredictable results
2058    in all the places that search a hash table chain for an equivalent
2059    for a given value.  A possible equivalent that has different structure
2060    has its hash code computed from different data.  Whether the hash code
2061    is the same as that of the the given value is pure luck.  */
2062
2063 static int
2064 exp_equiv_p (x, y, validate, equal_values)
2065      rtx x, y;
2066      int validate;
2067      int equal_values;
2068 {
2069   register int i, j;
2070   register enum rtx_code code;
2071   register char *fmt;
2072
2073   /* Note: it is incorrect to assume an expression is equivalent to itself
2074      if VALIDATE is nonzero.  */
2075   if (x == y && !validate)
2076     return 1;
2077   if (x == 0 || y == 0)
2078     return x == y;
2079
2080   code = GET_CODE (x);
2081   if (code != GET_CODE (y))
2082     {
2083       if (!equal_values)
2084         return 0;
2085
2086       /* If X is a constant and Y is a register or vice versa, they may be
2087          equivalent.  We only have to validate if Y is a register.  */
2088       if (CONSTANT_P (x) && GET_CODE (y) == REG
2089           && REGNO_QTY_VALID_P (REGNO (y))
2090           && GET_MODE (y) == qty_mode[reg_qty[REGNO (y)]]
2091           && rtx_equal_p (x, qty_const[reg_qty[REGNO (y)]])
2092           && (! validate || reg_in_table[REGNO (y)] == reg_tick[REGNO (y)]))
2093         return 1;
2094
2095       if (CONSTANT_P (y) && code == REG
2096           && REGNO_QTY_VALID_P (REGNO (x))
2097           && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]]
2098           && rtx_equal_p (y, qty_const[reg_qty[REGNO (x)]]))
2099         return 1;
2100
2101       return 0;
2102     }
2103
2104   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.  */
2105   if (GET_MODE (x) != GET_MODE (y))
2106     return 0;
2107
2108   switch (code)
2109     {
2110     case PC:
2111     case CC0:
2112       return x == y;
2113
2114     case CONST_INT:
2115       return INTVAL (x) == INTVAL (y);
2116
2117     case LABEL_REF:
2118       return XEXP (x, 0) == XEXP (y, 0);
2119
2120     case SYMBOL_REF:
2121       return XSTR (x, 0) == XSTR (y, 0);
2122
2123     case REG:
2124       {
2125         int regno = REGNO (y);
2126         int endregno
2127           = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
2128                      : HARD_REGNO_NREGS (regno, GET_MODE (y)));
2129         int i;
2130
2131         /* If the quantities are not the same, the expressions are not
2132            equivalent.  If there are and we are not to validate, they
2133            are equivalent.  Otherwise, ensure all regs are up-to-date.  */
2134
2135         if (reg_qty[REGNO (x)] != reg_qty[regno])
2136           return 0;
2137
2138         if (! validate)
2139           return 1;
2140
2141         for (i = regno; i < endregno; i++)
2142           if (reg_in_table[i] != reg_tick[i])
2143             return 0;
2144
2145         return 1;
2146       }
2147
2148     /*  For commutative operations, check both orders.  */
2149     case PLUS:
2150     case MULT:
2151     case AND:
2152     case IOR:
2153     case XOR:
2154     case NE:
2155     case EQ:
2156       return ((exp_equiv_p (XEXP (x, 0), XEXP (y, 0), validate, equal_values)
2157                && exp_equiv_p (XEXP (x, 1), XEXP (y, 1),
2158                                validate, equal_values))
2159               || (exp_equiv_p (XEXP (x, 0), XEXP (y, 1),
2160                                validate, equal_values)
2161                   && exp_equiv_p (XEXP (x, 1), XEXP (y, 0),
2162                                   validate, equal_values)));
2163     }
2164
2165   /* Compare the elements.  If any pair of corresponding elements
2166      fail to match, return 0 for the whole things.  */
2167
2168   fmt = GET_RTX_FORMAT (code);
2169   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2170     {
2171       switch (fmt[i])
2172         {
2173         case 'e':
2174           if (! exp_equiv_p (XEXP (x, i), XEXP (y, i), validate, equal_values))
2175             return 0;
2176           break;
2177
2178         case 'E':
2179           if (XVECLEN (x, i) != XVECLEN (y, i))
2180             return 0;
2181           for (j = 0; j < XVECLEN (x, i); j++)
2182             if (! exp_equiv_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
2183                                validate, equal_values))
2184               return 0;
2185           break;
2186
2187         case 's':
2188           if (strcmp (XSTR (x, i), XSTR (y, i)))
2189             return 0;
2190           break;
2191
2192         case 'i':
2193           if (XINT (x, i) != XINT (y, i))
2194             return 0;
2195           break;
2196
2197         case 'w':
2198           if (XWINT (x, i) != XWINT (y, i))
2199             return 0;
2200         break;
2201
2202         case '0':
2203           break;
2204
2205         default:
2206           abort ();
2207         }
2208       }
2209
2210   return 1;
2211 }
2212 \f
2213 /* Return 1 iff any subexpression of X matches Y.
2214    Here we do not require that X or Y be valid (for registers referred to)
2215    for being in the hash table.  */
2216
2217 static int
2218 refers_to_p (x, y)
2219      rtx x, y;
2220 {
2221   register int i;
2222   register enum rtx_code code;
2223   register char *fmt;
2224
2225  repeat:
2226   if (x == y)
2227     return 1;
2228   if (x == 0 || y == 0)
2229     return 0;
2230
2231   code = GET_CODE (x);
2232   /* If X as a whole has the same code as Y, they may match.
2233      If so, return 1.  */
2234   if (code == GET_CODE (y))
2235     {
2236       if (exp_equiv_p (x, y, 0, 1))
2237         return 1;
2238     }
2239
2240   /* X does not match, so try its subexpressions.  */
2241
2242   fmt = GET_RTX_FORMAT (code);
2243   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2244     if (fmt[i] == 'e')
2245       {
2246         if (i == 0)
2247           {
2248             x = XEXP (x, 0);
2249             goto repeat;
2250           }
2251         else
2252           if (refers_to_p (XEXP (x, i), y))
2253             return 1;
2254       }
2255     else if (fmt[i] == 'E')
2256       {
2257         int j;
2258         for (j = 0; j < XVECLEN (x, i); j++)
2259           if (refers_to_p (XVECEXP (x, i, j), y))
2260             return 1;
2261       }
2262
2263   return 0;
2264 }
2265 \f
2266 /* Given ADDR and SIZE (a memory address, and the size of the memory reference),
2267    set PBASE, PSTART, and PEND which correspond to the base of the address,
2268    the starting offset, and ending offset respectively.
2269
2270    ADDR is known to be a nonvarying address.  */
2271
2272 /* ??? Despite what the comments say, this function is in fact frequently
2273    passed varying addresses.  This does not appear to cause any problems.  */
2274
2275 static void
2276 set_nonvarying_address_components (addr, size, pbase, pstart, pend)
2277      rtx addr;
2278      int size;
2279      rtx *pbase;
2280      HOST_WIDE_INT *pstart, *pend;
2281 {
2282   rtx base;
2283   HOST_WIDE_INT start, end;
2284
2285   base = addr;
2286   start = 0;
2287   end = 0;
2288
2289   /* Registers with nonvarying addresses usually have constant equivalents;
2290      but the frame pointer register is also possible.  */
2291   if (GET_CODE (base) == REG
2292       && qty_const != 0
2293       && REGNO_QTY_VALID_P (REGNO (base))
2294       && qty_mode[reg_qty[REGNO (base)]] == GET_MODE (base)
2295       && qty_const[reg_qty[REGNO (base)]] != 0)
2296     base = qty_const[reg_qty[REGNO (base)]];
2297   else if (GET_CODE (base) == PLUS
2298            && GET_CODE (XEXP (base, 1)) == CONST_INT
2299            && GET_CODE (XEXP (base, 0)) == REG
2300            && qty_const != 0
2301            && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0)))
2302            && (qty_mode[reg_qty[REGNO (XEXP (base, 0))]]
2303                == GET_MODE (XEXP (base, 0)))
2304            && qty_const[reg_qty[REGNO (XEXP (base, 0))]])
2305     {
2306       start = INTVAL (XEXP (base, 1));
2307       base = qty_const[reg_qty[REGNO (XEXP (base, 0))]];
2308     }
2309   /* This can happen as the result of virtual register instantiation,
2310      if the initial offset is too large to be a valid address.  */
2311   else if (GET_CODE (base) == PLUS
2312            && GET_CODE (XEXP (base, 0)) == REG
2313            && GET_CODE (XEXP (base, 1)) == REG
2314            && qty_const != 0
2315            && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0)))
2316            && (qty_mode[reg_qty[REGNO (XEXP (base, 0))]]
2317                == GET_MODE (XEXP (base, 0)))
2318            && qty_const[reg_qty[REGNO (XEXP (base, 0))]]
2319            && REGNO_QTY_VALID_P (REGNO (XEXP (base, 1)))
2320            && (qty_mode[reg_qty[REGNO (XEXP (base, 1))]]
2321                == GET_MODE (XEXP (base, 1)))
2322            && qty_const[reg_qty[REGNO (XEXP (base, 1))]])
2323     {
2324       rtx tem = qty_const[reg_qty[REGNO (XEXP (base, 1))]];
2325       base = qty_const[reg_qty[REGNO (XEXP (base, 0))]];
2326
2327       /* One of the two values must be a constant.  */
2328       if (GET_CODE (base) != CONST_INT)
2329         {
2330           if (GET_CODE (tem) != CONST_INT)
2331             abort ();
2332           start = INTVAL (tem);
2333         }
2334       else
2335         {
2336           start = INTVAL (base);
2337           base = tem;
2338         }
2339     }
2340
2341   /* Handle everything that we can find inside an address that has been
2342      viewed as constant.  */
2343
2344   while (1)
2345     {
2346       /* If no part of this switch does a "continue", the code outside
2347          will exit this loop.  */
2348
2349       switch (GET_CODE (base))
2350         {
2351         case LO_SUM:
2352           /* By definition, operand1 of a LO_SUM is the associated constant
2353              address.  Use the associated constant address as the base
2354              instead.  */
2355           base = XEXP (base, 1);
2356           continue;
2357
2358         case CONST:
2359           /* Strip off CONST.  */
2360           base = XEXP (base, 0);
2361           continue;
2362
2363         case PLUS:
2364           if (GET_CODE (XEXP (base, 1)) == CONST_INT)
2365             {
2366               start += INTVAL (XEXP (base, 1));
2367               base = XEXP (base, 0);
2368               continue;
2369             }
2370           break;
2371
2372         case AND:
2373           /* Handle the case of an AND which is the negative of a power of
2374              two.  This is used to represent unaligned memory operations.  */
2375           if (GET_CODE (XEXP (base, 1)) == CONST_INT
2376               && exact_log2 (- INTVAL (XEXP (base, 1))) > 0)
2377             {
2378               set_nonvarying_address_components (XEXP (base, 0), size,
2379                                                  pbase, pstart, pend);
2380
2381               /* Assume the worst misalignment.  START is affected, but not
2382                  END, so compensate but adjusting SIZE.  Don't lose any
2383                  constant we already had.  */
2384
2385               size = *pend - *pstart - INTVAL (XEXP (base, 1)) - 1;
2386               start += *pstart + INTVAL (XEXP (base, 1)) + 1;
2387               end += *pend;
2388               base = *pbase;
2389             }
2390           break;
2391         }
2392
2393       break;
2394     }
2395
2396   if (GET_CODE (base) == CONST_INT)
2397     {
2398       start += INTVAL (base);
2399       base = const0_rtx;
2400     }
2401
2402   end = start + size;
2403
2404   /* Set the return values.  */
2405   *pbase = base;
2406   *pstart = start;
2407   *pend = end;
2408 }
2409
2410 /* Return 1 iff any subexpression of X refers to memory
2411    at an address of BASE plus some offset
2412    such that any of the bytes' offsets fall between START (inclusive)
2413    and END (exclusive).
2414
2415    The value is undefined if X is a varying address (as determined by
2416    cse_rtx_addr_varies_p).  This function is not used in such cases.
2417
2418    When used in the cse pass, `qty_const' is nonzero, and it is used
2419    to treat an address that is a register with a known constant value
2420    as if it were that constant value.
2421    In the loop pass, `qty_const' is zero, so this is not done.  */
2422
2423 static int
2424 refers_to_mem_p (x, base, start, end)
2425      rtx x, base;
2426      HOST_WIDE_INT start, end;
2427 {
2428   register HOST_WIDE_INT i;
2429   register enum rtx_code code;
2430   register char *fmt;
2431
2432  repeat:
2433   if (x == 0)
2434     return 0;
2435
2436   code = GET_CODE (x);
2437   if (code == MEM)
2438     {
2439       register rtx addr = XEXP (x, 0);  /* Get the address.  */
2440       rtx mybase;
2441       HOST_WIDE_INT mystart, myend;
2442
2443       set_nonvarying_address_components (addr, GET_MODE_SIZE (GET_MODE (x)),
2444                                          &mybase, &mystart, &myend);
2445
2446
2447       /* refers_to_mem_p is never called with varying addresses. 
2448          If the base addresses are not equal, there is no chance
2449          of the memory addresses conflicting.  */
2450       if (! rtx_equal_p (mybase, base))
2451         return 0;
2452
2453       return myend > start && mystart < end;
2454     }
2455
2456   /* X does not match, so try its subexpressions.  */
2457
2458   fmt = GET_RTX_FORMAT (code);
2459   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2460     if (fmt[i] == 'e')
2461       {
2462         if (i == 0)
2463           {
2464             x = XEXP (x, 0);
2465             goto repeat;
2466           }
2467         else
2468           if (refers_to_mem_p (XEXP (x, i), base, start, end))
2469             return 1;
2470       }
2471     else if (fmt[i] == 'E')
2472       {
2473         int j;
2474         for (j = 0; j < XVECLEN (x, i); j++)
2475           if (refers_to_mem_p (XVECEXP (x, i, j), base, start, end))
2476             return 1;
2477       }
2478
2479   return 0;
2480 }
2481
2482 /* Nonzero if X refers to memory at a varying address;
2483    except that a register which has at the moment a known constant value
2484    isn't considered variable.  */
2485
2486 static int
2487 cse_rtx_addr_varies_p (x)
2488      rtx x;
2489 {
2490   /* We need not check for X and the equivalence class being of the same
2491      mode because if X is equivalent to a constant in some mode, it
2492      doesn't vary in any mode.  */
2493
2494   if (GET_CODE (x) == MEM
2495       && GET_CODE (XEXP (x, 0)) == REG
2496       && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
2497       && GET_MODE (XEXP (x, 0)) == qty_mode[reg_qty[REGNO (XEXP (x, 0))]]
2498       && qty_const[reg_qty[REGNO (XEXP (x, 0))]] != 0)
2499     return 0;
2500
2501   if (GET_CODE (x) == MEM
2502       && GET_CODE (XEXP (x, 0)) == PLUS
2503       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2504       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2505       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0)))
2506       && (GET_MODE (XEXP (XEXP (x, 0), 0))
2507           == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
2508       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
2509     return 0;
2510
2511   /* This can happen as the result of virtual register instantiation, if
2512      the initial constant is too large to be a valid address.  This gives
2513      us a three instruction sequence, load large offset into a register,
2514      load fp minus a constant into a register, then a MEM which is the
2515      sum of the two `constant' registers.  */
2516   if (GET_CODE (x) == MEM
2517       && GET_CODE (XEXP (x, 0)) == PLUS
2518       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2519       && GET_CODE (XEXP (XEXP (x, 0), 1)) == REG
2520       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0)))
2521       && (GET_MODE (XEXP (XEXP (x, 0), 0))
2522           == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
2523       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]]
2524       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 1)))
2525       && (GET_MODE (XEXP (XEXP (x, 0), 1))
2526           == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 1))]])
2527       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 1))]])
2528     return 0;
2529
2530   return rtx_addr_varies_p (x);
2531 }
2532 \f
2533 /* Canonicalize an expression:
2534    replace each register reference inside it
2535    with the "oldest" equivalent register.
2536
2537    If INSN is non-zero and we are replacing a pseudo with a hard register
2538    or vice versa, validate_change is used to ensure that INSN remains valid
2539    after we make our substitution.  The calls are made with IN_GROUP non-zero
2540    so apply_change_group must be called upon the outermost return from this
2541    function (unless INSN is zero).  The result of apply_change_group can
2542    generally be discarded since the changes we are making are optional.  */
2543
2544 static rtx
2545 canon_reg (x, insn)
2546      rtx x;
2547      rtx insn;
2548 {
2549   register int i;
2550   register enum rtx_code code;
2551   register char *fmt;
2552
2553   if (x == 0)
2554     return x;
2555
2556   code = GET_CODE (x);
2557   switch (code)
2558     {
2559     case PC:
2560     case CC0:
2561     case CONST:
2562     case CONST_INT:
2563     case CONST_DOUBLE:
2564     case SYMBOL_REF:
2565     case LABEL_REF:
2566     case ADDR_VEC:
2567     case ADDR_DIFF_VEC:
2568       return x;
2569
2570     case REG:
2571       {
2572         register int first;
2573
2574         /* Never replace a hard reg, because hard regs can appear
2575            in more than one machine mode, and we must preserve the mode
2576            of each occurrence.  Also, some hard regs appear in
2577            MEMs that are shared and mustn't be altered.  Don't try to
2578            replace any reg that maps to a reg of class NO_REGS.  */
2579         if (REGNO (x) < FIRST_PSEUDO_REGISTER
2580             || ! REGNO_QTY_VALID_P (REGNO (x)))
2581           return x;
2582
2583         first = qty_first_reg[reg_qty[REGNO (x)]];
2584         return (first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first]
2585                 : REGNO_REG_CLASS (first) == NO_REGS ? x
2586                 : gen_rtx (REG, qty_mode[reg_qty[REGNO (x)]], first));
2587       }
2588     }
2589
2590   fmt = GET_RTX_FORMAT (code);
2591   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2592     {
2593       register int j;
2594
2595       if (fmt[i] == 'e')
2596         {
2597           rtx new = canon_reg (XEXP (x, i), insn);
2598           int insn_code;
2599
2600           /* If replacing pseudo with hard reg or vice versa, ensure the
2601              insn remains valid.  Likewise if the insn has MATCH_DUPs.  */
2602           if (insn != 0 && new != 0
2603               && GET_CODE (new) == REG && GET_CODE (XEXP (x, i)) == REG
2604               && (((REGNO (new) < FIRST_PSEUDO_REGISTER)
2605                    != (REGNO (XEXP (x, i)) < FIRST_PSEUDO_REGISTER))
2606                   || (insn_code = recog_memoized (insn)) < 0
2607                   || insn_n_dups[insn_code] > 0))
2608             validate_change (insn, &XEXP (x, i), new, 1);
2609           else
2610             XEXP (x, i) = new;
2611         }
2612       else if (fmt[i] == 'E')
2613         for (j = 0; j < XVECLEN (x, i); j++)
2614           XVECEXP (x, i, j) = canon_reg (XVECEXP (x, i, j), insn);
2615     }
2616
2617   return x;
2618 }
2619 \f
2620 /* LOC is a location within INSN that is an operand address (the contents of
2621    a MEM).  Find the best equivalent address to use that is valid for this
2622    insn.
2623
2624    On most CISC machines, complicated address modes are costly, and rtx_cost
2625    is a good approximation for that cost.  However, most RISC machines have
2626    only a few (usually only one) memory reference formats.  If an address is
2627    valid at all, it is often just as cheap as any other address.  Hence, for
2628    RISC machines, we use the configuration macro `ADDRESS_COST' to compare the
2629    costs of various addresses.  For two addresses of equal cost, choose the one
2630    with the highest `rtx_cost' value as that has the potential of eliminating
2631    the most insns.  For equal costs, we choose the first in the equivalence
2632    class.  Note that we ignore the fact that pseudo registers are cheaper
2633    than hard registers here because we would also prefer the pseudo registers.
2634   */
2635
2636 static void
2637 find_best_addr (insn, loc)
2638      rtx insn;
2639      rtx *loc;
2640 {
2641   struct table_elt *elt, *p;
2642   rtx addr = *loc;
2643   int our_cost;
2644   int found_better = 1;
2645   int save_do_not_record = do_not_record;
2646   int save_hash_arg_in_memory = hash_arg_in_memory;
2647   int save_hash_arg_in_struct = hash_arg_in_struct;
2648   int addr_volatile;
2649   int regno;
2650   unsigned hash;
2651
2652   /* Do not try to replace constant addresses or addresses of local and
2653      argument slots.  These MEM expressions are made only once and inserted
2654      in many instructions, as well as being used to control symbol table
2655      output.  It is not safe to clobber them.
2656
2657      There are some uncommon cases where the address is already in a register
2658      for some reason, but we cannot take advantage of that because we have
2659      no easy way to unshare the MEM.  In addition, looking up all stack
2660      addresses is costly.  */
2661   if ((GET_CODE (addr) == PLUS
2662        && GET_CODE (XEXP (addr, 0)) == REG
2663        && GET_CODE (XEXP (addr, 1)) == CONST_INT
2664        && (regno = REGNO (XEXP (addr, 0)),
2665            regno == FRAME_POINTER_REGNUM || regno == HARD_FRAME_POINTER_REGNUM
2666            || regno == ARG_POINTER_REGNUM))
2667       || (GET_CODE (addr) == REG
2668           && (regno = REGNO (addr), regno == FRAME_POINTER_REGNUM
2669               || regno == HARD_FRAME_POINTER_REGNUM
2670               || regno == ARG_POINTER_REGNUM))
2671       || CONSTANT_ADDRESS_P (addr))
2672     return;
2673
2674   /* If this address is not simply a register, try to fold it.  This will
2675      sometimes simplify the expression.  Many simplifications
2676      will not be valid, but some, usually applying the associative rule, will
2677      be valid and produce better code.  */
2678   if (GET_CODE (addr) != REG)
2679     {
2680       rtx folded = fold_rtx (copy_rtx (addr), NULL_RTX);
2681
2682       if (1
2683 #ifdef ADDRESS_COST
2684           && (ADDRESS_COST (folded) < ADDRESS_COST (addr)
2685               || (ADDRESS_COST (folded) == ADDRESS_COST (addr)
2686                   && rtx_cost (folded) > rtx_cost (addr)))
2687 #else
2688           && rtx_cost (folded) < rtx_cost (addr)
2689 #endif
2690           && validate_change (insn, loc, folded, 0))
2691         addr = folded;
2692     }
2693         
2694   /* If this address is not in the hash table, we can't look for equivalences
2695      of the whole address.  Also, ignore if volatile.  */
2696
2697   do_not_record = 0;
2698   hash = HASH (addr, Pmode);
2699   addr_volatile = do_not_record;
2700   do_not_record = save_do_not_record;
2701   hash_arg_in_memory = save_hash_arg_in_memory;
2702   hash_arg_in_struct = save_hash_arg_in_struct;
2703
2704   if (addr_volatile)
2705     return;
2706
2707   elt = lookup (addr, hash, Pmode);
2708
2709 #ifndef ADDRESS_COST
2710   if (elt)
2711     {
2712       our_cost = elt->cost;
2713
2714       /* Find the lowest cost below ours that works.  */
2715       for (elt = elt->first_same_value; elt; elt = elt->next_same_value)
2716         if (elt->cost < our_cost
2717             && (GET_CODE (elt->exp) == REG
2718                 || exp_equiv_p (elt->exp, elt->exp, 1, 0))
2719             && validate_change (insn, loc,
2720                                 canon_reg (copy_rtx (elt->exp), NULL_RTX), 0))
2721           return;
2722     }
2723 #else
2724
2725   if (elt)
2726     {
2727       /* We need to find the best (under the criteria documented above) entry
2728          in the class that is valid.  We use the `flag' field to indicate
2729          choices that were invalid and iterate until we can't find a better
2730          one that hasn't already been tried.  */
2731
2732       for (p = elt->first_same_value; p; p = p->next_same_value)
2733         p->flag = 0;
2734
2735       while (found_better)
2736         {
2737           int best_addr_cost = ADDRESS_COST (*loc);
2738           int best_rtx_cost = (elt->cost + 1) >> 1;
2739           struct table_elt *best_elt = elt; 
2740
2741           found_better = 0;
2742           for (p = elt->first_same_value; p; p = p->next_same_value)
2743             if (! p->flag
2744                 && (GET_CODE (p->exp) == REG
2745                     || exp_equiv_p (p->exp, p->exp, 1, 0))
2746                 && (ADDRESS_COST (p->exp) < best_addr_cost
2747                     || (ADDRESS_COST (p->exp) == best_addr_cost
2748                         && (p->cost + 1) >> 1 > best_rtx_cost)))
2749               {
2750                 found_better = 1;
2751                 best_addr_cost = ADDRESS_COST (p->exp);
2752                 best_rtx_cost = (p->cost + 1) >> 1;
2753                 best_elt = p;
2754               }
2755
2756           if (found_better)
2757             {
2758               if (validate_change (insn, loc,
2759                                    canon_reg (copy_rtx (best_elt->exp),
2760                                               NULL_RTX), 0))
2761                 return;
2762               else
2763                 best_elt->flag = 1;
2764             }
2765         }
2766     }
2767
2768   /* If the address is a binary operation with the first operand a register
2769      and the second a constant, do the same as above, but looking for
2770      equivalences of the register.  Then try to simplify before checking for
2771      the best address to use.  This catches a few cases:  First is when we
2772      have REG+const and the register is another REG+const.  We can often merge
2773      the constants and eliminate one insn and one register.  It may also be
2774      that a machine has a cheap REG+REG+const.  Finally, this improves the
2775      code on the Alpha for unaligned byte stores.  */
2776
2777   if (flag_expensive_optimizations
2778       && (GET_RTX_CLASS (GET_CODE (*loc)) == '2'
2779           || GET_RTX_CLASS (GET_CODE (*loc)) == 'c')
2780       && GET_CODE (XEXP (*loc, 0)) == REG
2781       && GET_CODE (XEXP (*loc, 1)) == CONST_INT)
2782     {
2783       rtx c = XEXP (*loc, 1);
2784
2785       do_not_record = 0;
2786       hash = HASH (XEXP (*loc, 0), Pmode);
2787       do_not_record = save_do_not_record;
2788       hash_arg_in_memory = save_hash_arg_in_memory;
2789       hash_arg_in_struct = save_hash_arg_in_struct;
2790
2791       elt = lookup (XEXP (*loc, 0), hash, Pmode);
2792       if (elt == 0)
2793         return;
2794
2795       /* We need to find the best (under the criteria documented above) entry
2796          in the class that is valid.  We use the `flag' field to indicate
2797          choices that were invalid and iterate until we can't find a better
2798          one that hasn't already been tried.  */
2799
2800       for (p = elt->first_same_value; p; p = p->next_same_value)
2801         p->flag = 0;
2802
2803       while (found_better)
2804         {
2805           int best_addr_cost = ADDRESS_COST (*loc);
2806           int best_rtx_cost = (COST (*loc) + 1) >> 1;
2807           struct table_elt *best_elt = elt; 
2808           rtx best_rtx = *loc;
2809           int count;
2810
2811           /* This is at worst case an O(n^2) algorithm, so limit our search
2812              to the first 32 elements on the list.  This avoids trouble
2813              compiling code with very long basic blocks that can easily
2814              call cse_gen_binary so many times that we run out of memory.  */
2815
2816           found_better = 0;
2817           for (p = elt->first_same_value, count = 0;
2818                p && count < 32;
2819                p = p->next_same_value, count++)
2820             if (! p->flag
2821                 && (GET_CODE (p->exp) == REG
2822                     || exp_equiv_p (p->exp, p->exp, 1, 0)))
2823               {
2824                 rtx new = cse_gen_binary (GET_CODE (*loc), Pmode, p->exp, c);
2825
2826                 if ((ADDRESS_COST (new) < best_addr_cost
2827                     || (ADDRESS_COST (new) == best_addr_cost
2828                         && (COST (new) + 1) >> 1 > best_rtx_cost)))
2829                   {
2830                     found_better = 1;
2831                     best_addr_cost = ADDRESS_COST (new);
2832                     best_rtx_cost = (COST (new) + 1) >> 1;
2833                     best_elt = p;
2834                     best_rtx = new;
2835                   }
2836               }
2837
2838           if (found_better)
2839             {
2840               if (validate_change (insn, loc,
2841                                    canon_reg (copy_rtx (best_rtx),
2842                                               NULL_RTX), 0))
2843                 return;
2844               else
2845                 best_elt->flag = 1;
2846             }
2847         }
2848     }
2849 #endif
2850 }
2851 \f
2852 /* Given an operation (CODE, *PARG1, *PARG2), where code is a comparison
2853    operation (EQ, NE, GT, etc.), follow it back through the hash table and
2854    what values are being compared.
2855
2856    *PARG1 and *PARG2 are updated to contain the rtx representing the values
2857    actually being compared.  For example, if *PARG1 was (cc0) and *PARG2
2858    was (const_int 0), *PARG1 and *PARG2 will be set to the objects that were
2859    compared to produce cc0.
2860
2861    The return value is the comparison operator and is either the code of
2862    A or the code corresponding to the inverse of the comparison.  */
2863
2864 static enum rtx_code
2865 find_comparison_args (code, parg1, parg2, pmode1, pmode2)
2866      enum rtx_code code;
2867      rtx *parg1, *parg2;
2868      enum machine_mode *pmode1, *pmode2;
2869 {
2870   rtx arg1, arg2;
2871
2872   arg1 = *parg1, arg2 = *parg2;
2873
2874   /* If ARG2 is const0_rtx, see what ARG1 is equivalent to.  */
2875
2876   while (arg2 == CONST0_RTX (GET_MODE (arg1)))
2877     {
2878       /* Set non-zero when we find something of interest.  */
2879       rtx x = 0;
2880       int reverse_code = 0;
2881       struct table_elt *p = 0;
2882
2883       /* If arg1 is a COMPARE, extract the comparison arguments from it.
2884          On machines with CC0, this is the only case that can occur, since
2885          fold_rtx will return the COMPARE or item being compared with zero
2886          when given CC0.  */
2887
2888       if (GET_CODE (arg1) == COMPARE && arg2 == const0_rtx)
2889         x = arg1;
2890
2891       /* If ARG1 is a comparison operator and CODE is testing for
2892          STORE_FLAG_VALUE, get the inner arguments.  */
2893
2894       else if (GET_RTX_CLASS (GET_CODE (arg1)) == '<')
2895         {
2896           if (code == NE
2897               || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
2898                   && code == LT && STORE_FLAG_VALUE == -1)
2899 #ifdef FLOAT_STORE_FLAG_VALUE
2900               || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
2901                   && FLOAT_STORE_FLAG_VALUE < 0)
2902 #endif
2903               )
2904             x = arg1;
2905           else if (code == EQ
2906                    || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
2907                        && code == GE && STORE_FLAG_VALUE == -1)
2908 #ifdef FLOAT_STORE_FLAG_VALUE
2909                    || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
2910                        && FLOAT_STORE_FLAG_VALUE < 0)
2911 #endif
2912                    )
2913             x = arg1, reverse_code = 1;
2914         }
2915
2916       /* ??? We could also check for
2917
2918          (ne (and (eq (...) (const_int 1))) (const_int 0))
2919
2920          and related forms, but let's wait until we see them occurring.  */
2921
2922       if (x == 0)
2923         /* Look up ARG1 in the hash table and see if it has an equivalence
2924            that lets us see what is being compared.  */
2925         p = lookup (arg1, safe_hash (arg1, GET_MODE (arg1)) % NBUCKETS,
2926                     GET_MODE (arg1));
2927       if (p) p = p->first_same_value;
2928
2929       for (; p; p = p->next_same_value)
2930         {
2931           enum machine_mode inner_mode = GET_MODE (p->exp);
2932
2933           /* If the entry isn't valid, skip it.  */
2934           if (! exp_equiv_p (p->exp, p->exp, 1, 0))
2935             continue;
2936
2937           if (GET_CODE (p->exp) == COMPARE
2938               /* Another possibility is that this machine has a compare insn
2939                  that includes the comparison code.  In that case, ARG1 would
2940                  be equivalent to a comparison operation that would set ARG1 to
2941                  either STORE_FLAG_VALUE or zero.  If this is an NE operation,
2942                  ORIG_CODE is the actual comparison being done; if it is an EQ,
2943                  we must reverse ORIG_CODE.  On machine with a negative value
2944                  for STORE_FLAG_VALUE, also look at LT and GE operations.  */
2945               || ((code == NE
2946                    || (code == LT
2947                        && GET_MODE_CLASS (inner_mode) == MODE_INT
2948                        && (GET_MODE_BITSIZE (inner_mode)
2949                            <= HOST_BITS_PER_WIDE_INT)
2950                        && (STORE_FLAG_VALUE
2951                            & ((HOST_WIDE_INT) 1
2952                               << (GET_MODE_BITSIZE (inner_mode) - 1))))
2953 #ifdef FLOAT_STORE_FLAG_VALUE
2954                    || (code == LT
2955                        && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
2956                        && FLOAT_STORE_FLAG_VALUE < 0)
2957 #endif
2958                    )
2959                   && GET_RTX_CLASS (GET_CODE (p->exp)) == '<'))
2960             {
2961               x = p->exp;
2962               break;
2963             }
2964           else if ((code == EQ
2965                     || (code == GE
2966                         && GET_MODE_CLASS (inner_mode) == MODE_INT
2967                         && (GET_MODE_BITSIZE (inner_mode)
2968                             <= HOST_BITS_PER_WIDE_INT)
2969                         && (STORE_FLAG_VALUE
2970                             & ((HOST_WIDE_INT) 1
2971                                << (GET_MODE_BITSIZE (inner_mode) - 1))))
2972 #ifdef FLOAT_STORE_FLAG_VALUE
2973                     || (code == GE
2974                         && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
2975                         && FLOAT_STORE_FLAG_VALUE < 0)
2976 #endif
2977                     )
2978                    && GET_RTX_CLASS (GET_CODE (p->exp)) == '<')
2979             {
2980               reverse_code = 1;
2981               x = p->exp;
2982               break;
2983             }
2984
2985           /* If this is fp + constant, the equivalent is a better operand since
2986              it may let us predict the value of the comparison.  */
2987           else if (NONZERO_BASE_PLUS_P (p->exp))
2988             {
2989               arg1 = p->exp;
2990               continue;
2991             }
2992         }
2993
2994       /* If we didn't find a useful equivalence for ARG1, we are done.
2995          Otherwise, set up for the next iteration.  */
2996       if (x == 0)
2997         break;
2998
2999       arg1 = XEXP (x, 0),  arg2 = XEXP (x, 1);
3000       if (GET_RTX_CLASS (GET_CODE (x)) == '<')
3001         code = GET_CODE (x);
3002
3003       if (reverse_code)
3004         code = reverse_condition (code);
3005     }
3006
3007   /* Return our results.  Return the modes from before fold_rtx
3008      because fold_rtx might produce const_int, and then it's too late.  */
3009   *pmode1 = GET_MODE (arg1), *pmode2 = GET_MODE (arg2);
3010   *parg1 = fold_rtx (arg1, 0), *parg2 = fold_rtx (arg2, 0);
3011
3012   return code;
3013 }
3014 \f
3015 /* Try to simplify a unary operation CODE whose output mode is to be
3016    MODE with input operand OP whose mode was originally OP_MODE.
3017    Return zero if no simplification can be made.  */
3018
3019 rtx
3020 simplify_unary_operation (code, mode, op, op_mode)
3021      enum rtx_code code;
3022      enum machine_mode mode;
3023      rtx op;
3024      enum machine_mode op_mode;
3025 {
3026   register int width = GET_MODE_BITSIZE (mode);
3027
3028   /* The order of these tests is critical so that, for example, we don't
3029      check the wrong mode (input vs. output) for a conversion operation,
3030      such as FIX.  At some point, this should be simplified.  */
3031
3032 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
3033
3034   if (code == FLOAT && GET_MODE (op) == VOIDmode
3035       && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
3036     {
3037       HOST_WIDE_INT hv, lv;
3038       REAL_VALUE_TYPE d;
3039
3040       if (GET_CODE (op) == CONST_INT)
3041         lv = INTVAL (op), hv = INTVAL (op) < 0 ? -1 : 0;
3042       else
3043         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
3044
3045 #ifdef REAL_ARITHMETIC
3046       REAL_VALUE_FROM_INT (d, lv, hv, mode);
3047 #else
3048       if (hv < 0)
3049         {
3050           d = (double) (~ hv);
3051           d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
3052                 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
3053           d += (double) (unsigned HOST_WIDE_INT) (~ lv);
3054           d = (- d - 1.0);
3055         }
3056       else
3057         {
3058           d = (double) hv;
3059           d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
3060                 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
3061           d += (double) (unsigned HOST_WIDE_INT) lv;
3062         }
3063 #endif  /* REAL_ARITHMETIC */
3064       d = real_value_truncate (mode, d);
3065       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
3066     }
3067   else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode
3068            && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
3069     {
3070       HOST_WIDE_INT hv, lv;
3071       REAL_VALUE_TYPE d;
3072
3073       if (GET_CODE (op) == CONST_INT)
3074         lv = INTVAL (op), hv = INTVAL (op) < 0 ? -1 : 0;
3075       else
3076         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
3077
3078       if (op_mode == VOIDmode)
3079         {
3080           /* We don't know how to interpret negative-looking numbers in
3081              this case, so don't try to fold those.  */
3082           if (hv < 0)
3083             return 0;
3084         }
3085       else if (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT * 2)
3086         ;
3087       else
3088         hv = 0, lv &= GET_MODE_MASK (op_mode);
3089
3090 #ifdef REAL_ARITHMETIC
3091       REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv, mode);
3092 #else
3093
3094       d = (double) (unsigned HOST_WIDE_INT) hv;
3095       d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
3096             * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
3097       d += (double) (unsigned HOST_WIDE_INT) lv;
3098 #endif  /* REAL_ARITHMETIC */
3099       d = real_value_truncate (mode, d);
3100       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
3101     }
3102 #endif
3103
3104   if (GET_CODE (op) == CONST_INT
3105       && width <= HOST_BITS_PER_WIDE_INT && width > 0)
3106     {
3107       register HOST_WIDE_INT arg0 = INTVAL (op);
3108       register HOST_WIDE_INT val;
3109
3110       switch (code)
3111         {
3112         case NOT:
3113           val = ~ arg0;
3114           break;
3115
3116         case NEG:
3117           val = - arg0;
3118           break;
3119
3120         case ABS:
3121           val = (arg0 >= 0 ? arg0 : - arg0);
3122           break;
3123
3124         case FFS:
3125           /* Don't use ffs here.  Instead, get low order bit and then its
3126              number.  If arg0 is zero, this will return 0, as desired.  */
3127           arg0 &= GET_MODE_MASK (mode);
3128           val = exact_log2 (arg0 & (- arg0)) + 1;
3129           break;
3130
3131         case TRUNCATE:
3132           val = arg0;
3133           break;
3134
3135         case ZERO_EXTEND:
3136           if (op_mode == VOIDmode)
3137             op_mode = mode;
3138           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
3139             {
3140               /* If we were really extending the mode,
3141                  we would have to distinguish between zero-extension
3142                  and sign-extension.  */
3143               if (width != GET_MODE_BITSIZE (op_mode))
3144                 abort ();
3145               val = arg0;
3146             }
3147           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
3148             val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
3149           else
3150             return 0;
3151           break;
3152
3153         case SIGN_EXTEND:
3154           if (op_mode == VOIDmode)
3155             op_mode = mode;
3156           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
3157             {
3158               /* If we were really extending the mode,
3159                  we would have to distinguish between zero-extension
3160                  and sign-extension.  */
3161               if (width != GET_MODE_BITSIZE (op_mode))
3162                 abort ();
3163               val = arg0;
3164             }
3165           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
3166             {
3167               val
3168                 = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
3169               if (val
3170                   & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1)))
3171                 val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
3172             }
3173           else
3174             return 0;
3175           break;
3176
3177         case SQRT:
3178           return 0;
3179
3180         default:
3181           abort ();
3182         }
3183
3184       /* Clear the bits that don't belong in our mode,
3185          unless they and our sign bit are all one.
3186          So we get either a reasonable negative value or a reasonable
3187          unsigned value for this mode.  */
3188       if (width < HOST_BITS_PER_WIDE_INT
3189           && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
3190               != ((HOST_WIDE_INT) (-1) << (width - 1))))
3191         val &= ((HOST_WIDE_INT) 1 << width) - 1;
3192
3193       return GEN_INT (val);
3194     }
3195
3196   /* We can do some operations on integer CONST_DOUBLEs.  Also allow
3197      for a DImode operation on a CONST_INT.  */
3198   else if (GET_MODE (op) == VOIDmode && width <= HOST_BITS_PER_INT * 2
3199            && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
3200     {
3201       HOST_WIDE_INT l1, h1, lv, hv;
3202
3203       if (GET_CODE (op) == CONST_DOUBLE)
3204         l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
3205       else
3206         l1 = INTVAL (op), h1 = l1 < 0 ? -1 : 0;
3207
3208       switch (code)
3209         {
3210         case NOT:
3211           lv = ~ l1;
3212           hv = ~ h1;
3213           break;
3214
3215         case NEG:
3216           neg_double (l1, h1, &lv, &hv);
3217           break;
3218
3219         case ABS:
3220           if (h1 < 0)
3221             neg_double (l1, h1, &lv, &hv);
3222           else
3223             lv = l1, hv = h1;
3224           break;
3225
3226         case FFS:
3227           hv = 0;
3228           if (l1 == 0)
3229             lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & (-h1)) + 1;
3230           else
3231             lv = exact_log2 (l1 & (-l1)) + 1;
3232           break;
3233
3234         case TRUNCATE:
3235           /* This is just a change-of-mode, so do nothing.  */
3236           lv = l1, hv = h1;
3237           break;
3238
3239         case ZERO_EXTEND:
3240           if (op_mode == VOIDmode
3241               || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
3242             return 0;
3243
3244           hv = 0;
3245           lv = l1 & GET_MODE_MASK (op_mode);
3246           break;
3247
3248         case SIGN_EXTEND:
3249           if (op_mode == VOIDmode
3250               || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
3251             return 0;
3252           else
3253             {
3254               lv = l1 & GET_MODE_MASK (op_mode);
3255               if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
3256                   && (lv & ((HOST_WIDE_INT) 1
3257                             << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
3258                 lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
3259
3260               hv = (lv < 0) ? ~ (HOST_WIDE_INT) 0 : 0;
3261             }
3262           break;
3263
3264         case SQRT:
3265           return 0;
3266
3267         default:
3268           return 0;
3269         }
3270
3271       return immed_double_const (lv, hv, mode);
3272     }
3273
3274 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3275   else if (GET_CODE (op) == CONST_DOUBLE
3276            && GET_MODE_CLASS (mode) == MODE_FLOAT)
3277     {
3278       REAL_VALUE_TYPE d;
3279       jmp_buf handler;
3280       rtx x;
3281
3282       if (setjmp (handler))
3283         /* There used to be a warning here, but that is inadvisable.
3284            People may want to cause traps, and the natural way
3285            to do it should not get a warning.  */
3286         return 0;
3287
3288       set_float_handler (handler);
3289
3290       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
3291
3292       switch (code)
3293         {
3294         case NEG:
3295           d = REAL_VALUE_NEGATE (d);
3296           break;
3297
3298         case ABS:
3299           if (REAL_VALUE_NEGATIVE (d))
3300             d = REAL_VALUE_NEGATE (d);
3301           break;
3302
3303         case FLOAT_TRUNCATE:
3304           d = real_value_truncate (mode, d);
3305           break;
3306
3307         case FLOAT_EXTEND:
3308           /* All this does is change the mode.  */
3309           break;
3310
3311         case FIX:
3312           d = REAL_VALUE_RNDZINT (d);
3313           break;
3314
3315         case UNSIGNED_FIX:
3316           d = REAL_VALUE_UNSIGNED_RNDZINT (d);
3317           break;
3318
3319         case SQRT:
3320           return 0;
3321
3322         default:
3323           abort ();
3324         }
3325
3326       x = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
3327       set_float_handler (NULL_PTR);
3328       return x;
3329     }
3330
3331   else if (GET_CODE (op) == CONST_DOUBLE
3332            && GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT
3333            && GET_MODE_CLASS (mode) == MODE_INT
3334            && width <= HOST_BITS_PER_WIDE_INT && width > 0)
3335     {
3336       REAL_VALUE_TYPE d;
3337       jmp_buf handler;
3338       HOST_WIDE_INT val;
3339
3340       if (setjmp (handler))
3341         return 0;
3342
3343       set_float_handler (handler);
3344
3345       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
3346
3347       switch (code)
3348         {
3349         case FIX:
3350           val = REAL_VALUE_FIX (d);
3351           break;
3352
3353         case UNSIGNED_FIX:
3354           val = REAL_VALUE_UNSIGNED_FIX (d);
3355           break;
3356
3357         default:
3358           abort ();
3359         }
3360
3361       set_float_handler (NULL_PTR);
3362
3363       /* Clear the bits that don't belong in our mode,
3364          unless they and our sign bit are all one.
3365          So we get either a reasonable negative value or a reasonable
3366          unsigned value for this mode.  */
3367       if (width < HOST_BITS_PER_WIDE_INT
3368           && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
3369               != ((HOST_WIDE_INT) (-1) << (width - 1))))
3370         val &= ((HOST_WIDE_INT) 1 << width) - 1;
3371
3372       /* If this would be an entire word for the target, but is not for
3373          the host, then sign-extend on the host so that the number will look
3374          the same way on the host that it would on the target.
3375
3376          For example, when building a 64 bit alpha hosted 32 bit sparc
3377          targeted compiler, then we want the 32 bit unsigned value -1 to be
3378          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
3379          The later confuses the sparc backend.  */
3380
3381       if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
3382           && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
3383         val |= ((HOST_WIDE_INT) (-1) << width);
3384
3385       return GEN_INT (val);
3386     }
3387 #endif
3388   /* This was formerly used only for non-IEEE float.
3389      eggert@twinsun.com says it is safe for IEEE also.  */
3390   else
3391     {
3392       /* There are some simplifications we can do even if the operands
3393          aren't constant.  */
3394       switch (code)
3395         {
3396         case NEG:
3397         case NOT:
3398           /* (not (not X)) == X, similarly for NEG.  */
3399           if (GET_CODE (op) == code)
3400             return XEXP (op, 0);
3401           break;
3402
3403         case SIGN_EXTEND:
3404           /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
3405              becomes just the MINUS if its mode is MODE.  This allows
3406              folding switch statements on machines using casesi (such as
3407              the Vax).  */
3408           if (GET_CODE (op) == TRUNCATE
3409               && GET_MODE (XEXP (op, 0)) == mode
3410               && GET_CODE (XEXP (op, 0)) == MINUS
3411               && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
3412               && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
3413             return XEXP (op, 0);
3414
3415 #ifdef POINTERS_EXTEND_UNSIGNED
3416           if (! POINTERS_EXTEND_UNSIGNED
3417               && mode == Pmode && GET_MODE (op) == ptr_mode
3418               && CONSTANT_P (op))
3419             return convert_memory_address (Pmode, op);
3420 #endif
3421           break;
3422
3423 #ifdef POINTERS_EXTEND_UNSIGNED
3424         case ZERO_EXTEND:
3425           if (POINTERS_EXTEND_UNSIGNED
3426               && mode == Pmode && GET_MODE (op) == ptr_mode
3427               && CONSTANT_P (op))
3428             return convert_memory_address (Pmode, op);
3429           break;
3430 #endif
3431         }
3432
3433       return 0;
3434     }
3435 }
3436 \f
3437 /* Simplify a binary operation CODE with result mode MODE, operating on OP0
3438    and OP1.  Return 0 if no simplification is possible.
3439
3440    Don't use this for relational operations such as EQ or LT.
3441    Use simplify_relational_operation instead.  */
3442
3443 rtx
3444 simplify_binary_operation (code, mode, op0, op1)
3445      enum rtx_code code;
3446      enum machine_mode mode;
3447      rtx op0, op1;
3448 {
3449   register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
3450   HOST_WIDE_INT val;
3451   int width = GET_MODE_BITSIZE (mode);
3452   rtx tem;
3453
3454   /* Relational operations don't work here.  We must know the mode
3455      of the operands in order to do the comparison correctly.
3456      Assuming a full word can give incorrect results.
3457      Consider comparing 128 with -128 in QImode.  */
3458
3459   if (GET_RTX_CLASS (code) == '<')
3460     abort ();
3461
3462 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3463   if (GET_MODE_CLASS (mode) == MODE_FLOAT
3464       && GET_CODE (op0) == CONST_DOUBLE && GET_CODE (op1) == CONST_DOUBLE
3465       && mode == GET_MODE (op0) && mode == GET_MODE (op1))
3466     {
3467       REAL_VALUE_TYPE f0, f1, value;
3468       jmp_buf handler;
3469
3470       if (setjmp (handler))
3471         return 0;
3472
3473       set_float_handler (handler);
3474
3475       REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
3476       REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
3477       f0 = real_value_truncate (mode, f0);
3478       f1 = real_value_truncate (mode, f1);
3479
3480 #ifdef REAL_ARITHMETIC
3481       REAL_ARITHMETIC (value, rtx_to_tree_code (code), f0, f1);
3482 #else
3483       switch (code)
3484         {
3485         case PLUS:
3486           value = f0 + f1;
3487           break;
3488         case MINUS:
3489           value = f0 - f1;
3490           break;
3491         case MULT:
3492           value = f0 * f1;
3493           break;
3494         case DIV:
3495 #ifndef REAL_INFINITY
3496           if (f1 == 0)
3497             return 0;
3498 #endif
3499           value = f0 / f1;
3500           break;
3501         case SMIN:
3502           value = MIN (f0, f1);
3503           break;
3504         case SMAX:
3505           value = MAX (f0, f1);
3506           break;
3507         default:
3508           abort ();
3509         }
3510 #endif
3511
3512       value = real_value_truncate (mode, value);
3513       set_float_handler (NULL_PTR);
3514       return CONST_DOUBLE_FROM_REAL_VALUE (value, mode);
3515     }
3516 #endif  /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3517
3518   /* We can fold some multi-word operations.  */
3519   if (GET_MODE_CLASS (mode) == MODE_INT
3520       && width == HOST_BITS_PER_WIDE_INT * 2
3521       && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT)
3522       && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
3523     {
3524       HOST_WIDE_INT l1, l2, h1, h2, lv, hv;
3525
3526       if (GET_CODE (op0) == CONST_DOUBLE)
3527         l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
3528       else
3529         l1 = INTVAL (op0), h1 = l1 < 0 ? -1 : 0;
3530
3531       if (GET_CODE (op1) == CONST_DOUBLE)
3532         l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1);
3533       else
3534         l2 = INTVAL (op1), h2 = l2 < 0 ? -1 : 0;
3535
3536       switch (code)
3537         {
3538         case MINUS:
3539           /* A - B == A + (-B).  */
3540           neg_double (l2, h2, &lv, &hv);
3541           l2 = lv, h2 = hv;
3542
3543           /* .. fall through ...  */
3544
3545         case PLUS:
3546           add_double (l1, h1, l2, h2, &lv, &hv);
3547           break;
3548
3549         case MULT:
3550           mul_double (l1, h1, l2, h2, &lv, &hv);
3551           break;
3552
3553         case DIV:  case MOD:   case UDIV:  case UMOD:
3554           /* We'd need to include tree.h to do this and it doesn't seem worth
3555              it.  */
3556           return 0;
3557
3558         case AND:
3559           lv = l1 & l2, hv = h1 & h2;
3560           break;
3561
3562         case IOR:
3563           lv = l1 | l2, hv = h1 | h2;
3564           break;
3565
3566         case XOR:
3567           lv = l1 ^ l2, hv = h1 ^ h2;
3568           break;
3569
3570         case SMIN:
3571           if (h1 < h2
3572               || (h1 == h2
3573                   && ((unsigned HOST_WIDE_INT) l1
3574                       < (unsigned HOST_WIDE_INT) l2)))
3575             lv = l1, hv = h1;
3576           else
3577             lv = l2, hv = h2;
3578           break;
3579
3580         case SMAX:
3581           if (h1 > h2
3582               || (h1 == h2
3583                   && ((unsigned HOST_WIDE_INT) l1
3584                       > (unsigned HOST_WIDE_INT) l2)))
3585             lv = l1, hv = h1;
3586           else
3587             lv = l2, hv = h2;
3588           break;
3589
3590         case UMIN:
3591           if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
3592               || (h1 == h2
3593                   && ((unsigned HOST_WIDE_INT) l1
3594                       < (unsigned HOST_WIDE_INT) l2)))
3595             lv = l1, hv = h1;
3596           else
3597             lv = l2, hv = h2;
3598           break;
3599
3600         case UMAX:
3601           if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
3602               || (h1 == h2
3603                   && ((unsigned HOST_WIDE_INT) l1
3604                       > (unsigned HOST_WIDE_INT) l2)))
3605             lv = l1, hv = h1;
3606           else
3607             lv = l2, hv = h2;
3608           break;
3609
3610         case LSHIFTRT:   case ASHIFTRT:
3611         case ASHIFT:
3612         case ROTATE:     case ROTATERT:
3613 #ifdef SHIFT_COUNT_TRUNCATED
3614           if (SHIFT_COUNT_TRUNCATED)
3615             l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
3616 #endif
3617
3618           if (h2 != 0 || l2 < 0 || l2 >= GET_MODE_BITSIZE (mode))
3619             return 0;
3620
3621           if (code == LSHIFTRT || code == ASHIFTRT)
3622             rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
3623                            code == ASHIFTRT);
3624           else if (code == ASHIFT)
3625             lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1);
3626           else if (code == ROTATE)
3627             lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3628           else /* code == ROTATERT */
3629             rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3630           break;
3631
3632         default:
3633           return 0;
3634         }
3635
3636       return immed_double_const (lv, hv, mode);
3637     }
3638
3639   if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
3640       || width > HOST_BITS_PER_WIDE_INT || width == 0)
3641     {
3642       /* Even if we can't compute a constant result,
3643          there are some cases worth simplifying.  */
3644
3645       switch (code)
3646         {
3647         case PLUS:
3648           /* In IEEE floating point, x+0 is not the same as x.  Similarly
3649              for the other optimizations below.  */
3650           if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3651               && FLOAT_MODE_P (mode) && ! flag_fast_math)
3652             break;
3653
3654           if (op1 == CONST0_RTX (mode))
3655             return op0;
3656
3657           /* ((-a) + b) -> (b - a) and similarly for (a + (-b)) */
3658           if (GET_CODE (op0) == NEG)
3659             return cse_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
3660           else if (GET_CODE (op1) == NEG)
3661             return cse_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
3662
3663           /* Handle both-operands-constant cases.  We can only add
3664              CONST_INTs to constants since the sum of relocatable symbols
3665              can't be handled by most assemblers.  Don't add CONST_INT
3666              to CONST_INT since overflow won't be computed properly if wider
3667              than HOST_BITS_PER_WIDE_INT.  */
3668
3669           if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode
3670               && GET_CODE (op1) == CONST_INT)
3671             return plus_constant (op0, INTVAL (op1));
3672           else if (CONSTANT_P (op1) && GET_MODE (op1) != VOIDmode
3673                    && GET_CODE (op0) == CONST_INT)
3674             return plus_constant (op1, INTVAL (op0));
3675
3676           /* See if this is something like X * C - X or vice versa or
3677              if the multiplication is written as a shift.  If so, we can
3678              distribute and make a new multiply, shift, or maybe just
3679              have X (if C is 2 in the example above).  But don't make
3680              real multiply if we didn't have one before.  */
3681
3682           if (! FLOAT_MODE_P (mode))
3683             {
3684               HOST_WIDE_INT coeff0 = 1, coeff1 = 1;
3685               rtx lhs = op0, rhs = op1;
3686               int had_mult = 0;
3687
3688               if (GET_CODE (lhs) == NEG)
3689                 coeff0 = -1, lhs = XEXP (lhs, 0);
3690               else if (GET_CODE (lhs) == MULT
3691                        && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
3692                 {
3693                   coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0);
3694                   had_mult = 1;
3695                 }
3696               else if (GET_CODE (lhs) == ASHIFT
3697                        && GET_CODE (XEXP (lhs, 1)) == CONST_INT
3698                        && INTVAL (XEXP (lhs, 1)) >= 0
3699                        && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
3700                 {
3701                   coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
3702                   lhs = XEXP (lhs, 0);
3703                 }
3704
3705               if (GET_CODE (rhs) == NEG)
3706                 coeff1 = -1, rhs = XEXP (rhs, 0);
3707               else if (GET_CODE (rhs) == MULT
3708                        && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
3709                 {
3710                   coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0);
3711                   had_mult = 1;
3712                 }
3713               else if (GET_CODE (rhs) == ASHIFT
3714                        && GET_CODE (XEXP (rhs, 1)) == CONST_INT
3715                        && INTVAL (XEXP (rhs, 1)) >= 0
3716                        && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
3717                 {
3718                   coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
3719                   rhs = XEXP (rhs, 0);
3720                 }
3721
3722               if (rtx_equal_p (lhs, rhs))
3723                 {
3724                   tem = cse_gen_binary (MULT, mode, lhs,
3725                                         GEN_INT (coeff0 + coeff1));
3726                   return (GET_CODE (tem) == MULT && ! had_mult) ? 0 : tem;
3727                 }
3728             }
3729
3730           /* If one of the operands is a PLUS or a MINUS, see if we can
3731              simplify this by the associative law. 
3732              Don't use the associative law for floating point.
3733              The inaccuracy makes it nonassociative,
3734              and subtle programs can break if operations are associated.  */
3735
3736           if (INTEGRAL_MODE_P (mode)
3737               && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
3738                   || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS)
3739               && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
3740             return tem;
3741           break;
3742
3743         case COMPARE:
3744 #ifdef HAVE_cc0
3745           /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
3746              using cc0, in which case we want to leave it as a COMPARE
3747              so we can distinguish it from a register-register-copy.
3748
3749              In IEEE floating point, x-0 is not the same as x.  */
3750
3751           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3752                || ! FLOAT_MODE_P (mode) || flag_fast_math)
3753               && op1 == CONST0_RTX (mode))
3754             return op0;
3755 #else
3756           /* Do nothing here.  */
3757 #endif
3758           break;
3759               
3760         case MINUS:
3761           /* None of these optimizations can be done for IEEE
3762              floating point.  */
3763           if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3764               && FLOAT_MODE_P (mode) && ! flag_fast_math)
3765             break;
3766
3767           /* We can't assume x-x is 0 even with non-IEEE floating point,
3768              but since it is zero except in very strange circumstances, we
3769              will treat it as zero with -ffast-math.  */
3770           if (rtx_equal_p (op0, op1)
3771               && ! side_effects_p (op0)
3772               && (! FLOAT_MODE_P (mode) || flag_fast_math))
3773             return CONST0_RTX (mode);
3774
3775           /* Change subtraction from zero into negation.  */
3776           if (op0 == CONST0_RTX (mode))
3777             return gen_rtx (NEG, mode, op1);
3778
3779           /* (-1 - a) is ~a.  */
3780           if (op0 == constm1_rtx)
3781             return gen_rtx (NOT, mode, op1);
3782
3783           /* Subtracting 0 has no effect.  */
3784           if (op1 == CONST0_RTX (mode))
3785             return op0;
3786
3787           /* See if this is something like X * C - X or vice versa or
3788              if the multiplication is written as a shift.  If so, we can
3789              distribute and make a new multiply, shift, or maybe just
3790              have X (if C is 2 in the example above).  But don't make
3791              real multiply if we didn't have one before.  */
3792
3793           if (! FLOAT_MODE_P (mode))
3794             {
3795               HOST_WIDE_INT coeff0 = 1, coeff1 = 1;
3796               rtx lhs = op0, rhs = op1;
3797               int had_mult = 0;
3798
3799               if (GET_CODE (lhs) == NEG)
3800                 coeff0 = -1, lhs = XEXP (lhs, 0);
3801               else if (GET_CODE (lhs) == MULT
3802                        && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
3803                 {
3804                   coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0);
3805                   had_mult = 1;
3806                 }
3807               else if (GET_CODE (lhs) == ASHIFT
3808                        && GET_CODE (XEXP (lhs, 1)) == CONST_INT
3809                        && INTVAL (XEXP (lhs, 1)) >= 0
3810                        && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
3811                 {
3812                   coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
3813                   lhs = XEXP (lhs, 0);
3814                 }
3815
3816               if (GET_CODE (rhs) == NEG)
3817                 coeff1 = - 1, rhs = XEXP (rhs, 0);
3818               else if (GET_CODE (rhs) == MULT
3819                        && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
3820                 {
3821                   coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0);
3822                   had_mult = 1;
3823                 }
3824               else if (GET_CODE (rhs) == ASHIFT
3825                        && GET_CODE (XEXP (rhs, 1)) == CONST_INT
3826                        && INTVAL (XEXP (rhs, 1)) >= 0
3827                        && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
3828                 {
3829                   coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
3830                   rhs = XEXP (rhs, 0);
3831                 }
3832
3833               if (rtx_equal_p (lhs, rhs))
3834                 {
3835                   tem = cse_gen_binary (MULT, mode, lhs,
3836                                         GEN_INT (coeff0 - coeff1));
3837                   return (GET_CODE (tem) == MULT && ! had_mult) ? 0 : tem;
3838                 }
3839             }
3840
3841           /* (a - (-b)) -> (a + b).  */
3842           if (GET_CODE (op1) == NEG)
3843             return cse_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
3844
3845           /* If one of the operands is a PLUS or a MINUS, see if we can
3846              simplify this by the associative law. 
3847              Don't use the associative law for floating point.
3848              The inaccuracy makes it nonassociative,
3849              and subtle programs can break if operations are associated.  */
3850
3851           if (INTEGRAL_MODE_P (mode)
3852               && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
3853                   || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS)
3854               && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
3855             return tem;
3856
3857           /* Don't let a relocatable value get a negative coeff.  */
3858           if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
3859             return plus_constant (op0, - INTVAL (op1));
3860
3861           /* (x - (x & y)) -> (x & ~y) */
3862           if (GET_CODE (op1) == AND)
3863             {
3864              if (rtx_equal_p (op0, XEXP (op1, 0)))
3865                return cse_gen_binary (AND, mode, op0, gen_rtx (NOT, mode, XEXP (op1, 1)));
3866              if (rtx_equal_p (op0, XEXP (op1, 1)))
3867                return cse_gen_binary (AND, mode, op0, gen_rtx (NOT, mode, XEXP (op1, 0)));
3868            }
3869           break;
3870
3871         case MULT:
3872           if (op1 == constm1_rtx)
3873             {
3874               tem = simplify_unary_operation (NEG, mode, op0, mode);
3875
3876               return tem ? tem : gen_rtx (NEG, mode, op0);
3877             }
3878
3879           /* In IEEE floating point, x*0 is not always 0.  */
3880           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3881                || ! FLOAT_MODE_P (mode) || flag_fast_math)
3882               && op1 == CONST0_RTX (mode)
3883               && ! side_effects_p (op0))
3884             return op1;
3885
3886           /* In IEEE floating point, x*1 is not equivalent to x for nans.
3887              However, ANSI says we can drop signals,
3888              so we can do this anyway.  */
3889           if (op1 == CONST1_RTX (mode))
3890             return op0;
3891
3892           /* Convert multiply by constant power of two into shift unless
3893              we are still generating RTL.  This test is a kludge.  */
3894           if (GET_CODE (op1) == CONST_INT
3895               && (val = exact_log2 (INTVAL (op1))) >= 0
3896               /* If the mode is larger than the host word size, and the
3897                  uppermost bit is set, then this isn't a power of two due
3898                  to implicit sign extension.  */
3899               && (width <= HOST_BITS_PER_WIDE_INT
3900                   || val != HOST_BITS_PER_WIDE_INT - 1)
3901               && ! rtx_equal_function_value_matters)
3902             return gen_rtx (ASHIFT, mode, op0, GEN_INT (val));
3903
3904           if (GET_CODE (op1) == CONST_DOUBLE
3905               && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT)
3906             {
3907               REAL_VALUE_TYPE d;
3908               jmp_buf handler;
3909               int op1is2, op1ism1;
3910
3911               if (setjmp (handler))
3912                 return 0;
3913
3914               set_float_handler (handler);
3915               REAL_VALUE_FROM_CONST_DOUBLE (d, op1);
3916               op1is2 = REAL_VALUES_EQUAL (d, dconst2);
3917               op1ism1 = REAL_VALUES_EQUAL (d, dconstm1);
3918               set_float_handler (NULL_PTR);
3919
3920               /* x*2 is x+x and x*(-1) is -x */
3921               if (op1is2 && GET_MODE (op0) == mode)
3922                 return gen_rtx (PLUS, mode, op0, copy_rtx (op0));
3923
3924               else if (op1ism1 && GET_MODE (op0) == mode)
3925                 return gen_rtx (NEG, mode, op0);
3926             }
3927           break;
3928
3929         case IOR:
3930           if (op1 == const0_rtx)
3931             return op0;
3932           if (GET_CODE (op1) == CONST_INT
3933               && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3934             return op1;
3935           if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3936             return op0;
3937           /* A | (~A) -> -1 */
3938           if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
3939                || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
3940               && ! side_effects_p (op0)
3941               && GET_MODE_CLASS (mode) != MODE_CC)
3942             return constm1_rtx;
3943           break;
3944
3945         case XOR:
3946           if (op1 == const0_rtx)
3947             return op0;
3948           if (GET_CODE (op1) == CONST_INT
3949               && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3950             return gen_rtx (NOT, mode, op0);
3951           if (op0 == op1 && ! side_effects_p (op0)
3952               && GET_MODE_CLASS (mode) != MODE_CC)
3953             return const0_rtx;
3954           break;
3955
3956         case AND:
3957           if (op1 == const0_rtx && ! side_effects_p (op0))
3958             return const0_rtx;
3959           if (GET_CODE (op1) == CONST_INT
3960               && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3961             return op0;
3962           if (op0 == op1 && ! side_effects_p (op0)
3963               && GET_MODE_CLASS (mode) != MODE_CC)
3964             return op0;
3965           /* A & (~A) -> 0 */
3966           if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
3967                || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
3968               && ! side_effects_p (op0)
3969               && GET_MODE_CLASS (mode) != MODE_CC)
3970             return const0_rtx;
3971           break;
3972
3973         case UDIV:
3974           /* Convert divide by power of two into shift (divide by 1 handled
3975              below).  */
3976           if (GET_CODE (op1) == CONST_INT
3977               && (arg1 = exact_log2 (INTVAL (op1))) > 0)
3978             return gen_rtx (LSHIFTRT, mode, op0, GEN_INT (arg1));
3979
3980           /* ... fall through ...  */
3981
3982         case DIV:
3983           if (op1 == CONST1_RTX (mode))
3984             return op0;
3985
3986           /* In IEEE floating point, 0/x is not always 0.  */
3987           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3988                || ! FLOAT_MODE_P (mode) || flag_fast_math)
3989               && op0 == CONST0_RTX (mode)
3990               && ! side_effects_p (op1))
3991             return op0;
3992
3993 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3994           /* Change division by a constant into multiplication.  Only do
3995              this with -ffast-math until an expert says it is safe in
3996              general.  */
3997           else if (GET_CODE (op1) == CONST_DOUBLE
3998                    && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT
3999                    && op1 != CONST0_RTX (mode)
4000                    && flag_fast_math)
4001             {
4002               REAL_VALUE_TYPE d;
4003               REAL_VALUE_FROM_CONST_DOUBLE (d, op1);
4004
4005               if (! REAL_VALUES_EQUAL (d, dconst0))
4006                 {
4007 #if defined (REAL_ARITHMETIC)
4008                   REAL_ARITHMETIC (d, rtx_to_tree_code (DIV), dconst1, d);
4009                   return gen_rtx (MULT, mode, op0, 
4010                                   CONST_DOUBLE_FROM_REAL_VALUE (d, mode));
4011 #else
4012                   return gen_rtx (MULT, mode, op0, 
4013                                   CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode));
4014 #endif
4015                 }
4016             }
4017 #endif
4018           break;
4019
4020         case UMOD:
4021           /* Handle modulus by power of two (mod with 1 handled below).  */
4022           if (GET_CODE (op1) == CONST_INT
4023               && exact_log2 (INTVAL (op1)) > 0)
4024             return gen_rtx (AND, mode, op0, GEN_INT (INTVAL (op1) - 1));
4025
4026           /* ... fall through ...  */
4027
4028         case MOD:
4029           if ((op0 == const0_rtx || op1 == const1_rtx)
4030               && ! side_effects_p (op0) && ! side_effects_p (op1))
4031             return const0_rtx;
4032           break;
4033
4034         case ROTATERT:
4035         case ROTATE:
4036           /* Rotating ~0 always results in ~0.  */
4037           if (GET_CODE (op0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
4038               && INTVAL (op0) == GET_MODE_MASK (mode)
4039               && ! side_effects_p (op1))
4040             return op0;
4041
4042           /* ... fall through ...  */
4043
4044         case ASHIFT:
4045         case ASHIFTRT:
4046         case LSHIFTRT:
4047           if (op1 == const0_rtx)
4048             return op0;
4049           if (op0 == const0_rtx && ! side_effects_p (op1))
4050             return op0;
4051           break;
4052
4053         case SMIN:
4054           if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT 
4055               && INTVAL (op1) == (HOST_WIDE_INT) 1 << (width -1)
4056               && ! side_effects_p (op0))
4057             return op1;
4058           else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
4059             return op0;
4060           break;
4061            
4062         case SMAX:
4063           if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT
4064               && (INTVAL (op1)
4065                   == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1)
4066               && ! side_effects_p (op0))
4067             return op1;
4068           else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
4069             return op0;
4070           break;
4071
4072         case UMIN:
4073           if (op1 == const0_rtx && ! side_effects_p (op0))
4074             return op1;
4075           else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
4076             return op0;
4077           break;
4078             
4079         case UMAX:
4080           if (op1 == constm1_rtx && ! side_effects_p (op0))
4081             return op1;
4082           else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
4083             return op0;
4084           break;
4085
4086         default:
4087           abort ();
4088         }
4089       
4090       return 0;
4091     }
4092
4093   /* Get the integer argument values in two forms:
4094      zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S.  */
4095
4096   arg0 = INTVAL (op0);
4097   arg1 = INTVAL (op1);
4098
4099   if (width < HOST_BITS_PER_WIDE_INT)
4100     {
4101       arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
4102       arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
4103
4104       arg0s = arg0;
4105       if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
4106         arg0s |= ((HOST_WIDE_INT) (-1) << width);