|| (new = lookup_as_function (x, CONST_DOUBLE)) != 0)
return new;
- /* If this is a paradoxical SUBREG, we can't do anything with
- it because we have no idea what value the extra bits would have. */
+ /* If this is a paradoxical SUBREG, we have no idea what value the
+ extra bits would have. However, if the operand is equivalent
+ to a SUBREG whose operand is the same as our mode, and all the
+ modes are within a word, we can just use the inner operand
+ because these SUBREGs just say how to treat the register. */
+
if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
- return x;
+ {
+ enum machine_mode imode = GET_MODE (SUBREG_REG (x));
+ struct table_elt *elt;
+
+ if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
+ && GET_MODE_SIZE (imode) <= UNITS_PER_WORD
+ && (elt = lookup (SUBREG_REG (x), HASH (SUBREG_REG (x), imode),
+ imode)) != 0)
+ {
+ for (elt = elt->first_same_value;
+ elt; elt = elt->next_same_value)
+ if (GET_CODE (elt->exp) == SUBREG
+ && GET_MODE (SUBREG_REG (elt->exp)) == mode
+ && exp_equiv_p (elt->exp, elt->exp, 1))
+ return copy_rtx (SUBREG_REG (elt->exp));
+ }
+
+ return x;
+ }
/* Fold SUBREG_REG. If it changed, see if we can simplify the SUBREG.
We might be able to if the SUBREG is extracting a single word in an
extra bits will be. But we can find an equivalence for this SUBREG
by folding that operation is the narrow mode. This allows us to
fold arithmetic in narrow modes when the machine only supports
- word-sized arithmetic. */
+ word-sized arithmetic.
+
+ Also look for a case where we have a SUBREG whose operand is the
+ same as our result. If both modes are smaller than a word, we
+ are simply interpreting a register in different modes and we
+ can use the inner value. */
if (GET_CODE (folded_arg0) == REG
&& GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (folded_arg0)))
op0, op1);
}
+ else if (GET_CODE (elt->exp) == SUBREG
+ && GET_MODE (SUBREG_REG (elt->exp)) == mode
+ && (GET_MODE_SIZE (GET_MODE (folded_arg0))
+ <= UNITS_PER_WORD)
+ && exp_equiv_p (elt->exp, elt->exp, 1))
+ new = copy_rtx (SUBREG_REG (elt->exp));
+
if (new)
return new;
}
else
op0 = subtarget;
+ /* If we want to keep subexpressions around, don't reuse our
+ last target. */
+
+ if (preserve_subexpressions_p ())
+ subtarget = 0;
+
/* Now normalize to the proper value in COMPARE_MODE. Sometimes
we don't have to do anything. */
if (normalizep == 0 || normalizep == STORE_FLAG_VALUE)
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
-
/* List of labels that must never be deleted. */
extern rtx forced_labels;
#include "obstack.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
extern struct obstack *function_maybepermanent_obstack;
#define obstack_chunk_free free
extern char *oballoc ();
-extern int xmalloc ();
-extern void free ();
\f
/* During the analysis of a loop, a chain of `struct movable's
is made to record all the movable insns found.
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
-
/* List of labels that must never be deleted. */
extern rtx forced_labels;
\f
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
-
#ifndef ANNUL_IFTRUE_SLOTS
#define eligible_for_annul_true(INSN, SLOTS, TRIAL) 0
#endif
#include "obstack.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
/* Obstack used for allocating RTL objects.
Between functions, this is the permanent_obstack.
\f
/* Generally useful functions. */
+extern char *xmalloc ();
+extern void free ();
extern rtx rtx_alloc ();
extern rtvec rtvec_alloc ();
extern rtx find_reg_note ();
#define obstack_chunk_free free
struct obstack stmt_obstack;
-extern int xmalloc ();
-extern void free ();
-
/* Filename and line number of last line-number note,
whether we actually emitted it or not. */
char *emit_filename;
/* Same as `malloc' but report error if no memory available. */
-int
+char *
xmalloc (size)
unsigned size;
{
- register int value = (int) malloc (size);
+ register char *value = (char *) malloc (size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
/* Same as `realloc' but report error if no memory available. */
-int
+char *
xrealloc (ptr, size)
char *ptr;
int size;
{
- int result = realloc (ptr, size);
+ char *result = (char *) realloc (ptr, size);
if (!result)
fatal ("virtual memory exhausted");
return result;
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-extern int xmalloc ();
-extern void free ();
-
/* Tree nodes of permanent duration are allocated in this obstack.
They are the identifier nodes, and everything outside of
the bodies and parameters of function definitions. */
extern char *oballoc ();
extern char *permalloc ();
extern char *savealloc ();
+extern char *xmalloc ();
+extern void free ();
/* Lowest level primitive for allocating a node.
The TREE_CODE is the only argument. Contents are initialized
extern struct obstack *saveable_obstack;
extern struct obstack permanent_obstack;
#define obstack_chunk_alloc xmalloc
-extern int xmalloc ();
/* Number for making the label on the next
constant that is stored in memory. */