OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

alias.c (can_address_p): Compnonents are not addressable if the containing type has alias set 0. 

* 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.
	* cp/cp-lang.c (cxx_get_alias_set): New function.
	Point LANG_HOOKS_GET_ALIAS_SET to it.
	* f/com.c (LANG_HOOKS_GET_ALIAS_SET): New macro.
	(lang_get_alias_set): Delete.
	* java/lang.c (lang_get_alias_set): Deleted.

From-SVN: r46440
This commit is contained in:
Richard Kenner 2001-10-23 18:51:18 +00:00 committed by Richard Kenner
parent 6c36d76bf6
commit 8ac61af705
32 changed files with 360 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
gcc/ChangeLog
View File

@ -1,3 +1,63 @@
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.

44
gcc/alias.c
View File

@ -438,13 +438,18 @@ can_address_p (t)
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;
@ -478,22 +483,25 @@ get_alias_set (t)
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. */
@ -540,27 +548,16 @@ get_alias_set (t)
/* 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
@ -580,7 +577,8 @@ get_alias_set (t)
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

27
gcc/builtins.c
View File

@ -724,6 +724,8 @@ get_memory_rtx (exp)
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. */
@ -739,7 +741,6 @@ get_memory_rtx (exp)
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;
@ -1040,7 +1041,7 @@ expand_builtin_apply (function, arguments, argsize)
{
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;
@ -1079,13 +1080,16 @@ expand_builtin_apply (function, arguments, argsize)
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);
@ -1813,6 +1817,7 @@ expand_builtin_memcpy (arglist)
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);
@ -1833,6 +1838,7 @@ expand_builtin_memcpy (arglist)
}
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)
@ -1842,9 +1848,7 @@ expand_builtin_memcpy (arglist)
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);
@ -2041,6 +2045,7 @@ expand_builtin_memset (exp)
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)
@ -2051,7 +2056,7 @@ expand_builtin_memset (exp)
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);
@ -3013,11 +3018,13 @@ expand_builtin_va_copy (arglist)
/* "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;

6
gcc/c-common.c
View File

@ -2146,7 +2146,7 @@ c_apply_type_quals_to_decl (type_quals, decl)
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;
@ -2221,10 +2221,6 @@ lang_get_alias_set (t)
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;
}

2
gcc/c-common.h
View File

@ -542,7 +542,7 @@ extern void c_common_nodes_and_builtins PARAMS ((void));
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));

3
gcc/c-lang.c
View File

@ -56,6 +56,9 @@ static int c_cannot_inline_tree_fn 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

79
gcc/calls.c
View File

@ -475,7 +475,7 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
&& 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
@ -497,10 +497,10 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
#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))
@ -573,12 +573,12 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
/* 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. */
@ -939,6 +939,8 @@ save_fixed_argument_area (reg_parm_stack_space, argblock,
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);
@ -954,6 +956,7 @@ save_fixed_argument_area (reg_parm_stack_space, argblock,
emit_move_insn (save_area, stack_area);
}
}
return save_area;
}
@ -3322,8 +3325,7 @@ expand_call (exp, target, ignore)
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;
@ -3447,6 +3449,7 @@ expand_call (exp, target, ignore)
/* 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;
@ -3894,8 +3897,8 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
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
{
@ -4161,12 +4164,13 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
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
@ -4250,44 +4254,6 @@ emit_library_call_value VPARAMS((rtx orgfun, rtx value,
return result;
}
#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
/* 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.
@ -4379,8 +4345,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
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
{

1
gcc/config/arc/arc.c
View File

@ -813,6 +813,7 @@ arc_setup_incoming_varargs (cum, mode, type, pretend_size, no_rtl)
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)

12
gcc/config/i386/i386.c
View File

@ -2249,14 +2249,16 @@ ix86_setup_incoming_varargs (cum, mode, type, pretend_size, no_rtl)
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));
}
}
@ -2467,6 +2469,7 @@ ix86_va_arg (valist, type)
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++)
{
@ -2492,7 +2495,6 @@ ix86_va_arg (valist, type)
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);
}
}

1
gcc/config/i960/i960.c
View File

@ -2583,6 +2583,7 @@ i960_setup_incoming_varargs (cum, mode, type, pretend_size, no_rtl)
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);

1
gcc/config/pa/pa.c
View File

@ -4872,6 +4872,7 @@ hppa_builtin_saveregs ()
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

20
gcc/config/rs6000/rs6000.c
View File

@ -2499,6 +2499,7 @@ setup_incoming_varargs (cum, mode, type, pretend_size, no_rtl)
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,
@ -2850,9 +2851,6 @@ expand_block_move_mem (mode, addr, orig_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;
}
@ -5697,12 +5695,16 @@ rs6000_return_addr (count, frame)
|| 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);

25
gcc/config/sparc/sparc.c
View File

@ -2811,8 +2811,8 @@ legitimize_pic_address (orig, mode, reg)
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);
@ -4833,17 +4833,18 @@ sparc_builtin_saveregs ()
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))
@ -4955,12 +4956,12 @@ sparc_va_arg (valist, type)
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

5
gcc/cp/ChangeLog
View File

@ -1,3 +1,8 @@
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.

18
gcc/cp/cp-lang.c
View File

@ -26,6 +26,8 @@ Boston, MA 02111-1307, USA. */
#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
@ -36,6 +38,8 @@ Boston, MA 02111-1307, USA. */
#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 \
@ -60,3 +64,17 @@ Boston, MA 02111-1307, USA. */
/* 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);
}

89
gcc/emit-rtl.c
View File

@ -1651,6 +1651,11 @@ set_mem_attributes (ref, t, objectp)
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
@ -1669,8 +1674,8 @@ set_mem_attributes (ref, t, objectp)
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);
@ -1678,57 +1683,54 @@ set_mem_attributes (ref, t, objectp)
|= (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);
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 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. */
if (TREE_CODE (t) == INDIRECT_REF)
set_mem_align (ref, TYPE_ALIGN (type));
/* If this is an INDIRECT_REF, we know its alignment. */
else if (TREE_CODE (t) == INDIRECT_REF)
align = 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))
/* 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)
@ -1878,10 +1880,9 @@ adjust_address_1 (memref, mode, offset, validate)
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)

75
gcc/expr.c
View File

@ -1635,16 +1635,16 @@ move_by_pieces_1 (genfun, mode, data)
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 ();
@ -2540,21 +2540,20 @@ store_by_pieces_2 (genfun, mode, data)
}
/* 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. */
@ -3415,6 +3414,8 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
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
@ -3833,8 +3834,8 @@ expand_assignment (to, from, want_value, suggest_reg)
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;
@ -3894,8 +3895,7 @@ expand_assignment (to, from, want_value, suggest_reg)
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
@ -3915,11 +3915,7 @@ expand_assignment (to, from, want_value, suggest_reg)
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
@ -4274,7 +4270,7 @@ store_expr (exp, target, want_value)
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. */
@ -4282,14 +4278,12 @@ store_expr (exp, target, want_value)
= 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. */
@ -4301,10 +4295,6 @@ store_expr (exp, target, want_value)
{
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
{
@ -4317,12 +4307,10 @@ store_expr (exp, target, want_value)
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)
{
@ -4340,7 +4328,7 @@ store_expr (exp, target, want_value)
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)
@ -4353,8 +4341,7 @@ store_expr (exp, target, want_value)
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);
}
@ -4552,7 +4539,7 @@ store_constructor (exp, target, align, cleared, size)
/* 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,
@ -4581,7 +4568,7 @@ store_constructor (exp, target, align, cleared, size)
|| (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;
}
@ -4776,7 +4763,7 @@ store_constructor (exp, target, align, cleared, size)
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))
@ -4962,7 +4949,7 @@ store_constructor (exp, target, align, cleared, size)
if (elt == NULL_TREE && size > 0)
{
if (!cleared)
clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
clear_storage (target, GEN_INT (size));
return;
}
@ -5037,7 +5024,7 @@ store_constructor (exp, target, align, cleared, size)
|| (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))
{
@ -5281,8 +5268,7 @@ store_field (target, bitsize, bitpos, mode, exp, value_mode,
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;
}
@ -5343,15 +5329,7 @@ store_field (target, bitsize, bitpos, mode, exp, value_mode,
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);
}
@ -5999,7 +5977,7 @@ highest_pow2_factor (exp)
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:
@ -7189,8 +7167,7 @@ expand_expr (exp, target, tmode, modifier)
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;
}
@ -9172,7 +9149,7 @@ expand_expr_unaligned (exp, palign)
/* 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. */

