* Makefile.in (print-rtl.o): Depend on TREE_H.
* alias.c (get_alias_set): Make two passes over objects to first
see if inner object is access via restricted pointer.
Defer allocating alias set for restricted pointer until here.
Call find_placeholder with second arg nonzero.
Minor cleanups.
* emit-rtl.c (set_mem_attributes): Set more attributes.
(set_mem_align, change_address, adjust_address_1): New functions.
(change_address_1): Now static.
(adjust_address, adjust_address_nv): Deleted.
(replace_equiv_address): Call change_address_1.
* expr.c (get_inner_reference): Handle PLACEHOLDER_EXPR.
(find_placeholder): Get starting point from PLIST arg.
(expand_expr, case PLACEHOLDER_EXPR): Initialize find_placeholder arg.
* expr.h (set_mem_align, change_address, adjust_address_1): New decls.
(adjust_address, adjust_address_nv): New macros.
* print-rtl.c (tree.h): New include.
(print_rtx, case MEM): Print all memory attributes.
From-SVN: r46313
+Wed Oct 17 05:26:39 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * Makefile.in (print-rtl.o): Depend on TREE_H.
+ * alias.c (get_alias_set): Make two passes over objects to first
+ see if inner object is access via restricted pointer.
+ Defer allocating alias set for restricted pointer until here.
+ Call find_placeholder with second arg nonzero.
+ Minor cleanups.
+ * emit-rtl.c (set_mem_attributes): Set more attributes.
+ (set_mem_align, change_address, adjust_address_1): New functions.
+ (change_address_1): Now static.
+ (adjust_address, adjust_address_nv): Deleted.
+ (replace_equiv_address): Call change_address_1.
+ * expr.c (get_inner_reference): Handle PLACEHOLDER_EXPR.
+ (find_placeholder): Get starting point from PLIST arg.
+ (expand_expr, case PLACEHOLDER_EXPR): Initialize find_placeholder arg.
+ * expr.h (set_mem_align, change_address, adjust_address_1): New decls.
+ (adjust_address, adjust_address_nv): New macros.
+ * print-rtl.c (tree.h): New include.
+ (print_rtx, case MEM): Print all memory attributes.
+
2001-10-17 Richard Henderson <rth@redhat.com>
* config/alpha/alpha.c (direct_call_operand): Don't fall off end.
rtl.o : rtl.c $(GCONFIG_H) $(SYSTEM_H) $(RTL_H) real.h $(GGC_H) errors.h
$(CC) -c $(ALL_CFLAGS) -DGENERATOR_FILE $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION)
-print-rtl.o : print-rtl.c $(GCONFIG_H) $(SYSTEM_H) $(RTL_H) hard-reg-set.h \
- $(BASIC_BLOCK_H)
+print-rtl.o : print-rtl.c $(GCONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) \
+ hard-reg-set.h $(BASIC_BLOCK_H)
$(CC) -c $(ALL_CFLAGS) -DGENERATOR_FILE $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION)
rtlanal.o : rtlanal.c $(CONFIG_H) $(SYSTEM_H) toplev.h $(RTL_H) hard-reg-set.h
static rtx find_base_value PARAMS ((rtx));
static int mems_in_disjoint_alias_sets_p PARAMS ((rtx, rtx));
static int insert_subset_children PARAMS ((splay_tree_node, void*));
-static tree find_base_decl PARAMS ((tree));
+static tree find_base_decl PARAMS ((tree));
static alias_set_entry get_alias_set_entry PARAMS ((HOST_WIDE_INT));
static rtx fixed_scalar_and_varying_struct_p PARAMS ((rtx, rtx, rtx, rtx,
int (*) (rtx, int)));
get_alias_set (t)
tree t;
{
- tree orig_t;
HOST_WIDE_INT set;
/* If we're not doing any alias analysis, just assume everything
language-specific routine may make mutually-recursive calls to each other
to figure out what to do. At each juncture, we see if this is a tree
that the language may need to handle specially. First handle things that
- aren't types and start by removing nops since we care only about the
- actual object. Also replace PLACEHOLDER_EXPRs and pick up the outermost
- object that we could have a pointer to. */
+ aren't types. */
if (! TYPE_P (t))
{
- /* Remove any NOPs and see what any PLACEHOLD_EXPRs will expand to. */
+ tree inner = t;
+ tree placeholder_ptr = 0;
+
+ /* First see if the actual object referenced is an INDIRECT_REF from a
+ restrict-qualified pointer or a "void *". Start by removing nops
+ since we care only about the actual object. Also replace
+ PLACEHOLDER_EXPRs. */
+ while (((TREE_CODE (inner) == NOP_EXPR
+ || TREE_CODE (inner) == CONVERT_EXPR)
+ && (TYPE_MODE (TREE_TYPE (inner))
+ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (inner, 0)))))
+ || TREE_CODE (inner) == NON_LVALUE_EXPR
+ || TREE_CODE (inner) == PLACEHOLDER_EXPR
+ || handled_component_p (inner))
+ {
+ if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
+ inner = find_placeholder (inner, &placeholder_ptr);
+ else
+ inner = TREE_OPERAND (inner, 0);
+ }
+
+ /* Check for accesses through restrict-qualified pointers. */
+ if (TREE_CODE (inner) == INDIRECT_REF)
+ {
+ tree decl = find_base_decl (TREE_OPERAND (inner, 0));
+
+ if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
+ {
+ /* If we haven't computed the actual alias set, do it now. */
+ if (DECL_POINTER_ALIAS_SET (decl) == -2)
+ {
+ /* No two restricted pointers can point at the same thing.
+ However, a restricted pointer can point at the same thing
+ as an unrestricted pointer, if that unrestricted pointer
+ is based on the restricted pointer. So, we make the
+ alias set for the restricted pointer a subset of the
+ alias set for the type pointed to by the type of the
+ decl. */
+ HOST_WIDE_INT pointed_to_alias_set
+ = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
+
+ if (pointed_to_alias_set == 0)
+ /* It's not legal to make a subset of alias set zero. */
+ ;
+ else
+ {
+ DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
+ record_alias_subset (pointed_to_alias_set,
+ DECL_POINTER_ALIAS_SET (decl));
+ }
+ }
+
+ /* We use the alias set indicated in the declaration. */
+ return DECL_POINTER_ALIAS_SET (decl);
+ }
+
+ /* If we have an INDIRECT_REF via a void pointer, we don't
+ know anything about what that might alias. */
+ else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE)
+ return 0;
+ }
+
+ /* Otherwise, pick up the outermost object that we could have a pointer
+ to, processing conversion and PLACEHOLDER_EXPR as above. */
+ placeholder_ptr = 0;
while (((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
- && (TYPE_MODE (TREE_TYPE (t))
+ && (TYPE_MODE (TREE_TYPE (t))
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 0)))))
|| TREE_CODE (t) == NON_LVALUE_EXPR
|| TREE_CODE (t) == PLACEHOLDER_EXPR
return set;
if (TREE_CODE (t) == PLACEHOLDER_EXPR)
- t = find_placeholder (t, 0);
+ t = find_placeholder (t, &placeholder_ptr);
else
t = TREE_OPERAND (t, 0);
}
- /* Now give the language a chance to do something but record what we
- gave it this time. */
- orig_t = t;
+ /* Give the language another chance to do something. */
if ((set = lang_get_alias_set (t)) != -1)
return set;
- /* Check for accesses through restrict-qualified pointers. */
- if (TREE_CODE (t) == INDIRECT_REF)
- {
- tree decl = find_base_decl (TREE_OPERAND (t, 0));
-
- if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
- /* We use the alias set indicated in the declaration. */
- return DECL_POINTER_ALIAS_SET (decl);
-
- /* If we have an INDIRECT_REF via a void pointer, we don't
- know anything about what that might alias. */
- if (TREE_CODE (TREE_TYPE (t)) == VOID_TYPE)
- return 0;
- }
-
- /* If we've already determined the alias set for this decl, just
- return it. This is necessary for C++ anonymous unions, whose
- component variables don't look like union members (boo!). */
+ /* If we've already determined the alias set for a decl, just return
+ it. This is necessary for C++ anonymous unions, whose component
+ variables don't look like union members (boo!). */
if (TREE_CODE (t) == VAR_DECL
&& DECL_RTL_SET_P (t) && GET_CODE (DECL_RTL (t)) == MEM)
return MEM_ALIAS_SET (DECL_RTL (t));
- /* Give the language another chance to do something special. */
- if (orig_t != t
- && (set = lang_get_alias_set (t)) != -1)
- return set;
-
/* Now all we care about is the type. */
t = TREE_TYPE (t);
}
/* Variant qualifiers don't affect the alias set, so get the main
variant. If this is a type with a known alias set, return it. */
t = TYPE_MAIN_VARIANT (t);
- if (TYPE_P (t) && TYPE_ALIAS_SET_KNOWN_P (t))
+ if (TYPE_ALIAS_SET_KNOWN_P (t))
return TYPE_ALIAS_SET (t);
/* See if the language has special handling for this type. */
if ((set = lang_get_alias_set (t)) != -1)
- {
- /* If the alias set is now known, we are done. */
- if (TYPE_ALIAS_SET_KNOWN_P (t))
- return TYPE_ALIAS_SET (t);
- }
+ return set;
/* There are no objects of FUNCTION_TYPE, so there's no point in
using up an alias set for them. (There are, of course, pointers
static rtx make_call_insn_raw PARAMS ((rtx));
static rtx find_line_note PARAMS ((rtx));
static void mark_sequence_stack PARAMS ((struct sequence_stack *));
+static rtx change_address_1 PARAMS ((rtx, enum machine_mode, rtx,
+ int));
static void unshare_all_rtl_1 PARAMS ((rtx));
static void unshare_all_decls PARAMS ((tree));
static void reset_used_decls PARAMS ((tree));
type = TYPE_P (t) ? t : TREE_TYPE (t);
- /* Get the alias set from the expression or type (perhaps using a
- front-end routine) and then copy bits from the type. */
-
- /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY (type)
- here, because, in C and C++, the fact that a location is accessed
- through a const expression does not mean that the value there can
- never change. */
-
/* If we have already set DECL_RTL = ref, get_alias_set will get the
wrong answer, as it assumes that DECL_RTL already has the right alias
info. Callers should not set DECL_RTL until after the call to
if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
abort ();
+ /* Get the alias set from the expression or type (perhaps using a
+ front-end routine). */
set_mem_alias_set (ref, get_alias_set (t));
+ /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY (type)
+ here, because, in C and C++, the fact that a location is accessed
+ through a const expression does not mean that the value there can
+ never change. */
+
MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
if (objectp && ! AGGREGATE_TYPE_P (type))
MEM_SCALAR_P (ref) = 1;
- /* If T is a type, this is all we can do. Otherwise, we may be able
+ /* If the size is known, we can set that. */
+ if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
+ MEM_ATTRS (ref)
+ = get_mem_attrs (MEM_ALIAS_SET (ref), MEM_DECL (ref), MEM_OFFSET (ref),
+ GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1)),
+ MEM_ALIGN (ref));
+
+ /* If T is a type, there's nothing more we can do. Otherwise, we may be able
to deduce some more information about the expression. */
if (TYPE_P (t))
return;
if (TREE_THIS_VOLATILE (t))
MEM_VOLATILE_P (ref) = 1;
- /* Now see if we can say more about whether it's an aggregate or
- scalar. If we already know it's an aggregate, don't bother. */
- if (MEM_IN_STRUCT_P (ref))
- return;
-
/* Now remove any NOPs: they don't change what the underlying object is.
Likewise for SAVE_EXPR. */
while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
|| TREE_CODE (t) == NON_LVALUE_EXPR || TREE_CODE (t) == SAVE_EXPR)
t = TREE_OPERAND (t, 0);
+ /* If this is a decl, set the attributes of the MEM from it. */
+ if (DECL_P (t))
+ MEM_ATTRS (ref)
+ = get_mem_attrs
+ (MEM_ALIAS_SET (ref), t, GEN_INT (0),
+ (TYPE_SIZE_UNIT (TREE_TYPE (t))
+ && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (t)), 1))
+ ? GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (t)), 1))
+ : 0, DECL_ALIGN (t) / BITS_PER_UNIT);
+
+ /* Now see if we can say more about whether it's an aggregate or
+ scalar. If we already know it's an aggregate, don't bother. */
+ if (MEM_IN_STRUCT_P (ref))
+ return;
+
/* Since we already know the type isn't an aggregate, if this is a decl,
it must be a scalar. Or if it is a reference into an aggregate,
this is part of an aggregate. Otherwise we don't know. */
rtx mem;
HOST_WIDE_INT set;
{
- /* It would be nice to enable this check, but we can't quite yet. */
#ifdef ENABLE_CHECKING
/* If the new and old alias sets don't conflict, something is wrong. */
if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
MEM_ATTRS (mem) = get_mem_attrs (set, MEM_DECL (mem), MEM_OFFSET (mem),
MEM_SIZE (mem), MEM_ALIGN (mem));
}
+
+/* Set the alignment of MEM to ALIGN. */
+
+void
+set_mem_align (mem, align)
+ rtx mem;
+ unsigned int align;
+{
+ MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_DECL (mem),
+ MEM_OFFSET (mem), MEM_SIZE (mem), align);
+}
\f
-/* Return a memory reference like MEMREF, but with its mode changed
- to MODE and its address changed to ADDR.
- (VOIDmode means don't change the mode.
- NULL for ADDR means don't change the address.)
- VALIDATE is nonzero if the returned memory location is required to be
- valid. */
+/* Return a memory reference like MEMREF, but with its mode changed to MODE
+ and its address changed to ADDR. (VOIDmode means don't change the mode.
+ NULL for ADDR means don't change the address.) VALIDATE is nonzero if the
+ returned memory location is required to be valid. The memory
+ attributes are not changed. */
-rtx
+static rtx
change_address_1 (memref, mode, addr, validate)
rtx memref;
enum machine_mode mode;
return new;
}
-/* Return a memory reference like MEMREF, but with its mode changed
- to MODE and its address offset by OFFSET bytes. */
+/* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
+ way we are changing MEMREF, so we only preserve the alias set. */
rtx
-adjust_address (memref, mode, offset)
+change_address (memref, mode, addr)
rtx memref;
enum machine_mode mode;
- HOST_WIDE_INT offset;
+ rtx addr;
{
- /* For now, this is just a wrapper for change_address, but eventually
- will do memref tracking. */
- rtx addr = XEXP (memref, 0);
-
- /* ??? Prefer to create garbage instead of creating shared rtl. */
- addr = copy_rtx (addr);
+ rtx new = change_address_1 (memref, mode, addr, 1);
+ enum machine_mode mmode = GET_MODE (new);
- /* If MEMREF is a LO_SUM and the offset is within the alignment of the
- object, we can merge it into the LO_SUM. */
- if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
- && offset >= 0
- && (unsigned HOST_WIDE_INT) offset
- < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
- addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
- plus_constant (XEXP (addr, 1), offset));
- else
- addr = plus_constant (addr, offset);
+ MEM_ATTRS (new)
+ = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0,
+ mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode)),
+ (mmode == BLKmode ? 1
+ : GET_MODE_ALIGNMENT (mmode) / BITS_PER_UNIT));
- return change_address (memref, mode, addr);
+ return new;
}
-/* Likewise, but the reference is not required to be valid. */
+/* Return a memory reference like MEMREF, but with its mode changed
+ to MODE and its address offset by OFFSET bytes. If VALIDATE is
+ nonzero, the memory address is forced to be valid. */
rtx
-adjust_address_nv (memref, mode, offset)
+adjust_address_1 (memref, mode, offset, validate)
rtx memref;
enum machine_mode mode;
HOST_WIDE_INT offset;
+ int validate;
{
- /* For now, this is just a wrapper for change_address, but eventually
- will do memref tracking. */
rtx addr = XEXP (memref, 0);
+ rtx new;
+ rtx memoffset = MEM_OFFSET (memref);
+ unsigned int memalign = MEM_ALIGN (memref);
- /* If MEMREF is a LO_SUM and the offset is within the size of the
+ /* If MEMREF is a LO_SUM and the offset is within the alignment of the
object, we can merge it into the LO_SUM. */
if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
&& offset >= 0
&& (unsigned HOST_WIDE_INT) offset
< GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
- addr = gen_rtx_LO_SUM (mode, XEXP (addr, 0),
+ addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
plus_constant (XEXP (addr, 1), offset));
+ else if (offset == 0)
+ /* ??? Prefer to create garbage instead of creating shared rtl. */
+ addr = copy_rtx (addr);
else
addr = plus_constant (addr, offset);
- return change_address_1 (memref, mode, addr, 0);
+ new = change_address_1 (memref, mode, addr, validate);
+
+ /* Compute the new values of the memory attributes due to this adjustment.
+ We add the offsets and update the alignment. */
+ if (memoffset)
+ memoffset = GEN_INT (offset + INTVAL (memoffset));
+
+ /* If the offset is negative, don't try to update the alignment. If it's
+ zero, the alignment hasn't changed. Otherwise, the known alignment may
+ be less strict. */
+ if (offset < 0)
+ memalign = 1;
+
+ while (offset > 0 && (offset % memalign) != 0)
+ memalign >>= 1;
+
+ MEM_ATTRS (new)
+ = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_DECL (memref), memoffset,
+ mode == BLKmode
+ ? 0 : GEN_INT (GET_MODE_SIZE (mode)), memalign);
+
+ /* At some point, we should validate that this offset is within the object,
+ if all the appropriate values are known. */
+ return new;
}
/* Return a memory reference like MEMREF, but with its address changed to
rtx memref;
rtx addr;
{
- /* For now, this is just a wrapper for change_address, but eventually
- will do memref tracking. */
- return change_address (memref, VOIDmode, addr);
+ /* change_address_1 copies the memory attribute structure without change
+ and that's exactly what we want here. */
+ return change_address_1 (memref, VOIDmode, addr, 1);
}
+
/* Likewise, but the reference is not required to be valid. */
rtx
rtx memref;
rtx addr;
{
- /* For now, this is just a wrapper for change_address, but eventually
- will do memref tracking. */
return change_address_1 (memref, VOIDmode, addr, 0);
}
\f
tree offset = size_zero_node;
tree bit_offset = bitsize_zero_node;
unsigned int alignment = BIGGEST_ALIGNMENT;
+ tree placeholder_ptr = 0;
tree tem;
/* First get the mode, signedness, and size. We do this from just the
unit_size));
}
+ else if (TREE_CODE (exp) == PLACEHOLDER_EXPR)
+ {
+ exp = find_placeholder (exp, &placeholder_ptr);
+ continue;
+ }
else if (TREE_CODE (exp) != NON_LVALUE_EXPR
&& ! ((TREE_CODE (exp) == NOP_EXPR
|| TREE_CODE (exp) == CONVERT_EXPR)
\f
/* Return an object on the placeholder list that matches EXP, a
PLACEHOLDER_EXPR. An object "matches" if it is of the type of the
- PLACEHOLDER_EXPR or a pointer type to it. For further information,
- see tree.def. If no such object is found, abort. If PLIST is nonzero,
- it is a location into which a pointer into the placeholder list at
- which the object is found is placed. */
+ PLACEHOLDER_EXPR or a pointer type to it. For further information, see
+ tree.def. If no such object is found, abort. If PLIST is nonzero, it is
+ a location which initially points to a starting location in the
+ placeholder list (zero means start of the list) and where a pointer into
+ the placeholder list at which the object is found is placed. */
tree
find_placeholder (exp, plist)
tree type = TREE_TYPE (exp);
tree placeholder_expr;
- for (placeholder_expr = placeholder_list; placeholder_expr != 0;
+ for (placeholder_expr
+ = plist && *plist ? TREE_CHAIN (*plist) : placeholder_list;
+ placeholder_expr != 0;
placeholder_expr = TREE_CHAIN (placeholder_expr))
{
tree need_type = TYPE_MAIN_VARIANT (type);
case PLACEHOLDER_EXPR:
{
tree old_list = placeholder_list;
- tree placeholder_expr;
+ tree placeholder_expr = 0;
exp = find_placeholder (exp, &placeholder_expr);
placeholder_list = TREE_CHAIN (placeholder_expr);
/* Return an object on the placeholder list that matches EXP, a
PLACEHOLDER_EXPR. An object "matches" if it is of the type of the
- PLACEHOLDER_EXPR or a pointer type to it. For further information,
- see tree.def. If no such object is found, abort. If PLIST is nonzero,
- it is a location into which a pointer into the placeholder list at
- which the object is found is placed. */
+ PLACEHOLDER_EXPR or a pointer type to it. For further information, see
+ tree.def. If no such object is found, abort. If PLIST is nonzero, it is
+ a location which initially points to a starting location in the
+ placeholder list (zero means start of the list) and where a pointer into
+ the placeholder list at which the object is found is placed. */
extern tree find_placeholder PARAMS ((tree, tree *));
/* Generate code for computing expression EXP.
/* Set the alias set of MEM to SET. */
extern void set_mem_alias_set PARAMS ((rtx, HOST_WIDE_INT));
+/* Set the alignment of MEM to ALIGN. */
+extern void set_mem_align PARAMS ((rtx, unsigned int));
+
/* Return a memory reference like MEMREF, but with its mode changed
to MODE and its address changed to ADDR.
(VOIDmode means don't change the mode.
- NULL for ADDR means don't change the address.)
- VALIDATE is nonzero if the returned memory location is required to be
- valid. */
-extern rtx change_address_1 PARAMS ((rtx, enum machine_mode, rtx, int));
-
-#define change_address(MEMREF, MODE, ADDR) \
- change_address_1 (MEMREF, MODE, ADDR, 1)
+ NULL for ADDR means don't change the address.) */
+extern rtx change_address PARAMS ((rtx, enum machine_mode, rtx));
/* Return a memory reference like MEMREF, but with its mode changed
to MODE and its address offset by OFFSET bytes. */
-extern rtx adjust_address PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT));
+#define adjust_address(MEMREF, MODE, OFFSET) \
+ adjust_address_1 (MEMREF, MODE, OFFSET, 1)
/* Likewise, but the reference is not required to be valid. */
-extern rtx adjust_address_nv PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT));
+#define adjust_address_nv(MEMREF, MODE, OFFSET) \
+ adjust_address_1 (MEMREF, MODE, OFFSET, 0)
+
+extern rtx adjust_address_1 PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT,
+ int));
/* Return a memory reference like MEMREF, but with its address changed to
ADDR. The caller is asserting that the actual piece of memory pointed
#include "config.h"
#include "system.h"
#include "rtl.h"
+
+/* We don't want the tree code checking code for the access to the
+ DECL_NAME to be included in the gen* programs. */
+#undef ENABLE_TREE_CHECKING
+#include "tree.h"
#include "real.h"
#include "flags.h"
#include "hard-reg-set.h"
switch (GET_CODE (in_rtx))
{
case MEM:
- fputc (' ', outfile);
+ fputs (" [", outfile);
fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));
+ if (MEM_DECL (in_rtx) && DECL_NAME (MEM_DECL (in_rtx)))
+ fprintf (outfile, " %s",
+ IDENTIFIER_POINTER (DECL_NAME (MEM_DECL (in_rtx))));
+
+ if (MEM_OFFSET (in_rtx))
+ {
+ fputc ('+', outfile);
+ fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
+ INTVAL (MEM_OFFSET (in_rtx)));
+ }
+
+ if (MEM_SIZE (in_rtx))
+ {
+ fputs (" S", outfile);
+ fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
+ INTVAL (MEM_SIZE (in_rtx)));
+ }
+
+ if (MEM_ALIGN (in_rtx) != 1)
+ fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
+
+ fputc (']', outfile);
break;
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && MAX_LONG_DOUBLE_TYPE_SIZE == 64
projects / platform / upstream / gcc.git / commitdiff