+Thu Feb 10 16:26:49 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * combine.c (make_extraction, force_to_mode): Avoid warning on
+ mixed-signedness conditionals.
+ (make_field_assignment, nonzero_bits): Likewise.
+ * expmed.c (store_fixed_bit_field): ALIGN arg now unsigned.
+ (store_split_bit_field, extract_split_bit_field): Likewise.
+ (extract_fixed_bit_field, store_bit_field,
+ * expr.c: Change alignment to be unsigned everywhere.
+ (move_by_pieces, store_constructor_field, store_constructor):
+ Alignment parm is unsigned.
+ (emit_block_move, emit_group_load, emit_group_store): Likewise.
+ (clear_storage, emit_push_insn, compare_from_rtx): Likewise.
+ (do_compare_rtx_and_jump): Likewise.
+ (move_by_pieces_ninsns, clear_by_pieces): Likewise.
+ Compare align with GET_MODE_ALIGNMENT.
+ (expand_expr_unaligned): Pointer to alignment is pointer to unsigned.
+ (get_inner_reference): Likewise.
+ (copy_blkmode_from_reg, emit_push_insn): Remove unneeded casts.
+ (expand_assignment): Local vars for alignment now unsigned.
+ (store_constructor, store_field, expand_expr, do_jump): Likewise.
+ (do_compare_and_jump): Likewise.
+ (store_field): Call new function expr_align.
+ * expr.h (emit_block_move, emit_group_load, emit_group_store):
+ Alignment arg now unsigned.
+ (clear_storage, emit_push_insn, compare_from_rtx): Likewise.
+ (do_compare_rtx_and_jump, store_bit_field): Likewise.
+ (extract_bit_field): Likewise.
+ * fold-const.c (add_double): Add cast to eliminate signedness warning.
+ * machmode.h (GET_MODE_ALIGNMENT): Result is unsigned.
+ (get_best_mode): Alignment arg is unsigned.
+ * rtl.h (move_by_pieces): Likewise.
+ * store-layout.c (maximum_field_alignment, set_alignment):
+ Now unsigned.
+ (layout_decl): Alignment arg is now unsigned.
+ Remove unneeded casts.
+ (layout_record, layout_union, layout_type): Remove unneeded casts.
+ Local alignment variables now unsigned.
+ (get_best_mode): Alignment arg now unsigned.
+ * tree.c (expr_align): New function.
+ * tree.h (expr_align): Likewise.
+ (maximum_field_alignment, set_alignment): Now unsigned.
+ (get_inner_reference): Alignment argument is now pointer to unsigned.
+ * varasm.c (assemble_variable): Add cast to eliminate warning.
+
Thu Feb 10 12:56:47 2000 Jim Wilson <wilson@cygnus.com>
* expmed.c (store_bit_field): If op0 and fieldmode are the same size,
new = force_to_mode (inner, tmode,
len >= HOST_BITS_PER_WIDE_INT
? GET_MODE_MASK (tmode)
- : ((HOST_WIDE_INT) 1 << len) - 1,
+ : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
NULL_RTX, 0);
/* If this extraction is going into the destination of a SET,
pos_rtx
|| len + orig_pos >= HOST_BITS_PER_WIDE_INT
? GET_MODE_MASK (wanted_inner_mode)
- : (((HOST_WIDE_INT) 1 << len) - 1) << orig_pos,
+ : ((((unsigned HOST_WIDE_INT) 1 << len) - 1)
+ << orig_pos),
NULL_RTX, 0);
}
if (op_mode)
fuller_mask = (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT
? GET_MODE_MASK (op_mode)
- : ((HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1)) - 1);
+ : (((unsigned HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1))
+ - 1));
else
fuller_mask = ~ (HOST_WIDE_INT) 0;
mode,
GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
? GET_MODE_MASK (mode)
- : ((HOST_WIDE_INT) 1 << len) - 1,
+ : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
dest, 0);
return gen_rtx_combine (SET, VOIDmode, assign, src);
/* If this is a typical RISC machine, we only have to worry
about the way loads are extended. */
if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
- ? (nonzero
- & (1L << (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1)))
+ ? (((nonzero
+ & (((unsigned HOST_WIDE_INT) 1
+ << (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1))))
+ != 0))
: LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) != ZERO_EXTEND)
#endif
{
#include "real.h"
#include "recog.h"
-static void store_fixed_bit_field PARAMS ((rtx, int, int, int, rtx, int));
-static void store_split_bit_field PARAMS ((rtx, int, int, rtx, int));
+static void store_fixed_bit_field PARAMS ((rtx, int, int, int, rtx,
+ unsigned int));
+static void store_split_bit_field PARAMS ((rtx, int, int, rtx,
+ unsigned int));
static rtx extract_fixed_bit_field PARAMS ((enum machine_mode, rtx, int,
- int, int, rtx, int, int));
+ int, int, rtx, int,
+ unsigned int));
static rtx mask_rtx PARAMS ((enum machine_mode, int,
int, int));
static rtx lshift_value PARAMS ((enum machine_mode, rtx,
int, int));
-static rtx extract_split_bit_field PARAMS ((rtx, int, int, int, int));
+static rtx extract_split_bit_field PARAMS ((rtx, int, int, int,
+ unsigned int));
static void do_cmp_and_jump PARAMS ((rtx, rtx, enum rtx_code,
enum machine_mode, rtx));
int bitnum;
enum machine_mode fieldmode;
rtx value;
- int align;
+ unsigned int align;
int total_size;
{
int unit = (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
if (bestmode == VOIDmode
|| (SLOW_UNALIGNED_ACCESS (bestmode, align)
- && GET_MODE_SIZE (bestmode) > align))
+ && GET_MODE_SIZE (bestmode) > (int) align))
goto insv_loses;
/* Adjust address to point to the containing unit of that mode. */
register rtx op0;
register int offset, bitsize, bitpos;
register rtx value;
- int struct_align;
+ unsigned int struct_align;
{
register enum machine_mode mode;
int total_bits = BITS_PER_WORD;
rtx op0;
int bitsize, bitpos;
rtx value;
- int align;
+ unsigned int align;
{
int unit;
int bitsdone = 0;
int unsignedp;
rtx target;
enum machine_mode mode, tmode;
- int align;
+ unsigned int align;
int total_size;
{
int unit = (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
if (bestmode == VOIDmode
|| (SLOW_UNALIGNED_ACCESS (bestmode, align)
- && GET_MODE_SIZE (bestmode) > align))
+ && GET_MODE_SIZE (bestmode) > (int) align))
goto extv_loses;
/* Compute offset as multiple of this unit,
register rtx op0, target;
register int offset, bitsize, bitpos;
int unsignedp;
- int align;
+ unsigned int align;
{
int total_bits = BITS_PER_WORD;
enum machine_mode mode;
static rtx
extract_split_bit_field (op0, bitsize, bitpos, unsignedp, align)
rtx op0;
- int bitsize, bitpos, unsignedp, align;
+ int bitsize, bitpos, unsignedp;
+ unsigned int align;
{
int unit;
int bitsdone = 0;
static rtx get_push_address PARAMS ((int));
static rtx enqueue_insn PARAMS ((rtx, rtx));
-static int move_by_pieces_ninsns PARAMS ((unsigned int, int));
+static int move_by_pieces_ninsns PARAMS ((unsigned int, unsigned int));
static void move_by_pieces_1 PARAMS ((rtx (*) (rtx, ...), enum machine_mode,
struct move_by_pieces *));
-static void clear_by_pieces PARAMS ((rtx, int, int));
+static void clear_by_pieces PARAMS ((rtx, int, unsigned int));
static void clear_by_pieces_1 PARAMS ((rtx (*) (rtx, ...),
enum machine_mode,
struct clear_by_pieces *));
static int is_zeros_p PARAMS ((tree));
static int mostly_zeros_p PARAMS ((tree));
static void store_constructor_field PARAMS ((rtx, int, int, enum machine_mode,
- tree, tree, int, int));
-static void store_constructor PARAMS ((tree, rtx, int, int, int));
+ tree, tree, unsigned int, int));
+static void store_constructor PARAMS ((tree, rtx, unsigned int, int, int));
static rtx store_field PARAMS ((rtx, int, int, enum machine_mode,
- tree, enum machine_mode, int, int,
- int, int));
+ tree, enum machine_mode, int,
+ unsigned int, int, int));
static enum memory_use_mode
get_memory_usage_from_modifier PARAMS ((enum expand_modifier));
static tree save_noncopied_parts PARAMS ((tree, tree));
static int fixed_type_p PARAMS ((tree));
static rtx var_rtx PARAMS ((tree));
static int readonly_fields_p PARAMS ((tree));
-static rtx expand_expr_unaligned PARAMS ((tree, int *));
+static rtx expand_expr_unaligned PARAMS ((tree, unsigned int *));
static rtx expand_increment PARAMS ((tree, int, int));
static void preexpand_calls PARAMS ((tree));
static void do_jump_by_parts_greater PARAMS ((tree, int, rtx, rtx));
void
move_by_pieces (to, from, len, align)
rtx to, from;
- int len, align;
+ int len;
+ unsigned int align;
{
struct move_by_pieces data;
rtx to_addr = XEXP (to, 0), from_addr = XEXP (from, 0);
icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing
&& align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
- GET_MODE_SIZE (mode)))
+ (unsigned int) GET_MODE_SIZE (mode)))
move_by_pieces_1 (GEN_FCN (icode), mode, &data);
max_size = GET_MODE_SIZE (mode);
static int
move_by_pieces_ninsns (l, align)
unsigned int l;
- int align;
+ unsigned int align;
{
register int n_insns = 0;
int max_size = MOVE_MAX + 1;
icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing
- && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
- GET_MODE_SIZE (mode)))
+ && align >= GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT)
n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
max_size = GET_MODE_SIZE (mode);
emit_block_move (x, y, size, align)
rtx x, y;
rtx size;
- int align;
+ unsigned int align;
{
rtx retval = 0;
#ifdef TARGET_MEM_FUNCTIONS
void
emit_group_load (dst, orig_src, ssize, align)
rtx dst, orig_src;
- int align, ssize;
+ unsigned int align;
+ int ssize;
{
rtx *tmps, src;
int start, i;
shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
bytelen = ssize - bytepos;
if (bytelen <= 0)
- abort();
+ abort ();
}
/* Optimize the access just a bit. */
if (GET_CODE (src) == MEM
- && align*BITS_PER_UNIT >= GET_MODE_ALIGNMENT (mode)
- && bytepos*BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
+ && align * BITS_PER_UNIT >= GET_MODE_ALIGNMENT (mode)
+ && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
&& bytelen == GET_MODE_SIZE (mode))
{
tmps[i] = gen_reg_rtx (mode);
void
emit_group_store (orig_dst, src, ssize, align)
rtx orig_dst, src;
- int ssize, align;
+ int ssize;
+ unsigned int align;
{
rtx *tmps, dst;
int start, i;
/* Optimize the access just a bit. */
if (GET_CODE (dst) == MEM
- && align*BITS_PER_UNIT >= GET_MODE_ALIGNMENT (mode)
- && bytepos*BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
+ && align * BITS_PER_UNIT >= GET_MODE_ALIGNMENT (mode)
+ && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
&& bytelen == GET_MODE_SIZE (mode))
- {
- emit_move_insn (change_address (dst, mode,
- plus_constant (XEXP (dst, 0),
- bytepos)),
- tmps[i]);
- }
+ emit_move_insn (change_address (dst, mode,
+ plus_constant (XEXP (dst, 0),
+ bytepos)),
+ tmps[i]);
else
- {
- store_bit_field (dst, bytelen*BITS_PER_UNIT, bytepos*BITS_PER_UNIT,
+ store_bit_field (dst, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
mode, tmps[i], align, ssize);
- }
}
+
emit_queue();
/* Copy from the pseudo into the (probable) hard reg. */
The primary purpose of this routine is to handle functions
that return BLKmode structures in registers. Some machines
(the PA for example) want to return all small structures
- in registers regardless of the structure's alignment.
- */
+ in registers regardless of the structure's alignment. */
rtx
-copy_blkmode_from_reg(tgtblk,srcreg,type)
+copy_blkmode_from_reg (tgtblk,srcreg,type)
rtx tgtblk;
rtx srcreg;
tree type;
{
int bytes = int_size_in_bytes (type);
rtx src = NULL, dst = NULL;
- int bitsize = MIN (TYPE_ALIGN (type), (unsigned int) BITS_PER_WORD);
+ int bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
int bitpos, xbitpos, big_endian_correction = 0;
if (tgtblk == 0)
static void
clear_by_pieces (to, len, align)
rtx to;
- int len, align;
+ int len;
+ unsigned int align;
{
struct clear_by_pieces data;
rtx to_addr = XEXP (to, 0);
icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing
- && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
- GET_MODE_SIZE (mode)))
+ && align >= GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT)
clear_by_pieces_1 (GEN_FCN (icode), mode, &data);
max_size = GET_MODE_SIZE (mode);
clear_storage (object, size, align)
rtx object;
rtx size;
- int align;
+ unsigned int align;
{
#ifdef TARGET_MEM_FUNCTIONS
static tree fn;
enum machine_mode mode;
tree type;
rtx size;
- int align;
+ unsigned int align;
int partial;
rtx reg;
int extra;
/* TEMP is the address of the block. Copy the data there. */
if (GET_CODE (size) == CONST_INT
- && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align)))
+ && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
{
move_by_pieces (gen_rtx_MEM (BLKmode, temp), xinner,
INTVAL (size), align);
int unsignedp;
int volatilep = 0;
tree tem;
- int alignment;
+ unsigned int alignment;
push_temp_slots ();
tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
int bitsize, bitpos;
enum machine_mode mode;
tree exp, type;
- int align;
+ unsigned int align;
int cleared;
{
if (TREE_CODE (exp) == CONSTRUCTOR
store_constructor (exp, target, align, cleared, size)
tree exp;
rtx target;
- int align;
+ unsigned int align;
int cleared;
int size;
{
int bitpos;
int unsignedp;
tree value = TREE_VALUE (elt);
- int align = TYPE_ALIGN (TREE_TYPE (value));
+ unsigned int align = TYPE_ALIGN (TREE_TYPE (value));
tree index = TREE_PURPOSE (elt);
rtx xtarget = target;
tree exp;
enum machine_mode value_mode;
int unsignedp;
- int align;
+ unsigned int align;
int total_size;
int alias_set;
{
boundary. If so, we simply do a block copy. */
if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
{
+ unsigned int exp_align = expr_align (exp) / BITS_PER_UNIT;
+
if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
|| bitpos % BITS_PER_UNIT != 0)
abort ();
plus_constant (XEXP (target, 0),
bitpos / BITS_PER_UNIT));
- /* Make sure that ALIGN is no stricter than the alignment of
- EXP. */
- if (TREE_CODE (exp) == VAR_DECL)
- align = MIN (DECL_ALIGN (exp) / BITS_PER_UNIT, align);
- else
- align = MIN (TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT, align);
+ /* Make sure that ALIGN is no stricter than the alignment of EXP. */
+ align = MIN (exp_align, align);
/* Find an alignment that is consistent with the bit position. */
while ((bitpos % (align * BITS_PER_UNIT)) != 0)
enum machine_mode *pmode;
int *punsignedp;
int *pvolatilep;
- int *palignment;
+ unsigned int *palignment;
{
tree orig_exp = exp;
tree size_tree = 0;
int bitpos;
tree offset;
int volatilep = 0;
- int alignment;
+ unsigned int alignment;
tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
&mode1, &unsignedp, &volatilep,
&alignment);
static rtx
expand_expr_unaligned (exp, palign)
register tree exp;
- int *palign;
+ unsigned int *palign;
{
register rtx op0;
tree type = TREE_TYPE (exp);
int bitpos;
tree offset;
int volatilep = 0;
- int alignment;
+ unsigned int alignment;
int unsignedp;
tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
&mode1, &unsignedp, &volatilep,
tree type;
tree offset;
int volatilep = 0;
- int alignment;
+ unsigned int alignment;
/* Get description of this reference. We don't actually care
about the underlying object here. */
int unsignedp;
enum machine_mode mode;
rtx size;
- int align;
+ unsigned int align;
{
rtx tem;
int unsignedp;
enum machine_mode mode;
rtx size;
- int align;
+ unsigned int align;
rtx if_false_label, if_true_label;
{
rtx tem;
enum rtx_code signed_code, unsigned_code;
rtx if_false_label, if_true_label;
{
- int align0, align1;
+ unsigned int align0, align1;
register rtx op0, op1;
register tree type;
register enum machine_mode mode;
extern rtx convert_to_mode PARAMS ((enum machine_mode, rtx, int));
/* Convert an rtx to MODE from OLDMODE and return the result. */
-extern rtx convert_modes PARAMS ((enum machine_mode, enum machine_mode, rtx, int));
+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, int));
+extern rtx emit_block_move PARAMS ((rtx, rtx, rtx, unsigned int));
/* Copy all or part of a value X into registers starting at REGNO.
The number of registers to be filled is NREGS. */
/* Load a BLKmode value into non-consecutive registers represented by a
PARALLEL. */
-extern void emit_group_load PARAMS ((rtx, rtx, int, int));
+extern void emit_group_load PARAMS ((rtx, rtx, int, unsigned int));
+
/* Store a BLKmode value from non-consecutive registers represented by a
PARALLEL. */
-extern void emit_group_store PARAMS ((rtx, rtx, int, int));
+extern void emit_group_store PARAMS ((rtx, rtx, int, unsigned int));
#ifdef TREE_CODE
/* Copy BLKmode object from a set of registers. */
/* Mark REG as holding a parameter for the next CALL_INSN. */
extern void use_reg PARAMS ((rtx *, rtx));
+
/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters
for the next CALL_INSN. */
extern void use_regs PARAMS ((rtx *, int, int));
+
/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */
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, int));
+extern rtx clear_storage PARAMS ((rtx, rtx, unsigned int));
/* Emit insns to set X from Y. */
extern rtx emit_move_insn PARAMS ((rtx, rtx));
#ifdef TREE_CODE
/* Generate code to push something onto the stack, given its mode and type. */
-extern void emit_push_insn PARAMS ((rtx, enum machine_mode, tree, rtx, int,
- int, rtx, int, rtx, rtx, int, rtx));
+extern void emit_push_insn PARAMS ((rtx, enum machine_mode, tree, rtx,
+ unsigned int, int, rtx, int, rtx, rtx,
+ int, rtx));
/* Emit library call. */
extern void emit_library_call PARAMS ((rtx orgfun, int no_queue,
/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */
extern rtx compare_from_rtx PARAMS ((rtx, rtx, enum rtx_code, int,
- enum machine_mode, rtx, int));
+ enum machine_mode, rtx, unsigned int));
extern void do_compare_rtx_and_jump PARAMS ((rtx, rtx, enum rtx_code, int,
- enum machine_mode, rtx, int,
- rtx, rtx));
+ enum machine_mode, rtx,
+ unsigned int, rtx, rtx));
/* Generate a tablejump instruction (used for switch statements). */
extern void do_tablejump PARAMS ((rtx, enum machine_mode, rtx, rtx, rtx));
of STACK_BOUNDARY / BITS_PER_UNIT. */
extern rtx round_push PARAMS ((rtx));
-extern rtx store_bit_field PARAMS ((rtx, int, int, enum machine_mode, rtx, int, int));
-extern rtx extract_bit_field PARAMS ((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int));
+extern rtx store_bit_field PARAMS ((rtx, int, int, enum machine_mode, rtx,
+ unsigned int, int));
+extern rtx extract_bit_field PARAMS ((rtx, int, int, int, rtx,
+ enum machine_mode, enum machine_mode,
+ unsigned int, int));
extern rtx expand_mult PARAMS ((enum machine_mode, rtx, rtx, rtx, int));
extern rtx expand_mult_add PARAMS ((rtx, rtx, rtx, rtx,enum machine_mode, int));
extern rtx expand_mult_highpart_adjust PARAMS ((enum machine_mode, rtx, rtx, rtx, rtx, int));
HOST_WIDE_INT l, h;
l = l1 + l2;
- h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < l1);
+ h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < (unsigned HOST_WIDE_INT) l1);
*lv = l;
*hv = h;
/* Find the best mode to use to access a bit field. */
-extern enum machine_mode get_best_mode PARAMS ((int, int, int, enum machine_mode, int));
+extern enum machine_mode get_best_mode PARAMS ((int, int, unsigned int,
+ enum machine_mode, int));
/* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */
#define GET_MODE_ALIGNMENT(MODE) \
- MIN (BIGGEST_ALIGNMENT, \
- MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
+ (unsigned int) MIN (BIGGEST_ALIGNMENT, \
+ MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
/* For each class, get the narrowest mode in that class. */
/* In expr.c */
extern void init_expr_once PARAMS ((void));
-extern void move_by_pieces PARAMS ((rtx, rtx, int, int));
+extern void move_by_pieces PARAMS ((rtx, rtx, int, unsigned int));
/* In stupid.c */
/* If nonzero, this is an upper limit on alignment of structure fields.
The value is measured in bits. */
-int maximum_field_alignment;
+unsigned int maximum_field_alignment;
/* If non-zero, the alignment of a bitstring or (power-)set value, in bits.
May be overridden by front-ends. */
-int set_alignment = 0;
+unsigned int set_alignment = 0;
static tree layout_record PARAMS ((tree));
static void layout_union PARAMS ((tree));
void
layout_decl (decl, known_align)
tree decl;
- unsigned known_align;
+ unsigned int known_align;
{
register tree type = TREE_TYPE (decl);
register enum tree_code code = TREE_CODE (decl);
{
DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
if (maximum_field_alignment != 0)
- DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl),
- (unsigned)maximum_field_alignment);
+ DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
else if (DECL_PACKED (decl))
DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
}
if (xmode != BLKmode
&& known_align % GET_MODE_ALIGNMENT (xmode) == 0)
{
- DECL_ALIGN (decl) = MAX ((unsigned) GET_MODE_ALIGNMENT (xmode),
+ DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
DECL_ALIGN (decl));
DECL_MODE (decl) = xmode;
DECL_SIZE (decl) = bitsize_int (GET_MODE_BITSIZE (xmode), 0);
tree rec;
{
register tree field;
- unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
- unsigned unpacked_align = record_align;
+ unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
+ unsigned int unpacked_align = record_align;
/* These must be laid out *after* the record is. */
tree pending_statics = NULL_TREE;
/* Record size so far is CONST_SIZE + VAR_SIZE bits,
and VAR_SIZE is a tree expression.
If VAR_SIZE is null, the size is just CONST_SIZE.
Naturally we try to avoid using VAR_SIZE. */
- register HOST_WIDE_INT const_size = 0;
- register tree var_size = 0;
+ HOST_WIDE_INT const_size = 0;
+ tree var_size = 0;
/* Once we start using VAR_SIZE, this is the maximum alignment
that we know VAR_SIZE has. */
- register int var_align = BITS_PER_UNIT;
+ unsigned int var_align = BITS_PER_UNIT;
int packed_maybe_necessary = 0;
#ifdef STRUCTURE_SIZE_BOUNDARY
for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
{
- register int known_align = var_size ? var_align : const_size;
- register int desired_align = 0;
+ unsigned int known_align = var_size ? var_align : const_size;
+ unsigned int desired_align = 0;
tree type = TREE_TYPE (field);
/* If FIELD is static, then treat it like a separate variable,
It does, however, affect the alignment of the next field
within the structure. */
if (! integer_zerop (DECL_SIZE (field)))
- record_align = MAX ((int)record_align, desired_align);
+ record_align = MAX (record_align, desired_align);
else if (! DECL_PACKED (field))
desired_align = TYPE_ALIGN (type);
/* A named bit field of declared type `int'
forces the entire structure to have `int' alignment. */
if (DECL_NAME (field) != 0)
{
- int type_align = TYPE_ALIGN (type);
+ unsigned int type_align = TYPE_ALIGN (type);
+
if (maximum_field_alignment != 0)
type_align = MIN (type_align, maximum_field_alignment);
else if (DECL_PACKED (field))
type_align = MIN (type_align, BITS_PER_UNIT);
- record_align = MAX ((int) record_align, type_align);
+ record_align = MAX (record_align, type_align);
if (warn_packed)
unpacked_align = MAX (unpacked_align, TYPE_ALIGN (type));
}
else
#endif
{
- record_align = MAX ((int) record_align, desired_align);
+ record_align = MAX (record_align, desired_align);
if (warn_packed)
unpacked_align = MAX (unpacked_align, TYPE_ALIGN (type));
}
if (warn_packed && DECL_PACKED (field))
{
if (const_size % TYPE_ALIGN (type) == 0
- || (var_align % TYPE_ALIGN (type) == 0
- && var_size != NULL_TREE))
+ || (var_align % TYPE_ALIGN (type) == 0 && var_size != NULL_TREE))
{
if (TYPE_ALIGN (type) > desired_align)
{
own alignment? */
if (const_size % desired_align != 0
- || (var_align % desired_align != 0
- && var_size != NULL_TREE))
+ || (var_align % desired_align != 0 && var_size != NULL_TREE))
{
/* No, we need to skip space before this field.
Bump the cumulative size to multiple of field alignment. */
if (warn_padded)
warning_with_decl (field, "padding struct to align `%s'");
- if (var_size == NULL_TREE
- || var_align % desired_align == 0)
+ if (var_size == NULL_TREE || var_align % desired_align == 0)
const_size
= CEIL (const_size, desired_align) * desired_align;
else
&& maximum_field_alignment == 0
&& !integer_zerop (DECL_SIZE (field)))
{
- int type_align = TYPE_ALIGN (type);
+ unsigned int type_align = TYPE_ALIGN (type);
register tree dsize = DECL_SIZE (field);
int field_size = TREE_INT_CST_LOW (dsize);
&& !DECL_PACKED (field)
&& !integer_zerop (DECL_SIZE (field)))
{
- int type_align = TYPE_ALIGN (type);
+ unsigned int type_align = TYPE_ALIGN (type);
register tree dsize = DECL_SIZE (field);
int field_size = TREE_INT_CST_LOW (dsize);
Round it up to a multiple of the record's alignment. */
if (var_size == NULL_TREE)
- {
- TYPE_SIZE (rec) = bitsize_int (const_size, 0L);
- }
+ TYPE_SIZE (rec) = bitsize_int (const_size, 0L);
else
{
if (const_size)
{
tree unpadded_size = TYPE_SIZE (rec);
+
#ifdef ROUND_TYPE_SIZE
TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
#else
/* Round the size up to be a multiple of the required alignment */
TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
#endif
+
if (warn_padded && var_size == NULL_TREE
&& simple_cst_equal (unpadded_size, TYPE_SIZE (rec)) == 0)
warning ("padding struct size to alignment boundary");
&& var_size == NULL_TREE)
{
tree unpacked_size;
+
TYPE_PACKED (rec) = 0;
#ifdef ROUND_TYPE_ALIGN
unpacked_align
#else
unpacked_size = round_up (TYPE_SIZE (rec), unpacked_align);
#endif
+
if (simple_cst_equal (unpacked_size, TYPE_SIZE (rec)))
{
if (TYPE_NAME (rec))
{
char *name;
+
if (TREE_CODE (TYPE_NAME (rec)) == IDENTIFIER_NODE)
name = IDENTIFIER_POINTER (TYPE_NAME (rec));
else
tree rec;
{
register tree field;
- unsigned union_align = BITS_PER_UNIT;
+ unsigned int union_align = BITS_PER_UNIT;
/* The size of the union, based on the fields scanned so far,
is max (CONST_SIZE, VAR_SIZE).
then stick with BLKmode. */
&& (! STRICT_ALIGNMENT
|| TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
- || (int)TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
+ || ((int) TYPE_ALIGN (type)
+ >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
{
tree field;
+
/* A union which has any BLKmode members must itself be BLKmode;
it can't go in a register.
Unless the member is BLKmode only because it isn't aligned. */
#ifndef SET_WORD_SIZE
#define SET_WORD_SIZE BITS_PER_WORD
#endif
- int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
+ unsigned int alignment
+ = set_alignment ? set_alignment : SET_WORD_SIZE;
int size_in_bits
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
- TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
int rounded_size
= ((size_in_bits + alignment - 1) / alignment) * alignment;
- if (rounded_size > alignment)
+
+ if (rounded_size > (int) alignment)
TYPE_MODE (type) = BLKmode;
else
TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
+
TYPE_SIZE (type) = bitsize_int (rounded_size, 0L);
TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
TYPE_ALIGN (type) = alignment;
default:
abort ();
- } /* end switch */
+ }
/* Normally, use the alignment corresponding to the mode chosen.
However, where strict alignment is not required, avoid
/* Record layout info of this variant. */
tree size = TYPE_SIZE (type);
tree size_unit = TYPE_SIZE_UNIT (type);
- int align = TYPE_ALIGN (type);
+ unsigned int align = TYPE_ALIGN (type);
enum machine_mode mode = TYPE_MODE (type);
/* Copy it into all variants. */
set_sizetype (type);
/* Lay out the type: set its alignment, size, etc. */
-
layout_type (type);
return type;
}
TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
/* Lay out the type: set its alignment, size, etc. */
-
layout_type (type);
}
TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
/* Lay out the type: set its alignment, size, etc. */
-
layout_type (type);
}
\f
enum machine_mode
get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
int bitsize, bitpos;
- int align;
+ unsigned int align;
enum machine_mode largest_mode;
int volatilep;
{
if the extra 4th byte is past the end of memory.
(Though at least one Unix compiler ignores this problem:
that on the Sequent 386 machine. */
- || MIN (unit, BIGGEST_ALIGNMENT) > align
+ || MIN (unit, BIGGEST_ALIGNMENT) > (int) align
|| (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
return VOIDmode;
unit = GET_MODE_BITSIZE (tmode);
if (bitpos / unit == (bitpos + bitsize - 1) / unit
&& unit <= BITS_PER_WORD
- && unit <= MIN (align, BIGGEST_ALIGNMENT)
+ && unit <= (int) MIN (align, BIGGEST_ALIGNMENT)
&& (largest_mode == VOIDmode
|| unit <= GET_MODE_BITSIZE (largest_mode)))
wide_mode = tmode;
return TREE_INT_CST_LOW (t);
}
+
+/* Return the strictest alignment, in bits, that T is known to have. */
+
+unsigned int
+expr_align (t)
+ tree t;
+{
+ unsigned int align0, align1;
+
+ switch (TREE_CODE (t))
+ {
+ case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
+ /* If we have conversions, we know that the alignment of the
+ object must meet each of the alignments of the types. */
+ align0 = expr_align (TREE_OPERAND (t, 0));
+ align1 = TYPE_ALIGN (TREE_TYPE (t));
+ return MAX (align0, align1);
+
+ case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
+ case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
+ case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR:
+ /* These don't change the alignment of an object. */
+ return expr_align (TREE_OPERAND (t, 0));
+
+ case COND_EXPR:
+ /* The best we can do is say that the alignment is the least aligned
+ of the two arms. */
+ align0 = expr_align (TREE_OPERAND (t, 1));
+ align1 = expr_align (TREE_OPERAND (t, 2));
+ return MIN (align0, align1);
+
+ case FUNCTION_DECL: case LABEL_DECL: case CONST_DECL:
+ case VAR_DECL: case PARM_DECL: case RESULT_DECL:
+ if (DECL_ALIGN (t) != 0)
+ return DECL_ALIGN (t);
+ break;
+
+ default:
+ break;
+ }
+
+ /* Otherwise take the alignment from that of the type. */
+ return TYPE_ALIGN (TREE_TYPE (t));
+}
\f
/* Return, as a tree node, the number of elements for TYPE (which is an
ARRAY_TYPE) minus one. This counts only elements of the top array. */
extern tree pedantic_non_lvalue PARAMS ((tree));
extern tree convert PARAMS ((tree, tree));
+extern unsigned int expr_align PARAMS ((tree));
extern tree size_in_bytes PARAMS ((tree));
extern HOST_WIDE_INT int_size_in_bytes PARAMS ((tree));
extern tree size_binop PARAMS ((enum tree_code, tree, tree));
#define ubitsizetype sizetype_tab.xubitsizetype
/* If nonzero, an upper limit on alignment of structure fields, in bits. */
-extern int maximum_field_alignment;
+extern unsigned int maximum_field_alignment;
/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
-extern int set_alignment;
+extern unsigned int set_alignment;
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
by making the last node in X point to Y.
extern tree get_inner_reference PARAMS ((tree, int *, int *, tree *,
enum machine_mode *, int *,
- int *, int *));
+ int *, unsigned int *));
/* Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope. */
* (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
#if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
- if ( (DECL_ALIGN (decl) / BITS_PER_UNIT) > rounded)
+ if ((DECL_ALIGN (decl) / BITS_PER_UNIT) > (unsigned int) rounded)
warning_with_decl
(decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
#endif
OSDN Git Service