7
gcc/expr.h
View File

@ -410,7 +410,7 @@ extern rtx convert_modes PARAMS ((enum machine_mode, enum machine_mode,
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. */
@ -444,9 +444,8 @@ extern void use_regs PARAMS ((rtx *, int, int));
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

5
gcc/f/ChangeLog
View File

@ -1,3 +1,8 @@
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.

23
gcc/f/com.c
View File

@ -14276,6 +14276,14 @@ static void ffe_init_options PARAMS ((void));
#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 */
@ -14303,21 +14311,6 @@ lang_identify ()
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 ()
{

2
gcc/ifcvt.c
View File

@ -1109,6 +1109,8 @@ noce_try_cmove_arith (if_info)
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);
}

19
gcc/integrate.c
View File

@ -2184,13 +2184,18 @@ copy_rtx_and_substitute (orig, map, for_lhs)
#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

4
gcc/java/ChangeLog
View File

@ -1,3 +1,7 @@
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.

10
gcc/java/lang.c
View File

@ -789,13 +789,3 @@ lang_print_xnode (file, node, indent)
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;
}

22
gcc/langhooks.c
View File

@ -30,12 +30,24 @@ Boston, MA 02111-1307, USA. */
#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;
@ -44,6 +56,16 @@ lang_hook_default_decode_option (argc, argv)
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

27
gcc/langhooks.h
View File

@ -22,6 +22,10 @@ Boston, MA 02111-1307, USA. */
#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
@ -33,30 +37,34 @@ Boston, MA 02111-1307, USA. */
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 \
@ -94,6 +102,7 @@ int tree_inlining_default_hook_anon_aggr_type_p PARAMS ((tree));
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 \
}

5
gcc/reload1.c
View File

@ -2025,10 +2025,11 @@ alter_reg (i, from_reg)
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;

18
gcc/rtl.c
View File

@ -531,6 +531,7 @@ copy_most_rtx (orig, may_share)
}
/* Create a new copy of an rtx. Only copy just one level. */
rtx
shallow_copy_rtx (orig)
rtx orig;
@ -551,6 +552,23 @@ shallow_copy_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;
}
/* This is 1 until after the rtl generation pass. */
int rtx_equal_function_value_matters;

6
gcc/rtl.h
View File

@ -913,7 +913,11 @@ extern unsigned int subreg_regno PARAMS ((rtx));
#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) \

17
gcc/stor-layout.c
View File

@ -1860,23 +1860,6 @@ get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
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

9
gcc/toplev.h
View File

@ -31,7 +31,7 @@ struct rtx_def;
#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));
@ -127,7 +127,8 @@ struct lang_hooks_for_tree_inlining
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 *,
@ -164,6 +165,10 @@ struct lang_hooks
/* 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;

3
gcc/tree.h
View File

@ -2818,9 +2818,6 @@ extern int alias_sets_conflict_p PARAMS ((HOST_WIDE_INT,
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