![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cse.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Common subexpression elimination for GNU compiler.
2: Copyright (C) 1987, 1988, 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "config.h"
22: #include "rtl.h"
23: #include "regs.h"
24: #include "hard-reg-set.h"
25: #include "flags.h"
26: #include "real.h"
27: #include "insn-config.h"
28: #include "recog.h"
29:
30: #include <stdio.h>
31: #include <setjmp.h>
32:
33: /* The basic idea of common subexpression elimination is to go
34: through the code, keeping a record of expressions that would
35: have the same value at the current scan point, and replacing
36: expressions encountered with the cheapest equivalent expression.
37:
38: It is too complicated to keep track of the different possibilities
39: when control paths merge; so, at each label, we forget all that is
40: known and start fresh. This can be described as processing each
41: basic block separately. Note, however, that these are not quite
42: the same as the basic blocks found by a later pass and used for
43: data flow analysis and register packing. We do not need to start fresh
44: after a conditional jump instruction if there is no label there.
45:
46: We use two data structures to record the equivalent expressions:
47: a hash table for most expressions, and several vectors together
48: with "quantity numbers" to record equivalent (pseudo) registers.
49:
50: The use of the special data structure for registers is desirable
51: because it is faster. It is possible because registers references
52: contain a fairly small number, the register number, taken from
53: a contiguously allocated series, and two register references are
54: identical if they have the same number. General expressions
55: do not have any such thing, so the only way to retrieve the
56: information recorded on an expression other than a register
57: is to keep it in a hash table.
58:
59: Registers and "quantity numbers":
60:
61: At the start of each basic block, all of the (hardware and pseudo)
62: registers used in the function are given distinct quantity
63: numbers to indicate their contents. During scan, when the code
64: copies one register into another, we copy the quantity number.
65: When a register is loaded in any other way, we allocate a new
66: quantity number to describe the value generated by this operation.
67: `reg_qty' records what quantity a register is currently thought
68: of as containing.
69:
70: All real quantity numbers are greater than or equal to `max_reg'.
71: If register N has not been assigned a quantity, reg_qty[N] will equal N.
72:
73: Quantity numbers below `max_reg' do not exist and none of the `qty_...'
74: variables should be referenced with an index below `max_reg'.
75:
76: We also maintain a bidirectional chain of registers for each
77: quantity number. `qty_first_reg', `qty_last_reg',
78: `reg_next_eqv' and `reg_prev_eqv' hold these chains.
79:
80: The first register in a chain is the one whose lifespan is least local.
81: Among equals, it is the one that was seen first.
82: We replace any equivalent register with that one.
83:
84: If two registers have the same quantity number, it must be true that
85: REG expressions with `qty_mode' must be in the hash table for both
86: registers and must be in the same class.
87:
88: The converse is not true. Since hard registers may be referenced in
89: any mode, two REG expressions might be equivalent in the hash table
90: but not have the same quantity number if the quantity number of one
91: of the registers is not the same mode as those expressions.
92:
93: Constants and quantity numbers
94:
95: When a quantity has a known constant value, that value is stored
96: in the appropriate element of qty_const. This is in addition to
97: putting the constant in the hash table as is usual for non-regs.
98:
1.1.1.2 root 99: Whether a reg or a constant is preferred is determined by the configuration
1.1 root 100: macro CONST_COSTS and will often depend on the constant value. In any
101: event, expressions containing constants can be simplified, by fold_rtx.
102:
103: When a quantity has a known nearly constant value (such as an address
104: of a stack slot), that value is stored in the appropriate element
105: of qty_const.
106:
107: Integer constants don't have a machine mode. However, cse
108: determines the intended machine mode from the destination
109: of the instruction that moves the constant. The machine mode
110: is recorded in the hash table along with the actual RTL
111: constant expression so that different modes are kept separate.
112:
113: Other expressions:
114:
115: To record known equivalences among expressions in general
116: we use a hash table called `table'. It has a fixed number of buckets
117: that contain chains of `struct table_elt' elements for expressions.
118: These chains connect the elements whose expressions have the same
119: hash codes.
120:
121: Other chains through the same elements connect the elements which
122: currently have equivalent values.
123:
124: Register references in an expression are canonicalized before hashing
125: the expression. This is done using `reg_qty' and `qty_first_reg'.
126: The hash code of a register reference is computed using the quantity
127: number, not the register number.
128:
129: When the value of an expression changes, it is necessary to remove from the
130: hash table not just that expression but all expressions whose values
131: could be different as a result.
132:
133: 1. If the value changing is in memory, except in special cases
134: ANYTHING referring to memory could be changed. That is because
135: nobody knows where a pointer does not point.
136: The function `invalidate_memory' removes what is necessary.
137:
138: The special cases are when the address is constant or is
139: a constant plus a fixed register such as the frame pointer
140: or a static chain pointer. When such addresses are stored in,
141: we can tell exactly which other such addresses must be invalidated
142: due to overlap. `invalidate' does this.
143: All expressions that refer to non-constant
144: memory addresses are also invalidated. `invalidate_memory' does this.
145:
146: 2. If the value changing is a register, all expressions
147: containing references to that register, and only those,
148: must be removed.
149:
150: Because searching the entire hash table for expressions that contain
151: a register is very slow, we try to figure out when it isn't necessary.
152: Precisely, this is necessary only when expressions have been
153: entered in the hash table using this register, and then the value has
154: changed, and then another expression wants to be added to refer to
155: the register's new value. This sequence of circumstances is rare
156: within any one basic block.
157:
158: The vectors `reg_tick' and `reg_in_table' are used to detect this case.
159: reg_tick[i] is incremented whenever a value is stored in register i.
160: reg_in_table[i] holds -1 if no references to register i have been
161: entered in the table; otherwise, it contains the value reg_tick[i] had
162: when the references were entered. If we want to enter a reference
163: and reg_in_table[i] != reg_tick[i], we must scan and remove old references.
164: Until we want to enter a new entry, the mere fact that the two vectors
165: don't match makes the entries be ignored if anyone tries to match them.
166:
167: Registers themselves are entered in the hash table as well as in
168: the equivalent-register chains. However, the vectors `reg_tick'
169: and `reg_in_table' do not apply to expressions which are simple
170: register references. These expressions are removed from the table
171: immediately when they become invalid, and this can be done even if
172: we do not immediately search for all the expressions that refer to
173: the register.
174:
175: A CLOBBER rtx in an instruction invalidates its operand for further
176: reuse. A CLOBBER or SET rtx whose operand is a MEM:BLK
177: invalidates everything that resides in memory.
178:
179: Related expressions:
180:
181: Constant expressions that differ only by an additive integer
182: are called related. When a constant expression is put in
183: the table, the related expression with no constant term
184: is also entered. These are made to point at each other
185: so that it is possible to find out if there exists any
186: register equivalent to an expression related to a given expression. */
187:
188: /* One plus largest register number used in this function. */
189:
190: static int max_reg;
191:
192: /* Length of vectors indexed by quantity number.
193: We know in advance we will not need a quantity number this big. */
194:
195: static int max_qty;
196:
197: /* Next quantity number to be allocated.
198: This is 1 + the largest number needed so far. */
199:
200: static int next_qty;
201:
202: /* Indexed by quantity number, gives the first (or last) (pseudo) register
203: in the chain of registers that currently contain this quantity. */
204:
205: static int *qty_first_reg;
206: static int *qty_last_reg;
207:
208: /* Index by quantity number, gives the mode of the quantity. */
209:
210: static enum machine_mode *qty_mode;
211:
212: /* Indexed by quantity number, gives the rtx of the constant value of the
213: quantity, or zero if it does not have a known value.
214: A sum of the frame pointer (or arg pointer) plus a constant
215: can also be entered here. */
216:
217: static rtx *qty_const;
218:
219: /* Indexed by qty number, gives the insn that stored the constant value
220: recorded in `qty_const'. */
221:
222: static rtx *qty_const_insn;
223:
224: /* The next three variables are used to track when a comparison between a
225: quantity and some constant or register has been passed. In that case, we
226: know the results of the comparison in case we see it again. These variables
227: record a comparison that is known to be true. */
228:
229: /* Indexed by qty number, gives the rtx code of a comparison with a known
230: result involving this quantity. If none, it is UNKNOWN. */
231: static enum rtx_code *qty_comparison_code;
232:
233: /* Indexed by qty number, gives the constant being compared against in a
234: comparison of known result. If no such comparison, it is undefined.
235: If the comparison is not with a constant, it is zero. */
236:
237: static rtx *qty_comparison_const;
238:
239: /* Indexed by qty number, gives the quantity being compared against in a
240: comparison of known result. If no such comparison, if it undefined.
241: If the comparison is not with a register, it is -1. */
242:
243: static int *qty_comparison_qty;
244:
245: #ifdef HAVE_cc0
246: /* For machines that have a CC0, we do not record its value in the hash
247: table since its use is guaranteed to be the insn immediately following
248: its definition and any other insn is presumed to invalidate it.
249:
250: Instead, we store below the value last assigned to CC0. If it should
251: happen to be a constant, it is stored in preference to the actual
252: assigned value. In case it is a constant, we store the mode in which
253: the constant should be interpreted. */
254:
255: static rtx prev_insn_cc0;
256: static enum machine_mode prev_insn_cc0_mode;
257: #endif
258:
259: /* Previous actual insn. 0 if at first insn of basic block. */
260:
261: static rtx prev_insn;
262:
263: /* Insn being scanned. */
264:
265: static rtx this_insn;
266:
267: /* Index by (pseudo) register number, gives the quantity number
268: of the register's current contents. */
269:
270: static int *reg_qty;
271:
272: /* Index by (pseudo) register number, gives the number of the next (or
273: previous) (pseudo) register in the chain of registers sharing the same
274: value.
275:
276: Or -1 if this register is at the end of the chain.
277:
278: If reg_qty[N] == N, reg_next_eqv[N] is undefined. */
279:
280: static int *reg_next_eqv;
281: static int *reg_prev_eqv;
282:
283: /* Index by (pseudo) register number, gives the number of times
284: that register has been altered in the current basic block. */
285:
286: static int *reg_tick;
287:
288: /* Index by (pseudo) register number, gives the reg_tick value at which
289: rtx's containing this register are valid in the hash table.
290: If this does not equal the current reg_tick value, such expressions
291: existing in the hash table are invalid.
292: If this is -1, no expressions containing this register have been
293: entered in the table. */
294:
295: static int *reg_in_table;
296:
297: /* A HARD_REG_SET containing all the hard registers for which there is
298: currently a REG expression in the hash table. Note the difference
299: from the above variables, which indicate if the REG is mentioned in some
300: expression in the table. */
301:
302: static HARD_REG_SET hard_regs_in_table;
303:
304: /* A HARD_REG_SET containing all the hard registers that are invalidated
305: by a CALL_INSN. */
306:
307: static HARD_REG_SET regs_invalidated_by_call;
308:
309: /* Two vectors of ints:
310: one containing max_reg -1's; the other max_reg + 500 (an approximation
311: for max_qty) elements where element i contains i.
312: These are used to initialize various other vectors fast. */
313:
314: static int *all_minus_one;
315: static int *consec_ints;
316:
317: /* CUID of insn that starts the basic block currently being cse-processed. */
318:
319: static int cse_basic_block_start;
320:
321: /* CUID of insn that ends the basic block currently being cse-processed. */
322:
323: static int cse_basic_block_end;
324:
325: /* Vector mapping INSN_UIDs to cuids.
1.1.1.2 root 326: The cuids are like uids but increase monotonically always.
1.1 root 327: We use them to see whether a reg is used outside a given basic block. */
328:
1.1.1.4 ! root 329: static int *uid_cuid;
! 330:
! 331: /* Highest UID in UID_CUID. */
! 332: static int max_uid;
1.1 root 333:
334: /* Get the cuid of an insn. */
335:
336: #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
337:
338: /* Nonzero if cse has altered conditional jump insns
339: in such a way that jump optimization should be redone. */
340:
341: static int cse_jumps_altered;
342:
343: /* canon_hash stores 1 in do_not_record
344: if it notices a reference to CC0, PC, or some other volatile
345: subexpression. */
346:
347: static int do_not_record;
348:
349: /* canon_hash stores 1 in hash_arg_in_memory
350: if it notices a reference to memory within the expression being hashed. */
351:
352: static int hash_arg_in_memory;
353:
354: /* canon_hash stores 1 in hash_arg_in_struct
355: if it notices a reference to memory that's part of a structure. */
356:
357: static int hash_arg_in_struct;
358:
359: /* The hash table contains buckets which are chains of `struct table_elt's,
360: each recording one expression's information.
361: That expression is in the `exp' field.
362:
363: Those elements with the same hash code are chained in both directions
364: through the `next_same_hash' and `prev_same_hash' fields.
365:
366: Each set of expressions with equivalent values
367: are on a two-way chain through the `next_same_value'
368: and `prev_same_value' fields, and all point with
369: the `first_same_value' field at the first element in
370: that chain. The chain is in order of increasing cost.
371: Each element's cost value is in its `cost' field.
372:
373: The `in_memory' field is nonzero for elements that
374: involve any reference to memory. These elements are removed
375: whenever a write is done to an unidentified location in memory.
376: To be safe, we assume that a memory address is unidentified unless
377: the address is either a symbol constant or a constant plus
378: the frame pointer or argument pointer.
379:
380: The `in_struct' field is nonzero for elements that
381: involve any reference to memory inside a structure or array.
382:
383: The `related_value' field is used to connect related expressions
384: (that differ by adding an integer).
385: The related expressions are chained in a circular fashion.
386: `related_value' is zero for expressions for which this
387: chain is not useful.
388:
389: The `cost' field stores the cost of this element's expression.
390:
391: The `is_const' flag is set if the element is a constant (including
392: a fixed address).
393:
394: The `flag' field is used as a temporary during some search routines.
395:
396: The `mode' field is usually the same as GET_MODE (`exp'), but
397: if `exp' is a CONST_INT and has no machine mode then the `mode'
398: field is the mode it was being used as. Each constant is
399: recorded separately for each mode it is used with. */
400:
401:
402: struct table_elt
403: {
404: rtx exp;
405: struct table_elt *next_same_hash;
406: struct table_elt *prev_same_hash;
407: struct table_elt *next_same_value;
408: struct table_elt *prev_same_value;
409: struct table_elt *first_same_value;
410: struct table_elt *related_value;
411: int cost;
412: enum machine_mode mode;
413: char in_memory;
414: char in_struct;
415: char is_const;
416: char flag;
417: };
418:
419: #define HASHBITS 16
420:
421: /* We don't want a lot of buckets, because we rarely have very many
422: things stored in the hash table, and a lot of buckets slows
423: down a lot of loops that happen frequently. */
424: #define NBUCKETS 31
425:
426: /* Compute hash code of X in mode M. Special-case case where X is a pseudo
427: register (hard registers may require `do_not_record' to be set). */
428:
429: #define HASH(X, M) \
430: (GET_CODE (X) == REG && REGNO (X) >= FIRST_PSEUDO_REGISTER \
431: ? ((((int) REG << 7) + reg_qty[REGNO (X)]) % NBUCKETS) \
432: : canon_hash (X, M) % NBUCKETS)
433:
434: /* Determine whether register number N is considered a fixed register for CSE.
435: It is desirable to replace other regs with fixed regs, to reduce need for
436: non-fixed hard regs.
437: A reg wins if it is either the frame pointer or designated as fixed,
438: but not if it is an overlapping register. */
439: #ifdef OVERLAPPING_REGNO_P
440: #define FIXED_REGNO_P(N) \
441: (((N) == FRAME_POINTER_REGNUM || fixed_regs[N]) \
442: && ! OVERLAPPING_REGNO_P ((N)))
443: #else
444: #define FIXED_REGNO_P(N) \
445: ((N) == FRAME_POINTER_REGNUM || fixed_regs[N])
446: #endif
447:
448: /* Compute cost of X, as stored in the `cost' field of a table_elt. Fixed
449: hard registers are the cheapest with a cost of 0. Next come pseudos
450: with a cost of one and other hard registers with a cost of 2. Aside
451: from these special cases, call `rtx_cost'. */
452:
453: #define COST(X) \
454: (GET_CODE (X) == REG \
455: ? (REGNO (X) >= FIRST_PSEUDO_REGISTER ? 1 \
456: : (FIXED_REGNO_P (REGNO (X)) \
457: && REGNO_REG_CLASS (REGNO (X)) != NO_REGS) ? 0 \
458: : 2) \
1.1.1.3 root 459: : rtx_cost (X, SET) * 2)
1.1 root 460:
461: /* Determine if the quantity number for register X represents a valid index
462: into the `qty_...' variables. */
463:
464: #define REGNO_QTY_VALID_P(N) (reg_qty[N] != (N))
465:
466: static struct table_elt *table[NBUCKETS];
467:
468: /* Chain of `struct table_elt's made so far for this function
469: but currently removed from the table. */
470:
471: static struct table_elt *free_element_chain;
472:
473: /* Number of `struct table_elt' structures made so far for this function. */
474:
475: static int n_elements_made;
476:
477: /* Maximum value `n_elements_made' has had so far in this compilation
478: for functions previously processed. */
479:
480: static int max_elements_made;
481:
482: /* Surviving equivalence class when two equivalence classes are merged
483: by recording the effects of a jump in the last insn. Zero if the
484: last insn was not a conditional jump. */
485:
486: static struct table_elt *last_jump_equiv_class;
487:
488: /* Set to the cost of a constant pool reference if one was found for a
489: symbolic constant. If this was found, it means we should try to
490: convert constants into constant pool entries if they don't fit in
491: the insn. */
492:
493: static int constant_pool_entries_cost;
494:
495: /* Bits describing what kind of values in memory must be invalidated
496: for a particular instruction. If all three bits are zero,
497: no memory refs need to be invalidated. Each bit is more powerful
498: than the preceding ones, and if a bit is set then the preceding
499: bits are also set.
500:
501: Here is how the bits are set:
502: Pushing onto the stack invalidates only the stack pointer,
503: writing at a fixed address invalidates only variable addresses,
504: writing in a structure element at variable address
505: invalidates all but scalar variables,
506: and writing in anything else at variable address invalidates everything. */
507:
508: struct write_data
509: {
510: int sp : 1; /* Invalidate stack pointer. */
511: int var : 1; /* Invalidate variable addresses. */
512: int nonscalar : 1; /* Invalidate all but scalar variables. */
513: int all : 1; /* Invalidate all memory refs. */
514: };
515:
516: /* Nonzero if X has the form (PLUS frame-pointer integer). We check for
517: virtual regs here because the simplify_*_operation routines are called
518: by integrate.c, which is called before virtual register instantiation. */
519:
520: #define FIXED_BASE_PLUS_P(X) \
521: ((X) == frame_pointer_rtx || (X) == arg_pointer_rtx \
522: || (X) == virtual_stack_vars_rtx \
523: || (X) == virtual_incoming_args_rtx \
524: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
525: && (XEXP (X, 0) == frame_pointer_rtx \
526: || XEXP (X, 0) == arg_pointer_rtx \
527: || XEXP (X, 0) == virtual_stack_vars_rtx \
528: || XEXP (X, 0) == virtual_incoming_args_rtx)))
529:
1.1.1.3 root 530: /* Similar, but also allows reference to the stack pointer.
531:
532: This used to include FIXED_BASE_PLUS_P, however, we can't assume that
533: arg_pointer_rtx by itself is nonzero, because on at least one machine,
534: the i960, the arg pointer is zero when it is unused. */
1.1 root 535:
536: #define NONZERO_BASE_PLUS_P(X) \
1.1.1.3 root 537: ((X) == frame_pointer_rtx \
538: || (X) == virtual_stack_vars_rtx \
539: || (X) == virtual_incoming_args_rtx \
540: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
541: && (XEXP (X, 0) == frame_pointer_rtx \
542: || XEXP (X, 0) == arg_pointer_rtx \
543: || XEXP (X, 0) == virtual_stack_vars_rtx \
544: || XEXP (X, 0) == virtual_incoming_args_rtx)) \
1.1 root 545: || (X) == stack_pointer_rtx \
546: || (X) == virtual_stack_dynamic_rtx \
547: || (X) == virtual_outgoing_args_rtx \
548: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
549: && (XEXP (X, 0) == stack_pointer_rtx \
550: || XEXP (X, 0) == virtual_stack_dynamic_rtx \
551: || XEXP (X, 0) == virtual_outgoing_args_rtx)))
552:
553: static struct table_elt *lookup ();
554: static void free_element ();
555:
556: static int insert_regs ();
557: static void rehash_using_reg ();
558: static void remove_invalid_refs ();
559: static int exp_equiv_p ();
560: int refers_to_p ();
561: int refers_to_mem_p ();
562: static void invalidate_from_clobbers ();
563: static int safe_hash ();
564: static int canon_hash ();
565: static rtx fold_rtx ();
566: static rtx equiv_constant ();
567: static void record_jump_cond ();
568: static void note_mem_written ();
569: static int cse_rtx_addr_varies_p ();
570: static enum rtx_code find_comparison_args ();
571: static void cse_insn ();
572: static void cse_set_around_loop ();
573:
574: /* Return an estimate of the cost of computing rtx X.
575: One use is in cse, to decide which expression to keep in the hash table.
576: Another is in rtl generation, to pick the cheapest way to multiply.
577: Other uses like the latter are expected in the future. */
578:
579: /* Return the right cost to give to an operation
580: to make the cost of the corresponding register-to-register instruction
581: N times that of a fast register-to-register instruction. */
582:
583: #define COSTS_N_INSNS(N) ((N) * 4 - 2)
584:
585: int
1.1.1.3 root 586: rtx_cost (x, outer_code)
1.1 root 587: rtx x;
1.1.1.3 root 588: enum rtx_code outer_code;
1.1 root 589: {
590: register int i, j;
591: register enum rtx_code code;
592: register char *fmt;
593: register int total;
594:
595: if (x == 0)
596: return 0;
597:
598: /* Compute the default costs of certain things.
599: Note that RTX_COSTS can override the defaults. */
600:
601: code = GET_CODE (x);
602: switch (code)
603: {
604: case MULT:
605: /* Count multiplication by 2**n as a shift,
606: because if we are considering it, we would output it as a shift. */
607: if (GET_CODE (XEXP (x, 1)) == CONST_INT
608: && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
609: total = 2;
610: else
611: total = COSTS_N_INSNS (5);
612: break;
613: case DIV:
614: case UDIV:
615: case MOD:
616: case UMOD:
617: total = COSTS_N_INSNS (7);
618: break;
619: case USE:
620: /* Used in loop.c and combine.c as a marker. */
621: total = 0;
622: break;
1.1.1.2 root 623: case ASM_OPERANDS:
624: /* We don't want these to be used in substitutions because
625: we have no way of validating the resulting insn. So assign
626: anything containing an ASM_OPERANDS a very high cost. */
627: total = 1000;
628: break;
1.1 root 629: default:
630: total = 2;
631: }
632:
633: switch (code)
634: {
635: case REG:
636: return 1;
637: case SUBREG:
1.1.1.3 root 638: /* If we can't tie these modes, make this expensive. The larger
639: the mode, the more expensive it is. */
640: if (! MODES_TIEABLE_P (GET_MODE (x), GET_MODE (SUBREG_REG (x))))
641: return COSTS_N_INSNS (2
642: + GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD);
1.1 root 643: return 2;
644: #ifdef RTX_COSTS
1.1.1.3 root 645: RTX_COSTS (x, code, outer_code);
1.1 root 646: #endif
1.1.1.3 root 647: CONST_COSTS (x, code, outer_code);
1.1 root 648: }
649:
650: /* Sum the costs of the sub-rtx's, plus cost of this operation,
651: which is already in total. */
652:
653: fmt = GET_RTX_FORMAT (code);
654: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
655: if (fmt[i] == 'e')
1.1.1.3 root 656: total += rtx_cost (XEXP (x, i), code);
1.1 root 657: else if (fmt[i] == 'E')
658: for (j = 0; j < XVECLEN (x, i); j++)
1.1.1.3 root 659: total += rtx_cost (XVECEXP (x, i, j), code);
1.1 root 660:
661: return total;
662: }
663:
664: /* Clear the hash table and initialize each register with its own quantity,
665: for a new basic block. */
666:
667: static void
668: new_basic_block ()
669: {
670: register int i;
671:
672: next_qty = max_reg;
673:
674: bzero (reg_tick, max_reg * sizeof (int));
675:
676: bcopy (all_minus_one, reg_in_table, max_reg * sizeof (int));
677: bcopy (consec_ints, reg_qty, max_reg * sizeof (int));
678: CLEAR_HARD_REG_SET (hard_regs_in_table);
679:
680: /* The per-quantity values used to be initialized here, but it is
681: much faster to initialize each as it is made in `make_new_qty'. */
682:
683: for (i = 0; i < NBUCKETS; i++)
684: {
685: register struct table_elt *this, *next;
686: for (this = table[i]; this; this = next)
687: {
688: next = this->next_same_hash;
689: free_element (this);
690: }
691: }
692:
693: bzero (table, sizeof table);
694:
695: prev_insn = 0;
696:
697: #ifdef HAVE_cc0
698: prev_insn_cc0 = 0;
699: #endif
700: }
701:
702: /* Say that register REG contains a quantity not in any register before
703: and initialize that quantity. */
704:
705: static void
706: make_new_qty (reg)
707: register int reg;
708: {
709: register int q;
710:
711: if (next_qty >= max_qty)
712: abort ();
713:
714: q = reg_qty[reg] = next_qty++;
715: qty_first_reg[q] = reg;
716: qty_last_reg[q] = reg;
717: qty_const[q] = qty_const_insn[q] = 0;
718: qty_comparison_code[q] = UNKNOWN;
719:
720: reg_next_eqv[reg] = reg_prev_eqv[reg] = -1;
721: }
722:
723: /* Make reg NEW equivalent to reg OLD.
724: OLD is not changing; NEW is. */
725:
726: static void
727: make_regs_eqv (new, old)
728: register int new, old;
729: {
730: register int lastr, firstr;
731: register int q = reg_qty[old];
732:
733: /* Nothing should become eqv until it has a "non-invalid" qty number. */
734: if (! REGNO_QTY_VALID_P (old))
735: abort ();
736:
737: reg_qty[new] = q;
738: firstr = qty_first_reg[q];
739: lastr = qty_last_reg[q];
740:
741: /* Prefer fixed hard registers to anything. Prefer pseudo regs to other
742: hard regs. Among pseudos, if NEW will live longer than any other reg
743: of the same qty, and that is beyond the current basic block,
744: make it the new canonical replacement for this qty. */
745: if (! (firstr < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (firstr))
746: /* Certain fixed registers might be of the class NO_REGS. This means
747: that not only can they not be allocated by the compiler, but
1.1.1.3 root 748: they cannot be used in substitutions or canonicalizations
1.1 root 749: either. */
750: && (new >= FIRST_PSEUDO_REGISTER || REGNO_REG_CLASS (new) != NO_REGS)
751: && ((new < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (new))
752: || (new >= FIRST_PSEUDO_REGISTER
753: && (firstr < FIRST_PSEUDO_REGISTER
754: || ((uid_cuid[regno_last_uid[new]] > cse_basic_block_end
755: || (uid_cuid[regno_first_uid[new]]
756: < cse_basic_block_start))
757: && (uid_cuid[regno_last_uid[new]]
758: > uid_cuid[regno_last_uid[firstr]]))))))
759: {
760: reg_prev_eqv[firstr] = new;
761: reg_next_eqv[new] = firstr;
762: reg_prev_eqv[new] = -1;
763: qty_first_reg[q] = new;
764: }
765: else
766: {
767: /* If NEW is a hard reg (known to be non-fixed), insert at end.
768: Otherwise, insert before any non-fixed hard regs that are at the
769: end. Registers of class NO_REGS cannot be used as an
770: equivalent for anything. */
771: while (lastr < FIRST_PSEUDO_REGISTER && reg_prev_eqv[lastr] >= 0
772: && (REGNO_REG_CLASS (lastr) == NO_REGS || ! FIXED_REGNO_P (lastr))
773: && new >= FIRST_PSEUDO_REGISTER)
774: lastr = reg_prev_eqv[lastr];
775: reg_next_eqv[new] = reg_next_eqv[lastr];
776: if (reg_next_eqv[lastr] >= 0)
777: reg_prev_eqv[reg_next_eqv[lastr]] = new;
778: else
779: qty_last_reg[q] = new;
780: reg_next_eqv[lastr] = new;
781: reg_prev_eqv[new] = lastr;
782: }
783: }
784:
785: /* Remove REG from its equivalence class. */
786:
787: static void
788: delete_reg_equiv (reg)
789: register int reg;
790: {
791: register int n = reg_next_eqv[reg];
792: register int p = reg_prev_eqv[reg];
793: register int q = reg_qty[reg];
794:
795: /* If invalid, do nothing. N and P above are undefined in that case. */
796: if (q == reg)
797: return;
798:
799: if (n != -1)
800: reg_prev_eqv[n] = p;
801: else
802: qty_last_reg[q] = p;
803: if (p != -1)
804: reg_next_eqv[p] = n;
805: else
806: qty_first_reg[q] = n;
807:
808: reg_qty[reg] = reg;
809: }
810:
811: /* Remove any invalid expressions from the hash table
812: that refer to any of the registers contained in expression X.
813:
814: Make sure that newly inserted references to those registers
815: as subexpressions will be considered valid.
816:
817: mention_regs is not called when a register itself
818: is being stored in the table.
819:
820: Return 1 if we have done something that may have changed the hash code
821: of X. */
822:
823: static int
824: mention_regs (x)
825: rtx x;
826: {
827: register enum rtx_code code;
828: register int i, j;
829: register char *fmt;
830: register int changed = 0;
831:
832: if (x == 0)
1.1.1.3 root 833: return 0;
1.1 root 834:
835: code = GET_CODE (x);
836: if (code == REG)
837: {
838: register int regno = REGNO (x);
839: register int endregno
840: = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
841: : HARD_REGNO_NREGS (regno, GET_MODE (x)));
842: int i;
843:
844: for (i = regno; i < endregno; i++)
845: {
846: if (reg_in_table[i] >= 0 && reg_in_table[i] != reg_tick[i])
847: remove_invalid_refs (i);
848:
849: reg_in_table[i] = reg_tick[i];
850: }
851:
852: return 0;
853: }
854:
855: /* If X is a comparison or a COMPARE and either operand is a register
856: that does not have a quantity, give it one. This is so that a later
857: call to record_jump_equiv won't cause X to be assigned a different
858: hash code and not found in the table after that call.
859:
860: It is not necessary to do this here, since rehash_using_reg can
861: fix up the table later, but doing this here eliminates the need to
862: call that expensive function in the most common case where the only
863: use of the register is in the comparison. */
864:
865: if (code == COMPARE || GET_RTX_CLASS (code) == '<')
866: {
867: if (GET_CODE (XEXP (x, 0)) == REG
868: && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))))
1.1.1.4 ! root 869: if (insert_regs (XEXP (x, 0), NULL_PTR, 0))
1.1 root 870: {
871: rehash_using_reg (XEXP (x, 0));
872: changed = 1;
873: }
874:
875: if (GET_CODE (XEXP (x, 1)) == REG
876: && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 1))))
1.1.1.4 ! root 877: if (insert_regs (XEXP (x, 1), NULL_PTR, 0))
1.1 root 878: {
879: rehash_using_reg (XEXP (x, 1));
880: changed = 1;
881: }
882: }
883:
884: fmt = GET_RTX_FORMAT (code);
885: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
886: if (fmt[i] == 'e')
887: changed |= mention_regs (XEXP (x, i));
888: else if (fmt[i] == 'E')
889: for (j = 0; j < XVECLEN (x, i); j++)
890: changed |= mention_regs (XVECEXP (x, i, j));
891:
892: return changed;
893: }
894:
895: /* Update the register quantities for inserting X into the hash table
896: with a value equivalent to CLASSP.
897: (If the class does not contain a REG, it is irrelevant.)
898: If MODIFIED is nonzero, X is a destination; it is being modified.
899: Note that delete_reg_equiv should be called on a register
900: before insert_regs is done on that register with MODIFIED != 0.
901:
902: Nonzero value means that elements of reg_qty have changed
903: so X's hash code may be different. */
904:
905: static int
906: insert_regs (x, classp, modified)
907: rtx x;
908: struct table_elt *classp;
909: int modified;
910: {
911: if (GET_CODE (x) == REG)
912: {
913: register int regno = REGNO (x);
914:
915: if (modified
916: || ! (REGNO_QTY_VALID_P (regno)
917: && qty_mode[reg_qty[regno]] == GET_MODE (x)))
918: {
919: if (classp)
920: for (classp = classp->first_same_value;
921: classp != 0;
922: classp = classp->next_same_value)
923: if (GET_CODE (classp->exp) == REG
924: && GET_MODE (classp->exp) == GET_MODE (x))
925: {
926: make_regs_eqv (regno, REGNO (classp->exp));
927: return 1;
928: }
929:
930: make_new_qty (regno);
931: qty_mode[reg_qty[regno]] = GET_MODE (x);
932: return 1;
933: }
934: }
1.1.1.4 ! root 935:
! 936: /* If X is a SUBREG, we will likely be inserting the inner register in the
! 937: table. If that register doesn't have an assigned quantity number at
! 938: this point but does later, the insertion that we will be doing now will
! 939: not be accessible because its hash code will have changed. So assign
! 940: a quantity number now. */
! 941:
! 942: else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
! 943: && ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
! 944: {
! 945: insert_regs (SUBREG_REG (x), NULL_PTR, 0);
! 946: mention_regs (SUBREG_REG (x));
! 947: return 1;
! 948: }
1.1 root 949: else
950: return mention_regs (x);
951: }
952:
953: /* Look in or update the hash table. */
954:
955: /* Put the element ELT on the list of free elements. */
956:
957: static void
958: free_element (elt)
959: struct table_elt *elt;
960: {
961: elt->next_same_hash = free_element_chain;
962: free_element_chain = elt;
963: }
964:
965: /* Return an element that is free for use. */
966:
967: static struct table_elt *
968: get_element ()
969: {
970: struct table_elt *elt = free_element_chain;
971: if (elt)
972: {
973: free_element_chain = elt->next_same_hash;
974: return elt;
975: }
976: n_elements_made++;
977: return (struct table_elt *) oballoc (sizeof (struct table_elt));
978: }
979:
980: /* Remove table element ELT from use in the table.
981: HASH is its hash code, made using the HASH macro.
982: It's an argument because often that is known in advance
983: and we save much time not recomputing it. */
984:
985: static void
986: remove_from_table (elt, hash)
987: register struct table_elt *elt;
988: int hash;
989: {
990: if (elt == 0)
991: return;
992:
993: /* Mark this element as removed. See cse_insn. */
994: elt->first_same_value = 0;
995:
996: /* Remove the table element from its equivalence class. */
997:
998: {
999: register struct table_elt *prev = elt->prev_same_value;
1000: register struct table_elt *next = elt->next_same_value;
1001:
1002: if (next) next->prev_same_value = prev;
1003:
1004: if (prev)
1005: prev->next_same_value = next;
1006: else
1007: {
1008: register struct table_elt *newfirst = next;
1009: while (next)
1010: {
1011: next->first_same_value = newfirst;
1012: next = next->next_same_value;
1013: }
1014: }
1015: }
1016:
1017: /* Remove the table element from its hash bucket. */
1018:
1019: {
1020: register struct table_elt *prev = elt->prev_same_hash;
1021: register struct table_elt *next = elt->next_same_hash;
1022:
1023: if (next) next->prev_same_hash = prev;
1024:
1025: if (prev)
1026: prev->next_same_hash = next;
1027: else if (table[hash] == elt)
1028: table[hash] = next;
1029: else
1030: {
1031: /* This entry is not in the proper hash bucket. This can happen
1032: when two classes were merged by `merge_equiv_classes'. Search
1033: for the hash bucket that it heads. This happens only very
1034: rarely, so the cost is acceptable. */
1035: for (hash = 0; hash < NBUCKETS; hash++)
1036: if (table[hash] == elt)
1037: table[hash] = next;
1038: }
1039: }
1040:
1041: /* Remove the table element from its related-value circular chain. */
1042:
1043: if (elt->related_value != 0 && elt->related_value != elt)
1044: {
1045: register struct table_elt *p = elt->related_value;
1046: while (p->related_value != elt)
1047: p = p->related_value;
1048: p->related_value = elt->related_value;
1049: if (p->related_value == p)
1050: p->related_value = 0;
1051: }
1052:
1053: free_element (elt);
1054: }
1055:
1056: /* Look up X in the hash table and return its table element,
1057: or 0 if X is not in the table.
1058:
1059: MODE is the machine-mode of X, or if X is an integer constant
1060: with VOIDmode then MODE is the mode with which X will be used.
1061:
1062: Here we are satisfied to find an expression whose tree structure
1063: looks like X. */
1064:
1065: static struct table_elt *
1066: lookup (x, hash, mode)
1067: rtx x;
1068: int hash;
1069: enum machine_mode mode;
1070: {
1071: register struct table_elt *p;
1072:
1073: for (p = table[hash]; p; p = p->next_same_hash)
1074: if (mode == p->mode && ((x == p->exp && GET_CODE (x) == REG)
1075: || exp_equiv_p (x, p->exp, GET_CODE (x) != REG, 0)))
1076: return p;
1077:
1078: return 0;
1079: }
1080:
1081: /* Like `lookup' but don't care whether the table element uses invalid regs.
1082: Also ignore discrepancies in the machine mode of a register. */
1083:
1084: static struct table_elt *
1085: lookup_for_remove (x, hash, mode)
1086: rtx x;
1087: int hash;
1088: enum machine_mode mode;
1089: {
1090: register struct table_elt *p;
1091:
1092: if (GET_CODE (x) == REG)
1093: {
1094: int regno = REGNO (x);
1095: /* Don't check the machine mode when comparing registers;
1096: invalidating (REG:SI 0) also invalidates (REG:DF 0). */
1097: for (p = table[hash]; p; p = p->next_same_hash)
1098: if (GET_CODE (p->exp) == REG
1099: && REGNO (p->exp) == regno)
1100: return p;
1101: }
1102: else
1103: {
1104: for (p = table[hash]; p; p = p->next_same_hash)
1105: if (mode == p->mode && (x == p->exp || exp_equiv_p (x, p->exp, 0, 0)))
1106: return p;
1107: }
1108:
1109: return 0;
1110: }
1111:
1112: /* Look for an expression equivalent to X and with code CODE.
1113: If one is found, return that expression. */
1114:
1115: static rtx
1116: lookup_as_function (x, code)
1117: rtx x;
1118: enum rtx_code code;
1119: {
1120: register struct table_elt *p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS,
1121: GET_MODE (x));
1122: if (p == 0)
1123: return 0;
1124:
1125: for (p = p->first_same_value; p; p = p->next_same_value)
1126: {
1127: if (GET_CODE (p->exp) == code
1128: /* Make sure this is a valid entry in the table. */
1129: && exp_equiv_p (p->exp, p->exp, 1, 0))
1130: return p->exp;
1131: }
1132:
1133: return 0;
1134: }
1135:
1136: /* Insert X in the hash table, assuming HASH is its hash code
1137: and CLASSP is an element of the class it should go in
1138: (or 0 if a new class should be made).
1139: It is inserted at the proper position to keep the class in
1140: the order cheapest first.
1141:
1142: MODE is the machine-mode of X, or if X is an integer constant
1143: with VOIDmode then MODE is the mode with which X will be used.
1144:
1145: For elements of equal cheapness, the most recent one
1146: goes in front, except that the first element in the list
1147: remains first unless a cheaper element is added. The order of
1148: pseudo-registers does not matter, as canon_reg will be called to
1.1.1.3 root 1149: find the cheapest when a register is retrieved from the table.
1.1 root 1150:
1151: The in_memory field in the hash table element is set to 0.
1152: The caller must set it nonzero if appropriate.
1153:
1154: You should call insert_regs (X, CLASSP, MODIFY) before calling here,
1155: and if insert_regs returns a nonzero value
1156: you must then recompute its hash code before calling here.
1157:
1158: If necessary, update table showing constant values of quantities. */
1159:
1160: #define CHEAPER(X,Y) ((X)->cost < (Y)->cost)
1161:
1162: static struct table_elt *
1163: insert (x, classp, hash, mode)
1164: register rtx x;
1165: register struct table_elt *classp;
1166: int hash;
1167: enum machine_mode mode;
1168: {
1169: register struct table_elt *elt;
1170:
1171: /* If X is a register and we haven't made a quantity for it,
1172: something is wrong. */
1173: if (GET_CODE (x) == REG && ! REGNO_QTY_VALID_P (REGNO (x)))
1174: abort ();
1175:
1176: /* If X is a hard register, show it is being put in the table. */
1177: if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
1178: {
1179: int regno = REGNO (x);
1180: int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
1181: int i;
1182:
1183: for (i = regno; i < endregno; i++)
1184: SET_HARD_REG_BIT (hard_regs_in_table, i);
1185: }
1186:
1187:
1188: /* Put an element for X into the right hash bucket. */
1189:
1190: elt = get_element ();
1191: elt->exp = x;
1192: elt->cost = COST (x);
1193: elt->next_same_value = 0;
1194: elt->prev_same_value = 0;
1195: elt->next_same_hash = table[hash];
1196: elt->prev_same_hash = 0;
1197: elt->related_value = 0;
1198: elt->in_memory = 0;
1199: elt->mode = mode;
1200: elt->is_const = (CONSTANT_P (x)
1201: /* GNU C++ takes advantage of this for `this'
1202: (and other const values). */
1203: || (RTX_UNCHANGING_P (x)
1204: && GET_CODE (x) == REG
1205: && REGNO (x) >= FIRST_PSEUDO_REGISTER)
1206: || FIXED_BASE_PLUS_P (x));
1207:
1208: if (table[hash])
1209: table[hash]->prev_same_hash = elt;
1210: table[hash] = elt;
1211:
1212: /* Put it into the proper value-class. */
1213: if (classp)
1214: {
1215: classp = classp->first_same_value;
1216: if (CHEAPER (elt, classp))
1217: /* Insert at the head of the class */
1218: {
1219: register struct table_elt *p;
1220: elt->next_same_value = classp;
1221: classp->prev_same_value = elt;
1222: elt->first_same_value = elt;
1223:
1224: for (p = classp; p; p = p->next_same_value)
1225: p->first_same_value = elt;
1226: }
1227: else
1228: {
1229: /* Insert not at head of the class. */
1230: /* Put it after the last element cheaper than X. */
1231: register struct table_elt *p, *next;
1232: for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt);
1233: p = next);
1234: /* Put it after P and before NEXT. */
1235: elt->next_same_value = next;
1236: if (next)
1237: next->prev_same_value = elt;
1238: elt->prev_same_value = p;
1239: p->next_same_value = elt;
1240: elt->first_same_value = classp;
1241: }
1242: }
1243: else
1244: elt->first_same_value = elt;
1245:
1246: /* If this is a constant being set equivalent to a register or a register
1247: being set equivalent to a constant, note the constant equivalence.
1248:
1249: If this is a constant, it cannot be equivalent to a different constant,
1250: and a constant is the only thing that can be cheaper than a register. So
1251: we know the register is the head of the class (before the constant was
1252: inserted).
1253:
1254: If this is a register that is not already known equivalent to a
1255: constant, we must check the entire class.
1256:
1257: If this is a register that is already known equivalent to an insn,
1258: update `qty_const_insn' to show that `this_insn' is the latest
1259: insn making that quantity equivalent to the constant. */
1260:
1261: if (elt->is_const && classp && GET_CODE (classp->exp) == REG)
1262: {
1263: qty_const[reg_qty[REGNO (classp->exp)]]
1264: = gen_lowpart_if_possible (qty_mode[reg_qty[REGNO (classp->exp)]], x);
1265: qty_const_insn[reg_qty[REGNO (classp->exp)]] = this_insn;
1266: }
1267:
1268: else if (GET_CODE (x) == REG && classp && ! qty_const[reg_qty[REGNO (x)]])
1269: {
1270: register struct table_elt *p;
1271:
1272: for (p = classp; p != 0; p = p->next_same_value)
1273: {
1274: if (p->is_const)
1275: {
1276: qty_const[reg_qty[REGNO (x)]]
1277: = gen_lowpart_if_possible (GET_MODE (x), p->exp);
1278: qty_const_insn[reg_qty[REGNO (x)]] = this_insn;
1279: break;
1280: }
1281: }
1282: }
1283:
1284: else if (GET_CODE (x) == REG && qty_const[reg_qty[REGNO (x)]]
1285: && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]])
1286: qty_const_insn[reg_qty[REGNO (x)]] = this_insn;
1287:
1288: /* If this is a constant with symbolic value,
1289: and it has a term with an explicit integer value,
1290: link it up with related expressions. */
1291: if (GET_CODE (x) == CONST)
1292: {
1293: rtx subexp = get_related_value (x);
1294: int subhash;
1295: struct table_elt *subelt, *subelt_prev;
1296:
1297: if (subexp != 0)
1298: {
1299: /* Get the integer-free subexpression in the hash table. */
1300: subhash = safe_hash (subexp, mode) % NBUCKETS;
1301: subelt = lookup (subexp, subhash, mode);
1302: if (subelt == 0)
1.1.1.4 ! root 1303: subelt = insert (subexp, NULL_PTR, subhash, mode);
1.1 root 1304: /* Initialize SUBELT's circular chain if it has none. */
1305: if (subelt->related_value == 0)
1306: subelt->related_value = subelt;
1307: /* Find the element in the circular chain that precedes SUBELT. */
1308: subelt_prev = subelt;
1309: while (subelt_prev->related_value != subelt)
1310: subelt_prev = subelt_prev->related_value;
1311: /* Put new ELT into SUBELT's circular chain just before SUBELT.
1312: This way the element that follows SUBELT is the oldest one. */
1313: elt->related_value = subelt_prev->related_value;
1314: subelt_prev->related_value = elt;
1315: }
1316: }
1317:
1318: return elt;
1319: }
1320:
1321: /* Given two equivalence classes, CLASS1 and CLASS2, put all the entries from
1322: CLASS2 into CLASS1. This is done when we have reached an insn which makes
1323: the two classes equivalent.
1324:
1325: CLASS1 will be the surviving class; CLASS2 should not be used after this
1326: call.
1327:
1328: Any invalid entries in CLASS2 will not be copied. */
1329:
1330: static void
1331: merge_equiv_classes (class1, class2)
1332: struct table_elt *class1, *class2;
1333: {
1334: struct table_elt *elt, *next, *new;
1335:
1336: /* Ensure we start with the head of the classes. */
1337: class1 = class1->first_same_value;
1338: class2 = class2->first_same_value;
1339:
1340: /* If they were already equal, forget it. */
1341: if (class1 == class2)
1342: return;
1343:
1344: for (elt = class2; elt; elt = next)
1345: {
1346: int hash;
1347: rtx exp = elt->exp;
1348: enum machine_mode mode = elt->mode;
1349:
1350: next = elt->next_same_value;
1351:
1352: /* Remove old entry, make a new one in CLASS1's class.
1353: Don't do this for invalid entries as we cannot find their
1354: hash code (it also isn't necessary). */
1355: if (GET_CODE (exp) == REG || exp_equiv_p (exp, exp, 1, 0))
1356: {
1357: hash_arg_in_memory = 0;
1358: hash_arg_in_struct = 0;
1359: hash = HASH (exp, mode);
1360:
1361: if (GET_CODE (exp) == REG)
1362: delete_reg_equiv (REGNO (exp));
1363:
1364: remove_from_table (elt, hash);
1365:
1366: if (insert_regs (exp, class1, 0))
1367: hash = HASH (exp, mode);
1368: new = insert (exp, class1, hash, mode);
1369: new->in_memory = hash_arg_in_memory;
1370: new->in_struct = hash_arg_in_struct;
1371: }
1372: }
1373: }
1374:
1375: /* Remove from the hash table, or mark as invalid,
1376: all expressions whose values could be altered by storing in X.
1377: X is a register, a subreg, or a memory reference with nonvarying address
1378: (because, when a memory reference with a varying address is stored in,
1379: all memory references are removed by invalidate_memory
1380: so specific invalidation is superfluous).
1381:
1382: A nonvarying address may be just a register or just
1383: a symbol reference, or it may be either of those plus
1384: a numeric offset. */
1385:
1386: static void
1387: invalidate (x)
1388: rtx x;
1389: {
1390: register int i;
1391: register struct table_elt *p;
1392: register rtx base;
1.1.1.4 ! root 1393: register HOST_WIDE_INT start, end;
1.1 root 1394:
1395: /* If X is a register, dependencies on its contents
1396: are recorded through the qty number mechanism.
1397: Just change the qty number of the register,
1398: mark it as invalid for expressions that refer to it,
1399: and remove it itself. */
1400:
1401: if (GET_CODE (x) == REG)
1402: {
1403: register int regno = REGNO (x);
1404: register int hash = HASH (x, GET_MODE (x));
1405:
1406: /* Remove REGNO from any quantity list it might be on and indicate
1407: that it's value might have changed. If it is a pseudo, remove its
1408: entry from the hash table.
1409:
1410: For a hard register, we do the first two actions above for any
1411: additional hard registers corresponding to X. Then, if any of these
1412: registers are in the table, we must remove any REG entries that
1413: overlap these registers. */
1414:
1415: delete_reg_equiv (regno);
1416: reg_tick[regno]++;
1417:
1418: if (regno >= FIRST_PSEUDO_REGISTER)
1419: remove_from_table (lookup_for_remove (x, hash, GET_MODE (x)), hash);
1420: else
1421: {
1422: int in_table = TEST_HARD_REG_BIT (hard_regs_in_table, regno);
1423: int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
1424: int tregno, tendregno;
1425: register struct table_elt *p, *next;
1426:
1427: CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
1428:
1429: for (i = regno + 1; i < endregno; i++)
1430: {
1431: in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, i);
1432: CLEAR_HARD_REG_BIT (hard_regs_in_table, i);
1433: delete_reg_equiv (i);
1434: reg_tick[i]++;
1435: }
1436:
1437: if (in_table)
1438: for (hash = 0; hash < NBUCKETS; hash++)
1439: for (p = table[hash]; p; p = next)
1440: {
1441: next = p->next_same_hash;
1442:
1443: if (GET_CODE (p->exp) != REG
1444: || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
1445: continue;
1446:
1447: tregno = REGNO (p->exp);
1448: tendregno
1449: = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (p->exp));
1450: if (tendregno > regno && tregno < endregno)
1451: remove_from_table (p, hash);
1452: }
1453: }
1454:
1455: return;
1456: }
1457:
1458: if (GET_CODE (x) == SUBREG)
1459: {
1460: if (GET_CODE (SUBREG_REG (x)) != REG)
1461: abort ();
1462: invalidate (SUBREG_REG (x));
1463: return;
1464: }
1465:
1466: /* X is not a register; it must be a memory reference with
1467: a nonvarying address. Remove all hash table elements
1468: that refer to overlapping pieces of memory. */
1469:
1470: if (GET_CODE (x) != MEM)
1471: abort ();
1472: base = XEXP (x, 0);
1473: start = 0;
1474:
1475: /* Registers with nonvarying addresses usually have constant equivalents;
1476: but the frame pointer register is also possible. */
1477: if (GET_CODE (base) == REG
1478: && REGNO_QTY_VALID_P (REGNO (base))
1479: && qty_mode[reg_qty[REGNO (base)]] == GET_MODE (base)
1480: && qty_const[reg_qty[REGNO (base)]] != 0)
1481: base = qty_const[reg_qty[REGNO (base)]];
1482: else if (GET_CODE (base) == PLUS
1483: && GET_CODE (XEXP (base, 1)) == CONST_INT
1484: && GET_CODE (XEXP (base, 0)) == REG
1485: && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0)))
1486: && (qty_mode[reg_qty[REGNO (XEXP (base, 0))]]
1487: == GET_MODE (XEXP (base, 0)))
1488: && qty_const[reg_qty[REGNO (XEXP (base, 0))]])
1489: {
1490: start = INTVAL (XEXP (base, 1));
1491: base = qty_const[reg_qty[REGNO (XEXP (base, 0))]];
1492: }
1493:
1494: if (GET_CODE (base) == CONST)
1495: base = XEXP (base, 0);
1496: if (GET_CODE (base) == PLUS
1497: && GET_CODE (XEXP (base, 1)) == CONST_INT)
1498: {
1499: start += INTVAL (XEXP (base, 1));
1500: base = XEXP (base, 0);
1501: }
1502:
1503: end = start + GET_MODE_SIZE (GET_MODE (x));
1504: for (i = 0; i < NBUCKETS; i++)
1505: {
1506: register struct table_elt *next;
1507: for (p = table[i]; p; p = next)
1508: {
1509: next = p->next_same_hash;
1510: if (refers_to_mem_p (p->exp, base, start, end))
1511: remove_from_table (p, i);
1512: }
1513: }
1514: }
1515:
1516: /* Remove all expressions that refer to register REGNO,
1517: since they are already invalid, and we are about to
1518: mark that register valid again and don't want the old
1519: expressions to reappear as valid. */
1520:
1521: static void
1522: remove_invalid_refs (regno)
1523: int regno;
1524: {
1525: register int i;
1526: register struct table_elt *p, *next;
1527:
1528: for (i = 0; i < NBUCKETS; i++)
1529: for (p = table[i]; p; p = next)
1530: {
1531: next = p->next_same_hash;
1532: if (GET_CODE (p->exp) != REG
1.1.1.4 ! root 1533: && refers_to_regno_p (regno, regno + 1, p->exp, NULL_PTR))
1.1 root 1534: remove_from_table (p, i);
1535: }
1536: }
1537:
1538: /* Recompute the hash codes of any valid entries in the hash table that
1539: reference X, if X is a register, or SUBREG_REG (X) if X is a SUBREG.
1540:
1541: This is called when we make a jump equivalence. */
1542:
1543: static void
1544: rehash_using_reg (x)
1545: rtx x;
1546: {
1547: int i;
1548: struct table_elt *p, *next;
1549: int hash;
1550:
1551: if (GET_CODE (x) == SUBREG)
1552: x = SUBREG_REG (x);
1553:
1554: /* If X is not a register or if the register is known not to be in any
1555: valid entries in the table, we have no work to do. */
1556:
1557: if (GET_CODE (x) != REG
1558: || reg_in_table[REGNO (x)] < 0
1559: || reg_in_table[REGNO (x)] != reg_tick[REGNO (x)])
1560: return;
1561:
1562: /* Scan all hash chains looking for valid entries that mention X.
1563: If we find one and it is in the wrong hash chain, move it. We can skip
1564: objects that are registers, since they are handled specially. */
1565:
1566: for (i = 0; i < NBUCKETS; i++)
1567: for (p = table[i]; p; p = next)
1568: {
1569: next = p->next_same_hash;
1570: if (GET_CODE (p->exp) != REG && reg_mentioned_p (x, p->exp)
1.1.1.2 root 1571: && exp_equiv_p (p->exp, p->exp, 1, 0)
1.1 root 1572: && i != (hash = safe_hash (p->exp, p->mode) % NBUCKETS))
1573: {
1574: if (p->next_same_hash)
1575: p->next_same_hash->prev_same_hash = p->prev_same_hash;
1576:
1577: if (p->prev_same_hash)
1578: p->prev_same_hash->next_same_hash = p->next_same_hash;
1579: else
1580: table[i] = p->next_same_hash;
1581:
1582: p->next_same_hash = table[hash];
1583: p->prev_same_hash = 0;
1584: if (table[hash])
1585: table[hash]->prev_same_hash = p;
1586: table[hash] = p;
1587: }
1588: }
1589: }
1590:
1591: /* Remove from the hash table all expressions that reference memory,
1592: or some of them as specified by *WRITES. */
1593:
1594: static void
1595: invalidate_memory (writes)
1596: struct write_data *writes;
1597: {
1598: register int i;
1599: register struct table_elt *p, *next;
1600: int all = writes->all;
1601: int nonscalar = writes->nonscalar;
1602:
1603: for (i = 0; i < NBUCKETS; i++)
1604: for (p = table[i]; p; p = next)
1605: {
1606: next = p->next_same_hash;
1607: if (p->in_memory
1608: && (all
1609: || (nonscalar && p->in_struct)
1610: || cse_rtx_addr_varies_p (p->exp)))
1611: remove_from_table (p, i);
1612: }
1613: }
1614:
1615: /* Remove from the hash table any expression that is a call-clobbered
1616: register. Also update their TICK values. */
1617:
1618: static void
1619: invalidate_for_call ()
1620: {
1621: int regno, endregno;
1622: int i;
1623: int hash;
1624: struct table_elt *p, *next;
1625: int in_table = 0;
1626:
1627: /* Go through all the hard registers. For each that is clobbered in
1628: a CALL_INSN, remove the register from quantity chains and update
1629: reg_tick if defined. Also see if any of these registers is currently
1630: in the table. */
1631:
1632: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1633: if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
1634: {
1635: delete_reg_equiv (regno);
1636: if (reg_tick[regno] >= 0)
1637: reg_tick[regno]++;
1638:
1639: in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, regno);
1640: }
1641:
1642: /* In the case where we have no call-clobbered hard registers in the
1643: table, we are done. Otherwise, scan the table and remove any
1644: entry that overlaps a call-clobbered register. */
1645:
1646: if (in_table)
1647: for (hash = 0; hash < NBUCKETS; hash++)
1648: for (p = table[hash]; p; p = next)
1649: {
1650: next = p->next_same_hash;
1651:
1652: if (GET_CODE (p->exp) != REG
1653: || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
1654: continue;
1655:
1656: regno = REGNO (p->exp);
1657: endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (p->exp));
1658:
1659: for (i = regno; i < endregno; i++)
1660: if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
1661: {
1662: remove_from_table (p, hash);
1663: break;
1664: }
1665: }
1666: }
1667:
1668: /* Given an expression X of type CONST,
1669: and ELT which is its table entry (or 0 if it
1670: is not in the hash table),
1671: return an alternate expression for X as a register plus integer.
1672: If none can be found, return 0. */
1673:
1674: static rtx
1675: use_related_value (x, elt)
1676: rtx x;
1677: struct table_elt *elt;
1678: {
1679: register struct table_elt *relt = 0;
1680: register struct table_elt *p, *q;
1.1.1.4 ! root 1681: HOST_WIDE_INT offset;
1.1 root 1682:
1683: /* First, is there anything related known?
1684: If we have a table element, we can tell from that.
1685: Otherwise, must look it up. */
1686:
1687: if (elt != 0 && elt->related_value != 0)
1688: relt = elt;
1689: else if (elt == 0 && GET_CODE (x) == CONST)
1690: {
1691: rtx subexp = get_related_value (x);
1692: if (subexp != 0)
1693: relt = lookup (subexp,
1694: safe_hash (subexp, GET_MODE (subexp)) % NBUCKETS,
1695: GET_MODE (subexp));
1696: }
1697:
1698: if (relt == 0)
1699: return 0;
1700:
1701: /* Search all related table entries for one that has an
1702: equivalent register. */
1703:
1704: p = relt;
1705: while (1)
1706: {
1707: /* This loop is strange in that it is executed in two different cases.
1708: The first is when X is already in the table. Then it is searching
1709: the RELATED_VALUE list of X's class (RELT). The second case is when
1710: X is not in the table. Then RELT points to a class for the related
1711: value.
1712:
1713: Ensure that, whatever case we are in, that we ignore classes that have
1714: the same value as X. */
1715:
1716: if (rtx_equal_p (x, p->exp))
1717: q = 0;
1718: else
1719: for (q = p->first_same_value; q; q = q->next_same_value)
1720: if (GET_CODE (q->exp) == REG)
1721: break;
1722:
1723: if (q)
1724: break;
1725:
1726: p = p->related_value;
1727:
1728: /* We went all the way around, so there is nothing to be found.
1729: Alternatively, perhaps RELT was in the table for some other reason
1730: and it has no related values recorded. */
1731: if (p == relt || p == 0)
1732: break;
1733: }
1734:
1735: if (q == 0)
1736: return 0;
1737:
1738: offset = (get_integer_term (x) - get_integer_term (p->exp));
1739: /* Note: OFFSET may be 0 if P->xexp and X are related by commutativity. */
1740: return plus_constant (q->exp, offset);
1741: }
1742:
1743: /* Hash an rtx. We are careful to make sure the value is never negative.
1744: Equivalent registers hash identically.
1745: MODE is used in hashing for CONST_INTs only;
1746: otherwise the mode of X is used.
1747:
1748: Store 1 in do_not_record if any subexpression is volatile.
1749:
1750: Store 1 in hash_arg_in_memory if X contains a MEM rtx
1751: which does not have the RTX_UNCHANGING_P bit set.
1752: In this case, also store 1 in hash_arg_in_struct
1753: if there is a MEM rtx which has the MEM_IN_STRUCT_P bit set.
1754:
1755: Note that cse_insn knows that the hash code of a MEM expression
1756: is just (int) MEM plus the hash code of the address. */
1757:
1758: static int
1759: canon_hash (x, mode)
1760: rtx x;
1761: enum machine_mode mode;
1762: {
1763: register int i, j;
1764: register int hash = 0;
1765: register enum rtx_code code;
1766: register char *fmt;
1767:
1768: /* repeat is used to turn tail-recursion into iteration. */
1769: repeat:
1770: if (x == 0)
1771: return hash;
1772:
1773: code = GET_CODE (x);
1774: switch (code)
1775: {
1776: case REG:
1777: {
1778: register int regno = REGNO (x);
1779:
1780: /* On some machines, we can't record any non-fixed hard register,
1781: because extending its life will cause reload problems. We
1782: consider ap, fp, and sp to be fixed for this purpose.
1783: On all machines, we can't record any global registers. */
1784:
1785: if (regno < FIRST_PSEUDO_REGISTER
1786: && (global_regs[regno]
1787: #ifdef SMALL_REGISTER_CLASSES
1788: || (! fixed_regs[regno]
1789: && regno != FRAME_POINTER_REGNUM
1790: && regno != ARG_POINTER_REGNUM
1791: && regno != STACK_POINTER_REGNUM)
1792: #endif
1793: ))
1794: {
1795: do_not_record = 1;
1796: return 0;
1797: }
1798: return hash + ((int) REG << 7) + reg_qty[regno];
1799: }
1800:
1801: case CONST_INT:
1802: hash += ((int) mode + ((int) CONST_INT << 7)
1803: + INTVAL (x) + (INTVAL (x) >> HASHBITS));
1804: return ((1 << HASHBITS) - 1) & hash;
1805:
1806: case CONST_DOUBLE:
1807: /* This is like the general case, except that it only counts
1808: the integers representing the constant. */
1809: hash += (int) code + (int) GET_MODE (x);
1810: {
1811: int i;
1812: for (i = 2; i < GET_RTX_LENGTH (CONST_DOUBLE); i++)
1813: {
1814: int tem = XINT (x, i);
1815: hash += ((1 << HASHBITS) - 1) & (tem + (tem >> HASHBITS));
1816: }
1817: }
1818: return hash;
1819:
1820: /* Assume there is only one rtx object for any given label. */
1821: case LABEL_REF:
1822: /* Use `and' to ensure a positive number. */
1.1.1.4 ! root 1823: return (hash + ((HOST_WIDE_INT) LABEL_REF << 7)
! 1824: + ((HOST_WIDE_INT) XEXP (x, 0) & ((1 << HASHBITS) - 1)));
1.1 root 1825:
1826: case SYMBOL_REF:
1.1.1.4 ! root 1827: return (hash + ((HOST_WIDE_INT) SYMBOL_REF << 7)
! 1828: + ((HOST_WIDE_INT) XEXP (x, 0) & ((1 << HASHBITS) - 1)));
1.1 root 1829:
1830: case MEM:
1831: if (MEM_VOLATILE_P (x))
1832: {
1833: do_not_record = 1;
1834: return 0;
1835: }
1836: if (! RTX_UNCHANGING_P (x))
1837: {
1838: hash_arg_in_memory = 1;
1839: if (MEM_IN_STRUCT_P (x)) hash_arg_in_struct = 1;
1840: }
1841: /* Now that we have already found this special case,
1842: might as well speed it up as much as possible. */
1843: hash += (int) MEM;
1844: x = XEXP (x, 0);
1845: goto repeat;
1846:
1847: case PRE_DEC:
1848: case PRE_INC:
1849: case POST_DEC:
1850: case POST_INC:
1851: case PC:
1852: case CC0:
1853: case CALL:
1854: case UNSPEC_VOLATILE:
1855: do_not_record = 1;
1856: return 0;
1857:
1858: case ASM_OPERANDS:
1859: if (MEM_VOLATILE_P (x))
1860: {
1861: do_not_record = 1;
1862: return 0;
1863: }
1864: }
1865:
1866: i = GET_RTX_LENGTH (code) - 1;
1867: hash += (int) code + (int) GET_MODE (x);
1868: fmt = GET_RTX_FORMAT (code);
1869: for (; i >= 0; i--)
1870: {
1871: if (fmt[i] == 'e')
1872: {
1873: rtx tem = XEXP (x, i);
1874: rtx tem1;
1875:
1876: /* If the operand is a REG that is equivalent to a constant, hash
1877: as if we were hashing the constant, since we will be comparing
1878: that way. */
1879: if (tem != 0 && GET_CODE (tem) == REG
1880: && REGNO_QTY_VALID_P (REGNO (tem))
1881: && qty_mode[reg_qty[REGNO (tem)]] == GET_MODE (tem)
1882: && (tem1 = qty_const[reg_qty[REGNO (tem)]]) != 0
1883: && CONSTANT_P (tem1))
1884: tem = tem1;
1885:
1886: /* If we are about to do the last recursive call
1887: needed at this level, change it into iteration.
1888: This function is called enough to be worth it. */
1889: if (i == 0)
1890: {
1891: x = tem;
1892: goto repeat;
1893: }
1894: hash += canon_hash (tem, 0);
1895: }
1896: else if (fmt[i] == 'E')
1897: for (j = 0; j < XVECLEN (x, i); j++)
1898: hash += canon_hash (XVECEXP (x, i, j), 0);
1899: else if (fmt[i] == 's')
1900: {
1901: register char *p = XSTR (x, i);
1902: if (p)
1903: while (*p)
1904: {
1905: register int tem = *p++;
1906: hash += ((1 << HASHBITS) - 1) & (tem + (tem >> HASHBITS));
1907: }
1908: }
1909: else if (fmt[i] == 'i')
1910: {
1911: register int tem = XINT (x, i);
1912: hash += ((1 << HASHBITS) - 1) & (tem + (tem >> HASHBITS));
1913: }
1914: else
1915: abort ();
1916: }
1917: return hash;
1918: }
1919:
1920: /* Like canon_hash but with no side effects. */
1921:
1922: static int
1923: safe_hash (x, mode)
1924: rtx x;
1925: enum machine_mode mode;
1926: {
1927: int save_do_not_record = do_not_record;
1928: int save_hash_arg_in_memory = hash_arg_in_memory;
1929: int save_hash_arg_in_struct = hash_arg_in_struct;
1930: int hash = canon_hash (x, mode);
1931: hash_arg_in_memory = save_hash_arg_in_memory;
1932: hash_arg_in_struct = save_hash_arg_in_struct;
1933: do_not_record = save_do_not_record;
1934: return hash;
1935: }
1936:
1937: /* Return 1 iff X and Y would canonicalize into the same thing,
1938: without actually constructing the canonicalization of either one.
1939: If VALIDATE is nonzero,
1940: we assume X is an expression being processed from the rtl
1941: and Y was found in the hash table. We check register refs
1942: in Y for being marked as valid.
1943:
1944: If EQUAL_VALUES is nonzero, we allow a register to match a constant value
1945: that is known to be in the register. Ordinarily, we don't allow them
1946: to match, because letting them match would cause unpredictable results
1947: in all the places that search a hash table chain for an equivalent
1948: for a given value. A possible equivalent that has different structure
1949: has its hash code computed from different data. Whether the hash code
1950: is the same as that of the the given value is pure luck. */
1951:
1952: static int
1953: exp_equiv_p (x, y, validate, equal_values)
1954: rtx x, y;
1955: int validate;
1956: int equal_values;
1957: {
1.1.1.4 ! root 1958: register int i, j;
1.1 root 1959: register enum rtx_code code;
1960: register char *fmt;
1961:
1962: /* Note: it is incorrect to assume an expression is equivalent to itself
1963: if VALIDATE is nonzero. */
1964: if (x == y && !validate)
1965: return 1;
1966: if (x == 0 || y == 0)
1967: return x == y;
1968:
1969: code = GET_CODE (x);
1970: if (code != GET_CODE (y))
1971: {
1972: if (!equal_values)
1973: return 0;
1974:
1975: /* If X is a constant and Y is a register or vice versa, they may be
1976: equivalent. We only have to validate if Y is a register. */
1977: if (CONSTANT_P (x) && GET_CODE (y) == REG
1978: && REGNO_QTY_VALID_P (REGNO (y))
1979: && GET_MODE (y) == qty_mode[reg_qty[REGNO (y)]]
1980: && rtx_equal_p (x, qty_const[reg_qty[REGNO (y)]])
1981: && (! validate || reg_in_table[REGNO (y)] == reg_tick[REGNO (y)]))
1982: return 1;
1983:
1984: if (CONSTANT_P (y) && code == REG
1985: && REGNO_QTY_VALID_P (REGNO (x))
1986: && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]]
1987: && rtx_equal_p (y, qty_const[reg_qty[REGNO (x)]]))
1988: return 1;
1989:
1990: return 0;
1991: }
1992:
1993: /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1994: if (GET_MODE (x) != GET_MODE (y))
1995: return 0;
1996:
1997: switch (code)
1998: {
1999: case PC:
2000: case CC0:
2001: return x == y;
2002:
2003: case CONST_INT:
1.1.1.4 ! root 2004: return INTVAL (x) == INTVAL (y);
1.1 root 2005:
2006: case LABEL_REF:
2007: case SYMBOL_REF:
2008: return XEXP (x, 0) == XEXP (y, 0);
2009:
2010: case REG:
2011: {
2012: int regno = REGNO (y);
2013: int endregno
2014: = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
2015: : HARD_REGNO_NREGS (regno, GET_MODE (y)));
2016: int i;
2017:
2018: /* If the quantities are not the same, the expressions are not
2019: equivalent. If there are and we are not to validate, they
2020: are equivalent. Otherwise, ensure all regs are up-to-date. */
2021:
2022: if (reg_qty[REGNO (x)] != reg_qty[regno])
2023: return 0;
2024:
2025: if (! validate)
2026: return 1;
2027:
2028: for (i = regno; i < endregno; i++)
2029: if (reg_in_table[i] != reg_tick[i])
2030: return 0;
2031:
2032: return 1;
2033: }
2034:
2035: /* For commutative operations, check both orders. */
2036: case PLUS:
2037: case MULT:
2038: case AND:
2039: case IOR:
2040: case XOR:
2041: case NE:
2042: case EQ:
2043: return ((exp_equiv_p (XEXP (x, 0), XEXP (y, 0), validate, equal_values)
2044: && exp_equiv_p (XEXP (x, 1), XEXP (y, 1),
2045: validate, equal_values))
2046: || (exp_equiv_p (XEXP (x, 0), XEXP (y, 1),
2047: validate, equal_values)
2048: && exp_equiv_p (XEXP (x, 1), XEXP (y, 0),
2049: validate, equal_values)));
2050: }
2051:
2052: /* Compare the elements. If any pair of corresponding elements
2053: fail to match, return 0 for the whole things. */
2054:
2055: fmt = GET_RTX_FORMAT (code);
2056: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2057: {
1.1.1.4 ! root 2058: switch (fmt[i])
1.1 root 2059: {
1.1.1.4 ! root 2060: case 'e':
1.1 root 2061: if (! exp_equiv_p (XEXP (x, i), XEXP (y, i), validate, equal_values))
2062: return 0;
1.1.1.4 ! root 2063: break;
! 2064:
! 2065: case 'E':
1.1 root 2066: if (XVECLEN (x, i) != XVECLEN (y, i))
2067: return 0;
2068: for (j = 0; j < XVECLEN (x, i); j++)
2069: if (! exp_equiv_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
2070: validate, equal_values))
2071: return 0;
1.1.1.4 ! root 2072: break;
! 2073:
! 2074: case 's':
1.1 root 2075: if (strcmp (XSTR (x, i), XSTR (y, i)))
2076: return 0;
1.1.1.4 ! root 2077: break;
! 2078:
! 2079: case 'i':
1.1 root 2080: if (XINT (x, i) != XINT (y, i))
2081: return 0;
1.1.1.4 ! root 2082: break;
! 2083:
! 2084: case 'w':
! 2085: if (XWINT (x, i) != XWINT (y, i))
! 2086: return 0;
! 2087: break;
! 2088:
! 2089: case '0':
! 2090: break;
! 2091:
! 2092: default:
! 2093: abort ();
1.1 root 2094: }
1.1.1.4 ! root 2095: }
! 2096:
1.1 root 2097: return 1;
2098: }
2099:
2100: /* Return 1 iff any subexpression of X matches Y.
2101: Here we do not require that X or Y be valid (for registers referred to)
2102: for being in the hash table. */
2103:
2104: int
2105: refers_to_p (x, y)
2106: rtx x, y;
2107: {
2108: register int i;
2109: register enum rtx_code code;
2110: register char *fmt;
2111:
2112: repeat:
2113: if (x == y)
2114: return 1;
2115: if (x == 0 || y == 0)
2116: return 0;
2117:
2118: code = GET_CODE (x);
2119: /* If X as a whole has the same code as Y, they may match.
2120: If so, return 1. */
2121: if (code == GET_CODE (y))
2122: {
2123: if (exp_equiv_p (x, y, 0, 1))
2124: return 1;
2125: }
2126:
2127: /* X does not match, so try its subexpressions. */
2128:
2129: fmt = GET_RTX_FORMAT (code);
2130: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2131: if (fmt[i] == 'e')
2132: {
2133: if (i == 0)
2134: {
2135: x = XEXP (x, 0);
2136: goto repeat;
2137: }
2138: else
2139: if (refers_to_p (XEXP (x, i), y))
2140: return 1;
2141: }
2142: else if (fmt[i] == 'E')
2143: {
2144: int j;
2145: for (j = 0; j < XVECLEN (x, i); j++)
2146: if (refers_to_p (XVECEXP (x, i, j), y))
2147: return 1;
2148: }
2149:
2150: return 0;
2151: }
2152:
2153: /* Return 1 iff any subexpression of X refers to memory
2154: at an address of BASE plus some offset
2155: such that any of the bytes' offsets fall between START (inclusive)
2156: and END (exclusive).
2157:
2158: The value is undefined if X is a varying address.
2159: This function is not used in such cases.
2160:
2161: When used in the cse pass, `qty_const' is nonzero, and it is used
2162: to treat an address that is a register with a known constant value
2163: as if it were that constant value.
2164: In the loop pass, `qty_const' is zero, so this is not done. */
2165:
2166: int
2167: refers_to_mem_p (x, base, start, end)
2168: rtx x, base;
1.1.1.4 ! root 2169: HOST_WIDE_INT start, end;
1.1 root 2170: {
1.1.1.4 ! root 2171: register HOST_WIDE_INT i;
1.1 root 2172: register enum rtx_code code;
2173: register char *fmt;
2174:
2175: if (GET_CODE (base) == CONST_INT)
2176: {
2177: start += INTVAL (base);
2178: end += INTVAL (base);
2179: base = const0_rtx;
2180: }
2181:
2182: repeat:
2183: if (x == 0)
2184: return 0;
2185:
2186: code = GET_CODE (x);
2187: if (code == MEM)
2188: {
2189: register rtx addr = XEXP (x, 0); /* Get the address. */
2190: int myend;
2191:
2192: i = 0;
2193: if (GET_CODE (addr) == REG
2194: /* qty_const is 0 when outside the cse pass;
2195: at such times, this info is not available. */
2196: && qty_const != 0
2197: && REGNO_QTY_VALID_P (REGNO (addr))
2198: && GET_MODE (addr) == qty_mode[reg_qty[REGNO (addr)]]
2199: && qty_const[reg_qty[REGNO (addr)]] != 0)
2200: addr = qty_const[reg_qty[REGNO (addr)]];
2201: else if (GET_CODE (addr) == PLUS
2202: && GET_CODE (XEXP (addr, 1)) == CONST_INT
2203: && GET_CODE (XEXP (addr, 0)) == REG
2204: && qty_const != 0
2205: && REGNO_QTY_VALID_P (REGNO (XEXP (addr, 0)))
2206: && (GET_MODE (XEXP (addr, 0))
2207: == qty_mode[reg_qty[REGNO (XEXP (addr, 0))]])
2208: && qty_const[reg_qty[REGNO (XEXP (addr, 0))]])
2209: {
2210: i = INTVAL (XEXP (addr, 1));
2211: addr = qty_const[reg_qty[REGNO (XEXP (addr, 0))]];
2212: }
2213:
2214: check_addr:
2215: if (GET_CODE (addr) == CONST)
2216: addr = XEXP (addr, 0);
2217:
2218: /* If ADDR is BASE, or BASE plus an integer, put
2219: the integer in I. */
2220: if (GET_CODE (addr) == PLUS
2221: && XEXP (addr, 0) == base
2222: && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2223: i += INTVAL (XEXP (addr, 1));
2224: else if (GET_CODE (addr) == LO_SUM)
2225: {
2226: if (GET_CODE (base) != LO_SUM)
2227: return 1;
2228: /* The REG component of the LO_SUM is known by the
2229: const value in the XEXP part. */
2230: addr = XEXP (addr, 1);
2231: base = XEXP (base, 1);
2232: i = 0;
2233: if (GET_CODE (base) == CONST)
2234: base = XEXP (base, 0);
2235: if (GET_CODE (base) == PLUS
2236: && GET_CODE (XEXP (base, 1)) == CONST_INT)
2237: {
1.1.1.4 ! root 2238: HOST_WIDE_INT tem = INTVAL (XEXP (base, 1));
1.1 root 2239: start += tem;
2240: end += tem;
2241: base = XEXP (base, 0);
2242: }
2243: goto check_addr;
2244: }
2245: else if (GET_CODE (base) == LO_SUM)
2246: {
2247: base = XEXP (base, 1);
2248: if (GET_CODE (base) == CONST)
2249: base = XEXP (base, 0);
2250: if (GET_CODE (base) == PLUS
2251: && GET_CODE (XEXP (base, 1)) == CONST_INT)
2252: {
1.1.1.4 ! root 2253: HOST_WIDE_INT tem = INTVAL (XEXP (base, 1));
1.1 root 2254: start += tem;
2255: end += tem;
2256: base = XEXP (base, 0);
2257: }
2258: goto check_addr;
2259: }
2260: else if (GET_CODE (addr) == CONST_INT && base == const0_rtx)
2261: i = INTVAL (addr);
2262: else if (addr != base)
2263: return 0;
2264:
2265: myend = i + GET_MODE_SIZE (GET_MODE (x));
2266: return myend > start && i < end;
2267: }
2268:
2269: /* X does not match, so try its subexpressions. */
2270:
2271: fmt = GET_RTX_FORMAT (code);
2272: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2273: if (fmt[i] == 'e')
2274: {
2275: if (i == 0)
2276: {
2277: x = XEXP (x, 0);
2278: goto repeat;
2279: }
2280: else
2281: if (refers_to_mem_p (XEXP (x, i), base, start, end))
2282: return 1;
2283: }
2284: else if (fmt[i] == 'E')
2285: {
2286: int j;
2287: for (j = 0; j < XVECLEN (x, i); j++)
2288: if (refers_to_mem_p (XVECEXP (x, i, j), base, start, end))
2289: return 1;
2290: }
2291:
2292: return 0;
2293: }
2294:
2295: /* Nonzero if X refers to memory at a varying address;
2296: except that a register which has at the moment a known constant value
2297: isn't considered variable. */
2298:
2299: static int
2300: cse_rtx_addr_varies_p (x)
2301: rtx x;
2302: {
2303: /* We need not check for X and the equivalence class being of the same
2304: mode because if X is equivalent to a constant in some mode, it
2305: doesn't vary in any mode. */
2306:
2307: if (GET_CODE (x) == MEM
2308: && GET_CODE (XEXP (x, 0)) == REG
2309: && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
2310: && GET_MODE (XEXP (x, 0)) == qty_mode[reg_qty[REGNO (XEXP (x, 0))]]
2311: && qty_const[reg_qty[REGNO (XEXP (x, 0))]] != 0)
2312: return 0;
2313:
2314: if (GET_CODE (x) == MEM
2315: && GET_CODE (XEXP (x, 0)) == PLUS
2316: && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2317: && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2318: && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0)))
2319: && (GET_MODE (XEXP (XEXP (x, 0), 0))
2320: == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
2321: && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
2322: return 0;
2323:
2324: return rtx_addr_varies_p (x);
2325: }
2326:
2327: /* Canonicalize an expression:
2328: replace each register reference inside it
2329: with the "oldest" equivalent register.
2330:
2331: If INSN is non-zero and we are replacing a pseudo with a hard register
1.1.1.4 ! root 2332: or vice versa, validate_change is used to ensure that INSN remains valid
! 2333: after we make our substitution. The calls are made with IN_GROUP non-zero
! 2334: so apply_change_group must be called upon the outermost return from this
! 2335: function (unless INSN is zero). The result of apply_change_group can
! 2336: generally be discarded since the changes we are making are optional. */
1.1 root 2337:
2338: static rtx
2339: canon_reg (x, insn)
2340: rtx x;
2341: rtx insn;
2342: {
2343: register int i;
2344: register enum rtx_code code;
2345: register char *fmt;
2346:
2347: if (x == 0)
2348: return x;
2349:
2350: code = GET_CODE (x);
2351: switch (code)
2352: {
2353: case PC:
2354: case CC0:
2355: case CONST:
2356: case CONST_INT:
2357: case CONST_DOUBLE:
2358: case SYMBOL_REF:
2359: case LABEL_REF:
2360: case ADDR_VEC:
2361: case ADDR_DIFF_VEC:
2362: return x;
2363:
2364: case REG:
2365: {
2366: register int first;
2367:
2368: /* Never replace a hard reg, because hard regs can appear
2369: in more than one machine mode, and we must preserve the mode
2370: of each occurrence. Also, some hard regs appear in
2371: MEMs that are shared and mustn't be altered. Don't try to
2372: replace any reg that maps to a reg of class NO_REGS. */
2373: if (REGNO (x) < FIRST_PSEUDO_REGISTER
2374: || ! REGNO_QTY_VALID_P (REGNO (x)))
2375: return x;
2376:
2377: first = qty_first_reg[reg_qty[REGNO (x)]];
2378: return (first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first]
2379: : REGNO_REG_CLASS (first) == NO_REGS ? x
2380: : gen_rtx (REG, qty_mode[reg_qty[REGNO (x)]], first));
2381: }
2382: }
2383:
2384: fmt = GET_RTX_FORMAT (code);
2385: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2386: {
2387: register int j;
2388:
2389: if (fmt[i] == 'e')
2390: {
2391: rtx new = canon_reg (XEXP (x, i), insn);
2392:
2393: /* If replacing pseudo with hard reg or vice versa, ensure the
1.1.1.3 root 2394: insn remains valid. Likewise if the insn has MATCH_DUPs. */
1.1.1.4 ! root 2395: if (insn != 0 && new != 0
! 2396: && GET_CODE (new) == REG && GET_CODE (XEXP (x, i)) == REG
1.1.1.3 root 2397: && (((REGNO (new) < FIRST_PSEUDO_REGISTER)
2398: != (REGNO (XEXP (x, i)) < FIRST_PSEUDO_REGISTER))
1.1.1.4 ! root 2399: || insn_n_dups[recog_memoized (insn)] > 0))
! 2400: validate_change (insn, &XEXP (x, i), new, 1);
1.1 root 2401: else
2402: XEXP (x, i) = new;
2403: }
2404: else if (fmt[i] == 'E')
2405: for (j = 0; j < XVECLEN (x, i); j++)
2406: XVECEXP (x, i, j) = canon_reg (XVECEXP (x, i, j), insn);
2407: }
2408:
2409: return x;
2410: }
2411:
2412: /* LOC is a location with INSN that is an operand address (the contents of
2413: a MEM). Find the best equivalent address to use that is valid for this
2414: insn.
2415:
2416: On most CISC machines, complicated address modes are costly, and rtx_cost
2417: is a good approximation for that cost. However, most RISC machines have
2418: only a few (usually only one) memory reference formats. If an address is
2419: valid at all, it is often just as cheap as any other address. Hence, for
2420: RISC machines, we use the configuration macro `ADDRESS_COST' to compare the
2421: costs of various addresses. For two addresses of equal cost, choose the one
2422: with the highest `rtx_cost' value as that has the potential of eliminating
2423: the most insns. For equal costs, we choose the first in the equivalence
2424: class. Note that we ignore the fact that pseudo registers are cheaper
2425: than hard registers here because we would also prefer the pseudo registers.
2426: */
2427:
2428: void
2429: find_best_addr (insn, loc)
2430: rtx insn;
2431: rtx *loc;
2432: {
2433: struct table_elt *elt, *p;
2434: rtx addr = *loc;
2435: int our_cost;
2436: int found_better = 1;
2437: int save_do_not_record = do_not_record;
2438: int save_hash_arg_in_memory = hash_arg_in_memory;
2439: int save_hash_arg_in_struct = hash_arg_in_struct;
2440: int hash_code;
2441: int addr_volatile;
2442: int regno;
2443:
2444: /* Do not try to replace constant addresses or addresses of local and
2445: argument slots. These MEM expressions are made only once and inserted
2446: in many instructions, as well as being used to control symbol table
2447: output. It is not safe to clobber them.
2448:
2449: There are some uncommon cases where the address is already in a register
2450: for some reason, but we cannot take advantage of that because we have
2451: no easy way to unshare the MEM. In addition, looking up all stack
2452: addresses is costly. */
2453: if ((GET_CODE (addr) == PLUS
2454: && GET_CODE (XEXP (addr, 0)) == REG
2455: && GET_CODE (XEXP (addr, 1)) == CONST_INT
2456: && (regno = REGNO (XEXP (addr, 0)),
2457: regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM))
2458: || (GET_CODE (addr) == REG
2459: && (regno = REGNO (addr),
2460: regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM))
2461: || CONSTANT_ADDRESS_P (addr))
2462: return;
2463:
2464: /* If this address is not simply a register, try to fold it. This will
2465: sometimes simplify the expression. Many simplifications
2466: will not be valid, but some, usually applying the associative rule, will
2467: be valid and produce better code. */
2468: if (GET_CODE (addr) != REG
2469: && validate_change (insn, loc, fold_rtx (addr, insn), 0))
2470: addr = *loc;
2471:
1.1.1.4 ! root 2472: /* If this address is not in the hash table, we can't look for equivalences
! 2473: of the whole address. Also, ignore if volatile. */
! 2474:
1.1 root 2475: do_not_record = 0;
2476: hash_code = HASH (addr, Pmode);
2477: addr_volatile = do_not_record;
2478: do_not_record = save_do_not_record;
2479: hash_arg_in_memory = save_hash_arg_in_memory;
2480: hash_arg_in_struct = save_hash_arg_in_struct;
2481:
2482: if (addr_volatile)
2483: return;
2484:
2485: elt = lookup (addr, hash_code, Pmode);
2486:
2487: #ifndef ADDRESS_COST
1.1.1.4 ! root 2488: if (elt)
! 2489: {
! 2490: our_cost = elt->cost;
1.1 root 2491:
1.1.1.4 ! root 2492: /* Find the lowest cost below ours that works. */
! 2493: for (elt = elt->first_same_value; elt; elt = elt->next_same_value)
! 2494: if (elt->cost < our_cost
! 2495: && (GET_CODE (elt->exp) == REG
! 2496: || exp_equiv_p (elt->exp, elt->exp, 1, 0))
! 2497: && validate_change (insn, loc,
! 2498: canon_reg (copy_rtx (elt->exp), NULL_RTX), 0))
! 2499: return;
! 2500: }
1.1 root 2501: #else
2502:
1.1.1.4 ! root 2503: if (elt)
! 2504: {
! 2505: /* We need to find the best (under the criteria documented above) entry
! 2506: in the class that is valid. We use the `flag' field to indicate
! 2507: choices that were invalid and iterate until we can't find a better
! 2508: one that hasn't already been tried. */
! 2509:
! 2510: for (p = elt->first_same_value; p; p = p->next_same_value)
! 2511: p->flag = 0;
1.1 root 2512:
1.1.1.4 ! root 2513: while (found_better)
! 2514: {
! 2515: int best_addr_cost = ADDRESS_COST (*loc);
! 2516: int best_rtx_cost = (elt->cost + 1) >> 1;
! 2517: struct table_elt *best_elt = elt;
! 2518:
! 2519: found_better = 0;
! 2520: for (p = elt->first_same_value; p; p = p->next_same_value)
! 2521: if (! p->flag
! 2522: && (GET_CODE (p->exp) == REG
! 2523: || exp_equiv_p (p->exp, p->exp, 1, 0))
! 2524: && (ADDRESS_COST (p->exp) < best_addr_cost
! 2525: || (ADDRESS_COST (p->exp) == best_addr_cost
! 2526: && (p->cost + 1) >> 1 > best_rtx_cost)))
! 2527: {
! 2528: found_better = 1;
! 2529: best_addr_cost = ADDRESS_COST (p->exp);
! 2530: best_rtx_cost = (p->cost + 1) >> 1;
! 2531: best_elt = p;
! 2532: }
1.1 root 2533:
1.1.1.4 ! root 2534: if (found_better)
! 2535: {
! 2536: if (validate_change (insn, loc,
! 2537: canon_reg (copy_rtx (best_elt->exp),
! 2538: NULL_RTX), 0))
! 2539: return;
! 2540: else
! 2541: best_elt->flag = 1;
! 2542: }
! 2543: }
! 2544: }
! 2545:
! 2546: /* If the address is a binary operation with the first operand a register
! 2547: and the second a constant, do the same as above, but looking for
! 2548: equivalences of the register. Then try to simplify before checking for
! 2549: the best address to use. This catches a few cases: First is when we
! 2550: have REG+const and the register is another REG+const. We can often merge
! 2551: the constants and eliminate one insn and one register. It may also be
! 2552: that a machine has a cheap REG+REG+const. Finally, this improves the
! 2553: code on the Alpha for unaligned byte stores. */
! 2554:
! 2555: if (flag_expensive_optimizations
! 2556: && (GET_RTX_CLASS (GET_CODE (*loc)) == '2'
! 2557: || GET_RTX_CLASS (GET_CODE (*loc)) == 'c')
! 2558: && GET_CODE (XEXP (*loc, 0)) == REG
! 2559: && GET_CODE (XEXP (*loc, 1)) == CONST_INT)
1.1 root 2560: {
1.1.1.4 ! root 2561: rtx c = XEXP (*loc, 1);
! 2562:
! 2563: do_not_record = 0;
! 2564: hash_code = HASH (XEXP (*loc, 0), Pmode);
! 2565: do_not_record = save_do_not_record;
! 2566: hash_arg_in_memory = save_hash_arg_in_memory;
! 2567: hash_arg_in_struct = save_hash_arg_in_struct;
! 2568:
! 2569: elt = lookup (XEXP (*loc, 0), hash_code, Pmode);
! 2570: if (elt == 0)
! 2571: return;
! 2572:
! 2573: /* We need to find the best (under the criteria documented above) entry
! 2574: in the class that is valid. We use the `flag' field to indicate
! 2575: choices that were invalid and iterate until we can't find a better
! 2576: one that hasn't already been tried. */
1.1 root 2577:
2578: for (p = elt->first_same_value; p; p = p->next_same_value)
1.1.1.4 ! root 2579: p->flag = 0;
1.1 root 2580:
1.1.1.4 ! root 2581: while (found_better)
1.1 root 2582: {
1.1.1.4 ! root 2583: int best_addr_cost = ADDRESS_COST (*loc);
! 2584: int best_rtx_cost = (COST (*loc) + 1) >> 1;
! 2585: struct table_elt *best_elt = elt;
! 2586: rtx best_rtx = *loc;
! 2587:
! 2588: found_better = 0;
! 2589: for (p = elt->first_same_value; p; p = p->next_same_value)
! 2590: if (! p->flag
! 2591: && (GET_CODE (p->exp) == REG
! 2592: || exp_equiv_p (p->exp, p->exp, 1, 0)))
! 2593: {
! 2594: rtx new = simplify_binary_operation (GET_CODE (*loc), Pmode,
! 2595: p->exp, c);
! 2596:
! 2597: if (new == 0)
! 2598: new = gen_rtx (GET_CODE (*loc), Pmode, p->exp, c);
! 2599:
! 2600: if ((ADDRESS_COST (new) < best_addr_cost
! 2601: || (ADDRESS_COST (new) == best_addr_cost
! 2602: && (COST (new) + 1) >> 1 > best_rtx_cost)))
! 2603: {
! 2604: found_better = 1;
! 2605: best_addr_cost = ADDRESS_COST (new);
! 2606: best_rtx_cost = (COST (new) + 1) >> 1;
! 2607: best_elt = p;
! 2608: best_rtx = new;
! 2609: }
! 2610: }
! 2611:
! 2612: if (found_better)
! 2613: {
! 2614: if (validate_change (insn, loc,
! 2615: canon_reg (copy_rtx (best_rtx),
! 2616: NULL_RTX), 0))
! 2617: return;
! 2618: else
! 2619: best_elt->flag = 1;
! 2620: }
1.1 root 2621: }
2622: }
2623: #endif
2624: }
2625:
2626: /* Given an operation (CODE, *PARG1, *PARG2), where code is a comparison
2627: operation (EQ, NE, GT, etc.), follow it back through the hash table and
2628: what values are being compared.
2629:
2630: *PARG1 and *PARG2 are updated to contain the rtx representing the values
2631: actually being compared. For example, if *PARG1 was (cc0) and *PARG2
2632: was (const_int 0), *PARG1 and *PARG2 will be set to the objects that were
2633: compared to produce cc0.
2634:
2635: The return value is the comparison operator and is either the code of
2636: A or the code corresponding to the inverse of the comparison. */
2637:
2638: static enum rtx_code
1.1.1.4 ! root 2639: find_comparison_args (code, parg1, parg2, pmode1, pmode2)
1.1 root 2640: enum rtx_code code;
2641: rtx *parg1, *parg2;
1.1.1.4 ! root 2642: enum machine_mode *pmode1, *pmode2;
1.1 root 2643: {
2644: rtx arg1, arg2;
2645:
2646: arg1 = *parg1, arg2 = *parg2;
2647:
2648: /* If ARG2 is const0_rtx, see what ARG1 is equivalent to. */
2649:
1.1.1.4 ! root 2650: while (arg2 == CONST0_RTX (GET_MODE (arg1)))
1.1 root 2651: {
2652: /* Set non-zero when we find something of interest. */
2653: rtx x = 0;
2654: int reverse_code = 0;
2655: struct table_elt *p = 0;
2656:
2657: /* If arg1 is a COMPARE, extract the comparison arguments from it.
2658: On machines with CC0, this is the only case that can occur, since
2659: fold_rtx will return the COMPARE or item being compared with zero
2660: when given CC0. */
2661:
2662: if (GET_CODE (arg1) == COMPARE && arg2 == const0_rtx)
2663: x = arg1;
2664:
2665: /* If ARG1 is a comparison operator and CODE is testing for
2666: STORE_FLAG_VALUE, get the inner arguments. */
2667:
2668: else if (GET_RTX_CLASS (GET_CODE (arg1)) == '<')
2669: {
1.1.1.4 ! root 2670: if (code == NE
! 2671: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
! 2672: && code == LT && STORE_FLAG_VALUE == -1)
! 2673: #ifdef FLOAT_STORE_FLAG_VALUE
! 2674: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
! 2675: && FLOAT_STORE_FLAG_VALUE < 0)
! 2676: #endif
! 2677: )
1.1 root 2678: x = arg1;
1.1.1.4 ! root 2679: else if (code == EQ
! 2680: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
! 2681: && code == GE && STORE_FLAG_VALUE == -1)
! 2682: #ifdef FLOAT_STORE_FLAG_VALUE
! 2683: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
! 2684: && FLOAT_STORE_FLAG_VALUE < 0)
! 2685: #endif
! 2686: )
1.1 root 2687: x = arg1, reverse_code = 1;
2688: }
2689:
2690: /* ??? We could also check for
2691:
2692: (ne (and (eq (...) (const_int 1))) (const_int 0))
2693:
2694: and related forms, but let's wait until we see them occurring. */
2695:
2696: if (x == 0)
2697: /* Look up ARG1 in the hash table and see if it has an equivalence
2698: that lets us see what is being compared. */
2699: p = lookup (arg1, safe_hash (arg1, GET_MODE (arg1)) % NBUCKETS,
2700: GET_MODE (arg1));
2701: if (p) p = p->first_same_value;
2702:
2703: for (; p; p = p->next_same_value)
2704: {
2705: enum machine_mode inner_mode = GET_MODE (p->exp);
2706:
2707: /* If the entry isn't valid, skip it. */
2708: if (! exp_equiv_p (p->exp, p->exp, 1, 0))
2709: continue;
2710:
2711: if (GET_CODE (p->exp) == COMPARE
2712: /* Another possibility is that this machine has a compare insn
2713: that includes the comparison code. In that case, ARG1 would
2714: be equivalent to a comparison operation that would set ARG1 to
2715: either STORE_FLAG_VALUE or zero. If this is an NE operation,
2716: ORIG_CODE is the actual comparison being done; if it is an EQ,
2717: we must reverse ORIG_CODE. On machine with a negative value
2718: for STORE_FLAG_VALUE, also look at LT and GE operations. */
2719: || ((code == NE
2720: || (code == LT
1.1.1.4 ! root 2721: && GET_MODE_CLASS (inner_mode) == MODE_INT
! 2722: && (GET_MODE_BITSIZE (inner_mode)
! 2723: <= HOST_BITS_PER_WIDE_INT)
1.1 root 2724: && (STORE_FLAG_VALUE
1.1.1.4 ! root 2725: & ((HOST_WIDE_INT) 1
! 2726: << (GET_MODE_BITSIZE (inner_mode) - 1))))
! 2727: #ifdef FLOAT_STORE_FLAG_VALUE
! 2728: || (code == LT
! 2729: && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
! 2730: && FLOAT_STORE_FLAG_VALUE < 0)
! 2731: #endif
! 2732: )
1.1 root 2733: && GET_RTX_CLASS (GET_CODE (p->exp)) == '<'))
2734: {
2735: x = p->exp;
2736: break;
2737: }
2738: else if ((code == EQ
2739: || (code == GE
1.1.1.4 ! root 2740: && GET_MODE_CLASS (inner_mode) == MODE_INT
! 2741: && (GET_MODE_BITSIZE (inner_mode)
! 2742: <= HOST_BITS_PER_WIDE_INT)
1.1 root 2743: && (STORE_FLAG_VALUE
1.1.1.4 ! root 2744: & ((HOST_WIDE_INT) 1
! 2745: << (GET_MODE_BITSIZE (inner_mode) - 1))))
! 2746: #ifdef FLOAT_STORE_FLAG_VALUE
! 2747: || (code == GE
! 2748: && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
! 2749: && FLOAT_STORE_FLAG_VALUE < 0)
! 2750: #endif
! 2751: )
1.1 root 2752: && GET_RTX_CLASS (GET_CODE (p->exp)) == '<')
2753: {
2754: reverse_code = 1;
2755: x = p->exp;
2756: break;
2757: }
2758:
2759: /* If this is fp + constant, the equivalent is a better operand since
2760: it may let us predict the value of the comparison. */
2761: else if (NONZERO_BASE_PLUS_P (p->exp))
2762: {
2763: arg1 = p->exp;
2764: continue;
2765: }
2766: }
2767:
2768: /* If we didn't find a useful equivalence for ARG1, we are done.
2769: Otherwise, set up for the next iteration. */
2770: if (x == 0)
2771: break;
2772:
2773: arg1 = XEXP (x, 0), arg2 = XEXP (x, 1);
2774: if (GET_RTX_CLASS (GET_CODE (x)) == '<')
2775: code = GET_CODE (x);
2776:
2777: if (reverse_code)
2778: code = reverse_condition (code);
2779: }
2780:
1.1.1.4 ! root 2781: /* Return our results. Return the modes from before fold_rtx
! 2782: because fold_rtx might produce const_int, and then it's too late. */
! 2783: *pmode1 = GET_MODE (arg1), *pmode2 = GET_MODE (arg2);
1.1 root 2784: *parg1 = fold_rtx (arg1, 0), *parg2 = fold_rtx (arg2, 0);
2785:
2786: return code;
2787: }
2788:
2789: /* Try to simplify a unary operation CODE whose output mode is to be
2790: MODE with input operand OP whose mode was originally OP_MODE.
2791: Return zero if no simplification can be made. */
2792:
2793: rtx
2794: simplify_unary_operation (code, mode, op, op_mode)
2795: enum rtx_code code;
2796: enum machine_mode mode;
2797: rtx op;
2798: enum machine_mode op_mode;
2799: {
2800: register int width = GET_MODE_BITSIZE (mode);
2801:
2802: /* The order of these tests is critical so that, for example, we don't
2803: check the wrong mode (input vs. output) for a conversion operation,
2804: such as FIX. At some point, this should be simplified. */
2805:
2806: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2807: if (code == FLOAT && GET_CODE (op) == CONST_INT)
2808: {
2809: REAL_VALUE_TYPE d;
2810:
2811: #ifdef REAL_ARITHMETIC
2812: REAL_VALUE_FROM_INT (d, INTVAL (op), INTVAL (op) < 0 ? ~0 : 0);
2813: #else
2814: d = (double) INTVAL (op);
2815: #endif
2816: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2817: }
2818: else if (code == UNSIGNED_FLOAT && GET_CODE (op) == CONST_INT)
2819: {
2820: REAL_VALUE_TYPE d;
2821:
2822: #ifdef REAL_ARITHMETIC
2823: REAL_VALUE_FROM_INT (d, INTVAL (op), 0);
2824: #else
2825: d = (double) (unsigned int) INTVAL (op);
2826: #endif
2827: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2828: }
2829:
2830: else if (code == FLOAT && GET_CODE (op) == CONST_DOUBLE
2831: && GET_MODE (op) == VOIDmode)
2832: {
2833: REAL_VALUE_TYPE d;
2834:
2835: #ifdef REAL_ARITHMETIC
2836: REAL_VALUE_FROM_INT (d, CONST_DOUBLE_LOW (op), CONST_DOUBLE_HIGH (op));
2837: #else
2838: if (CONST_DOUBLE_HIGH (op) < 0)
2839: {
2840: d = (double) (~ CONST_DOUBLE_HIGH (op));
1.1.1.4 ! root 2841: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
! 2842: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
! 2843: d += (double) (unsigned HOST_WIDE_INT) (~ CONST_DOUBLE_LOW (op));
1.1 root 2844: d = (- d - 1.0);
2845: }
2846: else
2847: {
2848: d = (double) CONST_DOUBLE_HIGH (op);
1.1.1.4 ! root 2849: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
! 2850: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
! 2851: d += (double) (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (op);
1.1 root 2852: }
2853: #endif /* REAL_ARITHMETIC */
2854: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2855: }
2856: else if (code == UNSIGNED_FLOAT && GET_CODE (op) == CONST_DOUBLE
2857: && GET_MODE (op) == VOIDmode)
2858: {
2859: REAL_VALUE_TYPE d;
2860:
2861: #ifdef REAL_ARITHMETIC
2862: REAL_VALUE_FROM_UNSIGNED_INT (d, CONST_DOUBLE_LOW (op),
2863: CONST_DOUBLE_HIGH (op));
2864: #else
2865: d = (double) CONST_DOUBLE_HIGH (op);
1.1.1.4 ! root 2866: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
! 2867: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
! 2868: d += (double) (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (op);
1.1 root 2869: #endif /* REAL_ARITHMETIC */
2870: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2871: }
2872: #endif
2873:
1.1.1.4 ! root 2874: if (GET_CODE (op) == CONST_INT
! 2875: && width <= HOST_BITS_PER_WIDE_INT && width > 0)
1.1 root 2876: {
1.1.1.4 ! root 2877: register HOST_WIDE_INT arg0 = INTVAL (op);
! 2878: register HOST_WIDE_INT val;
1.1 root 2879:
2880: switch (code)
2881: {
2882: case NOT:
2883: val = ~ arg0;
2884: break;
2885:
2886: case NEG:
2887: val = - arg0;
2888: break;
2889:
2890: case ABS:
2891: val = (arg0 >= 0 ? arg0 : - arg0);
2892: break;
2893:
2894: case FFS:
2895: /* Don't use ffs here. Instead, get low order bit and then its
2896: number. If arg0 is zero, this will return 0, as desired. */
2897: arg0 &= GET_MODE_MASK (mode);
2898: val = exact_log2 (arg0 & (- arg0)) + 1;
2899: break;
2900:
2901: case TRUNCATE:
2902: val = arg0;
2903: break;
2904:
2905: case ZERO_EXTEND:
2906: if (op_mode == VOIDmode)
2907: op_mode = mode;
1.1.1.4 ! root 2908: if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
! 2909: {
! 2910: /* If we were really extending the mode,
! 2911: we would have to distinguish between zero-extension
! 2912: and sign-extension. */
! 2913: if (width != GET_MODE_BITSIZE (op_mode))
! 2914: abort ();
! 2915: val = arg0;
! 2916: }
! 2917: else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
! 2918: val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
1.1 root 2919: else
2920: return 0;
2921: break;
2922:
2923: case SIGN_EXTEND:
2924: if (op_mode == VOIDmode)
2925: op_mode = mode;
1.1.1.4 ! root 2926: if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
! 2927: {
! 2928: /* If we were really extending the mode,
! 2929: we would have to distinguish between zero-extension
! 2930: and sign-extension. */
! 2931: if (width != GET_MODE_BITSIZE (op_mode))
! 2932: abort ();
! 2933: val = arg0;
! 2934: }
! 2935: else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
! 2936: {
! 2937: val
! 2938: = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
! 2939: if (val
! 2940: & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1)))
! 2941: val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
1.1 root 2942: }
2943: else
2944: return 0;
2945: break;
2946:
1.1.1.2 root 2947: case SQRT:
2948: return 0;
2949:
1.1 root 2950: default:
2951: abort ();
2952: }
2953:
2954: /* Clear the bits that don't belong in our mode,
2955: unless they and our sign bit are all one.
2956: So we get either a reasonable negative value or a reasonable
2957: unsigned value for this mode. */
1.1.1.4 ! root 2958: if (width < HOST_BITS_PER_WIDE_INT
! 2959: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
! 2960: != ((HOST_WIDE_INT) (-1) << (width - 1))))
1.1 root 2961: val &= (1 << width) - 1;
2962:
1.1.1.4 ! root 2963: return GEN_INT (val);
1.1 root 2964: }
2965:
2966: /* We can do some operations on integer CONST_DOUBLEs. Also allow
2967: for a DImode operation on a CONST_INT. */
2968: else if (GET_MODE (op) == VOIDmode
2969: && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
2970: {
1.1.1.4 ! root 2971: HOST_WIDE_INT l1, h1, lv, hv;
1.1 root 2972:
2973: if (GET_CODE (op) == CONST_DOUBLE)
2974: l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
2975: else
2976: l1 = INTVAL (op), h1 = l1 < 0 ? -1 : 0;
2977:
2978: switch (code)
2979: {
2980: case NOT:
2981: lv = ~ l1;
2982: hv = ~ h1;
2983: break;
2984:
2985: case NEG:
2986: neg_double (l1, h1, &lv, &hv);
2987: break;
2988:
2989: case ABS:
2990: if (h1 < 0)
2991: neg_double (l1, h1, &lv, &hv);
2992: else
2993: lv = l1, hv = h1;
2994: break;
2995:
2996: case FFS:
2997: hv = 0;
2998: if (l1 == 0)
1.1.1.4 ! root 2999: lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & (-h1)) + 1;
1.1 root 3000: else
3001: lv = exact_log2 (l1 & (-l1)) + 1;
3002: break;
3003:
3004: case TRUNCATE:
1.1.1.4 ! root 3005: if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
! 3006: return GEN_INT (l1 & GET_MODE_MASK (mode));
1.1 root 3007: else
3008: return 0;
3009: break;
3010:
1.1.1.4 ! root 3011: case ZERO_EXTEND:
! 3012: if (op_mode == VOIDmode
! 3013: || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
! 3014: return 0;
! 3015:
! 3016: hv = 0;
! 3017: lv = l1 & GET_MODE_MASK (op_mode);
! 3018: break;
! 3019:
! 3020: case SIGN_EXTEND:
! 3021: if (op_mode == VOIDmode
! 3022: || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
! 3023: return 0;
! 3024: else
! 3025: {
! 3026: lv = l1 & GET_MODE_MASK (op_mode);
! 3027: if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
! 3028: && (lv & ((HOST_WIDE_INT) 1
! 3029: << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
! 3030: lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
! 3031:
! 3032: hv = (lv < 0) ? ~ (HOST_WIDE_INT) 0 : 0;
! 3033: }
! 3034: break;
! 3035:
1.1.1.2 root 3036: case SQRT:
3037: return 0;
3038:
1.1 root 3039: default:
3040: return 0;
3041: }
3042:
3043: return immed_double_const (lv, hv, mode);
3044: }
3045:
3046: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3047: else if (GET_CODE (op) == CONST_DOUBLE
3048: && GET_MODE_CLASS (mode) == MODE_FLOAT)
3049: {
3050: REAL_VALUE_TYPE d;
3051: jmp_buf handler;
3052: rtx x;
3053:
3054: if (setjmp (handler))
3055: /* There used to be a warning here, but that is inadvisable.
3056: People may want to cause traps, and the natural way
3057: to do it should not get a warning. */
3058: return 0;
3059:
3060: set_float_handler (handler);
3061:
3062: REAL_VALUE_FROM_CONST_DOUBLE (d, op);
3063:
3064: switch (code)
3065: {
3066: case NEG:
3067: d = REAL_VALUE_NEGATE (d);
3068: break;
3069:
3070: case ABS:
1.1.1.3 root 3071: if (REAL_VALUE_NEGATIVE (d))
1.1 root 3072: d = REAL_VALUE_NEGATE (d);
3073: break;
3074:
3075: case FLOAT_TRUNCATE:
1.1.1.4 ! root 3076: d = (double) real_value_truncate (mode, d);
1.1 root 3077: break;
3078:
3079: case FLOAT_EXTEND:
3080: /* All this does is change the mode. */
3081: break;
3082:
3083: case FIX:
3084: d = (double) REAL_VALUE_FIX_TRUNCATE (d);
3085: break;
3086:
3087: case UNSIGNED_FIX:
3088: d = (double) REAL_VALUE_UNSIGNED_FIX_TRUNCATE (d);
3089: break;
3090:
1.1.1.2 root 3091: case SQRT:
3092: return 0;
3093:
1.1 root 3094: default:
3095: abort ();
3096: }
3097:
3098: x = immed_real_const_1 (d, mode);
1.1.1.4 ! root 3099: set_float_handler (NULL_PTR);
1.1 root 3100: return x;
3101: }
3102: else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE_CLASS (mode) == MODE_INT
1.1.1.4 ! root 3103: && width <= HOST_BITS_PER_WIDE_INT && width > 0)
1.1 root 3104: {
3105: REAL_VALUE_TYPE d;
3106: jmp_buf handler;
3107: rtx x;
1.1.1.4 ! root 3108: HOST_WIDE_INT val;
1.1 root 3109:
3110: if (setjmp (handler))
3111: return 0;
3112:
3113: set_float_handler (handler);
3114:
3115: REAL_VALUE_FROM_CONST_DOUBLE (d, op);
3116:
3117: switch (code)
3118: {
3119: case FIX:
3120: val = REAL_VALUE_FIX (d);
3121: break;
3122:
3123: case UNSIGNED_FIX:
3124: val = REAL_VALUE_UNSIGNED_FIX (d);
3125: break;
3126:
3127: default:
3128: abort ();
3129: }
3130:
1.1.1.4 ! root 3131: set_float_handler (NULL_PTR);
1.1 root 3132:
3133: /* Clear the bits that don't belong in our mode,
3134: unless they and our sign bit are all one.
3135: So we get either a reasonable negative value or a reasonable
3136: unsigned value for this mode. */
1.1.1.4 ! root 3137: if (width < HOST_BITS_PER_WIDE_INT
! 3138: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
! 3139: != ((HOST_WIDE_INT) (-1) << (width - 1))))
! 3140: val &= ((HOST_WIDE_INT) 1 << width) - 1;
1.1 root 3141:
1.1.1.4 ! root 3142: return GEN_INT (val);
1.1 root 3143: }
3144: #endif
1.1.1.3 root 3145: /* This was formerly used only for non-IEEE float.
3146: [email protected] says it is safe for IEEE also. */
3147: else
1.1 root 3148: {
3149: /* There are some simplifications we can do even if the operands
1.1.1.3 root 3150: aren't constant. */
1.1 root 3151: switch (code)
3152: {
3153: case NEG:
3154: case NOT:
3155: /* (not (not X)) == X, similarly for NEG. */
3156: if (GET_CODE (op) == code)
3157: return XEXP (op, 0);
3158: break;
3159:
3160: case SIGN_EXTEND:
3161: /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
3162: becomes just the MINUS if its mode is MODE. This allows
3163: folding switch statements on machines using casesi (such as
3164: the Vax). */
3165: if (GET_CODE (op) == TRUNCATE
3166: && GET_MODE (XEXP (op, 0)) == mode
3167: && GET_CODE (XEXP (op, 0)) == MINUS
3168: && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
3169: && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
3170: return XEXP (op, 0);
3171: break;
3172: }
3173:
3174: return 0;
3175: }
3176: }
3177:
3178: /* Simplify a binary operation CODE with result mode MODE, operating on OP0
3179: and OP1. Return 0 if no simplification is possible.
3180:
3181: Don't use this for relational operations such as EQ or LT.
3182: Use simplify_relational_operation instead. */
3183:
3184: rtx
3185: simplify_binary_operation (code, mode, op0, op1)
3186: enum rtx_code code;
3187: enum machine_mode mode;
3188: rtx op0, op1;
3189: {
1.1.1.4 ! root 3190: register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
! 3191: HOST_WIDE_INT val;
1.1 root 3192: int width = GET_MODE_BITSIZE (mode);
3193:
3194: /* Relational operations don't work here. We must know the mode
3195: of the operands in order to do the comparison correctly.
3196: Assuming a full word can give incorrect results.
3197: Consider comparing 128 with -128 in QImode. */
3198:
3199: if (GET_RTX_CLASS (code) == '<')
3200: abort ();
3201:
3202: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3203: if (GET_MODE_CLASS (mode) == MODE_FLOAT
3204: && GET_CODE (op0) == CONST_DOUBLE && GET_CODE (op1) == CONST_DOUBLE
3205: && mode == GET_MODE (op0) && mode == GET_MODE (op1))
3206: {
3207: REAL_VALUE_TYPE f0, f1, value;
3208: jmp_buf handler;
3209:
3210: if (setjmp (handler))
3211: return 0;
3212:
3213: set_float_handler (handler);
3214:
3215: REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
3216: REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
1.1.1.4 ! root 3217: f0 = real_value_truncate (mode, f0);
! 3218: f1 = real_value_truncate (mode, f1);
1.1 root 3219:
3220: #ifdef REAL_ARITHMETIC
3221: REAL_ARITHMETIC (value, code, f0, f1);
3222: #else
3223: switch (code)
3224: {
3225: case PLUS:
3226: value = f0 + f1;
3227: break;
3228: case MINUS:
3229: value = f0 - f1;
3230: break;
3231: case MULT:
3232: value = f0 * f1;
3233: break;
3234: case DIV:
3235: #ifndef REAL_INFINITY
3236: if (f1 == 0)
1.1.1.4 ! root 3237: return 0;
1.1 root 3238: #endif
3239: value = f0 / f1;
3240: break;
3241: case SMIN:
3242: value = MIN (f0, f1);
3243: break;
3244: case SMAX:
3245: value = MAX (f0, f1);
3246: break;
3247: default:
3248: abort ();
3249: }
3250: #endif
3251:
1.1.1.4 ! root 3252: set_float_handler (NULL_PTR);
! 3253: value = real_value_truncate (mode, value);
1.1 root 3254: return immed_real_const_1 (value, mode);
3255: }
3256:
3257: /* We can fold some multi-word operations. */
3258: else if (GET_MODE_CLASS (mode) == MODE_INT
3259: && GET_CODE (op0) == CONST_DOUBLE
3260: && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
3261: {
1.1.1.4 ! root 3262: HOST_WIDE_INT l1, l2, h1, h2, lv, hv;
1.1 root 3263:
3264: l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
3265:
3266: if (GET_CODE (op1) == CONST_DOUBLE)
3267: l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1);
3268: else
3269: l2 = INTVAL (op1), h2 = l2 < 0 ? -1 : 0;
3270:
3271: switch (code)
3272: {
3273: case MINUS:
3274: /* A - B == A + (-B). */
3275: neg_double (l2, h2, &lv, &hv);
3276: l2 = lv, h2 = hv;
3277:
3278: /* .. fall through ... */
3279:
3280: case PLUS:
3281: add_double (l1, h1, l2, h2, &lv, &hv);
3282: break;
3283:
3284: case MULT:
3285: mul_double (l1, h1, l2, h2, &lv, &hv);
3286: break;
3287:
3288: case DIV: case MOD: case UDIV: case UMOD:
3289: /* We'd need to include tree.h to do this and it doesn't seem worth
3290: it. */
3291: return 0;
3292:
3293: case AND:
3294: lv = l1 & l2, hv = h1 & h2;
3295: break;
3296:
3297: case IOR:
3298: lv = l1 | l2, hv = h1 | h2;
3299: break;
3300:
3301: case XOR:
3302: lv = l1 ^ l2, hv = h1 ^ h2;
3303: break;
3304:
3305: case SMIN:
1.1.1.4 ! root 3306: if (h1 < h2
! 3307: || (h1 == h2
! 3308: && ((unsigned HOST_WIDE_INT) l1
! 3309: < (unsigned HOST_WIDE_INT) l2)))
1.1 root 3310: lv = l1, hv = h1;
3311: else
3312: lv = l2, hv = h2;
3313: break;
3314:
3315: case SMAX:
1.1.1.4 ! root 3316: if (h1 > h2
! 3317: || (h1 == h2
! 3318: && ((unsigned HOST_WIDE_INT) l1
! 3319: > (unsigned HOST_WIDE_INT) l2)))
1.1 root 3320: lv = l1, hv = h1;
3321: else
3322: lv = l2, hv = h2;
3323: break;
3324:
3325: case UMIN:
1.1.1.4 ! root 3326: if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
! 3327: || (h1 == h2
! 3328: && ((unsigned HOST_WIDE_INT) l1
! 3329: < (unsigned HOST_WIDE_INT) l2)))
1.1 root 3330: lv = l1, hv = h1;
3331: else
3332: lv = l2, hv = h2;
3333: break;
3334:
3335: case UMAX:
1.1.1.4 ! root 3336: if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
! 3337: || (h1 == h2
! 3338: && ((unsigned HOST_WIDE_INT) l1
! 3339: > (unsigned HOST_WIDE_INT) l2)))
1.1 root 3340: lv = l1, hv = h1;
3341: else
3342: lv = l2, hv = h2;
3343: break;
3344:
3345: case LSHIFTRT: case ASHIFTRT:
3346: case ASHIFT: case LSHIFT:
3347: case ROTATE: case ROTATERT:
3348: #ifdef SHIFT_COUNT_TRUNCATED
3349: l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
3350: #endif
3351:
3352: if (h2 != 0 || l2 < 0 || l2 >= GET_MODE_BITSIZE (mode))
3353: return 0;
3354:
3355: if (code == LSHIFTRT || code == ASHIFTRT)
3356: rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
3357: code == ASHIFTRT);
3358: else if (code == ASHIFT || code == LSHIFT)
3359: lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
3360: code == ASHIFT);
3361: else if (code == ROTATE)
3362: lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3363: else /* code == ROTATERT */
3364: rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3365: break;
3366:
3367: default:
3368: return 0;
3369: }
3370:
3371: return immed_double_const (lv, hv, mode);
3372: }
3373: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3374:
3375: if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
1.1.1.4 ! root 3376: || width > HOST_BITS_PER_WIDE_INT || width == 0)
1.1 root 3377: {
3378: /* Even if we can't compute a constant result,
3379: there are some cases worth simplifying. */
3380:
3381: switch (code)
3382: {
3383: case PLUS:
3384: /* In IEEE floating point, x+0 is not the same as x. Similarly
3385: for the other optimizations below. */
3386: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3387: && GET_MODE_CLASS (mode) != MODE_INT)
3388: break;
3389:
3390: if (op1 == CONST0_RTX (mode))
3391: return op0;
3392:
3393: /* Strip off any surrounding CONSTs. They don't matter in any of
3394: the cases below. */
3395: if (GET_CODE (op0) == CONST)
3396: op0 = XEXP (op0, 0);
3397: if (GET_CODE (op1) == CONST)
3398: op1 = XEXP (op1, 0);
3399:
3400: /* ((-a) + b) -> (b - a) and similarly for (a + (-b)) */
3401: if (GET_CODE (op0) == NEG)
3402: {
3403: rtx tem = simplify_binary_operation (MINUS, mode,
3404: op1, XEXP (op0, 0));
3405: return tem ? tem : gen_rtx (MINUS, mode, op1, XEXP (op0, 0));
3406: }
3407: else if (GET_CODE (op1) == NEG)
3408: {
3409: rtx tem = simplify_binary_operation (MINUS, mode,
3410: op0, XEXP (op1, 0));
3411: return tem ? tem : gen_rtx (MINUS, mode, op0, XEXP (op1, 0));
3412: }
3413:
3414: /* Don't use the associative law for floating point.
3415: The inaccuracy makes it nonassociative,
3416: and subtle programs can break if operations are associated. */
3417: if (GET_MODE_CLASS (mode) != MODE_INT)
3418: break;
3419:
3420: /* (a - b) + b -> a, similarly a + (b - a) -> a */
3421: if (GET_CODE (op0) == MINUS
3422: && rtx_equal_p (XEXP (op0, 1), op1) && ! side_effects_p (op1))
3423: return XEXP (op0, 0);
3424:
3425: if (GET_CODE (op1) == MINUS
3426: && rtx_equal_p (XEXP (op1, 1), op0) && ! side_effects_p (op0))
3427: return XEXP (op1, 0);
3428:
3429: /* (c1 - a) + c2 becomes (c1 + c2) - a. */
3430: if (GET_CODE (op1) == CONST_INT && GET_CODE (op0) == MINUS
3431: && GET_CODE (XEXP (op0, 0)) == CONST_INT)
3432: {
3433: rtx tem = simplify_binary_operation (PLUS, mode, op1,
3434: XEXP (op0, 0));
3435:
3436: return tem ? gen_rtx (MINUS, mode, tem, XEXP (op0, 1)) : 0;
3437: }
3438:
3439: /* Handle both-operands-constant cases. */
3440: if (CONSTANT_P (op0) && CONSTANT_P (op1)
3441: && GET_CODE (op0) != CONST_DOUBLE
3442: && GET_CODE (op1) != CONST_DOUBLE
3443: && GET_MODE_CLASS (mode) == MODE_INT)
3444: {
3445: if (GET_CODE (op1) == CONST_INT)
3446: return plus_constant (op0, INTVAL (op1));
3447: else if (GET_CODE (op0) == CONST_INT)
3448: return plus_constant (op1, INTVAL (op0));
3449: else
1.1.1.4 ! root 3450: break;
! 3451: #if 0 /* No good, because this can produce the sum of two relocatable
! 3452: symbols, in an assembler instruction. Most UNIX assemblers can't
! 3453: handle that. */
! 3454: else
1.1 root 3455: return gen_rtx (CONST, mode,
3456: gen_rtx (PLUS, mode,
3457: GET_CODE (op0) == CONST
3458: ? XEXP (op0, 0) : op0,
3459: GET_CODE (op1) == CONST
3460: ? XEXP (op1, 0) : op1));
1.1.1.4 ! root 3461: #endif
1.1 root 3462: }
3463: else if (GET_CODE (op1) == CONST_INT
3464: && GET_CODE (op0) == PLUS
3465: && (CONSTANT_P (XEXP (op0, 0))
3466: || CONSTANT_P (XEXP (op0, 1))))
3467: /* constant + (variable + constant)
3468: can result if an index register is made constant.
3469: We simplify this by adding the constants.
3470: If we did not, it would become an invalid address. */
3471: return plus_constant (op0, INTVAL (op1));
3472: break;
3473:
3474: case COMPARE:
3475: #ifdef HAVE_cc0
3476: /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
3477: using cc0, in which case we want to leave it as a COMPARE
3478: so we can distinguish it from a register-register-copy.
3479:
3480: In IEEE floating point, x-0 is not the same as x. */
3481:
3482: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3483: || GET_MODE_CLASS (mode) == MODE_INT)
3484: && op1 == CONST0_RTX (mode))
3485: return op0;
3486: #else
3487: /* Do nothing here. */
3488: #endif
3489: break;
3490:
3491: case MINUS:
1.1.1.3 root 3492: /* None of these optimizations can be done for IEEE
3493: floating point. */
3494: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3495: && GET_MODE_CLASS (mode) != MODE_INT)
3496: break;
3497:
3498: /* We can't assume x-x is 0 even with non-IEEE floating point. */
1.1 root 3499: if (rtx_equal_p (op0, op1)
3500: && ! side_effects_p (op0)
3501: && GET_MODE_CLASS (mode) != MODE_FLOAT)
3502: return const0_rtx;
3503:
3504: /* Change subtraction from zero into negation. */
3505: if (op0 == CONST0_RTX (mode))
3506: return gen_rtx (NEG, mode, op1);
3507:
3508: /* Subtracting 0 has no effect. */
3509: if (op1 == CONST0_RTX (mode))
3510: return op0;
3511:
3512: /* Strip off any surrounding CONSTs. They don't matter in any of
3513: the cases below. */
3514: if (GET_CODE (op0) == CONST)
3515: op0 = XEXP (op0, 0);
3516: if (GET_CODE (op1) == CONST)
3517: op1 = XEXP (op1, 0);
3518:
3519: /* (a - (-b)) -> (a + b). */
3520: if (GET_CODE (op1) == NEG)
3521: {
3522: rtx tem = simplify_binary_operation (PLUS, mode,
3523: op0, XEXP (op1, 0));
3524: return tem ? tem : gen_rtx (PLUS, mode, op0, XEXP (op1, 0));
3525: }
3526:
3527: /* Don't use the associative law for floating point.
3528: The inaccuracy makes it nonassociative,
3529: and subtle programs can break if operations are associated. */
3530: if (GET_MODE_CLASS (mode) != MODE_INT)
3531: break;
3532:
3533: /* (a + b) - a -> b, and (b - (a + b)) -> -a */
3534: if (GET_CODE (op0) == PLUS
3535: && rtx_equal_p (XEXP (op0, 0), op1)
3536: && ! side_effects_p (op1))
3537: return XEXP (op0, 1);
3538: else if (GET_CODE (op0) == PLUS
3539: && rtx_equal_p (XEXP (op0, 1), op1)
3540: && ! side_effects_p (op1))
3541: return XEXP (op0, 0);
3542:
3543: if (GET_CODE (op1) == PLUS
3544: && rtx_equal_p (XEXP (op1, 0), op0)
3545: && ! side_effects_p (op0))
3546: {
3547: rtx tem = simplify_unary_operation (NEG, mode, XEXP (op1, 1),
3548: mode);
3549:
3550: return tem ? tem : gen_rtx (NEG, mode, XEXP (op1, 1));
3551: }
3552: else if (GET_CODE (op1) == PLUS
3553: && rtx_equal_p (XEXP (op1, 1), op0)
3554: && ! side_effects_p (op0))
3555: {
3556: rtx tem = simplify_unary_operation (NEG, mode, XEXP (op1, 0),
3557: mode);
3558:
3559: return tem ? tem : gen_rtx (NEG, mode, XEXP (op1, 0));
3560: }
3561:
3562: /* a - (a - b) -> b */
3563: if (GET_CODE (op1) == MINUS && rtx_equal_p (op0, XEXP (op1, 0))
3564: && ! side_effects_p (op0))
3565: return XEXP (op1, 1);
3566:
3567: /* (a +/- b) - (a +/- c) can be simplified. Do variants of
3568: this involving commutativity. The most common case is
3569: (a + C1) - (a + C2), but it's not hard to do all the cases. */
3570: if ((GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS)
3571: && (GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS))
3572: {
3573: rtx lhs0 = XEXP (op0, 0), lhs1 = XEXP (op0, 1);
3574: rtx rhs0 = XEXP (op1, 0), rhs1 = XEXP (op1, 1);
3575: int lhs_neg = GET_CODE (op0) == MINUS;
3576: int rhs_neg = GET_CODE (op1) == MINUS;
3577: rtx lhs = 0, rhs = 0;
3578:
3579: /* Set LHS and RHS to the two different terms. */
3580: if (rtx_equal_p (lhs0, rhs0) && ! side_effects_p (lhs0))
3581: lhs = lhs1, rhs = rhs1;
3582: else if (! rhs_neg && rtx_equal_p (lhs0, rhs1)
3583: && ! side_effects_p (lhs0))
3584: lhs = lhs1, rhs = rhs0;
3585: else if (! lhs_neg && rtx_equal_p (lhs1, rhs0)
3586: && ! side_effects_p (lhs1))
3587: lhs = lhs0, rhs = rhs1;
3588: else if (! lhs_neg && ! rhs_neg && rtx_equal_p (lhs1, rhs1)
3589: && ! side_effects_p (lhs1))
3590: lhs = lhs0, rhs = rhs0;
3591:
3592: /* The RHS is the operand of a MINUS, so its negation
3593: status should be complemented. */
3594: rhs_neg = ! rhs_neg;
3595:
3596: /* If we found two values equal, form the sum or difference
3597: of the remaining two terms. */
3598: if (lhs)
3599: {
3600: rtx tem = simplify_binary_operation (lhs_neg == rhs_neg
3601: ? PLUS : MINUS,
3602: mode,
3603: lhs_neg ? rhs : lhs,
3604: lhs_neg ? lhs : rhs);
3605: if (tem == 0)
3606: tem = gen_rtx (lhs_neg == rhs_neg
3607: ? PLUS : MINUS,
3608: mode, lhs_neg ? rhs : lhs,
3609: lhs_neg ? lhs : rhs);
3610:
3611: /* If both sides negated, negate result. */
3612: if (lhs_neg && rhs_neg)
3613: {
3614: rtx tem1
3615: = simplify_unary_operation (NEG, mode, tem, mode);
3616: if (tem1 == 0)
3617: tem1 = gen_rtx (NEG, mode, tem);
3618: tem = tem1;
3619: }
3620:
3621: return tem;
3622: }
3623:
3624: return 0;
3625: }
3626:
3627: /* c1 - (a + c2) becomes (c1 - c2) - a. */
3628: if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == PLUS
3629: && GET_CODE (XEXP (op1, 1)) == CONST_INT)
3630: {
3631: rtx tem = simplify_binary_operation (MINUS, mode, op0,
3632: XEXP (op1, 1));
3633:
3634: return tem ? gen_rtx (MINUS, mode, tem, XEXP (op1, 0)) : 0;
3635: }
3636:
3637: /* c1 - (c2 - a) becomes (c1 - c2) + a. */
3638: if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == MINUS
3639: && GET_CODE (XEXP (op1, 0)) == CONST_INT)
3640: {
3641: rtx tem = simplify_binary_operation (MINUS, mode, op0,
3642: XEXP (op1, 0));
3643:
3644: return (tem && GET_CODE (tem) == CONST_INT
3645: ? plus_constant (XEXP (op1, 1), INTVAL (tem))
3646: : 0);
3647: }
3648:
3649: /* Don't let a relocatable value get a negative coeff. */
3650: if (GET_CODE (op1) == CONST_INT)
3651: return plus_constant (op0, - INTVAL (op1));
3652: break;
3653:
3654: case MULT:
3655: if (op1 == constm1_rtx)
3656: {
3657: rtx tem = simplify_unary_operation (NEG, mode, op0, mode);
3658:
3659: return tem ? tem : gen_rtx (NEG, mode, op0);
3660: }
3661:
3662: /* In IEEE floating point, x*0 is not always 0. */
3663: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3664: || GET_MODE_CLASS (mode) == MODE_INT)
3665: && op1 == CONST0_RTX (mode)
3666: && ! side_effects_p (op0))
3667: return op1;
3668:
3669: /* In IEEE floating point, x*1 is not equivalent to x for nans.
3670: However, ANSI says we can drop signals,
3671: so we can do this anyway. */
3672: if (op1 == CONST1_RTX (mode))
3673: return op0;
3674:
3675: /* Convert multiply by constant power of two into shift. */
3676: if (GET_CODE (op1) == CONST_INT
3677: && (val = exact_log2 (INTVAL (op1))) >= 0)
1.1.1.4 ! root 3678: return gen_rtx (ASHIFT, mode, op0, GEN_INT (val));
1.1 root 3679:
3680: if (GET_CODE (op1) == CONST_DOUBLE
3681: && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT)
3682: {
3683: REAL_VALUE_TYPE d;
3684: REAL_VALUE_FROM_CONST_DOUBLE (d, op1);
3685:
3686: /* x*2 is x+x and x*(-1) is -x */
3687: if (REAL_VALUES_EQUAL (d, dconst2)
3688: && GET_MODE (op0) == mode)
3689: return gen_rtx (PLUS, mode, op0, copy_rtx (op0));
3690:
3691: else if (REAL_VALUES_EQUAL (d, dconstm1)
3692: && GET_MODE (op0) == mode)
3693: return gen_rtx (NEG, mode, op0);
3694: }
3695: break;
3696:
3697: case IOR:
3698: if (op1 == const0_rtx)
3699: return op0;
3700: if (GET_CODE (op1) == CONST_INT
3701: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3702: return op1;
3703: if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3704: return op0;
3705: /* A | (~A) -> -1 */
3706: if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
3707: || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
3708: && ! side_effects_p (op0))
3709: return constm1_rtx;
3710: break;
3711:
3712: case XOR:
3713: if (op1 == const0_rtx)
3714: return op0;
3715: if (GET_CODE (op1) == CONST_INT
3716: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3717: return gen_rtx (NOT, mode, op0);
3718: if (op0 == op1 && ! side_effects_p (op0))
3719: return const0_rtx;
3720: break;
3721:
3722: case AND:
3723: if (op1 == const0_rtx && ! side_effects_p (op0))
3724: return const0_rtx;
3725: if (GET_CODE (op1) == CONST_INT
3726: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode))
3727: return op0;
3728: if (op0 == op1 && ! side_effects_p (op0))
3729: return op0;
3730: /* A & (~A) -> 0 */
3731: if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
3732: || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
3733: && ! side_effects_p (op0))
3734: return const0_rtx;
3735: break;
3736:
3737: case UDIV:
3738: /* Convert divide by power of two into shift (divide by 1 handled
3739: below). */
3740: if (GET_CODE (op1) == CONST_INT
3741: && (arg1 = exact_log2 (INTVAL (op1))) > 0)
1.1.1.4 ! root 3742: return gen_rtx (LSHIFTRT, mode, op0, GEN_INT (arg1));
1.1 root 3743:
3744: /* ... fall through ... */
3745:
3746: case DIV:
3747: if (op1 == CONST1_RTX (mode))
3748: return op0;
1.1.1.4 ! root 3749:
! 3750: /* In IEEE floating point, 0/x is not always 0. */
! 3751: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
! 3752: || GET_MODE_CLASS (mode) == MODE_INT)
! 3753: && op0 == CONST0_RTX (mode)
! 3754: && ! side_effects_p (op1))
1.1 root 3755: return op0;
1.1.1.4 ! root 3756:
1.1 root 3757: #if 0 /* Turned off till an expert says this is a safe thing to do. */
3758: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3759: /* Change division by a constant into multiplication. */
3760: else if (GET_CODE (op1) == CONST_DOUBLE
3761: && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT
3762: && op1 != CONST0_RTX (mode))
3763: {
3764: REAL_VALUE_TYPE d;
3765: REAL_VALUE_FROM_CONST_DOUBLE (d, op1);
3766: if (REAL_VALUES_EQUAL (d, dconst0))
3767: abort();
3768: #if defined (REAL_ARITHMETIC)
3769: REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
3770: return gen_rtx (MULT, mode, op0,
3771: CONST_DOUBLE_FROM_REAL_VALUE (d, mode));
3772: #else
3773: return gen_rtx (MULT, mode, op0,
3774: CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode));
3775: }
3776: #endif
3777: #endif
3778: #endif
3779: break;
3780:
3781: case UMOD:
3782: /* Handle modulus by power of two (mod with 1 handled below). */
3783: if (GET_CODE (op1) == CONST_INT
3784: && exact_log2 (INTVAL (op1)) > 0)
1.1.1.4 ! root 3785: return gen_rtx (AND, mode, op0, GEN_INT (INTVAL (op1) - 1));
1.1 root 3786:
3787: /* ... fall through ... */
3788:
3789: case MOD:
3790: if ((op0 == const0_rtx || op1 == const1_rtx)
3791: && ! side_effects_p (op0) && ! side_effects_p (op1))
3792: return const0_rtx;
3793: break;
3794:
3795: case ROTATERT:
3796: case ROTATE:
3797: /* Rotating ~0 always results in ~0. */
1.1.1.4 ! root 3798: if (GET_CODE (op0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
1.1 root 3799: && INTVAL (op0) == GET_MODE_MASK (mode)
3800: && ! side_effects_p (op1))
3801: return op0;
3802:
3803: /* ... fall through ... */
3804:
3805: case LSHIFT:
3806: case ASHIFT:
3807: case ASHIFTRT:
3808: case LSHIFTRT:
3809: if (op1 == const0_rtx)
3810: return op0;
3811: if (op0 == const0_rtx && ! side_effects_p (op1))
3812: return op0;
3813: break;
3814:
3815: case SMIN:
1.1.1.4 ! root 3816: if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT
! 3817: && INTVAL (op1) == (HOST_WIDE_INT) 1 << (width -1)
1.1 root 3818: && ! side_effects_p (op0))
3819: return op1;
3820: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3821: return op0;
3822: break;
3823:
3824: case SMAX:
1.1.1.4 ! root 3825: if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT
1.1 root 3826: && INTVAL (op1) == GET_MODE_MASK (mode) >> 1
3827: && ! side_effects_p (op0))
3828: return op1;
3829: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3830: return op0;
3831: break;
3832:
3833: case UMIN:
3834: if (op1 == const0_rtx && ! side_effects_p (op0))
3835: return op1;
3836: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3837: return op0;
3838: break;
3839:
3840: case UMAX:
3841: if (op1 == constm1_rtx && ! side_effects_p (op0))
3842: return op1;
3843: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
3844: return op0;
3845: break;
3846:
3847: default:
3848: abort ();
3849: }
3850:
3851: return 0;
3852: }
3853:
3854: /* Get the integer argument values in two forms:
3855: zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S. */
3856:
3857: arg0 = INTVAL (op0);
3858: arg1 = INTVAL (op1);
3859:
1.1.1.4 ! root 3860: if (width < HOST_BITS_PER_WIDE_INT)
1.1 root 3861: {
1.1.1.4 ! root 3862: arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
! 3863: arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
1.1 root 3864:
3865: arg0s = arg0;
1.1.1.4 ! root 3866: if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
! 3867: arg0s |= ((HOST_WIDE_INT) (-1) << width);
1.1 root 3868:
3869: arg1s = arg1;
1.1.1.4 ! root 3870: if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
! 3871: arg1s |= ((HOST_WIDE_INT) (-1) << width);
1.1 root 3872: }
3873: else
3874: {
3875: arg0s = arg0;
3876: arg1s = arg1;
3877: }
3878:
3879: /* Compute the value of the arithmetic. */
3880:
3881: switch (code)
3882: {
3883: case PLUS:
1.1.1.2 root 3884: val = arg0s + arg1s;
1.1 root 3885: break;
3886:
3887: case MINUS:
1.1.1.2 root 3888: val = arg0s - arg1s;
1.1 root 3889: break;
3890:
3891: case MULT:
3892: val = arg0s * arg1s;
3893: break;
3894:
3895: case DIV:
3896: if (arg1s == 0)
3897: return 0;
3898: val = arg0s / arg1s;
3899: break;
3900:
3901: case MOD:
3902: if (arg1s == 0)
3903: return 0;
3904: val = arg0s % arg1s;
3905: break;
3906:
3907: case UDIV:
3908: if (arg1 == 0)
3909: return 0;
1.1.1.4 ! root 3910: val = (unsigned HOST_WIDE_INT) arg0 / arg1;
1.1 root 3911: break;
3912:
3913: case UMOD:
3914: if (arg1 == 0)
3915: return 0;
1.1.1.4 ! root 3916: val = (unsigned HOST_WIDE_INT) arg0 % arg1;
1.1 root 3917: break;
3918:
3919: case AND:
3920: val = arg0 & arg1;
3921: break;
3922:
3923: case IOR:
3924: val = arg0 | arg1;
3925: break;
3926:
3927: case XOR:
3928: val = arg0 ^ arg1;
3929: break;
3930:
3931: case LSHIFTRT:
3932: /* If shift count is undefined, don't fold it; let the machine do
3933: what it wants. But truncate it if the machine will do that. */
3934: if (arg1 < 0)
3935: return 0;
3936:
3937: #ifdef SHIFT_COUNT_TRUNCATED
3938: arg1 &= (BITS_PER_WORD - 1);
3939: #endif
3940:
3941: if (arg1 >= width)
3942: return 0;
3943:
1.1.1.4 ! root 3944: val = ((unsigned HOST_WIDE_INT) arg0) >> arg1;
1.1 root 3945: break;
3946:
3947: case ASHIFT:
3948: case LSHIFT:
3949: if (arg1 < 0)
3950: return 0;
3951:
3952: #ifdef SHIFT_COUNT_TRUNCATED
3953: arg1 &= (BITS_PER_WORD - 1);
3954: #endif
3955:
3956: if (arg1 >= width)
3957: return 0;
3958:
1.1.1.4 ! root 3959: val = ((unsigned HOST_WIDE_INT) arg0) << arg1;
1.1 root 3960: break;
3961:
3962: case ASHIFTRT:
3963: if (arg1 < 0)
3964: return 0;
3965:
3966: #ifdef SHIFT_COUNT_TRUNCATED
3967: arg1 &= (BITS_PER_WORD - 1);
3968: #endif
3969:
3970: if (arg1 >= width)
3971: return 0;
3972:
3973: val = arg0s >> arg1;
1.1.1.4 ! root 3974:
! 3975: /* Bootstrap compiler may not have sign extended the right shift.
! 3976: Manually extend the sign to insure bootstrap cc matches gcc. */
! 3977: if (arg0s < 0 && arg1 > 0)
! 3978: val |= ((HOST_WIDE_INT) -1) << (HOST_BITS_PER_WIDE_INT - arg1);
! 3979:
1.1 root 3980: break;
3981:
3982: case ROTATERT:
3983: if (arg1 < 0)
3984: return 0;
3985:
3986: arg1 %= width;
1.1.1.4 ! root 3987: val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
! 3988: | (((unsigned HOST_WIDE_INT) arg0) >> arg1));
1.1 root 3989: break;
3990:
3991: case ROTATE:
3992: if (arg1 < 0)
3993: return 0;
3994:
3995: arg1 %= width;
1.1.1.4 ! root 3996: val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
! 3997: | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
1.1 root 3998: break;
3999:
4000: case COMPARE:
4001: /* Do nothing here. */
4002: return 0;
4003:
1.1.1.3 root 4004: case SMIN:
4005: val = arg0s <= arg1s ? arg0s : arg1s;
4006: break;
4007:
4008: case UMIN:
1.1.1.4 ! root 4009: val = ((unsigned HOST_WIDE_INT) arg0
! 4010: <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
1.1.1.3 root 4011: break;
4012:
4013: case SMAX:
4014: val = arg0s > arg1s ? arg0s : arg1s;
4015: break;
4016:
4017: case UMAX:
1.1.1.4 ! root 4018: val = ((unsigned HOST_WIDE_INT) arg0
! 4019: > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
1.1.1.3 root 4020: break;
4021:
1.1 root 4022: default:
4023: abort ();
4024: }
4025:
4026: /* Clear the bits that don't belong in our mode, unless they and our sign
4027: bit are all one. So we get either a reasonable negative value or a
4028: reasonable unsigned value for this mode. */
1.1.1.4 ! root 4029: if (width < HOST_BITS_PER_WIDE_INT
! 4030: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
! 4031: != ((HOST_WIDE_INT) (-1) << (width - 1))))
! 4032: val &= ((HOST_WIDE_INT) 1 << width) - 1;
! 4033:
! 4034: return GEN_INT (val);
1.1 root 4035: }
4036:
4037: /* Like simplify_binary_operation except used for relational operators.
4038: MODE is the mode of the operands, not that of the result. */
4039:
4040: rtx
4041: simplify_relational_operation (code, mode, op0, op1)
4042: enum rtx_code code;
4043: enum machine_mode mode;
4044: rtx op0, op1;
4045: {
1.1.1.4 ! root 4046: register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
! 4047: HOST_WIDE_INT val;
1.1 root 4048: int width = GET_MODE_BITSIZE (mode);
4049:
4050: /* If op0 is a compare, extract the comparison arguments from it. */
4051: if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
4052: op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
4053:
4054: if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
1.1.1.4 ! root 4055: || width > HOST_BITS_PER_WIDE_INT || width == 0)
1.1 root 4056: {
4057: /* Even if we can't compute a constant result,
4058: there are some cases worth simplifying. */
4059:
4060: /* For non-IEEE floating-point, if the two operands are equal, we know
4061: the result. */
4062: if (rtx_equal_p (op0, op1)
4063: && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4064: || GET_MODE_CLASS (GET_MODE (op0)) != MODE_FLOAT))
4065: return (code == EQ || code == GE || code == LE || code == LEU
4066: || code == GEU) ? const_true_rtx : const0_rtx;
4067: else if (GET_CODE (op0) == CONST_DOUBLE
4068: && GET_CODE (op1) == CONST_DOUBLE
4069: && GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
4070: {
4071: REAL_VALUE_TYPE d0, d1;
4072: jmp_buf handler;
4073: int op0lt, op1lt, equal;
4074:
4075: if (setjmp (handler))
4076: return 0;
4077:
4078: set_float_handler (handler);
4079: REAL_VALUE_FROM_CONST_DOUBLE (d0, op0);
4080: REAL_VALUE_FROM_CONST_DOUBLE (d1, op1);
4081: equal = REAL_VALUES_EQUAL (d0, d1);
4082: op0lt = REAL_VALUES_LESS (d0, d1);
4083: op1lt = REAL_VALUES_LESS (d1, d0);
1.1.1.4 ! root 4084: set_float_handler (NULL_PTR);
1.1 root 4085:
4086: switch (code)
4087: {
4088: case EQ:
4089: return equal ? const_true_rtx : const0_rtx;
4090: case NE:
4091: return !equal ? const_true_rtx : const0_rtx;
4092: case LE:
4093: return equal || op0lt ? const_true_rtx : const0_rtx;
4094: case LT:
4095: return op0lt ? const_true_rtx : const0_rtx;
4096: case GE:
4097: return equal || op1lt ? const_true_rtx : const0_rtx;
4098: case GT:
4099: return op1lt ? const_true_rtx : const0_rtx;
4100: }
4101: }
4102:
4103: switch (code)
4104: {
4105: case EQ:
4106: {
4107: #if 0
4108: /* We can't make this assumption due to #pragma weak */
4109: if (CONSTANT_P (op0) && op1 == const0_rtx)
4110: return const0_rtx;
4111: #endif
1.1.1.3 root 4112: if (NONZERO_BASE_PLUS_P (op0) && op1 == const0_rtx
4113: /* On some machines, the ap reg can be 0 sometimes. */
4114: && op0 != arg_pointer_rtx)
1.1 root 4115: return const0_rtx;
4116: break;
4117: }
4118:
4119: case NE:
4120: #if 0
4121: /* We can't make this assumption due to #pragma weak */
4122: if (CONSTANT_P (op0) && op1 == const0_rtx)
4123: return const_true_rtx;
4124: #endif
1.1.1.3 root 4125: if (NONZERO_BASE_PLUS_P (op0) && op1 == const0_rtx
4126: /* On some machines, the ap reg can be 0 sometimes. */
4127: && op0 != arg_pointer_rtx)
1.1 root 4128: return const_true_rtx;
4129: break;
4130:
4131: case GEU:
4132: /* Unsigned values are never negative, but we must be sure we are
4133: actually comparing a value, not a CC operand. */
4134: if (op1 == const0_rtx
4135: && GET_MODE_CLASS (mode) == MODE_INT)
4136: return const_true_rtx;
4137: break;
4138:
4139: case LTU:
4140: if (op1 == const0_rtx
4141: && GET_MODE_CLASS (mode) == MODE_INT)
4142: return const0_rtx;
4143: break;
4144:
4145: case LEU:
4146: /* Unsigned values are never greater than the largest
4147: unsigned value. */
4148: if (GET_CODE (op1) == CONST_INT
4149: && INTVAL (op1) == GET_MODE_MASK (mode)
4150: && GET_MODE_CLASS (mode) == MODE_INT)
4151: return const_true_rtx;
4152: break;
4153:
4154: case GTU:
4155: if (GET_CODE (op1) == CONST_INT
4156: && INTVAL (op1) == GET_MODE_MASK (mode)
4157: && GET_MODE_CLASS (mode) == MODE_INT)
4158: return const0_rtx;
4159: break;
4160: }
4161:
4162: return 0;
4163: }
4164:
4165: /* Get the integer argument values in two forms:
4166: zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S. */
4167:
4168: arg0 = INTVAL (op0);
4169: arg1 = INTVAL (op1);
4170:
1.1.1.4 ! root 4171: if (width < HOST_BITS_PER_WIDE_INT)
1.1 root 4172: {
1.1.1.4 ! root 4173: arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
! 4174: arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
1.1 root 4175:
4176: arg0s = arg0;
1.1.1.4 ! root 4177: if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
! 4178: arg0s |= ((HOST_WIDE_INT) (-1) << width);
1.1 root 4179:
4180: arg1s = arg1;
1.1.1.4 ! root 4181: if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
! 4182: arg1s |= ((HOST_WIDE_INT) (-1) << width);
1.1 root 4183: }
4184: else
4185: {
4186: arg0s = arg0;
4187: arg1s = arg1;
4188: }
4189:
4190: /* Compute the value of the arithmetic. */
4191:
4192: switch (code)
4193: {
4194: case NE:
4195: val = arg0 != arg1 ? STORE_FLAG_VALUE : 0;
4196: break;
4197:
4198: case EQ:
4199: val = arg0 == arg1 ? STORE_FLAG_VALUE : 0;
4200: break;
4201:
4202: case LE:
4203: val = arg0s <= arg1s ? STORE_FLAG_VALUE : 0;
4204: break;
4205:
4206: case LT:
4207: val = arg0s < arg1s ? STORE_FLAG_VALUE : 0;
4208: break;
4209:
4210: case GE:
4211: val = arg0s >= arg1s ? STORE_FLAG_VALUE : 0;
4212: break;
4213:
4214: case GT:
4215: val = arg0s > arg1s ? STORE_FLAG_VALUE : 0;
4216: break;
4217:
4218: case LEU:
1.1.1.4 ! root 4219: val = (((unsigned HOST_WIDE_INT) arg0)
! 4220: <= ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
1.1 root 4221: break;
4222:
4223: case LTU:
1.1.1.4 ! root 4224: val = (((unsigned HOST_WIDE_INT) arg0)
! 4225: < ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
1.1 root 4226: break;
4227:
4228: case GEU:
1.1.1.4 ! root 4229: val = (((unsigned HOST_WIDE_INT) arg0)
! 4230: >= ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
1.1 root 4231: break;
4232:
4233: case GTU:
1.1.1.4 ! root 4234: val = (((unsigned HOST_WIDE_INT) arg0)
! 4235: > ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
1.1 root 4236: break;
4237:
4238: default:
4239: abort ();
4240: }
4241:
4242: /* Clear the bits that don't belong in our mode, unless they and our sign
4243: bit are all one. So we get either a reasonable negative value or a
4244: reasonable unsigned value for this mode. */
1.1.1.4 ! root 4245: if (width < HOST_BITS_PER_WIDE_INT
! 4246: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
! 4247: != ((HOST_WIDE_INT) (-1) << (width - 1))))
! 4248: val &= ((HOST_WIDE_INT) 1 << width) - 1;
1.1 root 4249:
1.1.1.4 ! root 4250: return GEN_INT (val);
1.1 root 4251: }
4252:
4253: /* Simplify CODE, an operation with result mode MODE and three operands,
4254: OP0, OP1, and OP2. OP0_MODE was the mode of OP0 before it became
4255: a constant. Return 0 if no simplifications is possible. */
4256:
4257: rtx
4258: simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2)
4259: enum rtx_code code;
4260: enum machine_mode mode, op0_mode;
4261: rtx op0, op1, op2;
4262: {
4263: int width = GET_MODE_BITSIZE (mode);
4264:
4265: /* VOIDmode means "infinite" precision. */
4266: if (width == 0)
1.1.1.4 ! root 4267: width = HOST_BITS_PER_WIDE_INT;
1.1 root 4268:
4269: switch (code)
4270: {
4271: case SIGN_EXTRACT:
4272: case ZERO_EXTRACT:
4273: if (GET_CODE (op0) == CONST_INT
4274: && GET_CODE (op1) == CONST_INT
4275: && GET_CODE (op2) == CONST_INT
4276: && INTVAL (op1) + INTVAL (op2) <= GET_MODE_BITSIZE (op0_mode)
1.1.1.4 ! root 4277: && width <= HOST_BITS_PER_WIDE_INT)
1.1 root 4278: {
4279: /* Extracting a bit-field from a constant */
1.1.1.4 ! root 4280: HOST_WIDE_INT val = INTVAL (op0);
1.1 root 4281:
4282: #if BITS_BIG_ENDIAN
4283: val >>= (GET_MODE_BITSIZE (op0_mode) - INTVAL (op2) - INTVAL (op1));
4284: #else
4285: val >>= INTVAL (op2);
4286: #endif
1.1.1.4 ! root 4287: if (HOST_BITS_PER_WIDE_INT != INTVAL (op1))
1.1 root 4288: {
4289: /* First zero-extend. */
1.1.1.4 ! root 4290: val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1;
1.1 root 4291: /* If desired, propagate sign bit. */
1.1.1.4 ! root 4292: if (code == SIGN_EXTRACT
! 4293: && (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1))))
! 4294: val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1);
1.1 root 4295: }
4296:
4297: /* Clear the bits that don't belong in our mode,
4298: unless they and our sign bit are all one.
4299: So we get either a reasonable negative value or a reasonable
4300: unsigned value for this mode. */
1.1.1.4 ! root 4301: if (width < HOST_BITS_PER_WIDE_INT
! 4302: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
! 4303: != ((HOST_WIDE_INT) (-1) << (width - 1))))
! 4304: val &= ((HOST_WIDE_INT) 1 << width) - 1;
1.1 root 4305:
1.1.1.4 ! root 4306: return GEN_INT (val);
1.1 root 4307: }
4308: break;
4309:
4310: case IF_THEN_ELSE:
4311: if (GET_CODE (op0) == CONST_INT)
4312: return op0 != const0_rtx ? op1 : op2;
4313: break;
4314:
4315: default:
4316: abort ();
4317: }
4318:
4319: return 0;
4320: }
4321:
4322: /* If X is a nontrivial arithmetic operation on an argument
4323: for which a constant value can be determined, return
4324: the result of operating on that value, as a constant.
4325: Otherwise, return X, possibly with one or more operands
4326: modified by recursive calls to this function.
4327:
4328: If X is a register whose contents are known, we do NOT
4329: return those contents. This is because an instruction that
4330: uses a register is usually faster than one that uses a constant.
4331:
4332: INSN is the insn that we may be modifying. If it is 0, make a copy
4333: of X before modifying it. */
4334:
4335: static rtx
4336: fold_rtx (x, insn)
4337: rtx x;
4338: rtx insn;
4339: {
4340: register enum rtx_code code;
4341: register enum machine_mode mode;
4342: register char *fmt;
1.1.1.4 ! root 4343: register int i;
1.1 root 4344: rtx new = 0;
4345: int copied = 0;
4346: int must_swap = 0;
4347:
4348: /* Folded equivalents of first two operands of X. */
4349: rtx folded_arg0;
4350: rtx folded_arg1;
4351:
4352: /* Constant equivalents of first three operands of X;
4353: 0 when no such equivalent is known. */
4354: rtx const_arg0;
4355: rtx const_arg1;
4356: rtx const_arg2;
4357:
4358: /* The mode of the first operand of X. We need this for sign and zero
4359: extends. */
4360: enum machine_mode mode_arg0;
4361:
4362: if (x == 0)
4363: return x;
4364:
4365: mode = GET_MODE (x);
4366: code = GET_CODE (x);
4367: switch (code)
4368: {
4369: case CONST:
4370: case CONST_INT:
4371: case CONST_DOUBLE:
4372: case SYMBOL_REF:
4373: case LABEL_REF:
4374: case REG:
4375: /* No use simplifying an EXPR_LIST
4376: since they are used only for lists of args
4377: in a function call's REG_EQUAL note. */
4378: case EXPR_LIST:
4379: return x;
4380:
4381: #ifdef HAVE_cc0
4382: case CC0:
4383: return prev_insn_cc0;
4384: #endif
4385:
4386: case PC:
4387: /* If the next insn is a CODE_LABEL followed by a jump table,
4388: PC's value is a LABEL_REF pointing to that label. That
4389: lets us fold switch statements on the Vax. */
4390: if (insn && GET_CODE (insn) == JUMP_INSN)
4391: {
4392: rtx next = next_nonnote_insn (insn);
4393:
4394: if (next && GET_CODE (next) == CODE_LABEL
4395: && NEXT_INSN (next) != 0
4396: && GET_CODE (NEXT_INSN (next)) == JUMP_INSN
4397: && (GET_CODE (PATTERN (NEXT_INSN (next))) == ADDR_VEC
4398: || GET_CODE (PATTERN (NEXT_INSN (next))) == ADDR_DIFF_VEC))
4399: return gen_rtx (LABEL_REF, Pmode, next);
4400: }
4401: break;
4402:
4403: case SUBREG:
1.1.1.4 ! root 4404: /* See if we previously assigned a constant value to this SUBREG. */
! 4405: if ((new = lookup_as_function (x, CONST_INT)) != 0
! 4406: || (new = lookup_as_function (x, CONST_DOUBLE)) != 0)
1.1 root 4407: return new;
4408:
1.1.1.4 ! root 4409: /* If this is a paradoxical SUBREG, we have no idea what value the
! 4410: extra bits would have. However, if the operand is equivalent
! 4411: to a SUBREG whose operand is the same as our mode, and all the
! 4412: modes are within a word, we can just use the inner operand
! 4413: because these SUBREGs just say how to treat the register. */
! 4414:
1.1.1.3 root 4415: if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
1.1.1.4 ! root 4416: {
! 4417: enum machine_mode imode = GET_MODE (SUBREG_REG (x));
! 4418: struct table_elt *elt;
! 4419:
! 4420: if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
! 4421: && GET_MODE_SIZE (imode) <= UNITS_PER_WORD
! 4422: && (elt = lookup (SUBREG_REG (x), HASH (SUBREG_REG (x), imode),
! 4423: imode)) != 0)
! 4424: {
! 4425: for (elt = elt->first_same_value;
! 4426: elt; elt = elt->next_same_value)
! 4427: if (GET_CODE (elt->exp) == SUBREG
! 4428: && GET_MODE (SUBREG_REG (elt->exp)) == mode
! 4429: && exp_equiv_p (elt->exp, elt->exp, 1, 0))
! 4430: return copy_rtx (SUBREG_REG (elt->exp));
! 4431: }
! 4432:
! 4433: return x;
! 4434: }
1.1.1.3 root 4435:
1.1 root 4436: /* Fold SUBREG_REG. If it changed, see if we can simplify the SUBREG.
4437: We might be able to if the SUBREG is extracting a single word in an
4438: integral mode or extracting the low part. */
4439:
4440: folded_arg0 = fold_rtx (SUBREG_REG (x), insn);
4441: const_arg0 = equiv_constant (folded_arg0);
4442: if (const_arg0)
4443: folded_arg0 = const_arg0;
4444:
4445: if (folded_arg0 != SUBREG_REG (x))
4446: {
4447: new = 0;
4448:
4449: if (GET_MODE_CLASS (mode) == MODE_INT
4450: && GET_MODE_SIZE (mode) == UNITS_PER_WORD
4451: && GET_MODE (SUBREG_REG (x)) != VOIDmode)
4452: new = operand_subword (folded_arg0, SUBREG_WORD (x), 0,
4453: GET_MODE (SUBREG_REG (x)));
4454: if (new == 0 && subreg_lowpart_p (x))
4455: new = gen_lowpart_if_possible (mode, folded_arg0);
4456: if (new)
4457: return new;
4458: }
1.1.1.3 root 4459:
4460: /* If this is a narrowing SUBREG and our operand is a REG, see if
1.1.1.4 ! root 4461: we can find an equivalence for REG that is an arithmetic operation
1.1.1.3 root 4462: in a wider mode where both operands are paradoxical SUBREGs
4463: from objects of our result mode. In that case, we couldn't report
4464: an equivalent value for that operation, since we don't know what the
4465: extra bits will be. But we can find an equivalence for this SUBREG
4466: by folding that operation is the narrow mode. This allows us to
4467: fold arithmetic in narrow modes when the machine only supports
1.1.1.4 ! root 4468: word-sized arithmetic.
! 4469:
! 4470: Also look for a case where we have a SUBREG whose operand is the
! 4471: same as our result. If both modes are smaller than a word, we
! 4472: are simply interpreting a register in different modes and we
! 4473: can use the inner value. */
1.1.1.3 root 4474:
4475: if (GET_CODE (folded_arg0) == REG
1.1.1.4 ! root 4476: && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (folded_arg0))
! 4477: && subreg_lowpart_p (x))
1.1.1.3 root 4478: {
4479: struct table_elt *elt;
4480:
4481: /* We can use HASH here since we know that canon_hash won't be
4482: called. */
4483: elt = lookup (folded_arg0,
4484: HASH (folded_arg0, GET_MODE (folded_arg0)),
4485: GET_MODE (folded_arg0));
4486:
4487: if (elt)
4488: elt = elt->first_same_value;
4489:
4490: for (; elt; elt = elt->next_same_value)
4491: {
1.1.1.4 ! root 4492: enum rtx_code eltcode = GET_CODE (elt->exp);
! 4493:
1.1.1.3 root 4494: /* Just check for unary and binary operations. */
4495: if (GET_RTX_CLASS (GET_CODE (elt->exp)) == '1'
4496: && GET_CODE (elt->exp) != SIGN_EXTEND
4497: && GET_CODE (elt->exp) != ZERO_EXTEND
4498: && GET_CODE (XEXP (elt->exp, 0)) == SUBREG
4499: && GET_MODE (SUBREG_REG (XEXP (elt->exp, 0))) == mode)
4500: {
4501: rtx op0 = SUBREG_REG (XEXP (elt->exp, 0));
4502:
4503: if (GET_CODE (op0) != REG && ! CONSTANT_P (op0))
1.1.1.4 ! root 4504: op0 = fold_rtx (op0, NULL_RTX);
1.1.1.3 root 4505:
4506: op0 = equiv_constant (op0);
4507: if (op0)
4508: new = simplify_unary_operation (GET_CODE (elt->exp), mode,
4509: op0, mode);
4510: }
4511: else if ((GET_RTX_CLASS (GET_CODE (elt->exp)) == '2'
4512: || GET_RTX_CLASS (GET_CODE (elt->exp)) == 'c')
1.1.1.4 ! root 4513: && eltcode != DIV && eltcode != MOD
! 4514: && eltcode != UDIV && eltcode != UMOD
! 4515: && eltcode != ASHIFTRT && eltcode != LSHIFTRT
! 4516: && eltcode != ROTATE && eltcode != ROTATERT
1.1.1.3 root 4517: && ((GET_CODE (XEXP (elt->exp, 0)) == SUBREG
4518: && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 0)))
4519: == mode))
4520: || CONSTANT_P (XEXP (elt->exp, 0)))
4521: && ((GET_CODE (XEXP (elt->exp, 1)) == SUBREG
4522: && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 1)))
4523: == mode))
4524: || CONSTANT_P (XEXP (elt->exp, 1))))
4525: {
4526: rtx op0 = gen_lowpart_common (mode, XEXP (elt->exp, 0));
4527: rtx op1 = gen_lowpart_common (mode, XEXP (elt->exp, 1));
4528:
4529: if (op0 && GET_CODE (op0) != REG && ! CONSTANT_P (op0))
1.1.1.4 ! root 4530: op0 = fold_rtx (op0, NULL_RTX);
1.1.1.3 root 4531:
4532: if (op0)
4533: op0 = equiv_constant (op0);
4534:
4535: if (op1 && GET_CODE (op1) != REG && ! CONSTANT_P (op1))
1.1.1.4 ! root 4536: op1 = fold_rtx (op1, NULL_RTX);
1.1.1.3 root 4537:
4538: if (op1)
4539: op1 = equiv_constant (op1);
4540:
4541: if (op0 && op1)
4542: new = simplify_binary_operation (GET_CODE (elt->exp), mode,
4543: op0, op1);
4544: }
4545:
1.1.1.4 ! root 4546: else if (GET_CODE (elt->exp) == SUBREG
! 4547: && GET_MODE (SUBREG_REG (elt->exp)) == mode
! 4548: && (GET_MODE_SIZE (GET_MODE (folded_arg0))
! 4549: <= UNITS_PER_WORD)
! 4550: && exp_equiv_p (elt->exp, elt->exp, 1, 0))
! 4551: new = copy_rtx (SUBREG_REG (elt->exp));
! 4552:
1.1.1.3 root 4553: if (new)
4554: return new;
4555: }
4556: }
4557:
1.1 root 4558: return x;
4559:
4560: case NOT:
4561: case NEG:
4562: /* If we have (NOT Y), see if Y is known to be (NOT Z).
4563: If so, (NOT Y) simplifies to Z. Similarly for NEG. */
4564: new = lookup_as_function (XEXP (x, 0), code);
4565: if (new)
4566: return fold_rtx (copy_rtx (XEXP (new, 0)), insn);
4567: break;
1.1.1.4 ! root 4568:
1.1 root 4569: case MEM:
4570: /* If we are not actually processing an insn, don't try to find the
4571: best address. Not only don't we care, but we could modify the
4572: MEM in an invalid way since we have no insn to validate against. */
4573: if (insn != 0)
4574: find_best_addr (insn, &XEXP (x, 0));
4575:
4576: {
4577: /* Even if we don't fold in the insn itself,
4578: we can safely do so here, in hopes of getting a constant. */
1.1.1.4 ! root 4579: rtx addr = fold_rtx (XEXP (x, 0), NULL_RTX);
1.1 root 4580: rtx base = 0;
1.1.1.4 ! root 4581: HOST_WIDE_INT offset = 0;
1.1 root 4582:
4583: if (GET_CODE (addr) == REG
4584: && REGNO_QTY_VALID_P (REGNO (addr))
4585: && GET_MODE (addr) == qty_mode[reg_qty[REGNO (addr)]]
4586: && qty_const[reg_qty[REGNO (addr)]] != 0)
4587: addr = qty_const[reg_qty[REGNO (addr)]];
4588:
4589: /* If address is constant, split it into a base and integer offset. */
4590: if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF)
4591: base = addr;
4592: else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
4593: && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
4594: {
4595: base = XEXP (XEXP (addr, 0), 0);
4596: offset = INTVAL (XEXP (XEXP (addr, 0), 1));
4597: }
4598: else if (GET_CODE (addr) == LO_SUM
4599: && GET_CODE (XEXP (addr, 1)) == SYMBOL_REF)
4600: base = XEXP (addr, 1);
4601:
4602: /* If this is a constant pool reference, we can fold it into its
4603: constant to allow better value tracking. */
4604: if (base && GET_CODE (base) == SYMBOL_REF
4605: && CONSTANT_POOL_ADDRESS_P (base))
4606: {
4607: rtx constant = get_pool_constant (base);
4608: enum machine_mode const_mode = get_pool_mode (base);
4609: rtx new;
4610:
4611: if (CONSTANT_P (constant) && GET_CODE (constant) != CONST_INT)
4612: constant_pool_entries_cost = COST (constant);
4613:
4614: /* If we are loading the full constant, we have an equivalence. */
4615: if (offset == 0 && mode == const_mode)
4616: return constant;
4617:
4618: /* If this actually isn't a constant (wierd!), we can't do
4619: anything. Otherwise, handle the two most common cases:
4620: extracting a word from a multi-word constant, and extracting
4621: the low-order bits. Other cases don't seem common enough to
4622: worry about. */
4623: if (! CONSTANT_P (constant))
4624: return x;
4625:
4626: if (GET_MODE_CLASS (mode) == MODE_INT
4627: && GET_MODE_SIZE (mode) == UNITS_PER_WORD
4628: && offset % UNITS_PER_WORD == 0
4629: && (new = operand_subword (constant,
4630: offset / UNITS_PER_WORD,
4631: 0, const_mode)) != 0)
4632: return new;
4633:
4634: if (((BYTES_BIG_ENDIAN
4635: && offset == GET_MODE_SIZE (GET_MODE (constant)) - 1)
4636: || (! BYTES_BIG_ENDIAN && offset == 0))
4637: && (new = gen_lowpart_if_possible (mode, constant)) != 0)
4638: return new;
4639: }
4640:
4641: /* If this is a reference to a label at a known position in a jump
4642: table, we also know its value. */
4643: if (base && GET_CODE (base) == LABEL_REF)
4644: {
4645: rtx label = XEXP (base, 0);
4646: rtx table_insn = NEXT_INSN (label);
4647:
4648: if (table_insn && GET_CODE (table_insn) == JUMP_INSN
4649: && GET_CODE (PATTERN (table_insn)) == ADDR_VEC)
4650: {
4651: rtx table = PATTERN (table_insn);
4652:
4653: if (offset >= 0
4654: && (offset / GET_MODE_SIZE (GET_MODE (table))
4655: < XVECLEN (table, 0)))
4656: return XVECEXP (table, 0,
4657: offset / GET_MODE_SIZE (GET_MODE (table)));
4658: }
4659: if (table_insn && GET_CODE (table_insn) == JUMP_INSN
4660: && GET_CODE (PATTERN (table_insn)) == ADDR_DIFF_VEC)
4661: {
4662: rtx table = PATTERN (table_insn);
4663:
4664: if (offset >= 0
4665: && (offset / GET_MODE_SIZE (GET_MODE (table))
4666: < XVECLEN (table, 1)))
4667: {
4668: offset /= GET_MODE_SIZE (GET_MODE (table));
4669: new = gen_rtx (MINUS, Pmode, XVECEXP (table, 1, offset),
4670: XEXP (table, 0));
4671:
4672: if (GET_MODE (table) != Pmode)
4673: new = gen_rtx (TRUNCATE, GET_MODE (table), new);
4674:
4675: return new;
4676: }
4677: }
4678: }
4679:
4680: return x;
4681: }
4682: }
4683:
4684: const_arg0 = 0;
4685: const_arg1 = 0;
4686: const_arg2 = 0;
4687: mode_arg0 = VOIDmode;
4688:
4689: /* Try folding our operands.
4690: Then see which ones have constant values known. */
4691:
4692: fmt = GET_RTX_FORMAT (code);
4693: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4694: if (fmt[i] == 'e')
4695: {
4696: rtx arg = XEXP (x, i);
4697: rtx folded_arg = arg, const_arg = 0;
4698: enum machine_mode mode_arg = GET_MODE (arg);
4699: rtx cheap_arg, expensive_arg;
4700: rtx replacements[2];
4701: int j;
4702:
4703: /* Most arguments are cheap, so handle them specially. */
4704: switch (GET_CODE (arg))
4705: {
4706: case REG:
4707: /* This is the same as calling equiv_constant; it is duplicated
4708: here for speed. */
4709: if (REGNO_QTY_VALID_P (REGNO (arg))
4710: && qty_const[reg_qty[REGNO (arg)]] != 0
4711: && GET_CODE (qty_const[reg_qty[REGNO (arg)]]) != REG
4712: && GET_CODE (qty_const[reg_qty[REGNO (arg)]]) != PLUS)
4713: const_arg
4714: = gen_lowpart_if_possible (GET_MODE (arg),
4715: qty_const[reg_qty[REGNO (arg)]]);
4716: break;
4717:
4718: case CONST:
4719: case CONST_INT:
4720: case SYMBOL_REF:
4721: case LABEL_REF:
4722: case CONST_DOUBLE:
4723: const_arg = arg;
4724: break;
4725:
4726: #ifdef HAVE_cc0
4727: case CC0:
4728: folded_arg = prev_insn_cc0;
4729: mode_arg = prev_insn_cc0_mode;
4730: const_arg = equiv_constant (folded_arg);
4731: break;
4732: #endif
4733:
4734: default:
4735: folded_arg = fold_rtx (arg, insn);
4736: const_arg = equiv_constant (folded_arg);
4737: }
4738:
4739: /* For the first three operands, see if the operand
4740: is constant or equivalent to a constant. */
4741: switch (i)
4742: {
4743: case 0:
4744: folded_arg0 = folded_arg;
4745: const_arg0 = const_arg;
4746: mode_arg0 = mode_arg;
4747: break;
4748: case 1:
4749: folded_arg1 = folded_arg;
4750: const_arg1 = const_arg;
4751: break;
4752: case 2:
4753: const_arg2 = const_arg;
4754: break;
4755: }
4756:
4757: /* Pick the least expensive of the folded argument and an
4758: equivalent constant argument. */
4759: if (const_arg == 0 || const_arg == folded_arg
4760: || COST (const_arg) > COST (folded_arg))
4761: cheap_arg = folded_arg, expensive_arg = const_arg;
4762: else
4763: cheap_arg = const_arg, expensive_arg = folded_arg;
4764:
4765: /* Try to replace the operand with the cheapest of the two
4766: possibilities. If it doesn't work and this is either of the first
4767: two operands of a commutative operation, try swapping them.
4768: If THAT fails, try the more expensive, provided it is cheaper
4769: than what is already there. */
4770:
4771: if (cheap_arg == XEXP (x, i))
4772: continue;
4773:
4774: if (insn == 0 && ! copied)
4775: {
4776: x = copy_rtx (x);
4777: copied = 1;
4778: }
4779:
4780: replacements[0] = cheap_arg, replacements[1] = expensive_arg;
4781: for (j = 0;
4782: j < 2 && replacements[j]
4783: && COST (replacements[j]) < COST (XEXP (x, i));
4784: j++)
4785: {
4786: if (validate_change (insn, &XEXP (x, i), replacements[j], 0))
4787: break;
4788:
4789: if (code == NE || code == EQ || GET_RTX_CLASS (code) == 'c')
4790: {
4791: validate_change (insn, &XEXP (x, i), XEXP (x, 1 - i), 1);
4792: validate_change (insn, &XEXP (x, 1 - i), replacements[j], 1);
4793:
4794: if (apply_change_group ())
4795: {
4796: /* Swap them back to be invalid so that this loop can
4797: continue and flag them to be swapped back later. */
4798: rtx tem;
4799:
4800: tem = XEXP (x, 0); XEXP (x, 0) = XEXP (x, 1);
4801: XEXP (x, 1) = tem;
4802: must_swap = 1;
4803: break;
4804: }
4805: }
4806: }
4807: }
4808:
4809: else if (fmt[i] == 'E')
4810: /* Don't try to fold inside of a vector of expressions.
4811: Doing nothing is harmless. */
4812: ;
4813:
4814: /* If a commutative operation, place a constant integer as the second
4815: operand unless the first operand is also a constant integer. Otherwise,
4816: place any constant second unless the first operand is also a constant. */
4817:
4818: if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
4819: {
4820: if (must_swap || (const_arg0
4821: && (const_arg1 == 0
4822: || (GET_CODE (const_arg0) == CONST_INT
4823: && GET_CODE (const_arg1) != CONST_INT))))
4824: {
4825: register rtx tem = XEXP (x, 0);
4826:
4827: if (insn == 0 && ! copied)
4828: {
4829: x = copy_rtx (x);
4830: copied = 1;
4831: }
4832:
4833: validate_change (insn, &XEXP (x, 0), XEXP (x, 1), 1);
4834: validate_change (insn, &XEXP (x, 1), tem, 1);
4835: if (apply_change_group ())
4836: {
4837: tem = const_arg0, const_arg0 = const_arg1, const_arg1 = tem;
4838: tem = folded_arg0, folded_arg0 = folded_arg1, folded_arg1 = tem;
4839: }
4840: }
4841: }
4842:
4843: /* If X is an arithmetic operation, see if we can simplify it. */
4844:
4845: switch (GET_RTX_CLASS (code))
4846: {
4847: case '1':
1.1.1.3 root 4848: /* We can't simplify extension ops unless we know the original mode. */
4849: if ((code == ZERO_EXTEND || code == SIGN_EXTEND)
4850: && mode_arg0 == VOIDmode)
4851: break;
1.1 root 4852: new = simplify_unary_operation (code, mode,
4853: const_arg0 ? const_arg0 : folded_arg0,
4854: mode_arg0);
4855: break;
4856:
4857: case '<':
4858: /* See what items are actually being compared and set FOLDED_ARG[01]
4859: to those values and CODE to the actual comparison code. If any are
4860: constant, set CONST_ARG0 and CONST_ARG1 appropriately. We needn't
4861: do anything if both operands are already known to be constant. */
4862:
4863: if (const_arg0 == 0 || const_arg1 == 0)
4864: {
4865: struct table_elt *p0, *p1;
1.1.1.4 ! root 4866: rtx true = const_true_rtx, false = const0_rtx;
! 4867: enum machine_mode mode_arg1;
! 4868:
! 4869: #ifdef FLOAT_STORE_FLAG_VALUE
! 4870: if (GET_MODE_CLASS (mode) == MODE_FLOAT)
! 4871: {
! 4872: true = immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode);
! 4873: false = CONST0_RTX (mode);
! 4874: }
! 4875: #endif
1.1 root 4876:
1.1.1.4 ! root 4877: code = find_comparison_args (code, &folded_arg0, &folded_arg1,
! 4878: &mode_arg0, &mode_arg1);
1.1 root 4879: const_arg0 = equiv_constant (folded_arg0);
4880: const_arg1 = equiv_constant (folded_arg1);
4881:
1.1.1.4 ! root 4882: /* If the mode is VOIDmode or a MODE_CC mode, we don't know
! 4883: what kinds of things are being compared, so we can't do
! 4884: anything with this comparison. */
1.1 root 4885:
4886: if (mode_arg0 == VOIDmode || GET_MODE_CLASS (mode_arg0) == MODE_CC)
4887: break;
4888:
4889: /* If we do not now have two constants being compared, see if we
4890: can nevertheless deduce some things about the comparison. */
4891: if (const_arg0 == 0 || const_arg1 == 0)
4892: {
4893: /* Is FOLDED_ARG0 frame-pointer plus a constant? Or non-explicit
4894: constant? These aren't zero, but we don't know their sign. */
4895: if (const_arg1 == const0_rtx
4896: && (NONZERO_BASE_PLUS_P (folded_arg0)
4897: #if 0 /* Sad to say, on sysvr4, #pragma weak can make a symbol address
4898: come out as 0. */
4899: || GET_CODE (folded_arg0) == SYMBOL_REF
4900: #endif
4901: || GET_CODE (folded_arg0) == LABEL_REF
4902: || GET_CODE (folded_arg0) == CONST))
4903: {
4904: if (code == EQ)
1.1.1.4 ! root 4905: return false;
1.1 root 4906: else if (code == NE)
1.1.1.4 ! root 4907: return true;
1.1 root 4908: }
4909:
4910: /* See if the two operands are the same. We don't do this
4911: for IEEE floating-point since we can't assume x == x
4912: since x might be a NaN. */
4913:
4914: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4915: || GET_MODE_CLASS (mode_arg0) != MODE_FLOAT)
4916: && (folded_arg0 == folded_arg1
4917: || (GET_CODE (folded_arg0) == REG
4918: && GET_CODE (folded_arg1) == REG
4919: && (reg_qty[REGNO (folded_arg0)]
4920: == reg_qty[REGNO (folded_arg1)]))
4921: || ((p0 = lookup (folded_arg0,
4922: (safe_hash (folded_arg0, mode_arg0)
4923: % NBUCKETS), mode_arg0))
4924: && (p1 = lookup (folded_arg1,
4925: (safe_hash (folded_arg1, mode_arg0)
4926: % NBUCKETS), mode_arg0))
4927: && p0->first_same_value == p1->first_same_value)))
4928: return ((code == EQ || code == LE || code == GE
4929: || code == LEU || code == GEU)
1.1.1.4 ! root 4930: ? true : false);
1.1 root 4931:
4932: /* If FOLDED_ARG0 is a register, see if the comparison we are
4933: doing now is either the same as we did before or the reverse
4934: (we only check the reverse if not floating-point). */
4935: else if (GET_CODE (folded_arg0) == REG)
4936: {
4937: int qty = reg_qty[REGNO (folded_arg0)];
4938:
4939: if (REGNO_QTY_VALID_P (REGNO (folded_arg0))
4940: && (comparison_dominates_p (qty_comparison_code[qty], code)
4941: || (comparison_dominates_p (qty_comparison_code[qty],
4942: reverse_condition (code))
4943: && GET_MODE_CLASS (mode_arg0) == MODE_INT))
4944: && (rtx_equal_p (qty_comparison_const[qty], folded_arg1)
4945: || (const_arg1
4946: && rtx_equal_p (qty_comparison_const[qty],
4947: const_arg1))
4948: || (GET_CODE (folded_arg1) == REG
4949: && (reg_qty[REGNO (folded_arg1)]
4950: == qty_comparison_qty[qty]))))
4951: return (comparison_dominates_p (qty_comparison_code[qty],
4952: code)
1.1.1.4 ! root 4953: ? true : false);
1.1 root 4954: }
4955: }
4956: }
4957:
4958: /* If we are comparing against zero, see if the first operand is
4959: equivalent to an IOR with a constant. If so, we may be able to
4960: determine the result of this comparison. */
4961:
4962: if (const_arg1 == const0_rtx)
4963: {
4964: rtx y = lookup_as_function (folded_arg0, IOR);
4965: rtx inner_const;
4966:
4967: if (y != 0
4968: && (inner_const = equiv_constant (XEXP (y, 1))) != 0
4969: && GET_CODE (inner_const) == CONST_INT
4970: && INTVAL (inner_const) != 0)
4971: {
4972: int sign_bitnum = GET_MODE_BITSIZE (mode_arg0) - 1;
1.1.1.4 ! root 4973: int has_sign = (HOST_BITS_PER_WIDE_INT >= sign_bitnum
! 4974: && (INTVAL (inner_const)
! 4975: & ((HOST_WIDE_INT) 1 << sign_bitnum)));
! 4976: rtx true = const_true_rtx, false = const0_rtx;
! 4977:
! 4978: #ifdef FLOAT_STORE_FLAG_VALUE
! 4979: if (GET_MODE_CLASS (mode) == MODE_FLOAT)
! 4980: {
! 4981: true = immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode);
! 4982: false = CONST0_RTX (mode);
! 4983: }
! 4984: #endif
1.1 root 4985:
4986: switch (code)
4987: {
4988: case EQ:
1.1.1.4 ! root 4989: return false;
1.1 root 4990: case NE:
1.1.1.4 ! root 4991: return true;
1.1 root 4992: case LT: case LE:
4993: if (has_sign)
1.1.1.4 ! root 4994: return true;
1.1 root 4995: break;
4996: case GT: case GE:
4997: if (has_sign)
1.1.1.4 ! root 4998: return false;
1.1 root 4999: break;
5000: }
5001: }
5002: }
5003:
5004: new = simplify_relational_operation (code, mode_arg0,
5005: const_arg0 ? const_arg0 : folded_arg0,
5006: const_arg1 ? const_arg1 : folded_arg1);
1.1.1.4 ! root 5007: #ifdef FLOAT_STORE_FLAG_VALUE
! 5008: if (new != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
! 5009: new = ((new == const0_rtx) ? CONST0_RTX (mode)
! 5010: : immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode));
! 5011: #endif
1.1 root 5012: break;
5013:
5014: case '2':
5015: case 'c':
5016: switch (code)
5017: {
5018: case PLUS:
5019: /* If the second operand is a LABEL_REF, see if the first is a MINUS
5020: with that LABEL_REF as its second operand. If so, the result is
5021: the first operand of that MINUS. This handles switches with an
5022: ADDR_DIFF_VEC table. */
5023: if (const_arg1 && GET_CODE (const_arg1) == LABEL_REF)
5024: {
5025: rtx y = lookup_as_function (folded_arg0, MINUS);
5026:
5027: if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF
5028: && XEXP (XEXP (y, 1), 0) == XEXP (const_arg1, 0))
5029: return XEXP (y, 0);
5030: }
1.1.1.4 ! root 5031: goto from_plus;
! 5032:
! 5033: case MINUS:
! 5034: /* If we have (MINUS Y C), see if Y is known to be (PLUS Z C2).
! 5035: If so, produce (PLUS Z C2-C). */
! 5036: if (const_arg1 != 0 && GET_CODE (const_arg1) == CONST_INT)
! 5037: {
! 5038: rtx y = lookup_as_function (XEXP (x, 0), PLUS);
! 5039: if (y && GET_CODE (XEXP (y, 1)) == CONST_INT)
! 5040: return fold_rtx (plus_constant (y, -INTVAL (const_arg1)));
! 5041: }
1.1 root 5042:
5043: /* ... fall through ... */
5044:
1.1.1.4 ! root 5045: from_plus:
1.1 root 5046: case SMIN: case SMAX: case UMIN: case UMAX:
5047: case IOR: case AND: case XOR:
5048: case MULT: case DIV: case UDIV:
5049: case ASHIFT: case LSHIFTRT: case ASHIFTRT:
5050: /* If we have (<op> <reg> <const_int>) for an associative OP and REG
5051: is known to be of similar form, we may be able to replace the
5052: operation with a combined operation. This may eliminate the
5053: intermediate operation if every use is simplified in this way.
5054: Note that the similar optimization done by combine.c only works
5055: if the intermediate operation's result has only one reference. */
5056:
5057: if (GET_CODE (folded_arg0) == REG
5058: && const_arg1 && GET_CODE (const_arg1) == CONST_INT)
5059: {
5060: int is_shift
5061: = (code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT);
5062: rtx y = lookup_as_function (folded_arg0, code);
5063: rtx inner_const;
5064: enum rtx_code associate_code;
5065: rtx new_const;
5066:
5067: if (y == 0
5068: || 0 == (inner_const
5069: = equiv_constant (fold_rtx (XEXP (y, 1), 0)))
5070: || GET_CODE (inner_const) != CONST_INT
5071: /* If we have compiled a statement like
5072: "if (x == (x & mask1))", and now are looking at
5073: "x & mask2", we will have a case where the first operand
5074: of Y is the same as our first operand. Unless we detect
5075: this case, an infinite loop will result. */
5076: || XEXP (y, 0) == folded_arg0)
5077: break;
5078:
5079: /* Don't associate these operations if they are a PLUS with the
5080: same constant and it is a power of two. These might be doable
5081: with a pre- or post-increment. Similarly for two subtracts of
5082: identical powers of two with post decrement. */
5083:
5084: if (code == PLUS && INTVAL (const_arg1) == INTVAL (inner_const)
5085: && (0
5086: #if defined(HAVE_PRE_INCREMENT) || defined(HAVE_POST_INCREMENT)
5087: || exact_log2 (INTVAL (const_arg1)) >= 0
5088: #endif
5089: #if defined(HAVE_PRE_DECREMENT) || defined(HAVE_POST_DECREMENT)
5090: || exact_log2 (- INTVAL (const_arg1)) >= 0
5091: #endif
5092: ))
5093: break;
5094:
5095: /* Compute the code used to compose the constants. For example,
5096: A/C1/C2 is A/(C1 * C2), so if CODE == DIV, we want MULT. */
5097:
5098: associate_code
5099: = (code == MULT || code == DIV || code == UDIV ? MULT
5100: : is_shift || code == PLUS || code == MINUS ? PLUS : code);
5101:
5102: new_const = simplify_binary_operation (associate_code, mode,
5103: const_arg1, inner_const);
5104:
5105: if (new_const == 0)
5106: break;
5107:
5108: /* If we are associating shift operations, don't let this
5109: produce a shift of larger than the object. This could
5110: occur when we following a sign-extend by a right shift on
5111: a machine that does a sign-extend as a pair of shifts. */
5112:
5113: if (is_shift && GET_CODE (new_const) == CONST_INT
5114: && INTVAL (new_const) > GET_MODE_BITSIZE (mode))
5115: break;
5116:
5117: y = copy_rtx (XEXP (y, 0));
5118:
5119: /* If Y contains our first operand (the most common way this
5120: can happen is if Y is a MEM), we would do into an infinite
5121: loop if we tried to fold it. So don't in that case. */
5122:
5123: if (! reg_mentioned_p (folded_arg0, y))
5124: y = fold_rtx (y, insn);
5125:
5126: new = simplify_binary_operation (code, mode, y, new_const);
5127: if (new)
5128: return new;
5129:
5130: return gen_rtx (code, mode, y, new_const);
5131: }
5132: }
5133:
5134: new = simplify_binary_operation (code, mode,
5135: const_arg0 ? const_arg0 : folded_arg0,
5136: const_arg1 ? const_arg1 : folded_arg1);
5137: break;
5138:
1.1.1.2 root 5139: case 'o':
5140: /* (lo_sum (high X) X) is simply X. */
5141: if (code == LO_SUM && const_arg0 != 0
5142: && GET_CODE (const_arg0) == HIGH
5143: && rtx_equal_p (XEXP (const_arg0, 0), const_arg1))
5144: return const_arg1;
5145: break;
5146:
1.1 root 5147: case '3':
5148: case 'b':
5149: new = simplify_ternary_operation (code, mode, mode_arg0,
5150: const_arg0 ? const_arg0 : folded_arg0,
5151: const_arg1 ? const_arg1 : folded_arg1,
5152: const_arg2 ? const_arg2 : XEXP (x, 2));
5153: break;
5154: }
5155:
5156: return new ? new : x;
5157: }
5158:
5159: /* Return a constant value currently equivalent to X.
5160: Return 0 if we don't know one. */
5161:
5162: static rtx
5163: equiv_constant (x)
5164: rtx x;
5165: {
5166: if (GET_CODE (x) == REG
5167: && REGNO_QTY_VALID_P (REGNO (x))
5168: && qty_const[reg_qty[REGNO (x)]])
5169: x = gen_lowpart_if_possible (GET_MODE (x), qty_const[reg_qty[REGNO (x)]]);
5170:
5171: if (x != 0 && CONSTANT_P (x))
5172: return x;
5173:
1.1.1.3 root 5174: /* If X is a MEM, try to fold it outside the context of any insn to see if
5175: it might be equivalent to a constant. That handles the case where it
5176: is a constant-pool reference. Then try to look it up in the hash table
5177: in case it is something whose value we have seen before. */
5178:
5179: if (GET_CODE (x) == MEM)
5180: {
5181: struct table_elt *elt;
5182:
1.1.1.4 ! root 5183: x = fold_rtx (x, NULL_RTX);
1.1.1.3 root 5184: if (CONSTANT_P (x))
5185: return x;
5186:
5187: elt = lookup (x, safe_hash (x, GET_MODE (x)) % NBUCKETS, GET_MODE (x));
5188: if (elt == 0)
5189: return 0;
5190:
5191: for (elt = elt->first_same_value; elt; elt = elt->next_same_value)
5192: if (elt->is_const && CONSTANT_P (elt->exp))
5193: return elt->exp;
5194: }
5195:
1.1 root 5196: return 0;
5197: }
5198:
5199: /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a fixed-point
5200: number, return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
5201: least-significant part of X.
5202: MODE specifies how big a part of X to return.
5203:
5204: If the requested operation cannot be done, 0 is returned.
5205:
5206: This is similar to gen_lowpart in emit-rtl.c. */
5207:
5208: rtx
5209: gen_lowpart_if_possible (mode, x)
5210: enum machine_mode mode;
5211: register rtx x;
5212: {
5213: rtx result = gen_lowpart_common (mode, x);
5214:
5215: if (result)
5216: return result;
5217: else if (GET_CODE (x) == MEM)
5218: {
5219: /* This is the only other case we handle. */
5220: register int offset = 0;
5221: rtx new;
5222:
5223: #if WORDS_BIG_ENDIAN
5224: offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
5225: - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
5226: #endif
5227: #if BYTES_BIG_ENDIAN
5228: /* Adjust the address so that the address-after-the-data
5229: is unchanged. */
5230: offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
5231: - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
5232: #endif
5233: new = gen_rtx (MEM, mode, plus_constant (XEXP (x, 0), offset));
5234: if (! memory_address_p (mode, XEXP (new, 0)))
5235: return 0;
5236: MEM_VOLATILE_P (new) = MEM_VOLATILE_P (x);
5237: RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x);
5238: MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (x);
5239: return new;
5240: }
5241: else
5242: return 0;
5243: }
5244:
5245: /* Given INSN, a jump insn, TAKEN indicates if we are following the "taken"
5246: branch. It will be zero if not.
5247:
5248: In certain cases, this can cause us to add an equivalence. For example,
5249: if we are following the taken case of
5250: if (i == 2)
5251: we can add the fact that `i' and '2' are now equivalent.
5252:
5253: In any case, we can record that this comparison was passed. If the same
5254: comparison is seen later, we will know its value. */
5255:
5256: static void
5257: record_jump_equiv (insn, taken)
5258: rtx insn;
5259: int taken;
5260: {
5261: int cond_known_true;
5262: rtx op0, op1;
1.1.1.4 ! root 5263: enum machine_mode mode, mode0, mode1;
1.1 root 5264: int reversed_nonequality = 0;
5265: enum rtx_code code;
5266:
5267: /* Ensure this is the right kind of insn. */
5268: if (! condjump_p (insn) || simplejump_p (insn))
5269: return;
5270:
5271: /* See if this jump condition is known true or false. */
5272: if (taken)
5273: cond_known_true = (XEXP (SET_SRC (PATTERN (insn)), 2) == pc_rtx);
5274: else
5275: cond_known_true = (XEXP (SET_SRC (PATTERN (insn)), 1) == pc_rtx);
5276:
5277: /* Get the type of comparison being done and the operands being compared.
5278: If we had to reverse a non-equality condition, record that fact so we
5279: know that it isn't valid for floating-point. */
5280: code = GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0));
5281: op0 = fold_rtx (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 0), insn);
5282: op1 = fold_rtx (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 1), insn);
5283:
1.1.1.4 ! root 5284: code = find_comparison_args (code, &op0, &op1, &mode0, &mode1);
1.1 root 5285: if (! cond_known_true)
5286: {
5287: reversed_nonequality = (code != EQ && code != NE);
5288: code = reverse_condition (code);
5289: }
5290:
5291: /* The mode is the mode of the non-constant. */
1.1.1.4 ! root 5292: mode = mode0;
! 5293: if (mode1 != VOIDmode)
! 5294: mode = mode1;
1.1 root 5295:
5296: record_jump_cond (code, mode, op0, op1, reversed_nonequality);
5297: }
5298:
5299: /* We know that comparison CODE applied to OP0 and OP1 in MODE is true.
5300: REVERSED_NONEQUALITY is nonzero if CODE had to be swapped.
5301: Make any useful entries we can with that information. Called from
5302: above function and called recursively. */
5303:
5304: static void
5305: record_jump_cond (code, mode, op0, op1, reversed_nonequality)
5306: enum rtx_code code;
5307: enum machine_mode mode;
5308: rtx op0, op1;
5309: int reversed_nonequality;
5310: {
5311: int op0_hash_code, op1_hash_code;
5312: int op0_in_memory, op0_in_struct, op1_in_memory, op1_in_struct;
5313: struct table_elt *op0_elt, *op1_elt;
5314:
5315: /* If OP0 and OP1 are known equal, and either is a paradoxical SUBREG,
5316: we know that they are also equal in the smaller mode (this is also
5317: true for all smaller modes whether or not there is a SUBREG, but
5318: is not worth testing for with no SUBREG. */
5319:
5320: if (code == EQ && GET_CODE (op0) == SUBREG
5321: && GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
5322: {
5323: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
5324: rtx tem = gen_lowpart_if_possible (inner_mode, op1);
5325:
5326: record_jump_cond (code, mode, SUBREG_REG (op0),
5327: tem ? tem : gen_rtx (SUBREG, inner_mode, op1, 0),
5328: reversed_nonequality);
5329: }
5330:
5331: if (code == EQ && GET_CODE (op1) == SUBREG
5332: && GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op1))))
5333: {
5334: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op1));
5335: rtx tem = gen_lowpart_if_possible (inner_mode, op0);
5336:
5337: record_jump_cond (code, mode, SUBREG_REG (op1),
5338: tem ? tem : gen_rtx (SUBREG, inner_mode, op0, 0),
5339: reversed_nonequality);
5340: }
5341:
5342: /* Similarly, if this is an NE comparison, and either is a SUBREG
5343: making a smaller mode, we know the whole thing is also NE. */
5344:
5345: if (code == NE && GET_CODE (op0) == SUBREG
5346: && subreg_lowpart_p (op0)
5347: && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
5348: {
5349: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
5350: rtx tem = gen_lowpart_if_possible (inner_mode, op1);
5351:
5352: record_jump_cond (code, mode, SUBREG_REG (op0),
5353: tem ? tem : gen_rtx (SUBREG, inner_mode, op1, 0),
5354: reversed_nonequality);
5355: }
5356:
5357: if (code == NE && GET_CODE (op1) == SUBREG
5358: && subreg_lowpart_p (op1)
5359: && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op1))))
5360: {
5361: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op1));
5362: rtx tem = gen_lowpart_if_possible (inner_mode, op0);
5363:
5364: record_jump_cond (code, mode, SUBREG_REG (op1),
5365: tem ? tem : gen_rtx (SUBREG, inner_mode, op0, 0),
5366: reversed_nonequality);
5367: }
5368:
5369: /* Hash both operands. */
5370:
5371: do_not_record = 0;
5372: hash_arg_in_memory = 0;
5373: hash_arg_in_struct = 0;
5374: op0_hash_code = HASH (op0, mode);
5375: op0_in_memory = hash_arg_in_memory;
5376: op0_in_struct = hash_arg_in_struct;
5377:
5378: if (do_not_record)
5379: return;
5380:
5381: do_not_record = 0;
5382: hash_arg_in_memory = 0;
5383: hash_arg_in_struct = 0;
5384: op1_hash_code = HASH (op1, mode);
5385: op1_in_memory = hash_arg_in_memory;
5386: op1_in_struct = hash_arg_in_struct;
5387:
5388: if (do_not_record)
5389: return;
5390:
5391: /* Look up both operands. */
5392: op0_elt = lookup (op0, op0_hash_code, mode);
5393: op1_elt = lookup (op1, op1_hash_code, mode);
5394:
5395: /* If we aren't setting two things equal all we can do is save this
1.1.1.4 ! root 5396: comparison. Similarly if this is floating-point. In the latter
! 5397: case, OP1 might be zero and both -0.0 and 0.0 are equal to it.
! 5398: If we record the equality, we might inadvertently delete code
! 5399: whose intent was to change -0 to +0. */
! 5400:
! 5401: if (code != EQ || GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
1.1 root 5402: {
5403: /* If we reversed a floating-point comparison, if OP0 is not a
5404: register, or if OP1 is neither a register or constant, we can't
5405: do anything. */
5406:
5407: if (GET_CODE (op1) != REG)
5408: op1 = equiv_constant (op1);
5409:
5410: if ((reversed_nonequality && GET_MODE_CLASS (mode) != MODE_INT)
5411: || GET_CODE (op0) != REG || op1 == 0)
5412: return;
5413:
5414: /* Put OP0 in the hash table if it isn't already. This gives it a
5415: new quantity number. */
5416: if (op0_elt == 0)
5417: {
1.1.1.4 ! root 5418: if (insert_regs (op0, NULL_PTR, 0))
1.1 root 5419: {
5420: rehash_using_reg (op0);
5421: op0_hash_code = HASH (op0, mode);
5422: }
5423:
1.1.1.4 ! root 5424: op0_elt = insert (op0, NULL_PTR, op0_hash_code, mode);
1.1 root 5425: op0_elt->in_memory = op0_in_memory;
5426: op0_elt->in_struct = op0_in_struct;
5427: }
5428:
5429: qty_comparison_code[reg_qty[REGNO (op0)]] = code;
5430: if (GET_CODE (op1) == REG)
5431: {
5432: /* Put OP1 in the hash table so it gets a new quantity number. */
5433: if (op1_elt == 0)
5434: {
1.1.1.4 ! root 5435: if (insert_regs (op1, NULL_PTR, 0))
1.1 root 5436: {
5437: rehash_using_reg (op1);
5438: op1_hash_code = HASH (op1, mode);
5439: }
5440:
1.1.1.4 ! root 5441: op1_elt = insert (op1, NULL_PTR, op1_hash_code, mode);
1.1 root 5442: op1_elt->in_memory = op1_in_memory;
5443: op1_elt->in_struct = op1_in_struct;
5444: }
5445:
5446: qty_comparison_qty[reg_qty[REGNO (op0)]] = reg_qty[REGNO (op1)];
5447: qty_comparison_const[reg_qty[REGNO (op0)]] = 0;
5448: }
5449: else
5450: {
5451: qty_comparison_qty[reg_qty[REGNO (op0)]] = -1;
5452: qty_comparison_const[reg_qty[REGNO (op0)]] = op1;
5453: }
5454:
5455: return;
5456: }
5457:
5458: /* If both are equivalent, merge the two classes. Save this class for
5459: `cse_set_around_loop'. */
5460: if (op0_elt && op1_elt)
5461: {
5462: merge_equiv_classes (op0_elt, op1_elt);
5463: last_jump_equiv_class = op0_elt;
5464: }
5465:
5466: /* For whichever side doesn't have an equivalence, make one. */
5467: if (op0_elt == 0)
5468: {
5469: if (insert_regs (op0, op1_elt, 0))
5470: {
5471: rehash_using_reg (op0);
5472: op0_hash_code = HASH (op0, mode);
5473: }
5474:
5475: op0_elt = insert (op0, op1_elt, op0_hash_code, mode);
5476: op0_elt->in_memory = op0_in_memory;
5477: op0_elt->in_struct = op0_in_struct;
5478: last_jump_equiv_class = op0_elt;
5479: }
5480:
5481: if (op1_elt == 0)
5482: {
5483: if (insert_regs (op1, op0_elt, 0))
5484: {
5485: rehash_using_reg (op1);
5486: op1_hash_code = HASH (op1, mode);
5487: }
5488:
5489: op1_elt = insert (op1, op0_elt, op1_hash_code, mode);
5490: op1_elt->in_memory = op1_in_memory;
5491: op1_elt->in_struct = op1_in_struct;
5492: last_jump_equiv_class = op1_elt;
5493: }
5494: }
5495:
5496: /* CSE processing for one instruction.
5497: First simplify sources and addresses of all assignments
5498: in the instruction, using previously-computed equivalents values.
5499: Then install the new sources and destinations in the table
5500: of available values.
5501:
5502: If IN_LIBCALL_BLOCK is nonzero, don't record any equivalence made in
5503: the insn. */
5504:
5505: /* Data on one SET contained in the instruction. */
5506:
5507: struct set
5508: {
5509: /* The SET rtx itself. */
5510: rtx rtl;
5511: /* The SET_SRC of the rtx (the original value, if it is changing). */
5512: rtx src;
5513: /* The hash-table element for the SET_SRC of the SET. */
5514: struct table_elt *src_elt;
5515: /* Hash code for the SET_SRC. */
5516: int src_hash_code;
5517: /* Hash code for the SET_DEST. */
5518: int dest_hash_code;
5519: /* The SET_DEST, with SUBREG, etc., stripped. */
5520: rtx inner_dest;
5521: /* Place where the pointer to the INNER_DEST was found. */
5522: rtx *inner_dest_loc;
5523: /* Nonzero if the SET_SRC is in memory. */
5524: char src_in_memory;
5525: /* Nonzero if the SET_SRC is in a structure. */
5526: char src_in_struct;
5527: /* Nonzero if the SET_SRC contains something
5528: whose value cannot be predicted and understood. */
5529: char src_volatile;
5530: /* Original machine mode, in case it becomes a CONST_INT. */
5531: enum machine_mode mode;
5532: /* A constant equivalent for SET_SRC, if any. */
5533: rtx src_const;
5534: /* Hash code of constant equivalent for SET_SRC. */
5535: int src_const_hash_code;
5536: /* Table entry for constant equivalent for SET_SRC, if any. */
5537: struct table_elt *src_const_elt;
5538: };
5539:
5540: static void
5541: cse_insn (insn, in_libcall_block)
5542: rtx insn;
5543: int in_libcall_block;
5544: {
5545: register rtx x = PATTERN (insn);
5546: rtx tem;
5547: register int i;
5548: register int n_sets = 0;
5549:
5550: /* Records what this insn does to set CC0. */
5551: rtx this_insn_cc0 = 0;
5552: enum machine_mode this_insn_cc0_mode;
5553: struct write_data writes_memory;
5554: static struct write_data init = {0, 0, 0, 0};
5555:
5556: rtx src_eqv = 0;
5557: struct table_elt *src_eqv_elt = 0;
5558: int src_eqv_volatile;
5559: int src_eqv_in_memory;
5560: int src_eqv_in_struct;
5561: int src_eqv_hash_code;
5562:
5563: struct set *sets;
5564:
5565: this_insn = insn;
5566: writes_memory = init;
5567:
5568: /* Find all the SETs and CLOBBERs in this instruction.
5569: Record all the SETs in the array `set' and count them.
5570: Also determine whether there is a CLOBBER that invalidates
5571: all memory references, or all references at varying addresses. */
5572:
5573: if (GET_CODE (x) == SET)
5574: {
5575: sets = (struct set *) alloca (sizeof (struct set));
5576: sets[0].rtl = x;
5577:
5578: /* Ignore SETs that are unconditional jumps.
5579: They never need cse processing, so this does not hurt.
5580: The reason is not efficiency but rather
5581: so that we can test at the end for instructions
5582: that have been simplified to unconditional jumps
5583: and not be misled by unchanged instructions
5584: that were unconditional jumps to begin with. */
5585: if (SET_DEST (x) == pc_rtx
5586: && GET_CODE (SET_SRC (x)) == LABEL_REF)
5587: ;
5588:
5589: /* Don't count call-insns, (set (reg 0) (call ...)), as a set.
5590: The hard function value register is used only once, to copy to
5591: someplace else, so it isn't worth cse'ing (and on 80386 is unsafe)!
5592: Ensure we invalidate the destination register. On the 80386 no
1.1.1.4 ! root 5593: other code would invalidate it since it is a fixed_reg.
! 5594: We need not check the return of apply_change_group; see canon_reg. */
1.1 root 5595:
5596: else if (GET_CODE (SET_SRC (x)) == CALL)
5597: {
5598: canon_reg (SET_SRC (x), insn);
1.1.1.4 ! root 5599: apply_change_group ();
1.1 root 5600: fold_rtx (SET_SRC (x), insn);
5601: invalidate (SET_DEST (x));
5602: }
5603: else
5604: n_sets = 1;
5605: }
5606: else if (GET_CODE (x) == PARALLEL)
5607: {
5608: register int lim = XVECLEN (x, 0);
5609:
5610: sets = (struct set *) alloca (lim * sizeof (struct set));
5611:
5612: /* Find all regs explicitly clobbered in this insn,
5613: and ensure they are not replaced with any other regs
5614: elsewhere in this insn.
5615: When a reg that is clobbered is also used for input,
5616: we should presume that that is for a reason,
5617: and we should not substitute some other register
5618: which is not supposed to be clobbered.
5619: Therefore, this loop cannot be merged into the one below
1.1.1.3 root 5620: because a CALL may precede a CLOBBER and refer to the
1.1 root 5621: value clobbered. We must not let a canonicalization do
5622: anything in that case. */
5623: for (i = 0; i < lim; i++)
5624: {
5625: register rtx y = XVECEXP (x, 0, i);
1.1.1.3 root 5626: if (GET_CODE (y) == CLOBBER
5627: && (GET_CODE (XEXP (y, 0)) == REG
5628: || GET_CODE (XEXP (y, 0)) == SUBREG))
1.1 root 5629: invalidate (XEXP (y, 0));
5630: }
5631:
5632: for (i = 0; i < lim; i++)
5633: {
5634: register rtx y = XVECEXP (x, 0, i);
5635: if (GET_CODE (y) == SET)
5636: {
1.1.1.4 ! root 5637: /* As above, we ignore unconditional jumps and call-insns and
! 5638: ignore the result of apply_change_group. */
1.1 root 5639: if (GET_CODE (SET_SRC (y)) == CALL)
5640: {
5641: canon_reg (SET_SRC (y), insn);
1.1.1.4 ! root 5642: apply_change_group ();
1.1 root 5643: fold_rtx (SET_SRC (y), insn);
5644: invalidate (SET_DEST (y));
5645: }
5646: else if (SET_DEST (y) == pc_rtx
5647: && GET_CODE (SET_SRC (y)) == LABEL_REF)
5648: ;
5649: else
5650: sets[n_sets++].rtl = y;
5651: }
5652: else if (GET_CODE (y) == CLOBBER)
5653: {
5654: /* If we clobber memory, take note of that,
5655: and canon the address.
5656: This does nothing when a register is clobbered
5657: because we have already invalidated the reg. */
5658: if (GET_CODE (XEXP (y, 0)) == MEM)
5659: {
1.1.1.4 ! root 5660: canon_reg (XEXP (y, 0), NULL_RTX);
1.1 root 5661: note_mem_written (XEXP (y, 0), &writes_memory);
5662: }
5663: }
5664: else if (GET_CODE (y) == USE
5665: && ! (GET_CODE (XEXP (y, 0)) == REG
5666: && REGNO (XEXP (y, 0)) < FIRST_PSEUDO_REGISTER))
1.1.1.4 ! root 5667: canon_reg (y, NULL_RTX);
1.1 root 5668: else if (GET_CODE (y) == CALL)
5669: {
1.1.1.4 ! root 5670: /* The result of apply_change_group can be ignored; see
! 5671: canon_reg. */
1.1 root 5672: canon_reg (y, insn);
1.1.1.4 ! root 5673: apply_change_group ();
1.1 root 5674: fold_rtx (y, insn);
5675: }
5676: }
5677: }
5678: else if (GET_CODE (x) == CLOBBER)
5679: {
5680: if (GET_CODE (XEXP (x, 0)) == MEM)
5681: {
1.1.1.4 ! root 5682: canon_reg (XEXP (x, 0), NULL_RTX);
1.1 root 5683: note_mem_written (XEXP (x, 0), &writes_memory);
5684: }
5685: }
5686:
5687: /* Canonicalize a USE of a pseudo register or memory location. */
5688: else if (GET_CODE (x) == USE
5689: && ! (GET_CODE (XEXP (x, 0)) == REG
5690: && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER))
1.1.1.4 ! root 5691: canon_reg (XEXP (x, 0), NULL_RTX);
1.1 root 5692: else if (GET_CODE (x) == CALL)
5693: {
1.1.1.4 ! root 5694: /* The result of apply_change_group can be ignored; see canon_reg. */
1.1 root 5695: canon_reg (x, insn);
1.1.1.4 ! root 5696: apply_change_group ();
1.1 root 5697: fold_rtx (x, insn);
5698: }
5699:
5700: if (n_sets == 1 && REG_NOTES (insn) != 0)
5701: {
5702: /* Store the equivalent value in SRC_EQV, if different. */
1.1.1.4 ! root 5703: rtx tem = find_reg_note (insn, REG_EQUAL, NULL_RTX);
1.1 root 5704:
5705: if (tem && ! rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl)))
1.1.1.4 ! root 5706: src_eqv = canon_reg (XEXP (tem, 0), NULL_RTX);
1.1 root 5707: }
5708:
5709: /* Canonicalize sources and addresses of destinations.
5710: We do this in a separate pass to avoid problems when a MATCH_DUP is
5711: present in the insn pattern. In that case, we want to ensure that
5712: we don't break the duplicate nature of the pattern. So we will replace
5713: both operands at the same time. Otherwise, we would fail to find an
5714: equivalent substitution in the loop calling validate_change below.
5715:
5716: We used to suppress canonicalization of DEST if it appears in SRC,
1.1.1.4 ! root 5717: but we don't do this any more. */
1.1 root 5718:
5719: for (i = 0; i < n_sets; i++)
5720: {
5721: rtx dest = SET_DEST (sets[i].rtl);
5722: rtx src = SET_SRC (sets[i].rtl);
5723: rtx new = canon_reg (src, insn);
5724:
1.1.1.4 ! root 5725: if ((GET_CODE (new) == REG && GET_CODE (src) == REG
! 5726: && ((REGNO (new) < FIRST_PSEUDO_REGISTER)
! 5727: != (REGNO (src) < FIRST_PSEUDO_REGISTER)))
! 5728: || insn_n_dups[recog_memoized (insn)] > 0)
! 5729: validate_change (insn, &SET_SRC (sets[i].rtl), new, 1);
1.1 root 5730: else
5731: SET_SRC (sets[i].rtl) = new;
5732:
5733: if (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT)
5734: {
5735: validate_change (insn, &XEXP (dest, 1),
1.1.1.4 ! root 5736: canon_reg (XEXP (dest, 1), insn), 1);
1.1 root 5737: validate_change (insn, &XEXP (dest, 2),
1.1.1.4 ! root 5738: canon_reg (XEXP (dest, 2), insn), 1);
1.1 root 5739: }
5740:
5741: while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
5742: || GET_CODE (dest) == ZERO_EXTRACT
5743: || GET_CODE (dest) == SIGN_EXTRACT)
5744: dest = XEXP (dest, 0);
5745:
5746: if (GET_CODE (dest) == MEM)
5747: canon_reg (dest, insn);
5748: }
5749:
1.1.1.4 ! root 5750: /* Now that we have done all the replacements, we can apply the change
! 5751: group and see if they all work. Note that this will cause some
! 5752: canonicalizations that would have worked individually not to be applied
! 5753: because some other canonicalization didn't work, but this should not
! 5754: occur often.
! 5755:
! 5756: The result of apply_change_group can be ignored; see canon_reg. */
! 5757:
! 5758: apply_change_group ();
! 5759:
1.1 root 5760: /* Set sets[i].src_elt to the class each source belongs to.
5761: Detect assignments from or to volatile things
5762: and set set[i] to zero so they will be ignored
5763: in the rest of this function.
5764:
5765: Nothing in this loop changes the hash table or the register chains. */
5766:
5767: for (i = 0; i < n_sets; i++)
5768: {
5769: register rtx src, dest;
5770: register rtx src_folded;
5771: register struct table_elt *elt = 0, *p;
5772: enum machine_mode mode;
5773: rtx src_eqv_here;
5774: rtx src_const = 0;
5775: rtx src_related = 0;
5776: struct table_elt *src_const_elt = 0;
5777: int src_cost = 10000, src_eqv_cost = 10000, src_folded_cost = 10000;
5778: int src_related_cost = 10000, src_elt_cost = 10000;
5779: /* Set non-zero if we need to call force_const_mem on with the
5780: contents of src_folded before using it. */
5781: int src_folded_force_flag = 0;
5782:
5783: dest = SET_DEST (sets[i].rtl);
5784: src = SET_SRC (sets[i].rtl);
5785:
5786: /* If SRC is a constant that has no machine mode,
5787: hash it with the destination's machine mode.
5788: This way we can keep different modes separate. */
5789:
5790: mode = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
5791: sets[i].mode = mode;
5792:
5793: if (src_eqv)
5794: {
5795: enum machine_mode eqvmode = mode;
5796: if (GET_CODE (dest) == STRICT_LOW_PART)
5797: eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0)));
5798: do_not_record = 0;
5799: hash_arg_in_memory = 0;
5800: hash_arg_in_struct = 0;
5801: src_eqv = fold_rtx (src_eqv, insn);
5802: src_eqv_hash_code = HASH (src_eqv, eqvmode);
5803:
5804: /* Find the equivalence class for the equivalent expression. */
5805:
5806: if (!do_not_record)
5807: src_eqv_elt = lookup (src_eqv, src_eqv_hash_code, eqvmode);
5808:
5809: src_eqv_volatile = do_not_record;
5810: src_eqv_in_memory = hash_arg_in_memory;
5811: src_eqv_in_struct = hash_arg_in_struct;
5812: }
5813:
5814: /* If this is a STRICT_LOW_PART assignment, src_eqv corresponds to the
5815: value of the INNER register, not the destination. So it is not
5816: a legal substitution for the source. But save it for later. */
5817: if (GET_CODE (dest) == STRICT_LOW_PART)
5818: src_eqv_here = 0;
5819: else
5820: src_eqv_here = src_eqv;
5821:
5822: /* Simplify and foldable subexpressions in SRC. Then get the fully-
5823: simplified result, which may not necessarily be valid. */
5824: src_folded = fold_rtx (src, insn);
5825:
5826: /* If storing a constant in a bitfield, pre-truncate the constant
5827: so we will be able to record it later. */
5828: if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT
5829: || GET_CODE (SET_DEST (sets[i].rtl)) == SIGN_EXTRACT)
5830: {
5831: rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
5832:
5833: if (GET_CODE (src) == CONST_INT
5834: && GET_CODE (width) == CONST_INT
1.1.1.4 ! root 5835: && INTVAL (width) < HOST_BITS_PER_WIDE_INT
! 5836: && (INTVAL (src) & ((HOST_WIDE_INT) (-1) << INTVAL (width))))
! 5837: src_folded
! 5838: = GEN_INT (INTVAL (src) & (((HOST_WIDE_INT) 1
! 5839: << INTVAL (width)) - 1));
1.1 root 5840: }
5841:
5842: /* Compute SRC's hash code, and also notice if it
5843: should not be recorded at all. In that case,
5844: prevent any further processing of this assignment. */
5845: do_not_record = 0;
5846: hash_arg_in_memory = 0;
5847: hash_arg_in_struct = 0;
5848:
5849: sets[i].src = src;
5850: sets[i].src_hash_code = HASH (src, mode);
5851: sets[i].src_volatile = do_not_record;
5852: sets[i].src_in_memory = hash_arg_in_memory;
5853: sets[i].src_in_struct = hash_arg_in_struct;
5854:
1.1.1.4 ! root 5855: #if 0
! 5856: /* It is no longer clear why we used to do this, but it doesn't
! 5857: appear to still be needed. So let's try without it since this
! 5858: code hurts cse'ing widened ops. */
1.1 root 5859: /* If source is a perverse subreg (such as QI treated as an SI),
5860: treat it as volatile. It may do the work of an SI in one context
5861: where the extra bits are not being used, but cannot replace an SI
5862: in general. */
5863: if (GET_CODE (src) == SUBREG
5864: && (GET_MODE_SIZE (GET_MODE (src))
5865: > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))))
5866: sets[i].src_volatile = 1;
1.1.1.4 ! root 5867: #endif
1.1 root 5868:
5869: /* Locate all possible equivalent forms for SRC. Try to replace
5870: SRC in the insn with each cheaper equivalent.
5871:
5872: We have the following types of equivalents: SRC itself, a folded
5873: version, a value given in a REG_EQUAL note, or a value related
5874: to a constant.
5875:
5876: Each of these equivalents may be part of an additional class
5877: of equivalents (if more than one is in the table, they must be in
5878: the same class; we check for this).
5879:
5880: If the source is volatile, we don't do any table lookups.
5881:
5882: We note any constant equivalent for possible later use in a
5883: REG_NOTE. */
5884:
5885: if (!sets[i].src_volatile)
5886: elt = lookup (src, sets[i].src_hash_code, mode);
5887:
5888: sets[i].src_elt = elt;
5889:
5890: if (elt && src_eqv_here && src_eqv_elt)
5891: {
5892: if (elt->first_same_value != src_eqv_elt->first_same_value)
5893: {
5894: /* The REG_EQUAL is indicating that two formerly distinct
5895: classes are now equivalent. So merge them. */
5896: merge_equiv_classes (elt, src_eqv_elt);
5897: src_eqv_hash_code = HASH (src_eqv, elt->mode);
5898: src_eqv_elt = lookup (src_eqv, src_eqv_hash_code, elt->mode);
5899: }
5900:
5901: src_eqv_here = 0;
5902: }
5903:
5904: else if (src_eqv_elt)
5905: elt = src_eqv_elt;
5906:
5907: /* Try to find a constant somewhere and record it in `src_const'.
5908: Record its table element, if any, in `src_const_elt'. Look in
5909: any known equivalences first. (If the constant is not in the
5910: table, also set `sets[i].src_const_hash_code'). */
5911: if (elt)
5912: for (p = elt->first_same_value; p; p = p->next_same_value)
5913: if (p->is_const)
5914: {
5915: src_const = p->exp;
5916: src_const_elt = elt;
5917: break;
5918: }
5919:
5920: if (src_const == 0
5921: && (CONSTANT_P (src_folded)
5922: /* Consider (minus (label_ref L1) (label_ref L2)) as
5923: "constant" here so we will record it. This allows us
5924: to fold switch statements when an ADDR_DIFF_VEC is used. */
5925: || (GET_CODE (src_folded) == MINUS
5926: && GET_CODE (XEXP (src_folded, 0)) == LABEL_REF
5927: && GET_CODE (XEXP (src_folded, 1)) == LABEL_REF)))
5928: src_const = src_folded, src_const_elt = elt;
5929: else if (src_const == 0 && src_eqv_here && CONSTANT_P (src_eqv_here))
5930: src_const = src_eqv_here, src_const_elt = src_eqv_elt;
5931:
5932: /* If we don't know if the constant is in the table, get its
5933: hash code and look it up. */
5934: if (src_const && src_const_elt == 0)
5935: {
5936: sets[i].src_const_hash_code = HASH (src_const, mode);
5937: src_const_elt = lookup (src_const, sets[i].src_const_hash_code,
5938: mode);
5939: }
5940:
5941: sets[i].src_const = src_const;
5942: sets[i].src_const_elt = src_const_elt;
5943:
5944: /* If the constant and our source are both in the table, mark them as
5945: equivalent. Otherwise, if a constant is in the table but the source
5946: isn't, set ELT to it. */
5947: if (src_const_elt && elt
5948: && src_const_elt->first_same_value != elt->first_same_value)
5949: merge_equiv_classes (elt, src_const_elt);
5950: else if (src_const_elt && elt == 0)
5951: elt = src_const_elt;
5952:
5953: /* See if there is a register linearly related to a constant
5954: equivalent of SRC. */
5955: if (src_const
5956: && (GET_CODE (src_const) == CONST
5957: || (src_const_elt && src_const_elt->related_value != 0)))
5958: {
5959: src_related = use_related_value (src_const, src_const_elt);
5960: if (src_related)
5961: {
5962: struct table_elt *src_related_elt
5963: = lookup (src_related, HASH (src_related, mode), mode);
5964: if (src_related_elt && elt)
5965: {
5966: if (elt->first_same_value
5967: != src_related_elt->first_same_value)
5968: /* This can occur when we previously saw a CONST
5969: involving a SYMBOL_REF and then see the SYMBOL_REF
5970: twice. Merge the involved classes. */
5971: merge_equiv_classes (elt, src_related_elt);
5972:
5973: src_related = 0;
5974: src_related_elt = 0;
5975: }
5976: else if (src_related_elt && elt == 0)
5977: elt = src_related_elt;
5978: }
5979: }
5980:
1.1.1.4 ! root 5981: /* See if we have a CONST_INT that is already in a register in a
! 5982: wider mode. */
! 5983:
! 5984: if (src_const && src_related == 0 && GET_CODE (src_const) == CONST_INT
! 5985: && GET_MODE_CLASS (mode) == MODE_INT
! 5986: && GET_MODE_BITSIZE (mode) < BITS_PER_WORD)
! 5987: {
! 5988: enum machine_mode wider_mode;
! 5989:
! 5990: for (wider_mode = GET_MODE_WIDER_MODE (mode);
! 5991: GET_MODE_BITSIZE (wider_mode) <= BITS_PER_WORD
! 5992: && src_related == 0;
! 5993: wider_mode = GET_MODE_WIDER_MODE (wider_mode))
! 5994: {
! 5995: struct table_elt *const_elt
! 5996: = lookup (src_const, HASH (src_const, wider_mode), wider_mode);
! 5997:
! 5998: if (const_elt == 0)
! 5999: continue;
! 6000:
! 6001: for (const_elt = const_elt->first_same_value;
! 6002: const_elt; const_elt = const_elt->next_same_value)
! 6003: if (GET_CODE (const_elt->exp) == REG)
! 6004: {
! 6005: src_related = gen_lowpart_if_possible (mode,
! 6006: const_elt->exp);
! 6007: break;
! 6008: }
! 6009: }
! 6010: }
! 6011:
1.1.1.2 root 6012: /* Another possibility is that we have an AND with a constant in
6013: a mode narrower than a word. If so, it might have been generated
6014: as part of an "if" which would narrow the AND. If we already
6015: have done the AND in a wider mode, we can use a SUBREG of that
6016: value. */
6017:
6018: if (flag_expensive_optimizations && ! src_related
6019: && GET_CODE (src) == AND && GET_CODE (XEXP (src, 1)) == CONST_INT
6020: && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6021: {
6022: enum machine_mode tmode;
1.1.1.4 ! root 6023: rtx new_and = gen_rtx (AND, VOIDmode, NULL_RTX, XEXP (src, 1));
1.1.1.2 root 6024:
6025: for (tmode = GET_MODE_WIDER_MODE (mode);
6026: GET_MODE_SIZE (tmode) <= UNITS_PER_WORD;
6027: tmode = GET_MODE_WIDER_MODE (tmode))
6028: {
6029: rtx inner = gen_lowpart_if_possible (tmode, XEXP (src, 0));
6030: struct table_elt *larger_elt;
6031:
6032: if (inner)
6033: {
6034: PUT_MODE (new_and, tmode);
6035: XEXP (new_and, 0) = inner;
6036: larger_elt = lookup (new_and, HASH (new_and, tmode), tmode);
6037: if (larger_elt == 0)
6038: continue;
6039:
6040: for (larger_elt = larger_elt->first_same_value;
6041: larger_elt; larger_elt = larger_elt->next_same_value)
6042: if (GET_CODE (larger_elt->exp) == REG)
6043: {
6044: src_related
6045: = gen_lowpart_if_possible (mode, larger_elt->exp);
6046: break;
6047: }
6048:
6049: if (src_related)
6050: break;
6051: }
6052: }
6053: }
6054:
1.1 root 6055: if (src == src_folded)
6056: src_folded = 0;
6057:
6058: /* At this point, ELT, if non-zero, points to a class of expressions
6059: equivalent to the source of this SET and SRC, SRC_EQV, SRC_FOLDED,
6060: and SRC_RELATED, if non-zero, each contain additional equivalent
6061: expressions. Prune these latter expressions by deleting expressions
6062: already in the equivalence class.
6063:
6064: Check for an equivalent identical to the destination. If found,
6065: this is the preferred equivalent since it will likely lead to
6066: elimination of the insn. Indicate this by placing it in
6067: `src_related'. */
6068:
6069: if (elt) elt = elt->first_same_value;
6070: for (p = elt; p; p = p->next_same_value)
6071: {
6072: enum rtx_code code = GET_CODE (p->exp);
6073:
6074: /* If the expression is not valid, ignore it. Then we do not
6075: have to check for validity below. In most cases, we can use
6076: `rtx_equal_p', since canonicalization has already been done. */
6077: if (code != REG && ! exp_equiv_p (p->exp, p->exp, 1, 0))
6078: continue;
6079:
6080: if (src && GET_CODE (src) == code && rtx_equal_p (src, p->exp))
6081: src = 0;
6082: else if (src_folded && GET_CODE (src_folded) == code
6083: && rtx_equal_p (src_folded, p->exp))
6084: src_folded = 0;
6085: else if (src_eqv_here && GET_CODE (src_eqv_here) == code
6086: && rtx_equal_p (src_eqv_here, p->exp))
6087: src_eqv_here = 0;
6088: else if (src_related && GET_CODE (src_related) == code
6089: && rtx_equal_p (src_related, p->exp))
6090: src_related = 0;
6091:
6092: /* This is the same as the destination of the insns, we want
6093: to prefer it. Copy it to src_related. The code below will
6094: then give it a negative cost. */
6095: if (GET_CODE (dest) == code && rtx_equal_p (p->exp, dest))
6096: src_related = dest;
6097:
6098: }
6099:
6100: /* Find the cheapest valid equivalent, trying all the available
6101: possibilities. Prefer items not in the hash table to ones
6102: that are when they are equal cost. Note that we can never
6103: worsen an insn as the current contents will also succeed.
1.1.1.3 root 6104: If we find an equivalent identical to the destination, use it as best,
1.1 root 6105: since this insn will probably be eliminated in that case. */
6106: if (src)
6107: {
6108: if (rtx_equal_p (src, dest))
6109: src_cost = -1;
6110: else
6111: src_cost = COST (src);
6112: }
6113:
6114: if (src_eqv_here)
6115: {
6116: if (rtx_equal_p (src_eqv_here, dest))
6117: src_eqv_cost = -1;
6118: else
6119: src_eqv_cost = COST (src_eqv_here);
6120: }
6121:
6122: if (src_folded)
6123: {
6124: if (rtx_equal_p (src_folded, dest))
6125: src_folded_cost = -1;
6126: else
6127: src_folded_cost = COST (src_folded);
6128: }
6129:
6130: if (src_related)
6131: {
6132: if (rtx_equal_p (src_related, dest))
6133: src_related_cost = -1;
6134: else
6135: src_related_cost = COST (src_related);
6136: }
6137:
6138: /* If this was an indirect jump insn, a known label will really be
6139: cheaper even though it looks more expensive. */
6140: if (dest == pc_rtx && src_const && GET_CODE (src_const) == LABEL_REF)
6141: src_folded = src_const, src_folded_cost = -1;
6142:
6143: /* Terminate loop when replacement made. This must terminate since
6144: the current contents will be tested and will always be valid. */
6145: while (1)
6146: {
6147: rtx trial;
6148:
6149: /* Skip invalid entries. */
6150: while (elt && GET_CODE (elt->exp) != REG
6151: && ! exp_equiv_p (elt->exp, elt->exp, 1, 0))
6152: elt = elt->next_same_value;
6153:
6154: if (elt) src_elt_cost = elt->cost;
6155:
6156: /* Find cheapest and skip it for the next time. For items
6157: of equal cost, use this order:
6158: src_folded, src, src_eqv, src_related and hash table entry. */
6159: if (src_folded_cost <= src_cost
6160: && src_folded_cost <= src_eqv_cost
6161: && src_folded_cost <= src_related_cost
6162: && src_folded_cost <= src_elt_cost)
6163: {
6164: trial = src_folded, src_folded_cost = 10000;
6165: if (src_folded_force_flag)
6166: trial = force_const_mem (mode, trial);
6167: }
6168: else if (src_cost <= src_eqv_cost
6169: && src_cost <= src_related_cost
6170: && src_cost <= src_elt_cost)
6171: trial = src, src_cost = 10000;
6172: else if (src_eqv_cost <= src_related_cost
6173: && src_eqv_cost <= src_elt_cost)
6174: trial = src_eqv_here, src_eqv_cost = 10000;
6175: else if (src_related_cost <= src_elt_cost)
6176: trial = src_related, src_related_cost = 10000;
6177: else
6178: {
1.1.1.3 root 6179: trial = copy_rtx (elt->exp);
1.1 root 6180: elt = elt->next_same_value;
6181: src_elt_cost = 10000;
6182: }
6183:
6184: /* We don't normally have an insn matching (set (pc) (pc)), so
6185: check for this separately here. We will delete such an
6186: insn below.
6187:
6188: Tablejump insns contain a USE of the table, so simply replacing
6189: the operand with the constant won't match. This is simply an
6190: unconditional branch, however, and is therefore valid. Just
6191: insert the substitution here and we will delete and re-emit
6192: the insn later. */
6193:
6194: if (n_sets == 1 && dest == pc_rtx
6195: && (trial == pc_rtx
6196: || (GET_CODE (trial) == LABEL_REF
6197: && ! condjump_p (insn))))
6198: {
6199: /* If TRIAL is a label in front of a jump table, we are
6200: really falling through the switch (this is how casesi
6201: insns work), so we must branch around the table. */
6202: if (GET_CODE (trial) == CODE_LABEL
6203: && NEXT_INSN (trial) != 0
6204: && GET_CODE (NEXT_INSN (trial)) == JUMP_INSN
6205: && (GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_DIFF_VEC
6206: || GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_VEC))
6207:
6208: trial = gen_rtx (LABEL_REF, Pmode, get_label_after (trial));
6209:
6210: SET_SRC (sets[i].rtl) = trial;
6211: break;
6212: }
6213:
6214: /* Look for a substitution that makes a valid insn. */
6215: else if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0))
1.1.1.3 root 6216: {
1.1.1.4 ! root 6217: /* The result of apply_change_group can be ignored; see
! 6218: canon_reg. */
! 6219:
! 6220: validate_change (insn, &SET_SRC (sets[i].rtl),
! 6221: canon_reg (SET_SRC (sets[i].rtl), insn),
! 6222: 1);
! 6223: apply_change_group ();
1.1.1.3 root 6224: break;
6225: }
1.1 root 6226:
6227: /* If we previously found constant pool entries for
6228: constants and this is a constant, try making a
6229: pool entry. Put it in src_folded unless we already have done
6230: this since that is where it likely came from. */
6231:
6232: else if (constant_pool_entries_cost
6233: && CONSTANT_P (trial)
6234: && (src_folded == 0 || GET_CODE (src_folded) != MEM)
6235: && GET_MODE_CLASS (mode) != MODE_CC)
6236: {
6237: src_folded_force_flag = 1;
6238: src_folded = trial;
6239: src_folded_cost = constant_pool_entries_cost;
6240: }
6241: }
6242:
6243: src = SET_SRC (sets[i].rtl);
6244:
6245: /* In general, it is good to have a SET with SET_SRC == SET_DEST.
6246: However, there is an important exception: If both are registers
6247: that are not the head of their equivalence class, replace SET_SRC
6248: with the head of the class. If we do not do this, we will have
6249: both registers live over a portion of the basic block. This way,
6250: their lifetimes will likely abut instead of overlapping. */
6251: if (GET_CODE (dest) == REG
6252: && REGNO_QTY_VALID_P (REGNO (dest))
6253: && qty_mode[reg_qty[REGNO (dest)]] == GET_MODE (dest)
6254: && qty_first_reg[reg_qty[REGNO (dest)]] != REGNO (dest)
6255: && GET_CODE (src) == REG && REGNO (src) == REGNO (dest)
6256: /* Don't do this if the original insn had a hard reg as
6257: SET_SRC. */
6258: && (GET_CODE (sets[i].src) != REG
6259: || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER))
6260: /* We can't call canon_reg here because it won't do anything if
6261: SRC is a hard register. */
6262: {
6263: int first = qty_first_reg[reg_qty[REGNO (src)]];
6264:
6265: src = SET_SRC (sets[i].rtl)
6266: = first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first]
6267: : gen_rtx (REG, GET_MODE (src), first);
6268:
6269: /* If we had a constant that is cheaper than what we are now
6270: setting SRC to, use that constant. We ignored it when we
6271: thought we could make this into a no-op. */
6272: if (src_const && COST (src_const) < COST (src)
6273: && validate_change (insn, &SET_SRC (sets[i].rtl), src_const, 0))
6274: src = src_const;
6275: }
6276:
6277: /* If we made a change, recompute SRC values. */
6278: if (src != sets[i].src)
6279: {
6280: do_not_record = 0;
6281: hash_arg_in_memory = 0;
6282: hash_arg_in_struct = 0;
6283: sets[i].src = src;
6284: sets[i].src_hash_code = HASH (src, mode);
6285: sets[i].src_volatile = do_not_record;
6286: sets[i].src_in_memory = hash_arg_in_memory;
6287: sets[i].src_in_struct = hash_arg_in_struct;
6288: sets[i].src_elt = lookup (src, sets[i].src_hash_code, mode);
6289: }
6290:
6291: /* If this is a single SET, we are setting a register, and we have an
6292: equivalent constant, we want to add a REG_NOTE. We don't want
6293: to write a REG_EQUAL note for a constant pseudo since verifying that
1.1.1.2 root 6294: that pseudo hasn't been eliminated is a pain. Such a note also
1.1 root 6295: won't help anything. */
6296: if (n_sets == 1 && src_const && GET_CODE (dest) == REG
6297: && GET_CODE (src_const) != REG)
6298: {
1.1.1.4 ! root 6299: rtx tem = find_reg_note (insn, REG_EQUAL, NULL_RTX);
1.1 root 6300:
6301: /* Record the actual constant value in a REG_EQUAL note, making
6302: a new one if one does not already exist. */
6303: if (tem)
6304: XEXP (tem, 0) = src_const;
6305: else
6306: REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
6307: src_const, REG_NOTES (insn));
6308:
6309: /* If storing a constant value in a register that
6310: previously held the constant value 0,
6311: record this fact with a REG_WAS_0 note on this insn.
6312:
6313: Note that the *register* is required to have previously held 0,
6314: not just any register in the quantity and we must point to the
6315: insn that set that register to zero.
6316:
6317: Rather than track each register individually, we just see if
6318: the last set for this quantity was for this register. */
6319:
6320: if (REGNO_QTY_VALID_P (REGNO (dest))
6321: && qty_const[reg_qty[REGNO (dest)]] == const0_rtx)
6322: {
6323: /* See if we previously had a REG_WAS_0 note. */
1.1.1.4 ! root 6324: rtx note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
1.1 root 6325: rtx const_insn = qty_const_insn[reg_qty[REGNO (dest)]];
6326:
6327: if ((tem = single_set (const_insn)) != 0
6328: && rtx_equal_p (SET_DEST (tem), dest))
6329: {
6330: if (note)
6331: XEXP (note, 0) = const_insn;
6332: else
6333: REG_NOTES (insn) = gen_rtx (INSN_LIST, REG_WAS_0,
6334: const_insn, REG_NOTES (insn));
6335: }
6336: }
6337: }
6338:
6339: /* Now deal with the destination. */
6340: do_not_record = 0;
6341: sets[i].inner_dest_loc = &SET_DEST (sets[0].rtl);
6342:
6343: /* Look within any SIGN_EXTRACT or ZERO_EXTRACT
6344: to the MEM or REG within it. */
6345: while (GET_CODE (dest) == SIGN_EXTRACT
6346: || GET_CODE (dest) == ZERO_EXTRACT
6347: || GET_CODE (dest) == SUBREG
6348: || GET_CODE (dest) == STRICT_LOW_PART)
6349: {
6350: sets[i].inner_dest_loc = &XEXP (dest, 0);
6351: dest = XEXP (dest, 0);
6352: }
6353:
6354: sets[i].inner_dest = dest;
6355:
6356: if (GET_CODE (dest) == MEM)
6357: {
6358: dest = fold_rtx (dest, insn);
6359:
6360: /* Decide whether we invalidate everything in memory,
6361: or just things at non-fixed places.
6362: Writing a large aggregate must invalidate everything
6363: because we don't know how long it is. */
6364: note_mem_written (dest, &writes_memory);
6365: }
6366:
6367: /* Compute the hash code of the destination now,
6368: before the effects of this instruction are recorded,
6369: since the register values used in the address computation
6370: are those before this instruction. */
6371: sets[i].dest_hash_code = HASH (dest, mode);
6372:
6373: /* Don't enter a bit-field in the hash table
6374: because the value in it after the store
6375: may not equal what was stored, due to truncation. */
6376:
6377: if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT
6378: || GET_CODE (SET_DEST (sets[i].rtl)) == SIGN_EXTRACT)
6379: {
6380: rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
6381:
6382: if (src_const != 0 && GET_CODE (src_const) == CONST_INT
6383: && GET_CODE (width) == CONST_INT
1.1.1.4 ! root 6384: && INTVAL (width) < HOST_BITS_PER_WIDE_INT
! 6385: && ! (INTVAL (src_const)
! 6386: & ((HOST_WIDE_INT) (-1) << INTVAL (width))))
1.1 root 6387: /* Exception: if the value is constant,
6388: and it won't be truncated, record it. */
6389: ;
6390: else
6391: {
6392: /* This is chosen so that the destination will be invalidated
6393: but no new value will be recorded.
6394: We must invalidate because sometimes constant
6395: values can be recorded for bitfields. */
6396: sets[i].src_elt = 0;
6397: sets[i].src_volatile = 1;
6398: src_eqv = 0;
6399: src_eqv_elt = 0;
6400: }
6401: }
6402:
6403: /* If only one set in a JUMP_INSN and it is now a no-op, we can delete
6404: the insn. */
6405: else if (n_sets == 1 && dest == pc_rtx && src == pc_rtx)
6406: {
6407: PUT_CODE (insn, NOTE);
6408: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
6409: NOTE_SOURCE_FILE (insn) = 0;
6410: cse_jumps_altered = 1;
6411: /* One less use of the label this insn used to jump to. */
6412: --LABEL_NUSES (JUMP_LABEL (insn));
6413: /* No more processing for this set. */
6414: sets[i].rtl = 0;
6415: }
6416:
6417: /* If this SET is now setting PC to a label, we know it used to
6418: be a conditional or computed branch. So we see if we can follow
6419: it. If it was a computed branch, delete it and re-emit. */
6420: else if (dest == pc_rtx && GET_CODE (src) == LABEL_REF)
6421: {
6422: rtx p;
6423:
6424: /* If this is not in the format for a simple branch and
6425: we are the only SET in it, re-emit it. */
6426: if (! simplejump_p (insn) && n_sets == 1)
6427: {
6428: rtx new = emit_jump_insn_before (gen_jump (XEXP (src, 0)), insn);
6429: JUMP_LABEL (new) = XEXP (src, 0);
6430: LABEL_NUSES (XEXP (src, 0))++;
6431: delete_insn (insn);
6432: insn = new;
6433: }
6434:
6435: /* Now that we've converted this jump to an unconditional jump,
6436: there is dead code after it. Delete the dead code until we
6437: reach a BARRIER, the end of the function, or a label. Do
6438: not delete NOTEs except for NOTE_INSN_DELETED since later
6439: phases assume these notes are retained. */
6440:
6441: p = insn;
6442:
6443: while (NEXT_INSN (p) != 0
6444: && GET_CODE (NEXT_INSN (p)) != BARRIER
6445: && GET_CODE (NEXT_INSN (p)) != CODE_LABEL)
6446: {
6447: if (GET_CODE (NEXT_INSN (p)) != NOTE
6448: || NOTE_LINE_NUMBER (NEXT_INSN (p)) == NOTE_INSN_DELETED)
6449: delete_insn (NEXT_INSN (p));
6450: else
6451: p = NEXT_INSN (p);
6452: }
6453:
6454: /* If we don't have a BARRIER immediately after INSN, put one there.
6455: Much code assumes that there are no NOTEs between a JUMP_INSN and
6456: BARRIER. */
6457:
6458: if (NEXT_INSN (insn) == 0
6459: || GET_CODE (NEXT_INSN (insn)) != BARRIER)
6460: emit_barrier_after (insn);
6461:
6462: /* We might have two BARRIERs separated by notes. Delete the second
6463: one if so. */
6464:
1.1.1.2 root 6465: if (p != insn && NEXT_INSN (p) != 0
6466: && GET_CODE (NEXT_INSN (p)) == BARRIER)
1.1 root 6467: delete_insn (NEXT_INSN (p));
6468:
6469: cse_jumps_altered = 1;
6470: sets[i].rtl = 0;
6471: }
6472:
1.1.1.3 root 6473: /* If destination is volatile, invalidate it and then do no further
6474: processing for this assignment. */
1.1 root 6475:
6476: else if (do_not_record)
1.1.1.3 root 6477: {
6478: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
6479: || GET_CODE (dest) == MEM)
6480: invalidate (dest);
6481: sets[i].rtl = 0;
6482: }
1.1 root 6483:
6484: if (sets[i].rtl != 0 && dest != SET_DEST (sets[i].rtl))
6485: sets[i].dest_hash_code = HASH (SET_DEST (sets[i].rtl), mode);
6486:
6487: #ifdef HAVE_cc0
6488: /* If setting CC0, record what it was set to, or a constant, if it
6489: is equivalent to a constant. If it is being set to a floating-point
6490: value, make a COMPARE with the appropriate constant of 0. If we
6491: don't do this, later code can interpret this as a test against
6492: const0_rtx, which can cause problems if we try to put it into an
6493: insn as a floating-point operand. */
6494: if (dest == cc0_rtx)
6495: {
6496: this_insn_cc0 = src_const && mode != VOIDmode ? src_const : src;
6497: this_insn_cc0_mode = mode;
6498: if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6499: this_insn_cc0 = gen_rtx (COMPARE, VOIDmode, this_insn_cc0,
6500: CONST0_RTX (mode));
6501: }
6502: #endif
6503: }
6504:
6505: /* Now enter all non-volatile source expressions in the hash table
6506: if they are not already present.
6507: Record their equivalence classes in src_elt.
6508: This way we can insert the corresponding destinations into
6509: the same classes even if the actual sources are no longer in them
6510: (having been invalidated). */
6511:
6512: if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile
6513: && ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl)))
6514: {
6515: register struct table_elt *elt;
6516: register struct table_elt *classp = sets[0].src_elt;
6517: rtx dest = SET_DEST (sets[0].rtl);
6518: enum machine_mode eqvmode = GET_MODE (dest);
6519:
6520: if (GET_CODE (dest) == STRICT_LOW_PART)
6521: {
6522: eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0)));
6523: classp = 0;
6524: }
6525: if (insert_regs (src_eqv, classp, 0))
6526: src_eqv_hash_code = HASH (src_eqv, eqvmode);
6527: elt = insert (src_eqv, classp, src_eqv_hash_code, eqvmode);
6528: elt->in_memory = src_eqv_in_memory;
6529: elt->in_struct = src_eqv_in_struct;
6530: src_eqv_elt = elt;
6531: }
6532:
6533: for (i = 0; i < n_sets; i++)
6534: if (sets[i].rtl && ! sets[i].src_volatile
6535: && ! rtx_equal_p (SET_SRC (sets[i].rtl), SET_DEST (sets[i].rtl)))
6536: {
6537: if (GET_CODE (SET_DEST (sets[i].rtl)) == STRICT_LOW_PART)
6538: {
6539: /* REG_EQUAL in setting a STRICT_LOW_PART
6540: gives an equivalent for the entire destination register,
6541: not just for the subreg being stored in now.
6542: This is a more interesting equivalence, so we arrange later
6543: to treat the entire reg as the destination. */
6544: sets[i].src_elt = src_eqv_elt;
6545: sets[i].src_hash_code = src_eqv_hash_code;
6546: }
6547: else
6548: {
6549: /* Insert source and constant equivalent into hash table, if not
6550: already present. */
6551: register struct table_elt *classp = src_eqv_elt;
6552: register rtx src = sets[i].src;
6553: register rtx dest = SET_DEST (sets[i].rtl);
6554: enum machine_mode mode
6555: = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
6556:
6557: if (sets[i].src_elt == 0)
6558: {
6559: register struct table_elt *elt;
6560:
6561: /* Note that these insert_regs calls cannot remove
6562: any of the src_elt's, because they would have failed to
6563: match if not still valid. */
6564: if (insert_regs (src, classp, 0))
6565: sets[i].src_hash_code = HASH (src, mode);
6566: elt = insert (src, classp, sets[i].src_hash_code, mode);
6567: elt->in_memory = sets[i].src_in_memory;
6568: elt->in_struct = sets[i].src_in_struct;
6569: sets[i].src_elt = classp = elt;
6570: }
6571:
6572: if (sets[i].src_const && sets[i].src_const_elt == 0
6573: && src != sets[i].src_const
6574: && ! rtx_equal_p (sets[i].src_const, src))
6575: sets[i].src_elt = insert (sets[i].src_const, classp,
6576: sets[i].src_const_hash_code, mode);
6577: }
6578: }
6579: else if (sets[i].src_elt == 0)
6580: /* If we did not insert the source into the hash table (e.g., it was
6581: volatile), note the equivalence class for the REG_EQUAL value, if any,
6582: so that the destination goes into that class. */
6583: sets[i].src_elt = src_eqv_elt;
6584:
6585: invalidate_from_clobbers (&writes_memory, x);
1.1.1.4 ! root 6586:
! 6587: /* Some registers are invalidated by subroutine calls. Memory is
! 6588: invalidated by non-constant calls. */
! 6589:
1.1 root 6590: if (GET_CODE (insn) == CALL_INSN)
6591: {
6592: static struct write_data everything = {0, 1, 1, 1};
1.1.1.4 ! root 6593:
! 6594: if (! CONST_CALL_P (insn))
! 6595: invalidate_memory (&everything);
1.1 root 6596: invalidate_for_call ();
6597: }
6598:
6599: /* Now invalidate everything set by this instruction.
6600: If a SUBREG or other funny destination is being set,
6601: sets[i].rtl is still nonzero, so here we invalidate the reg
6602: a part of which is being set. */
6603:
6604: for (i = 0; i < n_sets; i++)
6605: if (sets[i].rtl)
6606: {
6607: register rtx dest = sets[i].inner_dest;
6608:
6609: /* Needed for registers to remove the register from its
6610: previous quantity's chain.
6611: Needed for memory if this is a nonvarying address, unless
6612: we have just done an invalidate_memory that covers even those. */
6613: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
6614: || (! writes_memory.all && ! cse_rtx_addr_varies_p (dest)))
6615: invalidate (dest);
6616: }
6617:
6618: /* Make sure registers mentioned in destinations
6619: are safe for use in an expression to be inserted.
6620: This removes from the hash table
6621: any invalid entry that refers to one of these registers.
6622:
6623: We don't care about the return value from mention_regs because
6624: we are going to hash the SET_DEST values unconditionally. */
6625:
6626: for (i = 0; i < n_sets; i++)
6627: if (sets[i].rtl && GET_CODE (SET_DEST (sets[i].rtl)) != REG)
6628: mention_regs (SET_DEST (sets[i].rtl));
6629:
6630: /* We may have just removed some of the src_elt's from the hash table.
6631: So replace each one with the current head of the same class. */
6632:
6633: for (i = 0; i < n_sets; i++)
6634: if (sets[i].rtl)
6635: {
6636: if (sets[i].src_elt && sets[i].src_elt->first_same_value == 0)
6637: /* If elt was removed, find current head of same class,
6638: or 0 if nothing remains of that class. */
6639: {
6640: register struct table_elt *elt = sets[i].src_elt;
6641:
6642: while (elt && elt->prev_same_value)
6643: elt = elt->prev_same_value;
6644:
6645: while (elt && elt->first_same_value == 0)
6646: elt = elt->next_same_value;
6647: sets[i].src_elt = elt ? elt->first_same_value : 0;
6648: }
6649: }
6650:
6651: /* Now insert the destinations into their equivalence classes. */
6652:
6653: for (i = 0; i < n_sets; i++)
6654: if (sets[i].rtl)
6655: {
6656: register rtx dest = SET_DEST (sets[i].rtl);
6657: register struct table_elt *elt;
6658:
6659: /* Don't record value if we are not supposed to risk allocating
6660: floating-point values in registers that might be wider than
6661: memory. */
6662: if ((flag_float_store
6663: && GET_CODE (dest) == MEM
6664: && GET_MODE_CLASS (GET_MODE (dest)) == MODE_FLOAT)
6665: /* Don't record values of destinations set inside a libcall block
6666: since we might delete the libcall. Things should have been set
6667: up so we won't want to reuse such a value, but we play it safe
6668: here. */
6669: || in_libcall_block
6670: /* If we didn't put a REG_EQUAL value or a source into the hash
6671: table, there is no point is recording DEST. */
6672: || sets[i].src_elt == 0)
6673: continue;
6674:
6675: /* STRICT_LOW_PART isn't part of the value BEING set,
6676: and neither is the SUBREG inside it.
6677: Note that in this case SETS[I].SRC_ELT is really SRC_EQV_ELT. */
6678: if (GET_CODE (dest) == STRICT_LOW_PART)
6679: dest = SUBREG_REG (XEXP (dest, 0));
6680:
1.1.1.4 ! root 6681: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG)
1.1 root 6682: /* Registers must also be inserted into chains for quantities. */
6683: if (insert_regs (dest, sets[i].src_elt, 1))
6684: /* If `insert_regs' changes something, the hash code must be
6685: recalculated. */
6686: sets[i].dest_hash_code = HASH (dest, GET_MODE (dest));
6687:
6688: elt = insert (dest, sets[i].src_elt,
6689: sets[i].dest_hash_code, GET_MODE (dest));
6690: elt->in_memory = GET_CODE (sets[i].inner_dest) == MEM;
6691: if (elt->in_memory)
6692: {
6693: /* This implicitly assumes a whole struct
6694: need not have MEM_IN_STRUCT_P.
6695: But a whole struct is *supposed* to have MEM_IN_STRUCT_P. */
6696: elt->in_struct = (MEM_IN_STRUCT_P (sets[i].inner_dest)
6697: || sets[i].inner_dest != SET_DEST (sets[i].rtl));
6698: }
6699:
1.1.1.3 root 6700: /* If we have (set (subreg:m1 (reg:m2 foo) 0) (bar:m1)), M1 is no
6701: narrower than M2, and both M1 and M2 are the same number of words,
6702: we are also doing (set (reg:m2 foo) (subreg:m2 (bar:m1) 0)) so
6703: make that equivalence as well.
1.1 root 6704:
6705: However, BAR may have equivalences for which gen_lowpart_if_possible
6706: will produce a simpler value than gen_lowpart_if_possible applied to
6707: BAR (e.g., if BAR was ZERO_EXTENDed from M2), so we will scan all
6708: BAR's equivalences. If we don't get a simplified form, make
6709: the SUBREG. It will not be used in an equivalence, but will
6710: cause two similar assignments to be detected.
6711:
6712: Note the loop below will find SUBREG_REG (DEST) since we have
6713: already entered SRC and DEST of the SET in the table. */
6714:
6715: if (GET_CODE (dest) == SUBREG
1.1.1.3 root 6716: && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))) / UNITS_PER_WORD
6717: == GET_MODE_SIZE (GET_MODE (dest)) / UNITS_PER_WORD)
1.1 root 6718: && (GET_MODE_SIZE (GET_MODE (dest))
6719: >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))))
6720: && sets[i].src_elt != 0)
6721: {
6722: enum machine_mode new_mode = GET_MODE (SUBREG_REG (dest));
6723: struct table_elt *elt, *classp = 0;
6724:
6725: for (elt = sets[i].src_elt->first_same_value; elt;
6726: elt = elt->next_same_value)
6727: {
6728: rtx new_src = 0;
6729: int src_hash;
6730: struct table_elt *src_elt;
6731:
6732: /* Ignore invalid entries. */
6733: if (GET_CODE (elt->exp) != REG
6734: && ! exp_equiv_p (elt->exp, elt->exp, 1, 0))
6735: continue;
6736:
6737: new_src = gen_lowpart_if_possible (new_mode, elt->exp);
6738: if (new_src == 0)
6739: new_src = gen_rtx (SUBREG, new_mode, elt->exp, 0);
6740:
6741: src_hash = HASH (new_src, new_mode);
6742: src_elt = lookup (new_src, src_hash, new_mode);
6743:
6744: /* Put the new source in the hash table is if isn't
6745: already. */
6746: if (src_elt == 0)
6747: {
6748: if (insert_regs (new_src, classp, 0))
6749: src_hash = HASH (new_src, new_mode);
6750: src_elt = insert (new_src, classp, src_hash, new_mode);
6751: src_elt->in_memory = elt->in_memory;
6752: src_elt->in_struct = elt->in_struct;
6753: }
6754: else if (classp && classp != src_elt->first_same_value)
6755: /* Show that two things that we've seen before are
6756: actually the same. */
6757: merge_equiv_classes (src_elt, classp);
6758:
6759: classp = src_elt->first_same_value;
6760: }
6761: }
6762: }
6763:
6764: /* Special handling for (set REG0 REG1)
6765: where REG0 is the "cheapest", cheaper than REG1.
6766: After cse, REG1 will probably not be used in the sequel,
6767: so (if easily done) change this insn to (set REG1 REG0) and
6768: replace REG1 with REG0 in the previous insn that computed their value.
6769: Then REG1 will become a dead store and won't cloud the situation
6770: for later optimizations.
6771:
6772: Do not make this change if REG1 is a hard register, because it will
6773: then be used in the sequel and we may be changing a two-operand insn
6774: into a three-operand insn.
6775:
6776: Also do not do this if we are operating on a copy of INSN. */
6777:
6778: if (n_sets == 1 && sets[0].rtl && GET_CODE (SET_DEST (sets[0].rtl)) == REG
6779: && NEXT_INSN (PREV_INSN (insn)) == insn
6780: && GET_CODE (SET_SRC (sets[0].rtl)) == REG
6781: && REGNO (SET_SRC (sets[0].rtl)) >= FIRST_PSEUDO_REGISTER
6782: && REGNO_QTY_VALID_P (REGNO (SET_SRC (sets[0].rtl)))
6783: && (qty_first_reg[reg_qty[REGNO (SET_SRC (sets[0].rtl))]]
6784: == REGNO (SET_DEST (sets[0].rtl))))
6785: {
6786: rtx prev = PREV_INSN (insn);
6787: while (prev && GET_CODE (prev) == NOTE)
6788: prev = PREV_INSN (prev);
6789:
6790: if (prev && GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SET
6791: && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl))
6792: {
6793: rtx dest = SET_DEST (sets[0].rtl);
1.1.1.4 ! root 6794: rtx note = find_reg_note (prev, REG_EQUIV, NULL_RTX);
1.1 root 6795:
6796: validate_change (prev, & SET_DEST (PATTERN (prev)), dest, 1);
6797: validate_change (insn, & SET_DEST (sets[0].rtl),
6798: SET_SRC (sets[0].rtl), 1);
6799: validate_change (insn, & SET_SRC (sets[0].rtl), dest, 1);
6800: apply_change_group ();
6801:
6802: /* If REG1 was equivalent to a constant, REG0 is not. */
6803: if (note)
6804: PUT_REG_NOTE_KIND (note, REG_EQUAL);
6805:
6806: /* If there was a REG_WAS_0 note on PREV, remove it. Move
6807: any REG_WAS_0 note on INSN to PREV. */
1.1.1.4 ! root 6808: note = find_reg_note (prev, REG_WAS_0, NULL_RTX);
1.1 root 6809: if (note)
6810: remove_note (prev, note);
6811:
1.1.1.4 ! root 6812: note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
1.1 root 6813: if (note)
6814: {
6815: remove_note (insn, note);
6816: XEXP (note, 1) = REG_NOTES (prev);
6817: REG_NOTES (prev) = note;
6818: }
6819: }
6820: }
6821:
6822: /* If this is a conditional jump insn, record any known equivalences due to
6823: the condition being tested. */
6824:
6825: last_jump_equiv_class = 0;
6826: if (GET_CODE (insn) == JUMP_INSN
6827: && n_sets == 1 && GET_CODE (x) == SET
6828: && GET_CODE (SET_SRC (x)) == IF_THEN_ELSE)
6829: record_jump_equiv (insn, 0);
6830:
6831: #ifdef HAVE_cc0
6832: /* If the previous insn set CC0 and this insn no longer references CC0,
6833: delete the previous insn. Here we use the fact that nothing expects CC0
6834: to be valid over an insn, which is true until the final pass. */
6835: if (prev_insn && GET_CODE (prev_insn) == INSN
6836: && (tem = single_set (prev_insn)) != 0
6837: && SET_DEST (tem) == cc0_rtx
6838: && ! reg_mentioned_p (cc0_rtx, x))
6839: {
6840: PUT_CODE (prev_insn, NOTE);
6841: NOTE_LINE_NUMBER (prev_insn) = NOTE_INSN_DELETED;
6842: NOTE_SOURCE_FILE (prev_insn) = 0;
6843: }
6844:
6845: prev_insn_cc0 = this_insn_cc0;
6846: prev_insn_cc0_mode = this_insn_cc0_mode;
6847: #endif
6848:
6849: prev_insn = insn;
6850: }
6851:
6852: /* Store 1 in *WRITES_PTR for those categories of memory ref
6853: that must be invalidated when the expression WRITTEN is stored in.
6854: If WRITTEN is null, say everything must be invalidated. */
6855:
6856: static void
6857: note_mem_written (written, writes_ptr)
6858: rtx written;
6859: struct write_data *writes_ptr;
6860: {
6861: static struct write_data everything = {0, 1, 1, 1};
6862:
6863: if (written == 0)
6864: *writes_ptr = everything;
6865: else if (GET_CODE (written) == MEM)
6866: {
6867: /* Pushing or popping the stack invalidates just the stack pointer. */
6868: rtx addr = XEXP (written, 0);
6869: if ((GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
6870: || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
6871: && GET_CODE (XEXP (addr, 0)) == REG
6872: && REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM)
6873: {
6874: writes_ptr->sp = 1;
6875: return;
6876: }
6877: else if (GET_MODE (written) == BLKmode)
6878: *writes_ptr = everything;
6879: else if (cse_rtx_addr_varies_p (written))
6880: {
6881: /* A varying address that is a sum indicates an array element,
6882: and that's just as good as a structure element
6883: in implying that we need not invalidate scalar variables. */
6884: if (!(MEM_IN_STRUCT_P (written)
6885: || GET_CODE (XEXP (written, 0)) == PLUS))
6886: writes_ptr->all = 1;
6887: writes_ptr->nonscalar = 1;
6888: }
6889: writes_ptr->var = 1;
6890: }
6891: }
6892:
6893: /* Perform invalidation on the basis of everything about an insn
6894: except for invalidating the actual places that are SET in it.
6895: This includes the places CLOBBERed, and anything that might
6896: alias with something that is SET or CLOBBERed.
6897:
6898: W points to the writes_memory for this insn, a struct write_data
6899: saying which kinds of memory references must be invalidated.
6900: X is the pattern of the insn. */
6901:
6902: static void
6903: invalidate_from_clobbers (w, x)
6904: struct write_data *w;
6905: rtx x;
6906: {
6907: /* If W->var is not set, W specifies no action.
6908: If W->all is set, this step gets all memory refs
6909: so they can be ignored in the rest of this function. */
6910: if (w->var)
6911: invalidate_memory (w);
6912:
6913: if (w->sp)
6914: {
6915: if (reg_tick[STACK_POINTER_REGNUM] >= 0)
6916: reg_tick[STACK_POINTER_REGNUM]++;
6917:
6918: /* This should be *very* rare. */
6919: if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM))
6920: invalidate (stack_pointer_rtx);
6921: }
6922:
6923: if (GET_CODE (x) == CLOBBER)
6924: {
6925: rtx ref = XEXP (x, 0);
6926: if (ref
6927: && (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
6928: || (GET_CODE (ref) == MEM && ! w->all)))
6929: invalidate (ref);
6930: }
6931: else if (GET_CODE (x) == PARALLEL)
6932: {
6933: register int i;
6934: for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
6935: {
6936: register rtx y = XVECEXP (x, 0, i);
6937: if (GET_CODE (y) == CLOBBER)
6938: {
6939: rtx ref = XEXP (y, 0);
6940: if (ref
6941: &&(GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
6942: || (GET_CODE (ref) == MEM && !w->all)))
6943: invalidate (ref);
6944: }
6945: }
6946: }
6947: }
6948:
6949: /* Process X, part of the REG_NOTES of an insn. Look at any REG_EQUAL notes
6950: and replace any registers in them with either an equivalent constant
6951: or the canonical form of the register. If we are inside an address,
6952: only do this if the address remains valid.
6953:
6954: OBJECT is 0 except when within a MEM in which case it is the MEM.
6955:
6956: Return the replacement for X. */
6957:
6958: static rtx
6959: cse_process_notes (x, object)
6960: rtx x;
6961: rtx object;
6962: {
6963: enum rtx_code code = GET_CODE (x);
6964: char *fmt = GET_RTX_FORMAT (code);
6965: int qty;
6966: int i;
6967:
6968: switch (code)
6969: {
6970: case CONST_INT:
6971: case CONST:
6972: case SYMBOL_REF:
6973: case LABEL_REF:
6974: case CONST_DOUBLE:
6975: case PC:
6976: case CC0:
6977: case LO_SUM:
6978: return x;
6979:
6980: case MEM:
6981: XEXP (x, 0) = cse_process_notes (XEXP (x, 0), x);
6982: return x;
6983:
6984: case EXPR_LIST:
6985: case INSN_LIST:
6986: if (REG_NOTE_KIND (x) == REG_EQUAL)
1.1.1.4 ! root 6987: XEXP (x, 0) = cse_process_notes (XEXP (x, 0), NULL_RTX);
1.1 root 6988: if (XEXP (x, 1))
1.1.1.4 ! root 6989: XEXP (x, 1) = cse_process_notes (XEXP (x, 1), NULL_RTX);
1.1 root 6990: return x;
6991:
1.1.1.3 root 6992: case SIGN_EXTEND:
6993: case ZERO_EXTEND:
6994: {
6995: rtx new = cse_process_notes (XEXP (x, 0), object);
6996: /* We don't substitute VOIDmode constants into these rtx,
6997: since they would impede folding. */
6998: if (GET_MODE (new) != VOIDmode)
6999: validate_change (object, &XEXP (x, 0), new, 0);
7000: return x;
7001: }
7002:
1.1 root 7003: case REG:
7004: i = reg_qty[REGNO (x)];
7005:
7006: /* Return a constant or a constant register. */
7007: if (REGNO_QTY_VALID_P (REGNO (x))
7008: && qty_const[i] != 0
7009: && (CONSTANT_P (qty_const[i])
7010: || GET_CODE (qty_const[i]) == REG))
7011: {
7012: rtx new = gen_lowpart_if_possible (GET_MODE (x), qty_const[i]);
7013: if (new)
7014: return new;
7015: }
7016:
7017: /* Otherwise, canonicalize this register. */
1.1.1.4 ! root 7018: return canon_reg (x, NULL_RTX);
1.1 root 7019: }
7020:
7021: for (i = 0; i < GET_RTX_LENGTH (code); i++)
7022: if (fmt[i] == 'e')
7023: validate_change (object, &XEXP (x, i),
1.1.1.4 ! root 7024: cse_process_notes (XEXP (x, i), object), NULL_RTX);
1.1 root 7025:
7026: return x;
7027: }
7028:
7029: /* Find common subexpressions between the end test of a loop and the beginning
7030: of the loop. LOOP_START is the CODE_LABEL at the start of a loop.
7031:
7032: Often we have a loop where an expression in the exit test is used
7033: in the body of the loop. For example "while (*p) *q++ = *p++;".
7034: Because of the way we duplicate the loop exit test in front of the loop,
7035: however, we don't detect that common subexpression. This will be caught
7036: when global cse is implemented, but this is a quite common case.
7037:
7038: This function handles the most common cases of these common expressions.
7039: It is called after we have processed the basic block ending with the
7040: NOTE_INSN_LOOP_END note that ends a loop and the previous JUMP_INSN
7041: jumps to a label used only once. */
7042:
7043: static void
7044: cse_around_loop (loop_start)
7045: rtx loop_start;
7046: {
7047: rtx insn;
7048: int i;
7049: struct table_elt *p;
7050:
7051: /* If the jump at the end of the loop doesn't go to the start, we don't
7052: do anything. */
7053: for (insn = PREV_INSN (loop_start);
7054: insn && (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) >= 0);
7055: insn = PREV_INSN (insn))
7056: ;
7057:
7058: if (insn == 0
7059: || GET_CODE (insn) != NOTE
7060: || NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG)
7061: return;
7062:
7063: /* If the last insn of the loop (the end test) was an NE comparison,
7064: we will interpret it as an EQ comparison, since we fell through
1.1.1.4 ! root 7065: the loop. Any equivalences resulting from that comparison are
1.1 root 7066: therefore not valid and must be invalidated. */
7067: if (last_jump_equiv_class)
7068: for (p = last_jump_equiv_class->first_same_value; p;
7069: p = p->next_same_value)
7070: if (GET_CODE (p->exp) == MEM || GET_CODE (p->exp) == REG
7071: || GET_CODE (p->exp) == SUBREG)
7072: invalidate (p->exp);
7073:
7074: /* Process insns starting after LOOP_START until we hit a CALL_INSN or
7075: a CODE_LABEL (we could handle a CALL_INSN, but it isn't worth it).
7076:
7077: The only thing we do with SET_DEST is invalidate entries, so we
7078: can safely process each SET in order. It is slightly less efficient
7079: to do so, but we only want to handle the most common cases. */
7080:
7081: for (insn = NEXT_INSN (loop_start);
7082: GET_CODE (insn) != CALL_INSN && GET_CODE (insn) != CODE_LABEL
7083: && ! (GET_CODE (insn) == NOTE
7084: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
7085: insn = NEXT_INSN (insn))
7086: {
7087: if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
7088: && (GET_CODE (PATTERN (insn)) == SET
7089: || GET_CODE (PATTERN (insn)) == CLOBBER))
7090: cse_set_around_loop (PATTERN (insn), insn, loop_start);
7091: else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
7092: && GET_CODE (PATTERN (insn)) == PARALLEL)
7093: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7094: if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
7095: || GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == CLOBBER)
7096: cse_set_around_loop (XVECEXP (PATTERN (insn), 0, i), insn,
7097: loop_start);
7098: }
7099: }
7100:
1.1.1.3 root 7101: /* Variable used for communications between the next two routines. */
7102:
7103: static struct write_data skipped_writes_memory;
7104:
7105: /* Process one SET of an insn that was skipped. We ignore CLOBBERs
7106: since they are done elsewhere. This function is called via note_stores. */
7107:
7108: static void
7109: invalidate_skipped_set (dest, set)
7110: rtx set;
7111: rtx dest;
7112: {
7113: if (GET_CODE (set) == CLOBBER
7114: #ifdef HAVE_cc0
7115: || dest == cc0_rtx
7116: #endif
7117: || dest == pc_rtx)
7118: return;
7119:
7120: if (GET_CODE (dest) == MEM)
7121: note_mem_written (dest, &skipped_writes_memory);
7122:
7123: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
7124: || (! skipped_writes_memory.all && ! cse_rtx_addr_varies_p (dest)))
7125: invalidate (dest);
7126: }
7127:
7128: /* Invalidate all insns from START up to the end of the function or the
7129: next label. This called when we wish to CSE around a block that is
7130: conditionally executed. */
7131:
7132: static void
7133: invalidate_skipped_block (start)
7134: rtx start;
7135: {
7136: rtx insn;
7137: int i;
7138: static struct write_data init = {0, 0, 0, 0};
7139: static struct write_data everything = {0, 1, 1, 1};
7140:
7141: for (insn = start; insn && GET_CODE (insn) != CODE_LABEL;
7142: insn = NEXT_INSN (insn))
7143: {
7144: if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
7145: continue;
7146:
7147: skipped_writes_memory = init;
7148:
7149: if (GET_CODE (insn) == CALL_INSN)
7150: {
7151: invalidate_for_call ();
7152: skipped_writes_memory = everything;
7153: }
7154:
7155: note_stores (PATTERN (insn), invalidate_skipped_set);
7156: invalidate_from_clobbers (&skipped_writes_memory, PATTERN (insn));
7157: }
7158: }
7159:
1.1 root 7160: /* Used for communication between the following two routines; contains a
7161: value to be checked for modification. */
7162:
7163: static rtx cse_check_loop_start_value;
7164:
7165: /* If modifying X will modify the value in CSE_CHECK_LOOP_START_VALUE,
7166: indicate that fact by setting CSE_CHECK_LOOP_START_VALUE to 0. */
7167:
7168: static void
7169: cse_check_loop_start (x, set)
7170: rtx x;
7171: rtx set;
7172: {
7173: if (cse_check_loop_start_value == 0
7174: || GET_CODE (x) == CC0 || GET_CODE (x) == PC)
7175: return;
7176:
7177: if ((GET_CODE (x) == MEM && GET_CODE (cse_check_loop_start_value) == MEM)
7178: || reg_overlap_mentioned_p (x, cse_check_loop_start_value))
7179: cse_check_loop_start_value = 0;
7180: }
7181:
7182: /* X is a SET or CLOBBER contained in INSN that was found near the start of
7183: a loop that starts with the label at LOOP_START.
7184:
7185: If X is a SET, we see if its SET_SRC is currently in our hash table.
7186: If so, we see if it has a value equal to some register used only in the
7187: loop exit code (as marked by jump.c).
7188:
7189: If those two conditions are true, we search backwards from the start of
7190: the loop to see if that same value was loaded into a register that still
7191: retains its value at the start of the loop.
7192:
7193: If so, we insert an insn after the load to copy the destination of that
7194: load into the equivalent register and (try to) replace our SET_SRC with that
7195: register.
7196:
7197: In any event, we invalidate whatever this SET or CLOBBER modifies. */
7198:
7199: static void
7200: cse_set_around_loop (x, insn, loop_start)
7201: rtx x;
7202: rtx insn;
7203: rtx loop_start;
7204: {
7205: rtx p;
7206: struct table_elt *src_elt;
7207: static struct write_data init = {0, 0, 0, 0};
7208: struct write_data writes_memory;
7209:
7210: writes_memory = init;
7211:
7212: /* If this is a SET, see if we can replace SET_SRC, but ignore SETs that
7213: are setting PC or CC0 or whose SET_SRC is already a register. */
7214: if (GET_CODE (x) == SET
7215: && GET_CODE (SET_DEST (x)) != PC && GET_CODE (SET_DEST (x)) != CC0
7216: && GET_CODE (SET_SRC (x)) != REG)
7217: {
7218: src_elt = lookup (SET_SRC (x),
7219: HASH (SET_SRC (x), GET_MODE (SET_DEST (x))),
7220: GET_MODE (SET_DEST (x)));
7221:
7222: if (src_elt)
7223: for (src_elt = src_elt->first_same_value; src_elt;
7224: src_elt = src_elt->next_same_value)
7225: if (GET_CODE (src_elt->exp) == REG && REG_LOOP_TEST_P (src_elt->exp)
7226: && COST (src_elt->exp) < COST (SET_SRC (x)))
7227: {
7228: rtx p, set;
7229:
7230: /* Look for an insn in front of LOOP_START that sets
7231: something in the desired mode to SET_SRC (x) before we hit
7232: a label or CALL_INSN. */
7233:
7234: for (p = prev_nonnote_insn (loop_start);
7235: p && GET_CODE (p) != CALL_INSN
7236: && GET_CODE (p) != CODE_LABEL;
7237: p = prev_nonnote_insn (p))
7238: if ((set = single_set (p)) != 0
7239: && GET_CODE (SET_DEST (set)) == REG
7240: && GET_MODE (SET_DEST (set)) == src_elt->mode
7241: && rtx_equal_p (SET_SRC (set), SET_SRC (x)))
7242: {
7243: /* We now have to ensure that nothing between P
7244: and LOOP_START modified anything referenced in
7245: SET_SRC (x). We know that nothing within the loop
7246: can modify it, or we would have invalidated it in
7247: the hash table. */
7248: rtx q;
7249:
7250: cse_check_loop_start_value = SET_SRC (x);
7251: for (q = p; q != loop_start; q = NEXT_INSN (q))
7252: if (GET_RTX_CLASS (GET_CODE (q)) == 'i')
7253: note_stores (PATTERN (q), cse_check_loop_start);
7254:
7255: /* If nothing was changed and we can replace our
7256: SET_SRC, add an insn after P to copy its destination
7257: to what we will be replacing SET_SRC with. */
7258: if (cse_check_loop_start_value
7259: && validate_change (insn, &SET_SRC (x),
7260: src_elt->exp, 0))
7261: emit_insn_after (gen_move_insn (src_elt->exp,
7262: SET_DEST (set)),
7263: p);
7264: break;
7265: }
7266: }
7267: }
7268:
7269: /* Now invalidate anything modified by X. */
7270: note_mem_written (SET_DEST (x), &writes_memory);
7271:
7272: if (writes_memory.var)
7273: invalidate_memory (&writes_memory);
7274:
7275: /* See comment on similar code in cse_insn for explanation of these tests. */
7276: if (GET_CODE (SET_DEST (x)) == REG || GET_CODE (SET_DEST (x)) == SUBREG
7277: || (GET_CODE (SET_DEST (x)) == MEM && ! writes_memory.all
7278: && ! cse_rtx_addr_varies_p (SET_DEST (x))))
7279: invalidate (SET_DEST (x));
7280: }
7281:
7282: /* Find the end of INSN's basic block and return its range,
7283: the total number of SETs in all the insns of the block, the last insn of the
7284: block, and the branch path.
7285:
7286: The branch path indicates which branches should be followed. If a non-zero
7287: path size is specified, the block should be rescanned and a different set
7288: of branches will be taken. The branch path is only used if
1.1.1.3 root 7289: FLAG_CSE_FOLLOW_JUMPS or FLAG_CSE_SKIP_BLOCKS is non-zero.
1.1 root 7290:
7291: DATA is a pointer to a struct cse_basic_block_data, defined below, that is
7292: used to describe the block. It is filled in with the information about
7293: the current block. The incoming structure's branch path, if any, is used
7294: to construct the output branch path. */
7295:
7296: /* Define maximum length of a branch path. */
7297:
1.1.1.4 ! root 7298: #define PATHLENGTH 10
1.1 root 7299:
7300: struct cse_basic_block_data {
7301: /* Lowest CUID value of insns in block. */
7302: int low_cuid;
7303: /* Highest CUID value of insns in block. */
7304: int high_cuid;
7305: /* Total number of SETs in block. */
7306: int nsets;
7307: /* Last insn in the block. */
7308: rtx last;
7309: /* Size of current branch path, if any. */
7310: int path_size;
7311: /* Current branch path, indicating which branches will be taken. */
7312: struct branch_path {
7313: /* The branch insn. */
7314: rtx branch;
1.1.1.3 root 7315: /* Whether it should be taken or not. AROUND is the same as taken
7316: except that it is used when the destination label is not preceded
7317: by a BARRIER. */
7318: enum taken {TAKEN, NOT_TAKEN, AROUND} status;
1.1 root 7319: } path[PATHLENGTH];
7320: };
7321:
7322: void
1.1.1.3 root 7323: cse_end_of_basic_block (insn, data, follow_jumps, after_loop, skip_blocks)
1.1 root 7324: rtx insn;
7325: struct cse_basic_block_data *data;
7326: int follow_jumps;
7327: int after_loop;
1.1.1.3 root 7328: int skip_blocks;
1.1 root 7329: {
7330: rtx p = insn, q;
7331: int nsets = 0;
7332: int low_cuid = INSN_CUID (insn), high_cuid = INSN_CUID (insn);
1.1.1.3 root 7333: rtx next = GET_RTX_CLASS (GET_CODE (insn)) == 'i' ? insn : next_real_insn (insn);
1.1 root 7334: int path_size = data->path_size;
7335: int path_entry = 0;
7336: int i;
7337:
7338: /* Update the previous branch path, if any. If the last branch was
7339: previously TAKEN, mark it NOT_TAKEN. If it was previously NOT_TAKEN,
7340: shorten the path by one and look at the previous branch. We know that
7341: at least one branch must have been taken if PATH_SIZE is non-zero. */
7342: while (path_size > 0)
7343: {
1.1.1.3 root 7344: if (data->path[path_size - 1].status != NOT_TAKEN)
1.1 root 7345: {
7346: data->path[path_size - 1].status = NOT_TAKEN;
7347: break;
7348: }
7349: else
7350: path_size--;
7351: }
7352:
7353: /* Scan to end of this basic block. */
7354: while (p && GET_CODE (p) != CODE_LABEL)
7355: {
7356: /* Don't cse out the end of a loop. This makes a difference
7357: only for the unusual loops that always execute at least once;
7358: all other loops have labels there so we will stop in any case.
7359: Cse'ing out the end of the loop is dangerous because it
7360: might cause an invariant expression inside the loop
7361: to be reused after the end of the loop. This would make it
7362: hard to move the expression out of the loop in loop.c,
7363: especially if it is one of several equivalent expressions
7364: and loop.c would like to eliminate it.
7365:
7366: If we are running after loop.c has finished, we can ignore
7367: the NOTE_INSN_LOOP_END. */
7368:
7369: if (! after_loop && GET_CODE (p) == NOTE
7370: && NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)
7371: break;
7372:
7373: /* Don't cse over a call to setjmp; on some machines (eg vax)
7374: the regs restored by the longjmp come from
7375: a later time than the setjmp. */
7376: if (GET_CODE (p) == NOTE
7377: && NOTE_LINE_NUMBER (p) == NOTE_INSN_SETJMP)
7378: break;
7379:
7380: /* A PARALLEL can have lots of SETs in it,
7381: especially if it is really an ASM_OPERANDS. */
7382: if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
7383: && GET_CODE (PATTERN (p)) == PARALLEL)
7384: nsets += XVECLEN (PATTERN (p), 0);
7385: else if (GET_CODE (p) != NOTE)
7386: nsets += 1;
7387:
1.1.1.4 ! root 7388: /* Ignore insns made by CSE; they cannot affect the boundaries of
! 7389: the basic block. */
! 7390:
! 7391: if (INSN_UID (p) <= max_uid && INSN_CUID (p) > high_cuid)
1.1.1.3 root 7392: high_cuid = INSN_CUID (p);
1.1.1.4 ! root 7393: if (INSN_UID (p) <= max_uid && INSN_CUID (p) < low_cuid)
! 7394: low_cuid = INSN_CUID (p);
1.1 root 7395:
7396: /* See if this insn is in our branch path. If it is and we are to
7397: take it, do so. */
7398: if (path_entry < path_size && data->path[path_entry].branch == p)
7399: {
1.1.1.3 root 7400: if (data->path[path_entry].status != NOT_TAKEN)
1.1 root 7401: p = JUMP_LABEL (p);
7402:
7403: /* Point to next entry in path, if any. */
7404: path_entry++;
7405: }
7406:
7407: /* If this is a conditional jump, we can follow it if -fcse-follow-jumps
7408: was specified, we haven't reached our maximum path length, there are
7409: insns following the target of the jump, this is the only use of the
1.1.1.3 root 7410: jump label, and the target label is preceded by a BARRIER.
7411:
7412: Alternatively, we can follow the jump if it branches around a
7413: block of code and there are no other branches into the block.
7414: In this case invalidate_skipped_block will be called to invalidate any
7415: registers set in the block when following the jump. */
7416:
7417: else if ((follow_jumps || skip_blocks) && path_size < PATHLENGTH - 1
1.1 root 7418: && GET_CODE (p) == JUMP_INSN
7419: && GET_CODE (PATTERN (p)) == SET
7420: && GET_CODE (SET_SRC (PATTERN (p))) == IF_THEN_ELSE
7421: && LABEL_NUSES (JUMP_LABEL (p)) == 1
7422: && NEXT_INSN (JUMP_LABEL (p)) != 0)
7423: {
7424: for (q = PREV_INSN (JUMP_LABEL (p)); q; q = PREV_INSN (q))
7425: if ((GET_CODE (q) != NOTE
7426: || NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_END
7427: || NOTE_LINE_NUMBER (q) == NOTE_INSN_SETJMP)
7428: && (GET_CODE (q) != CODE_LABEL || LABEL_NUSES (q) != 0))
7429: break;
7430:
7431: /* If we ran into a BARRIER, this code is an extension of the
7432: basic block when the branch is taken. */
1.1.1.3 root 7433: if (follow_jumps && q != 0 && GET_CODE (q) == BARRIER)
1.1 root 7434: {
7435: /* Don't allow ourself to keep walking around an
7436: always-executed loop. */
1.1.1.3 root 7437: if (next_real_insn (q) == next)
7438: {
7439: p = NEXT_INSN (p);
7440: continue;
7441: }
1.1 root 7442:
7443: /* Similarly, don't put a branch in our path more than once. */
7444: for (i = 0; i < path_entry; i++)
7445: if (data->path[i].branch == p)
7446: break;
7447:
7448: if (i != path_entry)
7449: break;
7450:
7451: data->path[path_entry].branch = p;
7452: data->path[path_entry++].status = TAKEN;
7453:
7454: /* This branch now ends our path. It was possible that we
7455: didn't see this branch the last time around (when the
7456: insn in front of the target was a JUMP_INSN that was
7457: turned into a no-op). */
7458: path_size = path_entry;
7459:
7460: p = JUMP_LABEL (p);
7461: /* Mark block so we won't scan it again later. */
7462: PUT_MODE (NEXT_INSN (p), QImode);
7463: }
1.1.1.3 root 7464: /* Detect a branch around a block of code. */
7465: else if (skip_blocks && q != 0 && GET_CODE (q) != CODE_LABEL)
7466: {
7467: register rtx tmp;
7468:
7469: if (next_real_insn (q) == next)
7470: {
7471: p = NEXT_INSN (p);
7472: continue;
7473: }
7474:
7475: for (i = 0; i < path_entry; i++)
7476: if (data->path[i].branch == p)
7477: break;
7478:
7479: if (i != path_entry)
7480: break;
7481:
7482: /* This is no_labels_between_p (p, q) with an added check for
7483: reaching the end of a function (in case Q precedes P). */
7484: for (tmp = NEXT_INSN (p); tmp && tmp != q; tmp = NEXT_INSN (tmp))
7485: if (GET_CODE (tmp) == CODE_LABEL)
7486: break;
7487:
7488: if (tmp == q)
7489: {
7490: data->path[path_entry].branch = p;
7491: data->path[path_entry++].status = AROUND;
7492:
7493: path_size = path_entry;
7494:
7495: p = JUMP_LABEL (p);
7496: /* Mark block so we won't scan it again later. */
7497: PUT_MODE (NEXT_INSN (p), QImode);
7498: }
7499: }
1.1 root 7500: }
7501: p = NEXT_INSN (p);
7502: }
7503:
7504: data->low_cuid = low_cuid;
7505: data->high_cuid = high_cuid;
7506: data->nsets = nsets;
7507: data->last = p;
7508:
7509: /* If all jumps in the path are not taken, set our path length to zero
7510: so a rescan won't be done. */
7511: for (i = path_size - 1; i >= 0; i--)
1.1.1.3 root 7512: if (data->path[i].status != NOT_TAKEN)
1.1 root 7513: break;
7514:
7515: if (i == -1)
7516: data->path_size = 0;
7517: else
7518: data->path_size = path_size;
7519:
7520: /* End the current branch path. */
7521: data->path[path_size].branch = 0;
7522: }
7523:
7524: static rtx cse_basic_block ();
7525:
7526: /* Perform cse on the instructions of a function.
7527: F is the first instruction.
7528: NREGS is one plus the highest pseudo-reg number used in the instruction.
7529:
7530: AFTER_LOOP is 1 if this is the cse call done after loop optimization
7531: (only if -frerun-cse-after-loop).
7532:
7533: Returns 1 if jump_optimize should be redone due to simplifications
7534: in conditional jump instructions. */
7535:
7536: int
7537: cse_main (f, nregs, after_loop, file)
7538: rtx f;
7539: int nregs;
7540: int after_loop;
7541: FILE *file;
7542: {
7543: struct cse_basic_block_data val;
7544: register rtx insn = f;
7545: register int i;
7546:
7547: cse_jumps_altered = 0;
7548: constant_pool_entries_cost = 0;
7549: val.path_size = 0;
7550:
7551: init_recog ();
7552:
7553: max_reg = nregs;
7554:
7555: all_minus_one = (int *) alloca (nregs * sizeof (int));
7556: consec_ints = (int *) alloca (nregs * sizeof (int));
7557:
7558: for (i = 0; i < nregs; i++)
7559: {
7560: all_minus_one[i] = -1;
7561: consec_ints[i] = i;
7562: }
7563:
7564: reg_next_eqv = (int *) alloca (nregs * sizeof (int));
7565: reg_prev_eqv = (int *) alloca (nregs * sizeof (int));
7566: reg_qty = (int *) alloca (nregs * sizeof (int));
7567: reg_in_table = (int *) alloca (nregs * sizeof (int));
7568: reg_tick = (int *) alloca (nregs * sizeof (int));
7569:
7570: /* Discard all the free elements of the previous function
7571: since they are allocated in the temporarily obstack. */
7572: bzero (table, sizeof table);
7573: free_element_chain = 0;
7574: n_elements_made = 0;
7575:
7576: /* Find the largest uid. */
7577:
1.1.1.4 ! root 7578: max_uid = get_max_uid ();
! 7579: uid_cuid = (int *) alloca ((max_uid + 1) * sizeof (int));
! 7580: bzero (uid_cuid, (max_uid + 1) * sizeof (int));
1.1 root 7581:
7582: /* Compute the mapping from uids to cuids.
7583: CUIDs are numbers assigned to insns, like uids,
7584: except that cuids increase monotonically through the code.
7585: Don't assign cuids to line-number NOTEs, so that the distance in cuids
7586: between two insns is not affected by -g. */
7587:
7588: for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
7589: {
7590: if (GET_CODE (insn) != NOTE
7591: || NOTE_LINE_NUMBER (insn) < 0)
7592: INSN_CUID (insn) = ++i;
7593: else
7594: /* Give a line number note the same cuid as preceding insn. */
7595: INSN_CUID (insn) = i;
7596: }
7597:
7598: /* Initialize which registers are clobbered by calls. */
7599:
7600: CLEAR_HARD_REG_SET (regs_invalidated_by_call);
7601:
7602: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
7603: if ((call_used_regs[i]
7604: /* Used to check !fixed_regs[i] here, but that isn't safe;
7605: fixed regs are still call-clobbered, and sched can get
7606: confused if they can "live across calls".
7607:
7608: The frame pointer is always preserved across calls. The arg
7609: pointer is if it is fixed. The stack pointer usually is, unless
7610: RETURN_POPS_ARGS, in which case an explicit CLOBBER
7611: will be present. If we are generating PIC code, the PIC offset
7612: table register is preserved across calls. */
7613:
7614: && i != STACK_POINTER_REGNUM
7615: && i != FRAME_POINTER_REGNUM
7616: #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
7617: && ! (i == ARG_POINTER_REGNUM && fixed_regs[i])
7618: #endif
7619: #ifdef PIC_OFFSET_TABLE_REGNUM
7620: && ! (i == PIC_OFFSET_TABLE_REGNUM && flag_pic)
7621: #endif
7622: )
7623: || global_regs[i])
7624: SET_HARD_REG_BIT (regs_invalidated_by_call, i);
7625:
7626: /* Loop over basic blocks.
7627: Compute the maximum number of qty's needed for each basic block
7628: (which is 2 for each SET). */
7629: insn = f;
7630: while (insn)
7631: {
1.1.1.3 root 7632: cse_end_of_basic_block (insn, &val, flag_cse_follow_jumps, after_loop,
7633: flag_cse_skip_blocks);
1.1 root 7634:
7635: /* If this basic block was already processed or has no sets, skip it. */
7636: if (val.nsets == 0 || GET_MODE (insn) == QImode)
7637: {
7638: PUT_MODE (insn, VOIDmode);
7639: insn = (val.last ? NEXT_INSN (val.last) : 0);
7640: val.path_size = 0;
7641: continue;
7642: }
7643:
7644: cse_basic_block_start = val.low_cuid;
7645: cse_basic_block_end = val.high_cuid;
7646: max_qty = val.nsets * 2;
7647:
7648: if (file)
7649: fprintf (file, ";; Processing block from %d to %d, %d sets.\n",
7650: INSN_UID (insn), val.last ? INSN_UID (val.last) : 0,
7651: val.nsets);
7652:
7653: /* Make MAX_QTY bigger to give us room to optimize
7654: past the end of this basic block, if that should prove useful. */
7655: if (max_qty < 500)
7656: max_qty = 500;
7657:
7658: max_qty += max_reg;
7659:
7660: /* If this basic block is being extended by following certain jumps,
7661: (see `cse_end_of_basic_block'), we reprocess the code from the start.
7662: Otherwise, we start after this basic block. */
7663: if (val.path_size > 0)
7664: cse_basic_block (insn, val.last, val.path, 0);
7665: else
7666: {
7667: int old_cse_jumps_altered = cse_jumps_altered;
7668: rtx temp;
7669:
7670: /* When cse changes a conditional jump to an unconditional
7671: jump, we want to reprocess the block, since it will give
7672: us a new branch path to investigate. */
7673: cse_jumps_altered = 0;
7674: temp = cse_basic_block (insn, val.last, val.path, ! after_loop);
1.1.1.3 root 7675: if (cse_jumps_altered == 0
7676: || (flag_cse_follow_jumps == 0 && flag_cse_skip_blocks == 0))
1.1 root 7677: insn = temp;
7678:
7679: cse_jumps_altered |= old_cse_jumps_altered;
7680: }
7681:
7682: #ifdef USE_C_ALLOCA
7683: alloca (0);
7684: #endif
7685: }
7686:
7687: /* Tell refers_to_mem_p that qty_const info is not available. */
7688: qty_const = 0;
7689:
7690: if (max_elements_made < n_elements_made)
7691: max_elements_made = n_elements_made;
7692:
7693: return cse_jumps_altered;
7694: }
7695:
7696: /* Process a single basic block. FROM and TO and the limits of the basic
7697: block. NEXT_BRANCH points to the branch path when following jumps or
7698: a null path when not following jumps.
7699:
7700: AROUND_LOOP is non-zero if we are to try to cse around to the start of a
7701: loop. This is true when we are being called for the last time on a
7702: block and this CSE pass is before loop.c. */
7703:
7704: static rtx
7705: cse_basic_block (from, to, next_branch, around_loop)
7706: register rtx from, to;
7707: struct branch_path *next_branch;
7708: int around_loop;
7709: {
7710: register rtx insn;
7711: int to_usage = 0;
7712: int in_libcall_block = 0;
7713:
7714: /* Each of these arrays is undefined before max_reg, so only allocate
7715: the space actually needed and adjust the start below. */
7716:
7717: qty_first_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int));
7718: qty_last_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int));
7719: qty_mode= (enum machine_mode *) alloca ((max_qty - max_reg) * sizeof (enum machine_mode));
7720: qty_const = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx));
7721: qty_const_insn = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx));
7722: qty_comparison_code
7723: = (enum rtx_code *) alloca ((max_qty - max_reg) * sizeof (enum rtx_code));
7724: qty_comparison_qty = (int *) alloca ((max_qty - max_reg) * sizeof (int));
7725: qty_comparison_const = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx));
7726:
7727: qty_first_reg -= max_reg;
7728: qty_last_reg -= max_reg;
7729: qty_mode -= max_reg;
7730: qty_const -= max_reg;
7731: qty_const_insn -= max_reg;
7732: qty_comparison_code -= max_reg;
7733: qty_comparison_qty -= max_reg;
7734: qty_comparison_const -= max_reg;
7735:
7736: new_basic_block ();
7737:
7738: /* TO might be a label. If so, protect it from being deleted. */
7739: if (to != 0 && GET_CODE (to) == CODE_LABEL)
7740: ++LABEL_NUSES (to);
7741:
7742: for (insn = from; insn != to; insn = NEXT_INSN (insn))
7743: {
7744: register enum rtx_code code;
7745:
7746: /* See if this is a branch that is part of the path. If so, and it is
7747: to be taken, do so. */
7748: if (next_branch->branch == insn)
7749: {
1.1.1.3 root 7750: enum taken status = next_branch++->status;
7751: if (status != NOT_TAKEN)
1.1 root 7752: {
1.1.1.3 root 7753: if (status == TAKEN)
7754: record_jump_equiv (insn, 1);
7755: else
7756: invalidate_skipped_block (NEXT_INSN (insn));
7757:
1.1 root 7758: /* Set the last insn as the jump insn; it doesn't affect cc0.
7759: Then follow this branch. */
7760: #ifdef HAVE_cc0
7761: prev_insn_cc0 = 0;
7762: #endif
7763: prev_insn = insn;
7764: insn = JUMP_LABEL (insn);
7765: continue;
7766: }
7767: }
7768:
7769: code = GET_CODE (insn);
7770: if (GET_MODE (insn) == QImode)
7771: PUT_MODE (insn, VOIDmode);
7772:
7773: if (GET_RTX_CLASS (code) == 'i')
7774: {
7775: /* Process notes first so we have all notes in canonical forms when
7776: looking for duplicate operations. */
7777:
7778: if (REG_NOTES (insn))
1.1.1.4 ! root 7779: REG_NOTES (insn) = cse_process_notes (REG_NOTES (insn), NULL_RTX);
1.1 root 7780:
7781: /* Track when we are inside in LIBCALL block. Inside such a block,
7782: we do not want to record destinations. The last insn of a
7783: LIBCALL block is not considered to be part of the block, since
1.1.1.3 root 7784: its destination is the result of the block and hence should be
1.1 root 7785: recorded. */
7786:
1.1.1.4 ! root 7787: if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
1.1 root 7788: in_libcall_block = 1;
1.1.1.4 ! root 7789: else if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
1.1 root 7790: in_libcall_block = 0;
7791:
7792: cse_insn (insn, in_libcall_block);
7793: }
7794:
7795: /* If INSN is now an unconditional jump, skip to the end of our
7796: basic block by pretending that we just did the last insn in the
7797: basic block. If we are jumping to the end of our block, show
7798: that we can have one usage of TO. */
7799:
7800: if (simplejump_p (insn))
7801: {
7802: if (to == 0)
7803: return 0;
7804:
7805: if (JUMP_LABEL (insn) == to)
7806: to_usage = 1;
7807:
1.1.1.3 root 7808: /* Maybe TO was deleted because the jump is unconditional.
7809: If so, there is nothing left in this basic block. */
7810: /* ??? Perhaps it would be smarter to set TO
7811: to whatever follows this insn,
7812: and pretend the basic block had always ended here. */
7813: if (INSN_DELETED_P (to))
7814: break;
7815:
1.1 root 7816: insn = PREV_INSN (to);
7817: }
7818:
7819: /* See if it is ok to keep on going past the label
7820: which used to end our basic block. Remember that we incremented
1.1.1.2 root 7821: the count of that label, so we decrement it here. If we made
1.1 root 7822: a jump unconditional, TO_USAGE will be one; in that case, we don't
7823: want to count the use in that jump. */
7824:
7825: if (to != 0 && NEXT_INSN (insn) == to
7826: && GET_CODE (to) == CODE_LABEL && --LABEL_NUSES (to) == to_usage)
7827: {
7828: struct cse_basic_block_data val;
7829:
7830: insn = NEXT_INSN (to);
7831:
7832: if (LABEL_NUSES (to) == 0)
7833: delete_insn (to);
7834:
7835: /* Find the end of the following block. Note that we won't be
7836: following branches in this case. If TO was the last insn
7837: in the function, we are done. Similarly, if we deleted the
1.1.1.2 root 7838: insn after TO, it must have been because it was preceded by
1.1 root 7839: a BARRIER. In that case, we are done with this block because it
7840: has no continuation. */
7841:
7842: if (insn == 0 || INSN_DELETED_P (insn))
7843: return 0;
7844:
7845: to_usage = 0;
7846: val.path_size = 0;
1.1.1.3 root 7847: cse_end_of_basic_block (insn, &val, 0, 0, 0);
1.1 root 7848:
7849: /* If the tables we allocated have enough space left
7850: to handle all the SETs in the next basic block,
7851: continue through it. Otherwise, return,
7852: and that block will be scanned individually. */
7853: if (val.nsets * 2 + next_qty > max_qty)
7854: break;
7855:
7856: cse_basic_block_start = val.low_cuid;
7857: cse_basic_block_end = val.high_cuid;
7858: to = val.last;
7859:
7860: /* Prevent TO from being deleted if it is a label. */
7861: if (to != 0 && GET_CODE (to) == CODE_LABEL)
7862: ++LABEL_NUSES (to);
7863:
7864: /* Back up so we process the first insn in the extension. */
7865: insn = PREV_INSN (insn);
7866: }
7867: }
7868:
7869: if (next_qty > max_qty)
7870: abort ();
7871:
7872: /* If we are running before loop.c, we stopped on a NOTE_INSN_LOOP_END, and
7873: the previous insn is the only insn that branches to the head of a loop,
7874: we can cse into the loop. Don't do this if we changed the jump
7875: structure of a loop unless we aren't going to be following jumps. */
7876:
1.1.1.3 root 7877: if ((cse_jumps_altered == 0
7878: || (flag_cse_follow_jumps == 0 && flag_cse_skip_blocks == 0))
1.1 root 7879: && around_loop && to != 0
7880: && GET_CODE (to) == NOTE && NOTE_LINE_NUMBER (to) == NOTE_INSN_LOOP_END
7881: && GET_CODE (PREV_INSN (to)) == JUMP_INSN
7882: && JUMP_LABEL (PREV_INSN (to)) != 0
7883: && LABEL_NUSES (JUMP_LABEL (PREV_INSN (to))) == 1)
7884: cse_around_loop (JUMP_LABEL (PREV_INSN (to)));
7885:
7886: return to ? NEXT_INSN (to) : 0;
7887: }
7888:
7889: /* Count the number of times registers are used (not set) in X.
7890: COUNTS is an array in which we accumulate the count, INCR is how much
7891: we count each register usage. */
7892:
7893: static void
7894: count_reg_usage (x, counts, incr)
7895: rtx x;
7896: int *counts;
7897: int incr;
7898: {
7899: enum rtx_code code = GET_CODE (x);
7900: char *fmt;
7901: int i, j;
7902:
7903: switch (code)
7904: {
7905: case REG:
7906: counts[REGNO (x)] += incr;
7907: return;
7908:
7909: case PC:
7910: case CC0:
7911: case CONST:
7912: case CONST_INT:
7913: case CONST_DOUBLE:
7914: case SYMBOL_REF:
7915: case LABEL_REF:
7916: case CLOBBER:
7917: return;
7918:
7919: case SET:
7920: /* Unless we are setting a REG, count everything in SET_DEST. */
7921: if (GET_CODE (SET_DEST (x)) != REG)
7922: count_reg_usage (SET_DEST (x), counts, incr);
7923: count_reg_usage (SET_SRC (x), counts, incr);
7924: return;
7925:
7926: case INSN:
7927: case JUMP_INSN:
7928: case CALL_INSN:
7929: count_reg_usage (PATTERN (x), counts, incr);
7930:
7931: /* Things used in a REG_EQUAL note aren't dead since loop may try to
7932: use them. */
7933:
7934: if (REG_NOTES (x))
7935: count_reg_usage (REG_NOTES (x), counts, incr);
7936: return;
7937:
7938: case EXPR_LIST:
7939: case INSN_LIST:
7940: if (REG_NOTE_KIND (x) == REG_EQUAL)
7941: count_reg_usage (XEXP (x, 0), counts, incr);
7942: if (XEXP (x, 1))
7943: count_reg_usage (XEXP (x, 1), counts, incr);
7944: return;
7945: }
7946:
7947: fmt = GET_RTX_FORMAT (code);
7948: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7949: {
7950: if (fmt[i] == 'e')
7951: count_reg_usage (XEXP (x, i), counts, incr);
7952: else if (fmt[i] == 'E')
7953: for (j = XVECLEN (x, i) - 1; j >= 0; j--)
7954: count_reg_usage (XVECEXP (x, i, j), counts, incr);
7955: }
7956: }
7957:
7958: /* Scan all the insns and delete any that are dead; i.e., they store a register
7959: that is never used or they copy a register to itself.
7960:
7961: This is used to remove insns made obviously dead by cse. It improves the
7962: heuristics in loop since it won't try to move dead invariants out of loops
7963: or make givs for dead quantities. The remaining passes of the compilation
7964: are also sped up. */
7965:
7966: void
7967: delete_dead_from_cse (insns, nreg)
7968: rtx insns;
7969: int nreg;
7970: {
7971: int *counts = (int *) alloca (nreg * sizeof (int));
1.1.1.4 ! root 7972: rtx insn, prev;
1.1.1.2 root 7973: rtx tem;
1.1 root 7974: int i;
1.1.1.3 root 7975: int in_libcall = 0;
1.1 root 7976:
7977: /* First count the number of times each register is used. */
7978: bzero (counts, sizeof (int) * nreg);
7979: for (insn = next_real_insn (insns); insn; insn = next_real_insn (insn))
7980: count_reg_usage (insn, counts, 1);
7981:
7982: /* Go from the last insn to the first and delete insns that only set unused
7983: registers or copy a register to itself. As we delete an insn, remove
7984: usage counts for registers it uses. */
1.1.1.4 ! root 7985: for (insn = prev_real_insn (get_last_insn ()); insn; insn = prev)
1.1 root 7986: {
7987: int live_insn = 0;
7988:
1.1.1.4 ! root 7989: prev = prev_real_insn (insn);
! 7990:
1.1.1.3 root 7991: /* Don't delete any insns that are part of a libcall block.
1.1.1.4 ! root 7992: Flow or loop might get confused if we did that. Remember
! 7993: that we are scanning backwards. */
! 7994: if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
1.1.1.3 root 7995: in_libcall = 1;
7996:
7997: if (in_libcall)
7998: live_insn = 1;
7999: else if (GET_CODE (PATTERN (insn)) == SET)
1.1 root 8000: {
8001: if (GET_CODE (SET_DEST (PATTERN (insn))) == REG
8002: && SET_DEST (PATTERN (insn)) == SET_SRC (PATTERN (insn)))
8003: ;
8004:
1.1.1.2 root 8005: #ifdef HAVE_cc0
8006: else if (GET_CODE (SET_DEST (PATTERN (insn))) == CC0
8007: && ! side_effects_p (SET_SRC (PATTERN (insn)))
8008: && ((tem = next_nonnote_insn (insn)) == 0
8009: || GET_RTX_CLASS (GET_CODE (tem)) != 'i'
8010: || ! reg_referenced_p (cc0_rtx, PATTERN (tem))))
8011: ;
8012: #endif
1.1 root 8013: else if (GET_CODE (SET_DEST (PATTERN (insn))) != REG
8014: || REGNO (SET_DEST (PATTERN (insn))) < FIRST_PSEUDO_REGISTER
8015: || counts[REGNO (SET_DEST (PATTERN (insn)))] != 0
8016: || side_effects_p (SET_SRC (PATTERN (insn))))
8017: live_insn = 1;
8018: }
8019: else if (GET_CODE (PATTERN (insn)) == PARALLEL)
8020: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
8021: {
8022: rtx elt = XVECEXP (PATTERN (insn), 0, i);
8023:
8024: if (GET_CODE (elt) == SET)
8025: {
8026: if (GET_CODE (SET_DEST (elt)) == REG
8027: && SET_DEST (elt) == SET_SRC (elt))
8028: ;
8029:
1.1.1.2 root 8030: #ifdef HAVE_cc0
8031: else if (GET_CODE (SET_DEST (elt)) == CC0
8032: && ! side_effects_p (SET_SRC (elt))
8033: && ((tem = next_nonnote_insn (insn)) == 0
8034: || GET_RTX_CLASS (GET_CODE (tem)) != 'i'
8035: || ! reg_referenced_p (cc0_rtx, PATTERN (tem))))
8036: ;
8037: #endif
1.1 root 8038: else if (GET_CODE (SET_DEST (elt)) != REG
8039: || REGNO (SET_DEST (elt)) < FIRST_PSEUDO_REGISTER
8040: || counts[REGNO (SET_DEST (elt))] != 0
8041: || side_effects_p (SET_SRC (elt)))
8042: live_insn = 1;
8043: }
8044: else if (GET_CODE (elt) != CLOBBER && GET_CODE (elt) != USE)
8045: live_insn = 1;
8046: }
8047: else
8048: live_insn = 1;
8049:
8050: /* If this is a dead insn, delete it and show registers in it aren't
1.1.1.3 root 8051: being used. */
1.1 root 8052:
1.1.1.3 root 8053: if (! live_insn)
1.1 root 8054: {
8055: count_reg_usage (insn, counts, -1);
1.1.1.4 ! root 8056: delete_insn (insn);
1.1 root 8057: }
1.1.1.3 root 8058:
1.1.1.4 ! root 8059: if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
1.1.1.3 root 8060: in_libcall = 0;
1.1 root 8061: }
8062: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.