+Tue Oct 23 13:05:53 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * alias.c (can_address_p): Compnonents are not addressable if
+ the containing type has alias set 0.
+ (get_alias_set): Rework to use STRIP_NOPS.
+ Only call front-end routine on object, type, or object with
+ NOPs stripped, not inner values.
+ Use language hook to call front-end routine.
+ * builtins.c (get_memory_rtx): Always call set_mem_attributes.
+ (expand_builtin_apply): Call set_mem_align on MEMs we make.
+ Don't pass alignment to emit_block_move.
+ (expand_builtin_memcpy, expand_builtin_va_copy): Likewise.
+ (expand_builtin_memset): Likewise, but for clear_storage.
+ * c-common.c (lang_get_alias_set): Renamed to c_common_alias_set
+ and remove C++ specific parts.
+ * c-common.h (c_common_get_alias_set): Add declaration.
+ * c-lang.c (LANG_HOOKS_GET_ALIAS_SET): New macro.
+ * calls.c (emit_call_1): Fix typo in sibcall_pop case.
+ (save_fixed_argument_area): Call set_mem_align.
+ Remove alignment in call to emit_block_move.
+ (emit_library_call_value_1, store_one_arg): Likewise.
+ (target_for_arg): Remove; disabled long ago.
+ * emit-rtl.c (set_mem_attributes): Rework to only call get_mem_attrs
+ once and similar cleanups.
+ (offset_address): Use proper introductory comment.
+ * expr.c (emit_block_move): Use alignment from that of MEM args, not
+ from explicit operand; all callers changed.
+ (clear_storage): Likewise.
+ (expand_assignment): Don't call set_mem_alias_set on to_rtx.
+ (store_field): Remove kludge on alias set used for to_rtx.
+ (highest_pow2_factor, case *_DIV_EXPR): Never return 0.
+ (expand_expr_unaligned): Call set_mem_attributes instead of
+ set_mem_alias_set.
+ * expr.h (emit_block_move, clear_storage): Remove ALIGN argument.
+ * function.c (assign_stack_temp_for_type): Set MEM alignment.
+ (expand_function_end): Track MEM attributes of trampolines.
+ * ifcvt.c (noce_try_cmove_arith): Set alignment of new MEM.
+ * integrate.c (copy_rtx_and_substitute, case CALL): Copy memory
+ attributes from original.
+ * langhooks.c (lang_hook_default_get_alias_set): New function.
+ (hook_get_alias_set_0): New function.
+ * langhooks.h (hook_get_alias_set_0): New declaration.
+ (lang_hook_default_get_alias_set): Likewise.
+ (LANG_HOOKS_GET_ALIAS_SET): New macro; add to initializer.
+ * reload1.c (alter_reg): Use adjust_address_nv.
+ * rtl.c (get_mode_alignment): Moved to here.
+ * rtl.h (MEM_ALIGN): Take default from mode, if not BLKmode, and
+ change default if unknown from 1 to BITS_PER_UNIT.
+ * stor-layout.c (get_mode_alignment): Remove from here.
+ * toplev.h (struct lang_hoks): Add get_alias_set field.
+ * tree.h (lang_get_alias_set): Delete declaration.
+ * config/arc/arc.c (arc_setup_incoming_varags): Set MEM alignment.
+ * config/i386/i386.c (ix86_setup_incoming_varargs): Likewise.
+ (ix86_va_arg): Likewise.
+ * config/i960/i960.c (i960_setup_incoming_varargs): Likewise.
+ * config/pa/pa.c (hppa_builtin_saveregs): Likewise.
+ * config/sparc/sparc.c (sparc_va_arg): Likewise.
+ * config/rs6000/rs6000.c (setup_incoming_varargs): Likewise.
+ (expand_block_move_mem): Remove dead code.
+
2001-10-22 Neil Booth <neil@daikokuya.demon.co.uk>
* c-common.c (warn_div_by_zero): New.
else if (TREE_CODE (t) == BIT_FIELD_REF)
return 0;
+ /* Fields are addressable unless they are marked as nonaddressable or
+ the containing type has alias set 0. */
else if (TREE_CODE (t) == COMPONENT_REF
&& ! DECL_NONADDRESSABLE_P (TREE_OPERAND (t, 1))
+ && get_alias_set (TREE_TYPE (TREE_OPERAND (t, 0))) != 0
&& can_address_p (TREE_OPERAND (t, 0)))
return 1;
+ /* Likewise for arrays. */
else if ((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
&& ! TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t, 0)))
+ && get_alias_set (TREE_TYPE (TREE_OPERAND (t, 0))) != 0
&& can_address_p (TREE_OPERAND (t, 0)))
return 1;
tree inner = t;
tree placeholder_ptr = 0;
+ /* Remove any nops, then give the language a chance to do
+ something with this tree before we look at it. */
+ STRIP_NOPS (t);
+ set = (*lang_hooks.get_alias_set) (t);
+ if (set != -1)
+ return set;
+
/* 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
+ restrict-qualified pointer or a "void *". 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
+ while (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);
+
+ STRIP_NOPS (inner);
}
/* Check for accesses through restrict-qualified pointers. */
/* 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 (TREE_OPERAND (t, 0)))))
- || TREE_CODE (t) == NON_LVALUE_EXPR
- || TREE_CODE (t) == PLACEHOLDER_EXPR
+ while (TREE_CODE (t) == PLACEHOLDER_EXPR
|| (handled_component_p (t) && ! can_address_p (t)))
{
- /* Give the language a chance to do something with this tree
- before we go inside it. */
- if ((set = lang_get_alias_set (t)) != -1)
- return set;
-
if (TREE_CODE (t) == PLACEHOLDER_EXPR)
t = find_placeholder (t, &placeholder_ptr);
else
t = TREE_OPERAND (t, 0);
- }
- /* Give the language another chance to do something. */
- if ((set = lang_get_alias_set (t)) != -1)
- return set;
+ STRIP_NOPS (t);
+ }
/* If we've already determined the alias set for a decl, just return
it. This is necessary for C++ anonymous unions, whose component
return TYPE_ALIAS_SET (t);
/* See if the language has special handling for this type. */
- if ((set = lang_get_alias_set (t)) != -1)
+ set = (*lang_hooks.get_alias_set) (t);
+ if (set != -1)
return set;
/* There are no objects of FUNCTION_TYPE, so there's no point in
expand_expr (exp, NULL_RTX,
ptr_mode, EXPAND_SUM)));
+ set_mem_attributes (mem, exp, 0);
+
/* Get an expression we can use to find the attributes to assign to MEM.
If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
we can. First remove any nops. */
else
return mem;
- set_mem_attributes (mem, exp, 0);
/* memcpy, memset and other builtin stringops can alias with anything. */
set_mem_alias_set (mem, 0);
return mem;
{
int size, align, regno;
enum machine_mode mode;
- rtx incoming_args, result, reg, dest, call_insn;
+ rtx incoming_args, result, reg, dest, src, call_insn;
rtx old_stack_level = 0;
rtx call_fusage = 0;
but it's likely that the source and/or destination addresses in
the block copy will need updating in machine specific ways. */
dest = allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
- emit_block_move (gen_rtx_MEM (BLKmode, dest),
- gen_rtx_MEM (BLKmode, incoming_args),
- argsize, PARM_BOUNDARY);
+ dest = gen_rtx_MEM (BLKmode, dest);
+ set_mem_align (dest, PARM_BOUNDARY);
+ src = gen_rtx_MEM (BLKmode, incoming_args);
+ set_mem_align (src, PARM_BOUNDARY);
+ emit_block_move (dest, src, argsize);
/* Refer to the argument block. */
apply_args_size ();
arguments = gen_rtx_MEM (BLKmode, arguments);
+ set_mem_align (arguments, PARM_BOUNDARY);
/* Walk past the arg-pointer and structure value address. */
size = GET_MODE_SIZE (Pmode);
return 0;
dest_mem = get_memory_rtx (dest);
+ set_mem_align (dest_mem, dest_align);
len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
src_str = c_getstr (src);
}
src_mem = get_memory_rtx (src);
+ set_mem_align (src_mem, src_align);
/* Just copy the rights of SRC to the rights of DEST. */
if (current_function_check_memory_usage)
len_rtx, TYPE_MODE (sizetype));
/* Copy word part most expediently. */
- dest_addr
- = emit_block_move (dest_mem, src_mem, len_rtx,
- MIN (src_align, dest_align));
+ dest_addr = emit_block_move (dest_mem, src_mem, len_rtx);
if (dest_addr == 0)
dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
dest_mem = get_memory_rtx (dest);
+ set_mem_align (dest_mem, dest_align);
/* Just check DST is writable and mark it as readable. */
if (current_function_check_memory_usage)
TYPE_MODE (integer_type_node));
- dest_addr = clear_storage (dest_mem, len_rtx, dest_align);
+ dest_addr = clear_storage (dest_mem, len_rtx);
if (dest_addr == 0)
dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
/* "Dereference" to BLKmode memories. */
dstb = gen_rtx_MEM (BLKmode, dstb);
set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
+ set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
srcb = gen_rtx_MEM (BLKmode, srcb);
set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
+ set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
/* Copy. */
- emit_block_move (dstb, srcb, size, TYPE_ALIGN (va_list_type_node));
+ emit_block_move (dstb, srcb, size);
}
return const0_rtx;
or a type. Return -1 if we don't do anything special. */
HOST_WIDE_INT
-lang_get_alias_set (t)
+c_common_get_alias_set (t)
tree t;
{
tree u;
if (t1 != t)
return get_alias_set (t1);
}
- /* It's not yet safe to use alias sets for classes in C++ because
- the TYPE_FIELDs list for a class doesn't mention base classes. */
- else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
- return 0;
return -1;
}
extern tree build_va_arg PARAMS ((tree, tree));
extern void c_common_lang_init PARAMS ((void));
-
+extern HOST_WIDE_INT c_common_get_alias_set PARAMS ((tree));
extern bool c_promoting_integer_type_p PARAMS ((tree));
extern int self_promoting_args_p PARAMS ((tree));
extern tree simple_type_promotes_to PARAMS ((tree));
#define LANG_HOOKS_DECODE_OPTION c_decode_option
#undef LANG_HOOKS_POST_OPTIONS
#define LANG_HOOKS_POST_OPTIONS c_post_options
+#undef LANG_HOOKS_GET_ALIAS_SET
+#define LANG_HOOKS_GET_ALIAS_SET c_common_get_alias_set
+
#undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN
#define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \
c_cannot_inline_tree_fn
&& HAVE_sibcall_pop && HAVE_sibcall_value_pop
&& (n_popped > 0 || stack_size == 0))
{
- rtx n_pop = GEN_INT (n_popped));
+ rtx n_pop = GEN_INT (n_popped);
rtx pat;
/* If this subroutine pops its own args, record that in the call insn
#endif
#if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
-/* If the target has "call" or "call_value" insns, then prefer them
- if no arguments are actually popped. If the target does not have
- "call" or "call_value" insns, then we must use the popping versions
- even if the call has no arguments to pop. */
+ /* If the target has "call" or "call_value" insns, then prefer them
+ if no arguments are actually popped. If the target does not have
+ "call" or "call_value" insns, then we must use the popping versions
+ even if the call has no arguments to pop. */
#if defined (HAVE_call) && defined (HAVE_call_value)
if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
&& n_popped > 0 && ! (ecf_flags & ECF_SP_DEPRESSED))
/* Mark memory as used for "pure" function call. */
if (ecf_flags & ECF_PURE)
- {
- call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
- gen_rtx_USE (VOIDmode,
- gen_rtx_MEM (BLKmode,
- gen_rtx_SCRATCH (VOIDmode))), call_fusage);
- }
+ call_fusage
+ = gen_rtx_EXPR_LIST
+ (VOIDmode,
+ gen_rtx_USE (VOIDmode,
+ gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode))),
+ call_fusage);
/* Put the register usage information on the CALL. If there is already
some usage information, put ours at the end. */
plus_constant (argblock,
*low_to_save)));
#endif
+
+ set_mem_align (stack_area, PARM_BOUNDARY);
if (save_mode == BLKmode)
{
save_area = assign_stack_temp (BLKmode, num_to_save, 0);
emit_move_insn (save_area, stack_area);
}
}
+
return save_area;
}
else
emit_block_move (stack_area,
validize_mem (args[i].save_area),
- GEN_INT (args[i].size.constant),
- PARM_BOUNDARY);
+ GEN_INT (args[i].size.constant));
}
highest_outgoing_arg_in_use = initial_highest_arg_in_use;
/* Output a library call to function FUN (a SYMBOL_REF rtx).
The RETVAL parameter specifies whether return value needs to be saved, other
parameters are documented in the emit_library_call function below. */
+
static rtx
emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
int retval;
if (save_mode == BLKmode)
{
save_area = assign_stack_temp (BLKmode, num_to_save, 0);
- emit_block_move (validize_mem (save_area), stack_area,
- GEN_INT (num_to_save), PARM_BOUNDARY);
+ set_mem_align (save_area, PARM_BOUNDARY);
+ emit_block_move (validize_mem (save_area), stack_area);
}
else
{
memory_address (save_mode,
plus_constant (argblock, low_to_save)));
#endif
+
+ set_mem_align (stack_area, PARM_BOUNDARY);
if (save_mode != BLKmode)
emit_move_insn (stack_area, save_area);
else
emit_block_move (stack_area, validize_mem (save_area),
- GEN_INT (high_to_save - low_to_save + 1),
- PARM_BOUNDARY);
+ GEN_INT (high_to_save - low_to_save + 1));
}
#endif
return result;
}
\f
-#if 0
-/* Return an rtx which represents a suitable home on the stack
- given TYPE, the type of the argument looking for a home.
- This is called only for BLKmode arguments.
-
- SIZE is the size needed for this target.
- ARGS_ADDR is the address of the bottom of the argument block for this call.
- OFFSET describes this parameter's offset into ARGS_ADDR. It is meaningless
- if this machine uses push insns. */
-
-static rtx
-target_for_arg (type, size, args_addr, offset)
- tree type;
- rtx size;
- rtx args_addr;
- struct args_size offset;
-{
- rtx target;
- rtx offset_rtx = ARGS_SIZE_RTX (offset);
-
- /* We do not call memory_address if possible,
- because we want to address as close to the stack
- as possible. For non-variable sized arguments,
- this will be stack-pointer relative addressing. */
- if (GET_CODE (offset_rtx) == CONST_INT)
- target = plus_constant (args_addr, INTVAL (offset_rtx));
- else
- {
- /* I have no idea how to guarantee that this
- will work in the presence of register parameters. */
- target = gen_rtx_PLUS (Pmode, args_addr, offset_rtx);
- target = memory_address (QImode, target);
- }
-
- return gen_rtx_MEM (BLKmode, target);
-}
-#endif
-\f
/* Store a single argument for a function call
into the register or memory area where it must be passed.
*ARG describes the argument value and where to pass it.
arg->save_area = assign_temp (nt, 0, 1, 1);
preserve_temp_slots (arg->save_area);
emit_block_move (validize_mem (arg->save_area), stack_area,
- expr_size (arg->tree_value),
- MIN (PARM_BOUNDARY, TYPE_ALIGN (nt)));
+ expr_size (arg->tree_value));
}
else
{
FIRST_PARM_OFFSET (0)
+ align_slop * UNITS_PER_WORD));
set_mem_alias_set (regblock, get_varargs_alias_set ());
+ set_mem_align (regblock, BITS_PER_WORD);
move_block_from_reg (first_reg_offset, regblock,
MAX_ARC_PARM_REGS - first_reg_offset,
((MAX_ARC_PARM_REGS - first_reg_offset)
pointing 127 bytes after first byte to store - this is needed to keep
instruction size limited by 4 bytes. */
tmp_reg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET(VOIDmode, tmp_reg,
- plus_constant (save_area, 8 * REGPARM_MAX + 127)));
+ emit_insn (gen_rtx_SET (VOIDmode, tmp_reg,
+ plus_constant (save_area,
+ 8 * REGPARM_MAX + 127)));
mem = gen_rtx_MEM (BLKmode, plus_constant (tmp_reg, -127));
set_mem_alias_set (mem, set);
+ set_mem_align (mem, BITS_PER_WORD);
/* And finally do the dirty job! */
- emit_insn (gen_sse_prologue_save (mem, nsse_reg, GEN_INT (next_cum.sse_regno),
- label));
+ emit_insn (gen_sse_prologue_save (mem, nsse_reg,
+ GEN_INT (next_cum.sse_regno), label));
}
}
addr_rtx = XEXP (assign_temp (type, 0, 1, 0), 0);
mem = gen_rtx_MEM (BLKmode, addr_rtx);
set_mem_alias_set (mem, get_varargs_alias_set ());
+ set_mem_align (mem, BITS_PER_UNIT);
for (i = 0; i < XVECLEN (container, 0); i++)
{
set_mem_alias_set (src_mem, get_varargs_alias_set ());
src_mem = adjust_address (src_mem, mode, src_offset);
dest_mem = adjust_address (mem, mode, INTVAL (XEXP (slot, 1)));
- PUT_MODE (dest_mem, mode);
emit_move_insn (dest_mem, src_mem);
}
}
regblock = gen_rtx_MEM (BLKmode,
plus_constant (arg_pointer_rtx, first_reg * 4));
set_mem_alias_set (regblock, get_varargs_alias_set ());
+ set_mem_align (regblock, BITS_PER_WORD);
move_block_from_reg (first_reg, regblock,
NPARM_REGS - first_reg,
(NPARM_REGS - first_reg) * UNITS_PER_WORD);
plus_constant (current_function_internal_arg_pointer,
-16));
set_mem_alias_set (dest, get_varargs_alias_set ());
+ set_mem_align (dest, BITS_PER_WORD);
move_block_from_reg (23, dest, 4, 4 * UNITS_PER_WORD);
/* move_block_from_reg will emit code to store the argument registers
plus_constant (save_area,
first_reg_offset * reg_size)),
set_mem_alias_set (mem, set);
+ set_mem_align (mem, BITS_PER_WORD);
move_block_from_reg
(GP_ARG_MIN_REG + first_reg_offset, mem,
rtx mem = gen_rtx_MEM (mode, addr);
MEM_COPY_ATTRIBUTES (mem, orig_mem);
-#ifdef MEM_UNALIGNED_P
- MEM_UNALIGNED_P (mem) = MEM_UNALIGNED_P (orig_mem);
-#endif
return mem;
}
|| DEFAULT_ABI == ABI_AIX_NODESC)
{
cfun->machine->ra_needs_full_frame = 1;
- return gen_rtx_MEM (Pmode,
- memory_address (Pmode,
- plus_constant (copy_to_reg
- (gen_rtx_MEM (Pmode,
- memory_address (Pmode, frame))),
- RETURN_ADDRESS_OFFSET)));
+
+ return
+ gen_rtx_MEM
+ (Pmode,
+ memory_address
+ (Pmode,
+ plus_constant (copy_to_reg
+ (gen_rtx_MEM (Pmode,
+ memory_address (Pmode, frame))),
+ RETURN_ADDRESS_OFFSET)));
}
return get_hard_reg_initial_val (Pmode, LINK_REGISTER_REGNUM);
address = orig;
pic_ref = gen_rtx_MEM (Pmode,
- gen_rtx_PLUS (Pmode,
- pic_offset_table_rtx, address));
+ gen_rtx_PLUS (Pmode,
+ pic_offset_table_rtx, address));
current_function_uses_pic_offset_table = 1;
RTX_UNCHANGING_P (pic_ref) = 1;
insn = emit_move_insn (reg, pic_ref);
for (regno = first_reg; regno < NPARM_REGS (word_mode); regno++)
emit_move_insn (gen_rtx_MEM (word_mode,
- gen_rtx_PLUS (Pmode,
- frame_pointer_rtx,
- GEN_INT (STACK_POINTER_OFFSET
- + UNITS_PER_WORD * regno))),
+ gen_rtx_PLUS (Pmode,
+ frame_pointer_rtx,
+ GEN_INT (STACK_POINTER_OFFSET
+ + (UNITS_PER_WORD
+ * regno)))),
gen_rtx_REG (word_mode,
- BASE_INCOMING_ARG_REG (word_mode) + regno));
+ BASE_INCOMING_ARG_REG (word_mode) + regno));
address = gen_rtx_PLUS (Pmode,
- frame_pointer_rtx,
- GEN_INT (STACK_POINTER_OFFSET
- + UNITS_PER_WORD * first_reg));
+ frame_pointer_rtx,
+ GEN_INT (STACK_POINTER_OFFSET
+ + UNITS_PER_WORD * first_reg));
if (current_function_check_memory_usage
&& first_reg < NPARM_REGS (word_mode))
addr_rtx = force_reg (Pmode, addr_rtx);
addr_rtx = gen_rtx_MEM (BLKmode, addr_rtx);
set_mem_alias_set (addr_rtx, get_varargs_alias_set ());
+ set_mem_align (addr_rtx, BITS_PER_WORD);
tmp = shallow_copy_rtx (tmp);
PUT_MODE (tmp, BLKmode);
set_mem_alias_set (tmp, 0);
- dest_addr = emit_block_move (tmp, addr_rtx, GEN_INT (rsize),
- BITS_PER_WORD);
+ dest_addr = emit_block_move (tmp, addr_rtx, GEN_INT (rsize));
if (dest_addr != NULL_RTX)
addr_rtx = dest_addr;
else
+Tue Oct 23 14:00:20 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * cp-lang.c (cxx_get_alias_set): New function.
+ Point LANG_HOOKS_GET_ALIAS_SET to it.
+
2001-10-23 Kriang Lerdsuwanakij <lerdsuwa@users.sourceforge.net>
* cp-tree.def (UNBOUND_CLASS_TEMPLATE): New tree node.
#include "toplev.h"
#include "langhooks.h"
+static HOST_WIDE_INT cxx_get_alias_set PARAMS ((tree));
+
#undef LANG_HOOKS_INIT
#define LANG_HOOKS_INIT cxx_init
#undef LANG_HOOKS_FINISH
#define LANG_HOOKS_DECODE_OPTION cxx_decode_option
#undef LANG_HOOKS_POST_OPTIONS
#define LANG_HOOKS_POST_OPTIONS cxx_post_options
+#undef LANG_HOOKS_GET_ALIAS_SET
+#define LANG_HOOKS_GET_ALIAS_SET cxx_get_alias_set
#undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES
#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES \
/* Each front end provides its own hooks, for toplev.c. */
struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
+
+/* Special routine to get the alias set for C++. */
+
+static HOST_WIDE_INT
+cxx_get_alias_set (t)
+ tree t;
+{
+ /* It's not yet safe to use alias sets for classes in C++ because
+ the TYPE_FIELDs list for a class doesn't mention base classes. */
+ if (AGGREGATE_TYPE_P (t))
+ return 0;
+
+ return c_common_get_alias_set (t);
+}
tree t;
int objectp;
{
+ HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
+ tree decl = MEM_DECL (ref);
+ rtx offset = MEM_OFFSET (ref);
+ rtx size = MEM_SIZE (ref);
+ unsigned int align = MEM_ALIGN (ref);
tree type;
/* It can happen that type_for_mode was given a mode for which there
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));
+ front-end routine) and use it. */
+ alias = get_alias_set (t);
MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
|= (lang_hooks.honor_readonly
&& (TYPE_READONLY (type) || TREE_READONLY (t)));
- /* If we are making an object of this type, we know that it is a scalar if
- the type is not an aggregate. */
- if (objectp && ! AGGREGATE_TYPE_P (type))
+ /* If we are making an object of this type, or if this is a DECL, we know
+ that it is a scalar if the type is not an aggregate. */
+ if ((objectp || DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
MEM_SCALAR_P (ref) = 1;
/* 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));
+ size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
- /* 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 T is not a type. Otherwise, we may be able to deduce some more
+ information about the expression. */
if (TYPE_P (t))
- return;
-
- maybe_set_unchanging (ref, t);
- if (TREE_THIS_VOLATILE (t))
- MEM_VOLATILE_P (ref) = 1;
+ {
+ maybe_set_unchanging (ref, t);
+ if (TREE_THIS_VOLATILE (t))
+ MEM_VOLATILE_P (ref) = 1;
- /* Now remove any NOPs: they don't change what the underlying object is.
+ /* 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));
-
- /* If this is an INDIRECT_REF, we know its alignment. */
- if (TREE_CODE (t) == INDIRECT_REF)
- set_mem_align (ref, TYPE_ALIGN (type));
-
- /* 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))
+ 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))
+ {
+ decl = t;
+ offset = GEN_INT (0);
+ size = (DECL_SIZE_UNIT (t)
+ && host_integerp (DECL_SIZE_UNIT (t), 1)
+ ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
+ align = DECL_ALIGN (t);
+ }
+
+ /* If this is an INDIRECT_REF, we know its alignment. */
+ else if (TREE_CODE (t) == INDIRECT_REF)
+ align = TYPE_ALIGN (type);
+ }
+
+ /* Now set the attributes we computed above. */
+ MEM_ATTRS (ref) = get_mem_attrs (alias, decl, offset, size, align);
+
+ /* If this is already known to be a scalar or aggregate, we are done. */
+ if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_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. */
- if (DECL_P (t))
- MEM_SCALAR_P (ref) = 1;
+ /* If it is a reference into an aggregate, this is part of an aggregate.
+ Otherwise we don't know. */
else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
|| TREE_CODE (t) == ARRAY_RANGE_REF
|| TREE_CODE (t) == BIT_FIELD_REF)
return new;
}
-/* Return a memory reference like MEMREF, but with its address changed to
- ADDR. The caller is asserting that the actual piece of memory pointed
- to is the same, just the form of the address is being changed, such as
- by putting something into a register. */
+/* Return a memory reference like MEMREF, but whose address is changed by
+ adding OFFSET, an RTX, to it. POW2 is the highest power of two factor
+ known to be in OFFSET (possibly 1). */
rtx
offset_address (memref, offset, pow2)
0 otherwise. */
rtx
-emit_block_move (x, y, size, align)
+emit_block_move (x, y, size)
rtx x, y;
rtx size;
- unsigned int align;
{
rtx retval = 0;
#ifdef TARGET_MEM_FUNCTIONS
static tree fn;
tree call_expr, arg_list;
#endif
+ unsigned int align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
if (GET_MODE (x) != BLKmode)
abort ();
}
\f
/* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
- its length in bytes and ALIGN is the maximum alignment we can is has.
-
- If we call a function that returns the length of the block, return it. */
+ its length in bytes. */
rtx
-clear_storage (object, size, align)
+clear_storage (object, size)
rtx object;
rtx size;
- unsigned int align;
{
#ifdef TARGET_MEM_FUNCTIONS
static tree fn;
tree call_expr, arg_list;
#endif
rtx retval = 0;
+ unsigned int align = (GET_CODE (object) == MEM ? MEM_ALIGN (object)
+ : GET_MODE_ALIGNMENT (GET_MODE (object)));
/* If OBJECT is not BLKmode and SIZE is the same size as its mode,
just move a zero. Otherwise, do this a piece at a time. */
of sibling calls. */
set_mem_alias_set (target, 0);
}
+ else
+ set_mem_align (target, align);
/* TEMP is the address of the block. Copy the data there. */
if (GET_CODE (size) == CONST_INT
rtx inner_to_rtx
= adjust_address (to_rtx, BLKmode, bitpos / BITS_PER_UNIT);
- emit_block_move (inner_to_rtx, from_rtx, expr_size (from),
- MIN (alignment, from_align));
+ emit_block_move (inner_to_rtx, from_rtx, expr_size (from));
+
free_temp_slots ();
pop_temp_slots ();
return to_rtx;
emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)),
TYPE_ALIGN (TREE_TYPE (from)));
else if (GET_MODE (to_rtx) == BLKmode)
- emit_block_move (to_rtx, value, expr_size (from),
- TYPE_ALIGN (TREE_TYPE (from)));
+ emit_block_move (to_rtx, value, expr_size (from));
else
{
#ifdef POINTERS_EXTEND_UNSIGNED
Don't re-expand if it was expanded already (in COMPONENT_REF case). */
if (to_rtx == 0)
- {
- to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
- if (GET_CODE (to_rtx) == MEM)
- set_mem_alias_set (to_rtx, get_alias_set (to));
- }
+ to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
/* Don't move directly into a return register. */
if (TREE_CODE (to) == RESULT_DECL
size = expr_size (exp);
if (GET_CODE (size) == CONST_INT
&& INTVAL (size) < TREE_STRING_LENGTH (exp))
- emit_block_move (target, temp, size, TYPE_ALIGN (TREE_TYPE (exp)));
+ emit_block_move (target, temp, size);
else
{
/* Compute the size of the data to copy from the string. */
= size_binop (MIN_EXPR,
make_tree (sizetype, size),
size_int (TREE_STRING_LENGTH (exp)));
- unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
VOIDmode, 0);
rtx label = 0;
/* Copy that much. */
- emit_block_move (target, temp, copy_size_rtx,
- TYPE_ALIGN (TREE_TYPE (exp)));
+ emit_block_move (target, temp, copy_size_rtx);
/* Figure out how much is left in TARGET that we have to clear.
Do all calculations in ptr_mode. */
{
addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
size = plus_constant (size, -TREE_STRING_LENGTH (exp));
- align = MIN (align,
- (unsigned int) (BITS_PER_UNIT
- * (INTVAL (copy_size_rtx)
- & - INTVAL (copy_size_rtx))));
}
else
{
copy_size_rtx, NULL_RTX, 0,
OPTAB_LIB_WIDEN);
- align = BITS_PER_UNIT;
label = gen_label_rtx ();
emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
GET_MODE (size), 0, 0, label);
}
- align = MIN (align, expr_align (copy_size));
if (size != const0_rtx)
{
GEN_INT (MEMORY_USE_WO),
TYPE_MODE (integer_type_node));
in_check_memory_usage = 0;
- clear_storage (dest, size, align);
+ clear_storage (dest, size);
}
if (label)
emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)),
TYPE_ALIGN (TREE_TYPE (exp)));
else if (GET_MODE (temp) == BLKmode)
- emit_block_move (target, temp, expr_size (exp),
- TYPE_ALIGN (TREE_TYPE (exp)));
+ emit_block_move (target, temp, expr_size (exp));
else
emit_move_insn (target, temp);
}
/* If the constructor is empty, clear the union. */
if (! CONSTRUCTOR_ELTS (exp) && ! cleared)
- clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
+ clear_storage (target, expr_size (exp));
}
/* If we are building a static constructor into a register,
|| (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target)) == size))
{
if (! cleared)
- clear_storage (target, GEN_INT (size), align);
+ clear_storage (target, GEN_INT (size));
cleared = 1;
}
if (need_to_clear && size > 0)
{
if (! cleared)
- clear_storage (target, GEN_INT (size), align);
+ clear_storage (target, GEN_INT (size));
cleared = 1;
}
else if (REG_P (target))
if (elt == NULL_TREE && size > 0)
{
if (!cleared)
- clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
+ clear_storage (target, GEN_INT (size));
return;
}
|| (tree_low_cst (TREE_VALUE (elt), 0)
- tree_low_cst (TREE_PURPOSE (elt), 0) + 1
!= (HOST_WIDE_INT) nbits))))
- clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
+ clear_storage (target, expr_size (exp));
for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
{
emit_block_move (target, temp,
bitsize == -1 ? expr_size (exp)
: GEN_INT ((bitsize + BITS_PER_UNIT - 1)
- / BITS_PER_UNIT),
- align);
+ / BITS_PER_UNIT));
return value_mode == VOIDmode ? const0_rtx : target;
}
bitpos / BITS_PER_UNIT));
MEM_SET_IN_STRUCT_P (to_rtx, 1);
- /* If the address of the structure varies, then it might be on
- the stack. And, stack slots may be shared across scopes.
- So, two different structures, of different types, can end up
- at the same location. We will give the structures alias set
- zero; here we must be careful not to give non-zero alias sets
- to their fields. */
- set_mem_alias_set (to_rtx,
- rtx_varies_p (addr, /*for_alias=*/0)
- ? 0 : alias_set);
+ set_mem_alias_set (to_rtx, alias_set);
return store_expr (exp, to_rtx, value_mode != VOIDmode);
}
case CEIL_DIV_EXPR:
c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
- return c0 / c1;
+ return MAX (1, c0 / c1);
case NON_LVALUE_EXPR: case NOP_EXPR: case CONVERT_EXPR:
case COMPOUND_EXPR: case SAVE_EXPR:
emit_block_move (target, op0,
bitsize == -1 ? expr_size (exp)
: GEN_INT ((bitsize + BITS_PER_UNIT - 1)
- / BITS_PER_UNIT),
- BITS_PER_UNIT);
+ / BITS_PER_UNIT));
return target;
}
/* Get a reference to just this component. */
op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
- set_mem_alias_set (op0, get_alias_set (exp));
+ set_mem_attributes (op0, exp, 0);
/* Adjust the alignment in case the bit position is not
a multiple of the alignment of the inner object. */
rtx, int));
/* Emit code to move a block Y to a block X. */
-extern rtx emit_block_move PARAMS ((rtx, rtx, rtx, unsigned int));
+extern rtx emit_block_move PARAMS ((rtx, rtx, rtx));
/* Copy all or part of a value X into registers starting at REGNO.
The number of registers to be filled is NREGS. */
extern void use_group_regs PARAMS ((rtx *, rtx));
/* Write zeros through the storage of OBJECT.
- If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is its
- alignment. */
-extern rtx clear_storage PARAMS ((rtx, rtx, unsigned int));
+ If OBJECT has BLKmode, SIZE is its length in bytes. */
+extern rtx clear_storage PARAMS ((rtx, rtx));
/* Return non-zero if it is desirable to store LEN bytes generated by
CONSTFUN with several move instructions by store_by_pieces
+Tue Oct 23 14:01:27 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * com.c (LANG_HOOKS_GET_ALIAS_SET): New macro.
+ (lang_get_alias_set): Delete.
+
2001-10-23 Joseph S. Myers <jsm28@cam.ac.uk>
* g77.texi (Sending Patches): Remove.
#undef LANG_HOOKS_DECODE_OPTION
#define LANG_HOOKS_DECODE_OPTION ffe_decode_option
+/* We do not wish to use alias-set based aliasing at all. Used in the
+ extreme (every object with its own set, with equivalences recorded) it
+ might be helpful, but there are problems when it comes to inlining. We
+ get on ok with flag_argument_noalias, and alias-set aliasing does
+ currently limit how stack slots can be reused, which is a lose. */
+#undef LANG_HOOKS_GET_ALIAS_SET
+#define LANG_HOOKS_GET_ALIAS_SET hook_get_alias_set_0
+
struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
/* used by print-tree.c */
return "f77";
}
-/* Return the typed-based alias set for T, which may be an expression
- or a type. Return -1 if we don't do anything special. */
-
-HOST_WIDE_INT
-lang_get_alias_set (t)
- tree t ATTRIBUTE_UNUSED;
-{
- /* We do not wish to use alias-set based aliasing at all. Used in the
- extreme (every object with its own set, with equivalences recorded)
- it might be helpful, but there are problems when it comes to inlining.
- We get on ok with flag_argument_noalias, and alias-set aliasing does
- currently limit how stack slots can be reused, which is a lose. */
- return 0;
-}
-
static void
ffe_init_options ()
{
MEM_SCALAR_P (tmp) = 1;
if (MEM_ALIAS_SET (if_info->a) == MEM_ALIAS_SET (if_info->b))
set_mem_alias_set (tmp, MEM_ALIAS_SET (if_info->a));
+ set_mem_align (tmp,
+ MIN (MEM_ALIGN (if_info->a), MEM_ALIGN (if_info->b)));
noce_emit_move_insn (if_info->x, tmp);
}
#ifndef NO_FUNCTION_CSE
if (! (optimize && ! flag_no_function_cse))
#endif
- return
- gen_rtx_CALL
- (GET_MODE (orig),
- gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
- copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0),
- map, 0)),
- copy_rtx_and_substitute (XEXP (orig, 1), map, 0));
+ {
+ rtx copy
+ = gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
+ copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0),
+ map, 0));
+
+ MEM_COPY_ATTRIBUTES (copy, orig);
+
+ return
+ gen_rtx_CALL (GET_MODE (orig), copy,
+ copy_rtx_and_substitute (XEXP (orig, 1), map, 0));
+ }
break;
#if 0
+Tue Oct 23 14:02:17 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * lang.c (lang_get_alias_set): Deleted.
+
2001-10-21 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* gjavah.c (jni_print_char): Fix thinko in last change.
int indent __attribute ((__unused__));
{
}
-
-/* Return the typed-based alias set for T, which may be an expression
- or a type. Return -1 if we don't do anything special. */
-
-HOST_WIDE_INT
-lang_get_alias_set (t)
- tree t ATTRIBUTE_UNUSED;
-{
- return -1;
-}
#include "langhooks.h"
/* Do nothing; in many cases the default hook. */
+
void
lang_hook_default_do_nothing ()
{
}
+/* Provide a default routine for alias sets that always returns -1. This
+ is used by languages that don't need to do anything special. */
+
+HOST_WIDE_INT
+lang_hook_default_get_alias_set (t)
+ tree t ATTRIBUTE_UNUSED;
+{
+ return -1;
+}
+
/* Do nothing; the default hook to decode an option. */
+
int
lang_hook_default_decode_option (argc, argv)
int argc ATTRIBUTE_UNUSED;
return 0;
}
+/* Provide a hook routine for alias sets that always returns 0. This is
+ used by languages that haven't deal with alias sets yet. */
+
+HOST_WIDE_INT
+hook_get_alias_set_0 (t)
+ tree t ATTRIBUTE_UNUSED;
+{
+ return 0;
+}
+
/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
after handling common cases, but before walking code-specific
sub-trees. If this hook is overridden for a language, it should
#ifndef GCC_LANG_HOOKS_H
#define GCC_LANG_HOOKS_H
+/* Provide a hook routine for alias sets that always returns 1. This is
+ used by languages that haven't deal with alias sets yet. */
+extern HOST_WIDE_INT hook_get_alias_set_0 PARAMS ((tree));
+
/* Note to creators of new hooks:
The macros in this file should NOT be surrounded by a
extern void lang_hook_default_do_nothing PARAMS ((void));
extern int lang_hook_default_decode_option PARAMS ((int, char **));
+extern HOST_WIDE_INT lang_hook_default_get_alias_set PARAMS ((tree));
#define LANG_HOOKS_INIT lang_hook_default_do_nothing
#define LANG_HOOKS_FINISH lang_hook_default_do_nothing
#define LANG_HOOKS_INIT_OPTIONS lang_hook_default_do_nothing
#define LANG_HOOKS_DECODE_OPTION lang_hook_default_decode_option
#define LANG_HOOKS_POST_OPTIONS lang_hook_default_do_nothing
+#define LANG_HOOKS_GET_ALIAS_SET lang_hook_default_get_alias_set
#define LANG_HOOKS_HONOR_READONLY false
/* Declarations of default tree inlining hooks. */
-tree tree_inlining_default_hook_walk_subtrees PARAMS ((tree*, int *,
- walk_tree_fn,
- void *, void *));
-int tree_inlining_default_hook_cannot_inline_tree_fn PARAMS ((tree*));
-int tree_inlining_default_hook_disregard_inline_limits PARAMS ((tree));
-tree tree_inlining_default_hook_add_pending_fn_decls PARAMS ((void*, tree));
-int tree_inlining_default_hook_tree_chain_matters_p PARAMS ((tree));
-int tree_inlining_default_hook_auto_var_in_fn_p PARAMS ((tree, tree));
+tree tree_inlining_default_hook_walk_subtrees PARAMS ((tree *, int *,
+ walk_tree_fn,
+ void *,
+ void *));
+int tree_inlining_default_hook_cannot_inline_tree_fn PARAMS ((tree *));
+int tree_inlining_default_hook_disregard_inline_limits PARAMS ((tree));
+tree tree_inlining_default_hook_add_pending_fn_decls PARAMS ((void *,
+ tree));
+int tree_inlining_default_hook_tree_chain_matters_p PARAMS ((tree));
+int tree_inlining_default_hook_auto_var_in_fn_p PARAMS ((tree, tree));
tree tree_inlining_default_hook_copy_res_decl_for_inlining PARAMS ((tree, tree,
tree,
void *,
int *,
void *));
-int tree_inlining_default_hook_anon_aggr_type_p PARAMS ((tree));
+int tree_inlining_default_hook_anon_aggr_type_p PARAMS ((tree));
/* Tree inlining hooks. */
#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES \
LANG_HOOKS_INIT_OPTIONS, \
LANG_HOOKS_DECODE_OPTION, \
LANG_HOOKS_POST_OPTIONS, \
+ LANG_HOOKS_GET_ALIAS_SET, \
LANG_HOOKS_HONOR_READONLY, \
LANG_HOOKS_TREE_INLINING_INITIALIZER \
}
below. */
adjust = GET_MODE_SIZE (mode) - total_size;
if (adjust)
- stack_slot = gen_rtx_MEM (mode_for_size (total_size
+ stack_slot
+ = adjust_address_nv (x, mode_for_size (total_size
* BITS_PER_UNIT,
MODE_INT, 1),
- plus_constant (XEXP (x, 0), adjust));
+ adjust);
}
spill_stack_slot[from_reg] = stack_slot;
}
/* Create a new copy of an rtx. Only copy just one level. */
+
rtx
shallow_copy_rtx (orig)
rtx orig;
return copy;
}
+
+/* Return the alignment of MODE. This will be bounded by 1 and
+ BIGGEST_ALIGNMENT. */
+
+unsigned int
+get_mode_alignment (mode)
+ enum machine_mode mode;
+{
+ unsigned int alignment = GET_MODE_UNIT_SIZE (mode);
+
+ /* Extract the LSB of the size. */
+ alignment = alignment & -alignment;
+ alignment *= BITS_PER_UNIT;
+
+ alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
+ return alignment;
+}
\f
/* This is 1 until after the rtl generation pass. */
int rtx_equal_function_value_matters;
#define MEM_SIZE(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->size)
/* For a MEM rtx, the alignment in bits. */
-#define MEM_ALIGN(RTX) (MEM_ATTRS (RTX) == 0 ? 1 : MEM_ATTRS (RTX)->align)
+#define MEM_ALIGN(RTX) \
+(MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->align \
+ : GET_MODE (RTX) != BLKmode ? GET_MODE_ALIGNMENT (GET_MODE (RTX)) \
+ : BITS_PER_UNIT)
+
/* Copy the attributes that apply to memory locations from RHS to LHS. */
#define MEM_COPY_ATTRIBUTES(LHS, RHS) \
return mode;
}
-/* Return the alignment of MODE. This will be bounded by 1 and
- BIGGEST_ALIGNMENT. */
-
-unsigned int
-get_mode_alignment (mode)
- enum machine_mode mode;
-{
- unsigned int alignment = GET_MODE_UNIT_SIZE (mode);
-
- /* Extract the LSB of the size. */
- alignment = alignment & -alignment;
- alignment *= BITS_PER_UNIT;
-
- alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
- return alignment;
-}
-
/* This function is run once to initialize stor-layout.c. */
void
#define skip_leading_substring(whole, part) \
(strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
-extern int toplev_main PARAMS ((int argc, char **argv));
+extern int toplev_main PARAMS ((int, char **));
extern int read_integral_parameter PARAMS ((const char *, const char *,
const int));
extern int count_error PARAMS ((int));
void *, void *));
int (*cannot_inline_tree_fn) PARAMS ((union tree_node **));
int (*disregard_inline_limits) PARAMS ((union tree_node *));
- union tree_node *(*add_pending_fn_decls) PARAMS ((void*, union tree_node *));
+ union tree_node *(*add_pending_fn_decls) PARAMS ((void *,
+ union tree_node *));
int (*tree_chain_matters_p) PARAMS ((union tree_node *));
int (*auto_var_in_fn_p) PARAMS ((union tree_node *, union tree_node *));
union tree_node *(*copy_res_decl_for_inlining) PARAMS ((union tree_node *,
/* Called when all command line options have been processed. */
void (*post_options) PARAMS ((void));
+ /* Called to obtain the alias set to be used for an expression or type.
+ Returns -1 if the language does nothing special for it. */
+ HOST_WIDE_INT (*get_alias_set) PARAMS ((tree));
+
/* Nonzero if TYPE_READONLY and TREE_READONLY should always be honored. */
bool honor_readonly;
extern int readonly_fields_p PARAMS ((tree));
extern int objects_must_conflict_p PARAMS ((tree, tree));
-/* In c-common.c */
-extern HOST_WIDE_INT lang_get_alias_set PARAMS ((tree));
-
/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
appropriate IDENTIFIER_NODE. Otherwise, set it to the
projects / thirdparty / gcc.git / commitdiff
