+Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * builtins.c (c_strlen): Use size_diffop and return ssizetype value.
+ (expand_builtin_strcpy): Pass correct type to size_binop.
+ (expand_builtin_strcmp): Likewise.
+ Clean up conditional structure.
+ * c-decl.c (init_decl_processing): Don't call set_sizetype twice.
+ (complete_array_type): Don't use size_binop for MAXINDEX.
+ * c-typeck.c (c_sizeof): Use size_one_node and TYPE_SIZE_UNIT.
+ (c_sizeof_nowarn, c_size_in_bytes): Likewise.
+ (c_alignof): Use size_one_node.
+ (build_unary_op): Pass arg of proper type to size_binop.
+ (really_start_incremental_init, push_init_level): Use sizetype for
+ constructor{,_bit,_unfilled}_index.
+ (pop_init_label, output_init_element): Likewise.
+ (output_pending_init_elements, process_init_element): Likewise.
+ * calls.c (compute_argument_block_size): Field VAR is ssizetype.
+ * expr.c (store_expr): Use size_int.
+ (store_constructor): Use proper types for size_binop args.
+ (get_inner_reference, expand_expr, case ARRAY_REF): Likewise.
+ (expand_expr_unaligned): Likewise.
+ (string_contant): Return object of sizetype.
+ * expr.h (SUB_PARM_SIZE): Call size_diffop and pass proper types.
+ (ARGS_SIZE_RTX): Call ARGS_SIZE_TREE.
+ (ARGS_SIZE_TREE): Pass proper types to size_binop.
+ * fold-const.c (int_const_binop): Refine when size_int is called.
+ (fold_convert): Likewise.
+ (size_int_wide): Rework to take KIND as arg, only take low order
+ bits, handle new sizetype_tab datatype, and chain entries in
+ size_table.
+ (size_int_type_wide): New function.
+ (size_binop): Validate types of arguments.
+ (ssize_binop): Deleted.
+ (size_diffop): New function.
+ (extract_muldiv): Only fold division into multiplication for sizetypes.
+ * function.c (assign_parms): Use size_diffop and make sure
+ VAR field is of ssizetype; also pass proper type to size_binop.
+ (locate_and_pad_parm, pad_to_arg_alignment): Likewise.
+ (round_down): Deleted from here.
+ * store-layout.c (sizetype_tab): Now an array.
+ (sizetype_set, early_root_list): New variables.
+ (variable_size): Use size_one_node.
+ (round_up): Pass proper type to size_binop.
+ (round_down): Moved to here and corrected as above.
+ (layout_record): Pass proper arg types to size_binop.
+ (layout_type): Likewise.
+ If sizetype_set is zero, record the type just laid out.
+ (make_unsigned_type): Don't call set_sizetype;
+ (make_signed_type): Likewise; also, call fixup_signed_type.
+ (initialize_sizetypes): New function.
+ (set_sizetype): Make copy of types, set TYPE_IS_SIZETYPE, and
+ set name of bitsizetype to "bit_size_type".
+ Fix up type of sizes of all types made before call.
+ * tm.texi (ROUND_TYPE_SIZE_UNIT): New macro.
+ * tree.c (fix_sizetype): Deleted.
+ (build_common_tree_nodes): Call initialize_sizetypes.
+ (build_common_tree_nodes_2): Don't call fix_sizetype.
+ * tree.h (TYPE_IS_SIZETYPE): New macro.
+ (initialize_sizetype): New declaration.
+ (enum size_type_kind): New type.
+ (struct sizetype_tab): Deleted.
+ (sizetype_tab): Now array; adjust sizetype macros.
+ (size_diffop, size_int_type_wide): New functions.
+ (size_int_wide): Change number of args and type; access macros changed.
+ (ssize_int, sbitsize_int): New macros.
+ * config/i960/i960.h (ROUND_TYPE_SIZE): Use size_int.
+ (ROUND_TYPE_SIZE_UNIT): New macro.
+
2000-02-27 Zack Weinberg <zack@wolery.cumb.org>
* c-lex.c (putback_buffer): Make 'buffer' an unsigned char *.
way, because it could contain a zero byte in the middle.
TREE_STRING_LENGTH is the size of the character array, not the string.
+ The value returned is of type `ssizetype'.
+
Unfortunately, string_constant can't access the values of const char
arrays with initializers, so neither can we do so here. */
src = string_constant (src, &offset_node);
if (src == 0)
return 0;
+
max = TREE_STRING_LENGTH (src);
ptr = TREE_STRING_POINTER (src);
+
if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
{
/* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
compute the offset to the following null if we don't know where to
start searching for it. */
int i;
+
for (i = 0; i < max; i++)
if (ptr[i] == 0)
return 0;
+
/* We don't know the starting offset, but we do know that the string
has no internal zero bytes. We can assume that the offset falls
within the bounds of the string; otherwise, the programmer deserves
what he gets. Subtract the offset from the length of the string,
- and return that. */
- /* This would perhaps not be valid if we were dealing with named
- arrays in addition to literal string constants. */
- return size_binop (MINUS_EXPR, size_int (max), offset_node);
+ and return that. This would perhaps not be valid if we were dealing
+ with named arrays in addition to literal string constants. */
+
+ return size_diffop (size_int (max), offset_node);
}
/* We have a known offset into the string. Start searching there for
return 0;
offset = TREE_INT_CST_LOW (offset_node);
}
+
/* If the offset is known to be out of bounds, warn, and call strlen at
runtime. */
if (offset < 0 || offset > max)
warning ("offset outside bounds of constant string");
return 0;
}
+
/* Use strlen to search for the first zero byte. Since any strings
constructed with build_string will have nulls appended, we win even
if we get handed something like (char[4])"abcd".
Since OFFSET is our starting index into the string, no further
calculation is needed. */
- return size_int (strlen (ptr + offset));
+ return ssize_int (strlen (ptr + offset));
}
/* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
times to get the address of either a higher stack frame, or a return
address located within it (depending on FNDECL_CODE). */
+
rtx
expand_builtin_return_addr (fndecl_code, count, tem)
enum built_in_function fndecl_code;
/* Expand expression EXP, which is a call to the strcpy builtin. Return 0
if we failed the caller should emit a normal call. */
+
static rtx
expand_builtin_strcpy (exp)
tree exp;
/* Arg could be non-pointer if user redeclared this fcn wrong. */
|| TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
|| TREE_CHAIN (arglist) == 0
- || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
+ || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist))))
+ != POINTER_TYPE))
return 0;
else
{
if (len == 0)
return 0;
- len = size_binop (PLUS_EXPR, len, integer_one_node);
-
+ len = size_binop (PLUS_EXPR, len, ssize_int (1));
chainon (arglist, build_tree_list (NULL_TREE, len));
}
+
result = expand_builtin_memcpy (arglist);
+
if (! result)
TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
return result;
/* Expand expression EXP, which is a call to the memset builtin. Return 0
if we failed the caller should emit a normal call. */
+
static rtx
expand_builtin_memset (exp)
tree exp;
/* Expand expression EXP, which is a call to the strcmp builtin. Return 0
if we failed the caller should emit a normal call, otherwise try to get
the result in TARGET, if convenient. */
+
static rtx
expand_builtin_strcmp (exp, target)
tree exp;
/* Arg could be non-pointer if user redeclared this fcn wrong. */
|| TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
|| TREE_CHAIN (arglist) == 0
- || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
+ || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist))))
+ != POINTER_TYPE))
return 0;
- else if (!HAVE_cmpstrsi)
+
+ else if (! HAVE_cmpstrsi)
return 0;
{
tree arg1 = TREE_VALUE (arglist);
tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
- tree len, len2;
+ tree len = c_strlen (arg1);
+ tree len2 = c_strlen (arg2);
rtx result;
- len = c_strlen (arg1);
+
if (len)
- len = size_binop (PLUS_EXPR, integer_one_node, len);
- len2 = c_strlen (arg2);
+ len = size_binop (PLUS_EXPR, ssize_int (1), len);
+
if (len2)
- len2 = size_binop (PLUS_EXPR, integer_one_node, len2);
+ len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
/* If we don't have a constant length for the first, use the length
of the second, if we know it. We don't require a constant for
two fixed strings, or if the code was machine-generated. We should
add some code to the `memcmp' handler below to deal with such
situations, someday. */
+
if (!len || TREE_CODE (len) != INTEGER_CST)
{
if (len2)
else if (len == 0)
return 0;
}
- else if (len2 && TREE_CODE (len2) == INTEGER_CST)
- {
- if (tree_int_cst_lt (len2, len))
- len = len2;
- }
+ else if (len2 && TREE_CODE (len2) == INTEGER_CST
+ && tree_int_cst_lt (len2, len))
+ len = len2;
chainon (arglist, build_tree_list (NULL_TREE, len));
result = expand_builtin_memcmp (exp, arglist, target);
if (! result)
TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
+
return result;
}
}
/* Expand a call to __builtin_saveregs, generating the result in TARGET,
if that's convenient. */
+
rtx
expand_builtin_saveregs ()
{
tree ptr_ftype_void, ptr_ftype_ptr;
int wchar_type_size;
tree array_domain_type;
+ tree t;
current_function_decl = NULL;
named_labels = NULL;
Traditionally, use a signed type.
Note that stddef.h uses `unsigned long',
and this must agree, even if long and int are the same size. */
- set_sizetype
- (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
- if (flag_traditional && TREE_UNSIGNED (sizetype))
- set_sizetype (signed_type (sizetype));
+ t = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
+ if (flag_traditional && TREE_UNSIGNED (t))
+ t = signed_type (t);
+
+ set_sizetype (t);
/* Create the widest literal types. */
- widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
- widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
+ widest_integer_literal_type_node
+ = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
+ widest_unsigned_literal_type_node
+ = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
pushdecl (build_decl (TYPE_DECL, NULL_TREE,
widest_integer_literal_type_node));
pushdecl (build_decl (TYPE_DECL, NULL_TREE,
else if (TREE_CODE (initial_value) == CONSTRUCTOR)
{
tree elts = CONSTRUCTOR_ELTS (initial_value);
- maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
+ maxindex = build_int_2 (-1, -1);
for (; elts; elts = TREE_CHAIN (elts))
{
if (TREE_PURPOSE (elts))
maxindex = TREE_PURPOSE (elts);
else
- maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
+ maxindex = fold (build (PLUS_EXPR, integer_type_node,
+ maxindex, integer_one_node));
}
maxindex = copy_node (maxindex);
}
tree type;
{
enum tree_code code = TREE_CODE (type);
- tree t;
if (code == FUNCTION_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("sizeof applied to a function type");
- return size_int (1);
+ return size_one_node;
}
if (code == VOID_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("sizeof applied to a void type");
- return size_int (1);
+ return size_one_node;
}
+
if (code == ERROR_MARK)
- return size_int (1);
+ return size_one_node;
+
if (TYPE_SIZE (type) == 0)
{
error ("sizeof applied to an incomplete type");
- return size_int (0);
+ return size_zero_node;
}
/* Convert in case a char is more than one unit. */
- t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (TYPE_PRECISION (char_type_node)));
- t = convert (sizetype, t);
- /* size_binop does not put the constant in range, so do it now. */
- if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
- TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
- return t;
+ return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
}
tree
tree type;
{
enum tree_code code = TREE_CODE (type);
- tree t;
- if (code == FUNCTION_TYPE
- || code == VOID_TYPE
- || code == ERROR_MARK)
- return size_int (1);
+ if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
+ return size_one_node;
+
if (TYPE_SIZE (type) == 0)
- return size_int (0);
+ return size_zero_node;
/* Convert in case a char is more than one unit. */
- t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (TYPE_PRECISION (char_type_node)));
- t = convert (sizetype, t);
- force_fit_type (t, 0);
- return t;
+ return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
}
/* Compute the size to increment a pointer by. */
tree type;
{
enum tree_code code = TREE_CODE (type);
- tree t;
- if (code == FUNCTION_TYPE)
- return size_int (1);
- if (code == VOID_TYPE)
- return size_int (1);
- if (code == ERROR_MARK)
- return size_int (1);
+ if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
+ return size_one_node;
+
if (TYPE_SIZE (type) == 0)
{
error ("arithmetic on pointer to an incomplete type");
- return size_int (1);
+ return size_one_node;
}
/* Convert in case a char is more than one unit. */
- t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (BITS_PER_UNIT));
- t = convert (sizetype, t);
- force_fit_type (t, 0);
- return t;
+ return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
}
/* Implement the __alignof keyword: Return the minimum required
return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
if (code == VOID_TYPE || code == ERROR_MARK)
- return size_int (1);
+ return size_one_node;
return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
}
&& DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
{
error ("`__alignof' applied to a bit-field");
- return size_int (1);
+ return size_one_node;
}
else if (TREE_CODE (expr) == COMPONENT_REF
&& TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
{
tree offset
= size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
int flag = TREE_CONSTANT (addr);
+
addr = fold (build (PLUS_EXPR, argtype,
addr, convert (argtype, offset)));
TREE_CONSTANT (addr) = flag;
&& DECL_NAME (constructor_fields) == 0)
constructor_fields = TREE_CHAIN (constructor_fields);
constructor_unfilled_fields = constructor_fields;
- constructor_bit_index = copy_node (integer_zero_node);
- TREE_TYPE (constructor_bit_index) = sbitsizetype;
+ constructor_bit_index = copy_node (size_zero_node);
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
constructor_max_index
= TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
constructor_index
- = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
+ = copy_node (convert (bitsizetype,
+ TYPE_MIN_VALUE
+ (TYPE_DOMAIN (constructor_type))));
}
else
- constructor_index = copy_node (integer_zero_node);
+ constructor_index = copy_node (bitsize_int (0));
+
constructor_unfilled_index = copy_node (constructor_index);
}
else
&& DECL_NAME (constructor_fields) == 0)
constructor_fields = TREE_CHAIN (constructor_fields);
constructor_unfilled_fields = constructor_fields;
- constructor_bit_index = copy_node (integer_zero_node);
- TREE_TYPE (constructor_bit_index) = sbitsizetype;
+ constructor_bit_index = copy_node (size_zero_node);
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
constructor_max_index
= TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
constructor_index
- = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
+ = copy_node (convert (bitsizetype,
+ TYPE_MIN_VALUE
+ (TYPE_DOMAIN (constructor_type))));
}
else
- constructor_index = copy_node (integer_zero_node);
+ constructor_index = bitsize_int (0);
+
constructor_unfilled_index = copy_node (constructor_index);
}
else
else
{
tree filled;
+
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
- {
- /* Find the offset of the end of that field. */
- filled = size_binop (CEIL_DIV_EXPR,
- constructor_bit_index,
- size_int (BITS_PER_UNIT));
- }
+ /* Find the offset of the end of that field. */
+ filled = size_binop (CEIL_DIV_EXPR,
+ constructor_bit_index,
+ size_int (BITS_PER_UNIT));
+
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
/* If initializing an array of unknown size,
&& TYPE_DOMAIN (constructor_type) == 0)
{
tree maxindex
- = size_binop (MINUS_EXPR,
- constructor_unfilled_index,
- integer_one_node);
+ = copy_node (size_diffop (constructor_unfilled_index,
+ bitsize_int (1)));
- maxindex = copy_node (maxindex);
TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
size = int_size_in_bytes (constructor_type);
}
- filled = size_binop (MULT_EXPR, constructor_unfilled_index,
- size_in_bytes (TREE_TYPE (constructor_type)));
+ filled
+ = size_binop (MULT_EXPR, constructor_unfilled_index,
+ convert (bitsizetype,
+ TYPE_SIZE_UNIT
+ (TREE_TYPE (constructor_type))));
}
else
filled = 0;
if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
- integer_one_node);
+ bitsize_int (1));
+
TREE_INT_CST_LOW (constructor_unfilled_index)
= TREE_INT_CST_LOW (tem);
TREE_INT_CST_HIGH (constructor_unfilled_index)
if (constructor_incremental)
{
tree filled;
- tree nextpos_tree = size_int (0);
+ tree nextpos_tree = bitsize_int (0);
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
{
tree tail;
+
/* Find the last field written out, if any. */
for (tail = TYPE_FIELDS (constructor_type); tail;
tail = TREE_CHAIN (tail))
size_binop (PLUS_EXPR,
DECL_FIELD_BITPOS (tail),
DECL_SIZE (tail)),
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
else
- filled = size_int (0);
+ filled = bitsize_int (0);
nextpos_tree = size_binop (CEIL_DIV_EXPR,
DECL_FIELD_BITPOS (next),
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
TREE_INT_CST_HIGH (constructor_bit_index)
= TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
- filled = size_binop (MULT_EXPR, constructor_unfilled_index,
- size_in_bytes (TREE_TYPE (constructor_type)));
+ filled
+ = size_binop (MULT_EXPR, constructor_unfilled_index,
+ convert (bitsizetype,
+ TYPE_SIZE_UNIT
+ (TREE_TYPE (constructor_type))));
nextpos_tree
= size_binop (MULT_EXPR, next,
- size_in_bytes (TREE_TYPE (constructor_type)));
+ convert (bitsizetype, TYPE_SIZE_UNIT
+ (TREE_TYPE (constructor_type))));
TREE_INT_CST_LOW (constructor_unfilled_index)
= TREE_INT_CST_LOW (next);
TREE_INT_CST_HIGH (constructor_unfilled_index)
tree temp = size_binop (PLUS_EXPR,
DECL_FIELD_BITPOS (constructor_fields),
DECL_SIZE (constructor_fields));
+
TREE_INT_CST_LOW (constructor_bit_index)
= TREE_INT_CST_LOW (temp);
TREE_INT_CST_HIGH (constructor_bit_index)
RESTORE_SPELLING_DEPTH (constructor_depth);
}
- tem = size_binop (PLUS_EXPR, constructor_index,
- integer_one_node);
+ tem = size_binop (PLUS_EXPR, constructor_index, bitsize_int (1));
TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (tem);
TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (tem);
args[i].slot_offset.constant = -args_size->constant;
if (args_size->var)
- {
- SUB_PARM_SIZE (args[i].slot_offset, args_size->var);
- }
+ SUB_PARM_SIZE (args[i].slot_offset, args_size->var);
#endif
/* Increment ARGS_SO_FAR, which has info about which arg-registers
{
args_size->var
= size_binop (MAX_EXPR, args_size->var,
- size_int (reg_parm_stack_space));
+ ssize_int (reg_parm_stack_space));
#ifndef OUTGOING_REG_PARM_STACK_SPACE
/* The area corresponding to register parameters is not to count in
the size of the block we need. So make the adjustment. */
args_size->var
= size_binop (MINUS_EXPR, args_size->var,
- size_int (reg_parm_stack_space));
+ ssize_int (reg_parm_stack_space));
#endif
}
}
+Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * actions.c (chill_convert_for_assignment): Don't use size_binop
+ for things that aren't sizes.
+ (expand_varying_length_assignment): Likewise.
+ * convert.c (digest_array_tuple, convert): Likewise.
+ * typeck.c (build_chill_slice, smash_dummy_type): Likewise.
+ (build_chill_slice_with_range): Likewise.
+ (build_chill_slice_with_length): Likewise.
+ (build_array_from_set): Adjust types for size_binop.
+ * expr.c (build_concat_expr, build_chill_repetition_op): Likewise.
+ (build_chill_sizeof): Use TYPE_SIZE_UNIT.
+ * tree.c (build_string_type): Pass proper type to size_binop.
+
Sat Feb 19 18:43:13 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* decl.c (layout_enum): Set DECL_SIZE_UNIT.
/* Implement actions for CHILL.
- Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+ Free Software Foundation, Inc.
Authors: Per Bothner, Bill Cox, Michael Tiemann, Michael North
This file is part of GNU CC.
return expr;
}
\f
-/*
- * There are four conditions to generate a runtime check:
- * 1) assigning a longer INT to a shorter (signs irrelevant)
- * 2) assigning a signed to an unsigned
- * 3) assigning an unsigned to a signed of the same size.
- * 4) TYPE is a discrete subrange
- */
+/* There are four conditions to generate a runtime check:
+ 1) assigning a longer INT to a shorter (signs irrelevant)
+ 2) assigning a signed to an unsigned
+ 3) assigning an unsigned to a signed of the same size.
+ 4) TYPE is a discrete subrange */
+
tree
chill_convert_for_assignment (type, expr, place)
tree type, expr;
}
result = convert (type, expr);
- /* If the type is a array of PACK bits and the expression is an array constructor,
- then build a CONSTRUCTOR for a bitstring. Bitstrings are zero based, so
- decrement the value of each CONSTRUCTOR element by the amount of the lower
- bound of the array. */
+ /* If the type is a array of PACK bits and the expression is an array
+ constructor, then build a CONSTRUCTOR for a bitstring. Bitstrings are
+ zero based, so decrement the value of each CONSTRUCTOR element by the
+ amount of the lower bound of the array. */
if (TREE_CODE (type) == ARRAY_TYPE && TYPE_PACKED (type)
&& TREE_CODE (result) == CONSTRUCTOR)
{
tree new_list = NULL_TREE;
long index;
tree element;
+
for (element = TREE_OPERAND (result, 1);
element != NULL_TREE;
element = TREE_CHAIN (element))
switch (TREE_CODE (purpose))
{
case INTEGER_CST:
- new_list = tree_cons (NULL_TREE,
- size_binop (MINUS_EXPR, purpose, domain_min),
- new_list);
+ new_list
+ = tree_cons (NULL_TREE,
+ fold (build (MINUS_EXPR, TREE_TYPE (purpose),
+ purpose, domain_min)),
+ new_list);
break;
case RANGE_EXPR:
for (index = TREE_INT_CST_LOW (TREE_OPERAND (purpose, 0));
index <= TREE_INT_CST_LOW (TREE_OPERAND (purpose, 1));
index++)
new_list = tree_cons (NULL_TREE,
- size_binop (MINUS_EXPR,
- build_int_2 (index, 0),
- domain_min),
+ fold (build (MINUS_EXPR,
+ integer_type_node,
+ build_int_2 (index, 0),
+ domain_min)),
new_list);
break;
default:
tree from_pos = save_expr (TREE_OPERAND (lhs, 0));
tree set = TREE_OPERAND (lhs, 1);
tree domain = TYPE_DOMAIN (TREE_TYPE (set));
- tree set_length = size_binop (PLUS_EXPR,
- size_binop (MINUS_EXPR,
- TYPE_MAX_VALUE (domain),
- TYPE_MIN_VALUE (domain)),
- integer_one_node);
+ tree set_length
+ = fold (build (PLUS_EXPR, integer_type_node,
+ fold (build (MINUS_EXPR, integer_type_node,
+ TYPE_MAX_VALUE (domain),
+ TYPE_MIN_VALUE (domain))),
+ integer_one_node));
tree filename = force_addr_of (get_chill_filename());
if (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE)
tree numbits = TREE_OPERAND (lhs, 1);
tree from_pos = save_expr (TREE_OPERAND (lhs, 2));
tree domain = TYPE_DOMAIN (TREE_TYPE (set));
- tree set_length = size_binop (PLUS_EXPR,
- size_binop (MINUS_EXPR,
- TYPE_MAX_VALUE (domain),
- TYPE_MIN_VALUE (domain)),
- integer_one_node);
+ tree set_length
+ = fold (build (PLUS_EXPR, integer_type_node,
+ fold (build (MINUS_EXPR, integer_type_node,
+ TYPE_MAX_VALUE (domain),
+ TYPE_MIN_VALUE (domain))),
+ integer_one_node));
tree filename = force_addr_of (get_chill_filename());
tree to_pos;
+
switch (TREE_CODE (TREE_TYPE (rhs)))
{
case SET_TYPE:
- to_pos = size_binop (MINUS_EXPR,
- size_binop (PLUS_EXPR, from_pos, numbits),
- integer_one_node);
+ to_pos = fold (build (MINUS_EXPR, integer_type_node,
+ fold (build (PLUS_EXPR, integer_type_node,
+ from_pos, numbits)),
+ integer_one_node));
break;
case BOOLEAN_TYPE:
to_pos = from_pos;
min_domain_val = TYPE_MIN_VALUE (TYPE_DOMAIN (base_array));
lhs = build_component_ref (lhs, var_length_id);
- rhs = size_binop (MINUS_EXPR, rhs, min_domain_val);
+ rhs = fold (build (MINUS_EXPR, TREE_TYPE (rhs), rhs, min_domain_val));
expand_expr_stmt (build_chill_modify_expr (lhs, rhs));
}
/* Language-level data type conversion for GNU CHILL.
- Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GNU CC.
}
/* Calculate the last element of the gap. */
if (*ptr)
- {
- /* Actually end up with correct type. */
- last = size_binop (MINUS_EXPR,
- CONSTRUCTOR_ELT_LO (*ptr),
- integer_one_node);
- }
+ last = fold (build (MINUS_EXPR, integer_type_node,
+ CONSTRUCTOR_ELT_LO (*ptr),
+ integer_one_node));
else
last = domain_max;
+
if (TREE_CODE (last) == INTEGER_CST && tree_int_cst_lt (last, first))
; /* Empty "gap" - no missing elements. */
else if (default_value)
{
/* Note that array_type_nelts returns 1 less than the size. */
nentries = array_type_nelts (TREE_TYPE (e));
- needed_padding = size_binop (MINUS_EXPR,
- array_type_nelts (target_array_type),
- nentries);
+ needed_padding = fold (build (MINUS_EXPR, integer_type_node,
+ array_type_nelts (target_array_type),
+ nentries));
if (TREE_CODE (needed_padding) != INTEGER_CST)
{
padding_max_size = size_in_bytes (TREE_TYPE (e));
if (TREE_CODE (padding_max_size) != INTEGER_CST)
padding_max_size = TYPE_ARRAY_MAX_SIZE (TREE_TYPE (e));
}
- nentries = size_binop (PLUS_EXPR, nentries, integer_one_node);
+ nentries = fold (build (PLUS_EXPR, integer_type_node,
+ nentries, integer_one_node));
}
else if (TREE_CODE (e) == CONSTRUCTOR)
{
/* Convert language-specific tree expression to rtl instructions,
for GNU CHILL compiler.
- Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GNU CC.
return error_mark_node;
}
- temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (TYPE_PRECISION (char_type_node)));
+ temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
if (signame != NULL_TREE)
{
/* we have a signal definition. This signal may have no
if (TREE_CODE (type0) == SET_TYPE)
{
- result_size = size_binop (PLUS_EXPR,
- discrete_count (TYPE_DOMAIN (type0)),
- discrete_count (TYPE_DOMAIN (type1)));
+ result_size = fold (build (PLUS_EXPR, integer_type_node,
+ discrete_count (TYPE_DOMAIN (type0)),
+ discrete_count (TYPE_DOMAIN (type1))));
result_class.mode = build_bitstring_type (result_size);
}
else
for (temp = vallist; temp; temp = TREE_CHAIN (temp))
{
tree new_value
- = fold (size_binop (PLUS_EXPR, origin, TREE_VALUE (temp)));
+ = fold (build (PLUS_EXPR, TREE_TYPE (origin),
+ TREE_VALUE (temp)));
tree new_purpose = NULL_TREE;
+
if (! TREE_CONSTANT (TREE_VALUE (temp)))
tree_const = 0;
if (TREE_PURPOSE (temp))
{
- new_purpose = fold (size_binop (PLUS_EXPR,
- origin,
- TREE_PURPOSE (temp)));
+ new_purpose = fold (build (PLUS_EXPR, TREE_TYPE (origin),
+ origin, TREE_PURPOSE (temp)));
if (! TREE_CONSTANT (TREE_PURPOSE (temp)))
tree_const = 0;
}
/* Language-dependent node constructors for parse phase of GNU compiler.
- Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GNU CC.
/* Subtract 1 from length to get max index value.
Note we cannot use size_binop for pass 1 expressions. */
if (TREE_CODE (length) == INTEGER_CST || pass != 1)
- length = size_binop (MINUS_EXPR, length, integer_one_node);
+ length = size_binop (MINUS_EXPR, length, size_one_node);
else
- length = build (MINUS_EXPR, sizetype, length, integer_one_node);
+ length = build (MINUS_EXPR, sizetype, length, size_one_node);
t = make_node (elt_type == boolean_type_node ? SET_TYPE : ARRAY_TYPE);
TREE_TYPE (t) = elt_type;
tree t;
{
tree hi = convert (sizetype, TYPE_MAX_VALUE (t));
+
if (TYPE_MIN_VALUE (t))
hi = size_binop (MINUS_EXPR, hi, convert (sizetype, TYPE_MIN_VALUE (t)));
+
return size_binop (PLUS_EXPR, hi, integer_one_node);
}
/* Build expressions with type checking for CHILL compiler.
- Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GNU CC.
The static allocation info is passed by using the parent array's
limits to compute a temp_size, which is passed in the lang_specific
- field of the slice_type.
- */
+ field of the slice_type. */
if (TREE_CODE (array_type) == ARRAY_TYPE)
{
tree domain_type = TYPE_DOMAIN (array_type);
tree domain_min = TYPE_MIN_VALUE (domain_type);
- tree domain_max = fold (build (PLUS_EXPR, domain_type,
- domain_min,
- size_binop (MINUS_EXPR,
- length, integer_one_node)));
+ tree domain_max
+ = fold (build (PLUS_EXPR, domain_type,
+ domain_min,
+ fold (build (MINUS_EXPR, integer_type_node,
+ length, integer_one_node))));
tree index_type = build_chill_range_type (TYPE_DOMAIN (array_type),
domain_min,
domain_max);
&& tree_int_cst_lt (max_value, min_value))
return build_empty_string (TREE_TYPE (TREE_TYPE (array)));
- return build_chill_slice (array, min_value,
- save_expr (size_binop (PLUS_EXPR,
- size_binop (MINUS_EXPR, max_value, min_value),
- integer_one_node)));
+ return
+ build_chill_slice
+ (array, min_value,
+ save_expr (fold (build (PLUS_EXPR, integer_type_node,
+ fold (build (MINUS_EXPR, integer_type_node,
+ max_value, min_value)),
+ integer_one_node))));
}
-
tree
build_chill_slice_with_length (array, min_value, length)
tree array, min_value, length;
length = integer_one_node;
}
- max_index = size_binop (MINUS_EXPR,
- size_binop (PLUS_EXPR, length, min_value),
- integer_one_node);
+ max_index = fold (build (MINUS_EXPR, integer_type_node,
+ fold (build (PLUS_EXPR, integer_type_node,
+ length, min_value)),
+ integer_one_node));
max_index = convert_to_class (chill_expr_class (min_value), max_index);
min_value = valid_array_index_p (array, min_value,
return expr;
}
\f
-/*
- * given a set_type, build an integer array from it that C will grok.
- */
+/* Given a set_type, build an integer array from it that C will grok. */
+
tree
build_array_from_set (type)
tree type;
{
tree bytespint, bit_array_size, int_array_count;
- if (type == NULL_TREE || type == error_mark_node || TREE_CODE (type) != SET_TYPE)
+ if (type == NULL_TREE || type == error_mark_node
+ || TREE_CODE (type) != SET_TYPE)
return error_mark_node;
- bytespint = build_int_2 (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR, 0);
+ /* ??? Should this really be *HOST*?? */
+ bytespint = size_int (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR);
bit_array_size = size_in_bytes (type);
- int_array_count = fold (size_binop (TRUNC_DIV_EXPR, bit_array_size,
- bytespint));
+ int_array_count = size_binop (TRUNC_DIV_EXPR, bit_array_size, bytespint);
if (integer_zerop (int_array_count))
int_array_count = size_one_node;
type = build_array_type (integer_type_node,
{
tree oldindex = TYPE_DOMAIN (origin);
new_max = check_range (new_max, new_max, NULL_TREE,
- size_binop (PLUS_EXPR,
- TYPE_MAX_VALUE (oldindex),
- integer_one_node));
+ fold (build (PLUS_EXPR, integer_type_node,
+ TYPE_MAX_VALUE (oldindex),
+ integer_one_node)));
origin = build_string_type (TREE_TYPE (origin), new_max);
}
else if (TREE_CODE (origin) == ARRAY_TYPE)
#define ROUND_TYPE_SIZE(TYPE, COMPUTED, SPECIFIED) \
((TREE_CODE (TYPE) == REAL_TYPE && TYPE_MODE (TYPE) == XFmode) \
- ? build_int_2 (128, 0) : round_up (COMPUTED, SPECIFIED))
+ ? bitsize_int (128) : round_up (COMPUTED, SPECIFIED))
+#define ROUND_TYPE_SIZE_UNIT(TYPE, COMPUTED, SPECIFIED) \
+ ((TREE_CODE (TYPE) == REAL_TYPE && TYPE_MODE (TYPE) == XFmode) \
+ ? bitsize_int (16) : round_up (COMPUTED, SPECIFIED))
+
\f
/* Standard register usage. */
+Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * class.c (dfs_build_vtable_offset_vtbl_entries): Don't use size_binop
+ on things that are not sizes; ssize_binop deleted.
+ Call size_diffop when appropriate.
+ (dfs_build_vcall_offset_vtbl_entries): Likewise.
+ (build_primary_vtable, build_secondary_vtable): Likewise.
+ (dfs_set_offset_for_unshared_vbases, dfs_modify_vtables): Likewise.
+ Variable I is HOST_WIDE_INT.
+ (get_vfield_offset): Pass proper types to size_binop.
+ (size_extra_vtbl_entries, layout_virtual_bases): Likewise.
+ (finish_struct_1): Likewise.
+ (skip_rtti_stuff): Arg N is now pointer to signed.
+ (layout_class_type): Use size_zero_node.
+ * cp-tree.h (skip_rtti_stuff): Arg N is pointer to signed.
+ * cvt.c (cp_convert_to_pointer): Pass proper types to size_binop.
+ * decl.c (complete_arry_type): Pass proper types to size_binop.
+ (xref_basetypes): BINFO_OFFSET is sizetype.
+ * error.c (dump_expr): Don't use size_binop non-sizes.
+ * expr.c (cplus_expand_constant): Pass proper types to size_binop.
+ * init.c (construct_virtual_bases): Fix type error.
+ (build_vec_delete_1): Pass proper type to size_binop and don't
+ fold result.
+ * lex.c (cp_make_lang_type): BINFO_OFFSET is sizetype.
+ * rtti.c (get_base_offset): Pass proper type to size_binop.
+ * search.c (dfs_find_vbases): Fix type error.
+ (expand_upcast_fixups): Arg to skip_rtti_stuff is pointer to signed.
+ (dfs_get_vbase_types): BINFO_OFFSET is sizetype.
+ * tree.c (debug_binfo): Variable N is signed.
+ Use HOST_WIDE_INT_PRINT_DEC.
+ * typeck.c (comptypes): sizetype is same as equivalent integer type.
+ (c_sizeof, c_sizeof_nowarn, expr_sizeof): Use TYPE_SIZE_UNIT,
+ size_one_node and size_zero_node.
+ (c_alignof): Use size_one_node.
+ (build_component_addr): Pass proper types to size_binop.
+ (expand_ptrmemfunc_cst): Don't use size_binop on non-sizes.
+
2000-02-26 Jason Merrill <jason@casey.cygnus.com>
Implement class scope using-declarations for functions.
else
{
BINFO_VPTR_FIELD (vbase) = TREE_PURPOSE (TREE_VALUE (list));
- BINFO_VPTR_FIELD (vbase) = ssize_binop (MINUS_EXPR,
- BINFO_VPTR_FIELD (vbase),
- integer_one_node);
+ BINFO_VPTR_FIELD (vbase)
+ = fold (build (MINUS_EXPR, integer_type_node,
+ BINFO_VPTR_FIELD (vbase), integer_one_node));
}
/* And record the offset at which this virtual base lies in the
vtable. */
init = BINFO_OFFSET (binfo);
TREE_VALUE (list) = tree_cons (BINFO_VPTR_FIELD (vbase),
- init,
- TREE_VALUE (list));
+ init, TREE_VALUE (list));
}
SET_BINFO_VTABLE_PATH_MARKED (binfo);
object, and we need offsets from this BINFO. */
for (init = inits; init; init = TREE_CHAIN (init))
{
- tree exp = TREE_VALUE (init);
-
- exp = ssize_binop (MINUS_EXPR, exp, BINFO_OFFSET (binfo));
- exp = build1 (NOP_EXPR, vtable_entry_type, exp);
- exp = fold (exp);
- TREE_CONSTANT (exp) = 1;
/* The dfs_build_vbase_offset_vtbl_entries routine uses the
TREE_PURPOSE to scribble in. But, we need to clear it now so
that the values are not perceived as labeled initializers. */
TREE_PURPOSE (init) = NULL_TREE;
- TREE_VALUE (init) = exp;
+ TREE_VALUE (init)
+ = fold (build1 (NOP_EXPR, vtable_entry_type,
+ size_diffop (TREE_VALUE (init),
+ BINFO_OFFSET (binfo))));
}
return inits;
virtuals;
virtuals = TREE_CHAIN (virtuals))
{
- tree fn;
- tree base;
- tree base_binfo;
- tree offset;
-
/* Figure out what function we're looking at. */
- fn = TREE_VALUE (virtuals);
- base = DECL_CONTEXT (fn);
-
+ tree fn = TREE_VALUE (virtuals);
+ tree base = DECL_CONTEXT (fn);
/* The FN comes from BASE. So, we must caculate the adjustment
from the virtual base that derived from BINFO to BASE. */
- base_binfo = get_binfo (base, vod->derived, /*protect=*/0);
- offset = ssize_binop (MINUS_EXPR,
- BINFO_OFFSET (base_binfo),
- BINFO_OFFSET (vod->vbase));
- offset = build1 (NOP_EXPR, vtable_entry_type, offset);
- offset = fold (offset);
- TREE_CONSTANT (offset) = 1;
- binfo_inits = tree_cons (NULL_TREE, offset, binfo_inits);
+ tree base_binfo = get_binfo (base, vod->derived, /*protect=*/0);
+
+ binfo_inits
+ = tree_cons (NULL_TREE,
+ fold (build1 (NOP_EXPR, vtable_entry_type,
+ size_diffop (BINFO_OFFSET (base_binfo),
+ BINFO_OFFSET (vod->vbase)))),
+ binfo_inits);
}
/* Now add the initializers we've just created to the list that will
if (changed)
{
tree intype = TREE_TYPE (TREE_TYPE (expr));
+
if (TYPE_MAIN_VARIANT (intype) != BINFO_TYPE (last))
- {
- tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
- offset = BINFO_OFFSET (binfo);
- }
+ offset
+ = BINFO_OFFSET (get_binfo (last, TYPE_MAIN_VARIANT (intype), 0));
}
else
offset = BINFO_OFFSET (last);
{
/* Bash types to make the backend happy. */
offset = cp_convert (type, offset);
-#if 0
- /* This shouldn't be necessary. (mrs) */
- expr = build1 (NOP_EXPR, type, expr);
-#endif
/* If expr might be 0, we need to preserve that zeroness. */
if (nonnull == 0)
tree tmp
= size_binop (FLOOR_DIV_EXPR,
DECL_FIELD_BITPOS (TYPE_VFIELD (BINFO_TYPE (binfo))),
- size_int (BITS_PER_UNIT));
- tmp = convert (sizetype, tmp);
- return size_binop (PLUS_EXPR, tmp, BINFO_OFFSET (binfo));
+ bitsize_int (BITS_PER_UNIT));
+
+ return size_binop (PLUS_EXPR, convert (sizetype, tmp),
+ BINFO_OFFSET (binfo));
}
/* Get the offset to the start of the original binfo that we derived
this binfo from. If we find TYPE first, return the offset only
that far. The shortened search is useful because the this pointer
on method calling is expected to point to a DECL_CONTEXT (fndecl)
- object, and not a baseclass of it. */
+ object, and not a baseclass of it. */
+
static tree
get_derived_offset (binfo, type)
tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
tree offset2;
int i;
+
while (BINFO_BASETYPES (binfo)
- && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
+ && (i = CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
{
tree binfos = BINFO_BASETYPES (binfo);
if (BINFO_TYPE (binfo) == type)
break;
binfo = TREE_VEC_ELT (binfos, i);
}
+
offset2 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
return size_binop (MINUS_EXPR, offset1, offset2);
}
/* Now do rtti stuff. */
offset = get_derived_offset (TYPE_BINFO (type), NULL_TREE);
- offset = ssize_binop (MINUS_EXPR, integer_zero_node, offset);
+ offset = size_diffop (size_zero_node, offset);
set_rtti_entry (virtuals, offset, type);
}
else
offset = BINFO_OFFSET (binfo);
set_rtti_entry (BINFO_VIRTUALS (binfo),
- ssize_binop (MINUS_EXPR, integer_zero_node, offset),
+ size_diffop (size_zero_node, offset),
for_type);
/* In the new ABI, secondary vtables are laid out as part of the
size_extra_vtbl_entries (binfo)
tree binfo;
{
- tree offset;
-
- offset = size_binop (EXACT_DIV_EXPR,
- TYPE_SIZE (vtable_entry_type),
- size_int (BITS_PER_UNIT));
- offset = size_binop (MULT_EXPR, offset, num_extra_vtbl_entries (binfo));
+ tree offset = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (vtable_entry_type),
+ num_extra_vtbl_entries (binfo));
return fold (offset);
}
skip_rtti_stuff (binfo, t, n)
tree binfo;
tree t;
- unsigned HOST_WIDE_INT *n;
+ HOST_WIDE_INT *n;
{
tree virtuals;
tree overrider;
tree vindex;
tree delta;
- int i;
+ HOST_WIDE_INT i;
/* Find the function which originally caused this vtable
entry to be present. */
get_derived_offset (binfo,
DECL_VIRTUAL_CONTEXT (fn)),
BINFO_OFFSET (binfo));
- delta = ssize_binop (MINUS_EXPR,
- BINFO_OFFSET (TREE_VALUE (overrider)),
- delta);
+ delta = size_diffop (BINFO_OFFSET (TREE_VALUE (overrider)), delta);
modify_vtable_entry (t,
binfo,
tree offset = (tree) data;
/* Update the BINFO_OFFSET for this base. */
- BINFO_OFFSET (binfo)
- = size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), offset);
+ BINFO_OFFSET (binfo) = size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), offset);
SET_BINFO_MARKED (binfo);
tree offset;
vbase = BINFO_FOR_VBASE (BINFO_TYPE (binfo), t);
- offset = ssize_binop (MINUS_EXPR,
- BINFO_OFFSET (vbase),
- BINFO_OFFSET (binfo));
+ offset = size_binop (MINUS_EXPR,
+ BINFO_OFFSET (vbase), BINFO_OFFSET (binfo));
propagate_binfo_offsets (binfo, offset);
}
/* Now, make sure that the total size of the type is a multiple of
its alignment. */
dsize = CEIL (dsize, TYPE_ALIGN (t)) * TYPE_ALIGN (t);
- TYPE_SIZE (t) = size_int (dsize);
- TYPE_SIZE_UNIT (t) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (t),
- size_int (BITS_PER_UNIT));
+ TYPE_SIZE (t) = bitsize_int (dsize);
+ TYPE_SIZE_UNIT (t) = convert (sizetype,
+ size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (t),
+ bitsize_int (BITS_PER_UNIT)));
}
/* Finish the work of layout_record, now taking virtual bases into account.
if (*empty_p && flag_new_abi)
{
CLASSTYPE_SIZE (t) = bitsize_int (0);
- CLASSTYPE_SIZE_UNIT (t) = size_int (0);
+ CLASSTYPE_SIZE_UNIT (t) = size_zero_node;
}
else if (flag_new_abi && TYPE_HAS_COMPLEX_INIT_REF (t)
&& TYPE_HAS_COMPLEX_ASSIGN_REF (t))
&& DECL_FIELD_CONTEXT (vfield) != t)
{
tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
- tree offset = BINFO_OFFSET (binfo);
+ tree offset = convert (bitsizetype, BINFO_OFFSET (binfo));
vfield = copy_node (vfield);
copy_lang_decl (vfield);
if (! integer_zerop (offset))
- offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
+ offset = size_binop (MULT_EXPR, offset, bitsize_int (BITS_PER_UNIT));
+
DECL_FIELD_CONTEXT (vfield) = t;
DECL_FIELD_BITPOS (vfield)
= size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
extern void pop_lang_context PARAMS ((void));
extern tree instantiate_type PARAMS ((tree, tree, int));
extern void print_class_statistics PARAMS ((void));
-extern tree skip_rtti_stuff PARAMS ((tree, tree, unsigned HOST_WIDE_INT *));
+extern tree skip_rtti_stuff PARAMS ((tree, tree,
+ HOST_WIDE_INT *));
extern void build_self_reference PARAMS ((void));
extern void warn_hidden PARAMS ((tree));
extern tree get_enclosing_class PARAMS ((tree));
expr = cplus_expand_constant (expr);
if (binfo && ! TREE_VIA_VIRTUAL (binfo))
- expr = size_binop (code, expr, BINFO_OFFSET (binfo));
+ expr = size_binop (code, convert (sizetype,expr),
+ BINFO_OFFSET (binfo));
}
else if (TYPE_PTRMEMFUNC_P (type))
{
else if (TREE_CODE (initial_value) == CONSTRUCTOR)
{
tree elts = CONSTRUCTOR_ELTS (initial_value);
- maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
+
+ maxindex = ssize_int (-1);
for (; elts; elts = TREE_CHAIN (elts))
{
if (TREE_PURPOSE (elts))
maxindex = TREE_PURPOSE (elts);
else
- maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
+ maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
}
maxindex = copy_node (maxindex);
}
the `accessibility' of that particular inheritance is.) */
base_binfo
- = make_binfo (integer_zero_node, basetype,
+ = make_binfo (size_zero_node, basetype,
CLASS_TYPE_P (basetype)
? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
CLASS_TYPE_P (basetype)
This code is non-reentrant.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
Free Software Foundation, Inc.
-
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
if (TREE_CODE (type) == ARRAY_REF)
type = build_cplus_array_type
(TREE_OPERAND (type, 0),
- build_index_type (size_binop (MINUS_EXPR, TREE_OPERAND (type, 1),
- integer_one_node)));
+ build_index_type (fold (build (MINUS_EXPR, integer_type_node,
+ TREE_OPERAND (type, 1),
+ integer_one_node))));
dump_type (type, flags);
if (TREE_OPERAND (t, 2))
{
offset = convert (sizetype,
size_binop (EASY_DIV_EXPR,
DECL_FIELD_BITPOS (member),
- size_int (BITS_PER_UNIT)));
+ bitsize_int (BITS_PER_UNIT)));
/* We offset all pointer to data members by 1 so that we
can distinguish between a null pointer to data member
and the first data member of a structure. */
- offset = size_binop (PLUS_EXPR, offset, size_int (1));
-
+ offset = size_binop (PLUS_EXPR, offset, size_one_node);
cst = cp_convert (type, offset);
}
else
exp = build (PLUS_EXPR,
TREE_TYPE (this_ptr),
this_ptr,
- BINFO_OFFSET (vbases));
+ fold (build1 (NOP_EXPR, this_ptr, BINFO_OFFSET (vbases))));
exp = build1 (NOP_EXPR,
build_pointer_type (BINFO_TYPE (vbases)),
exp);
}
/* The below is short by BI_header_size */
- virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
+ virtual_size = size_binop (MULT_EXPR, size_exp,
+ convert (sizetype, maxindex));
tbase = create_temporary_var (ptype);
tbase_init = build_modify_expr (tbase, NOP_EXPR,
tree base_tbd;
/* The below is short by BI_header_size */
- virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
+ virtual_size = size_binop (MULT_EXPR, size_exp,
+ convert (sizetype, maxindex));
if (! TYPE_VEC_NEW_USES_COOKIE (type))
/* no header */
canonical binfo for them. Ideally, this would be done lazily for
all types. */
if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM)
- TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE);
+ TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
return t;
}
/* RunTime Type Identification
- Copyright (C) 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
+ Free Software Foundation, Inc.
Mostly written by Jason Merrill (jason@cygnus.com).
This file is part of GNU CC.
field = lookup_field (parent, get_identifier (name), 0, 0);
offset = size_binop (FLOOR_DIV_EXPR,
DECL_FIELD_BITPOS (field),
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
offset = convert (sizetype, offset);
}
else
/* Breadth-first and depth-first routines for
searching multiple-inheritance lattice for GNU C++.
- Copyright (C) 1987, 89, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com)
{
tree vbase = BINFO_TYPE (base_binfo);
tree binfo = binfo_member (vbase, vi->vbase_types);
+ tree ptr_type = build_pointer_type (vbase);
CLASSTYPE_SEARCH_SLOT (vbase)
- = build (PLUS_EXPR, build_pointer_type (vbase),
- vi->decl_ptr, BINFO_OFFSET (binfo));
+ = build (PLUS_EXPR, ptr_type, vi->decl_ptr,
+ convert (ptr_type, BINFO_OFFSET (binfo)));
}
}
SET_BINFO_VTABLE_PATH_MARKED (binfo);
tree virtuals;
tree vc;
tree delta;
- unsigned HOST_WIDE_INT n;
+ HOST_WIDE_INT n;
while (BINFO_PRIMARY_MARKED_P (binfo))
{
if (TREE_VIA_VIRTUAL (binfo) && ! BINFO_VBASE_MARKED (binfo))
{
- tree new_vbase = make_binfo (integer_zero_node,
+ tree new_vbase = make_binfo (size_zero_node,
BINFO_TYPE (binfo),
BINFO_VTABLE (binfo),
BINFO_VIRTUALS (binfo));
debug_binfo (elem)
tree elem;
{
- unsigned HOST_WIDE_INT n;
+ HOST_WIDE_INT n;
tree virtuals;
- fprintf (stderr, "type \"%s\"; offset = %ld\n",
- TYPE_NAME_STRING (BINFO_TYPE (elem)),
- (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
- fprintf (stderr, "vtable type:\n");
+ fprintf (stderr, "type \"%s\", offset = ",
+ TYPE_NAME_STRING (BINFO_TYPE (elem)));
+ fprintf (stderr, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
+ fprintf (stderr, "\nvtable type:\n");
debug_tree (BINFO_TYPE (elem));
if (BINFO_VTABLE (elem))
- fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
+ fprintf (stderr, "vtable decl \"%s\"\n",
+ IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
else
fprintf (stderr, "no vtable decl yet\n");
fprintf (stderr, "virtuals:\n");
if (t2 == error_mark_node)
return 0;
+ /* If this is a strict comparison with a sizetype, the actual types
+ won't be the same (since we need to set TYPE_IS_SIZETYPE, so verify
+ if they are both the same size and signedness. */
+ if (strict == COMPARE_STRICT
+ && TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
+ && TREE_CODE (t1) == INTEGER_TYPE
+ && TREE_UNSIGNED (t1) == TREE_UNSIGNED (t2)
+ && TYPE_MODE (t1) == TYPE_MODE (t2)
+ && TYPE_MIN_VALUE (t1) == TYPE_MIN_VALUE (t2)
+ && TYPE_MAX_VALUE (t1) == TYPE_MAX_VALUE (t2))
+ return 1;
+
if (strict & COMPARE_RELAXED)
{
/* Treat an enum type as the unsigned integer type of the same width. */
tree type;
{
enum tree_code code = TREE_CODE (type);
- tree t;
if (processing_template_decl)
return build_min (SIZEOF_EXPR, sizetype, type);
{
if (pedantic || warn_pointer_arith)
pedwarn ("ISO C++ forbids applying `sizeof' to a function type");
- return size_int (1);
+ return size_one_node;
}
if (code == METHOD_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("ISO C++ forbids applying `sizeof' to a member function");
- return size_int (1);
+ return size_one_node;
}
if (code == VOID_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("ISO C++ forbids applying `sizeof' to type `void' which is an incomplete type");
- return size_int (1);
+ return size_one_node;
}
if (code == ERROR_MARK)
- return size_int (1);
+ return size_one_node;
/* ARM $5.3.2: ``When applied to a reference, the result is the size of the
referenced object.'' */
if (code == OFFSET_TYPE)
{
cp_error ("`sizeof' applied to non-static member");
- return size_int (0);
+ return size_zero_node;
}
if (TYPE_SIZE (complete_type (type)) == 0)
{
cp_error ("`sizeof' applied to incomplete type `%T'", type);
- return size_int (0);
+ return size_zero_node;
}
/* Convert in case a char is more than one unit. */
- t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (TYPE_PRECISION (char_type_node)));
- t = convert (sizetype, t);
- /* size_binop does not put the constant in range, so do it now. */
- if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
- TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
- return t;
+ return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
}
tree
if (is_overloaded_fn (e))
{
pedwarn ("ISO C++ forbids applying `sizeof' to an expression of function type");
- return size_int (1);
+ return size_one_node;
}
else if (type_unknown_p (e))
{
incomplete_type_error (e, TREE_TYPE (e));
- return size_int (1);
+ return size_one_node;
}
/* It's illegal to say `sizeof (X::i)' for `i' a non-static data
member unless you're in a non-static member of X. So hand off to
tree type;
{
enum tree_code code = TREE_CODE (type);
- tree t;
if (code == FUNCTION_TYPE
|| code == METHOD_TYPE
|| code == VOID_TYPE
|| code == ERROR_MARK)
- return size_int (1);
+ return size_one_node;
+
if (code == REFERENCE_TYPE)
type = TREE_TYPE (type);
if (TYPE_SIZE (type) == 0)
- return size_int (0);
+ return size_zero_node;
/* Convert in case a char is more than one unit. */
- t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
- size_int (TYPE_PRECISION (char_type_node)));
- t = convert (sizetype, t);
- force_fit_type (t, 0);
- return t;
+ return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
}
/* Implement the __alignof keyword: Return the minimum required
return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
if (code == VOID_TYPE || code == ERROR_MARK)
- return size_int (1);
+ return size_one_node;
/* C++: this is really correct! */
if (code == REFERENCE_TYPE)
if (! integer_zerop (DECL_FIELD_BITPOS (field)))
{
tree offset = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
int flag = TREE_CONSTANT (rval);
offset = convert (sizetype, offset);
rval = fold (build (PLUS_EXPR, argtype,
}
/* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
- given by CST. */
+ given by CST.
+
+ ??? There is no consistency as to the types returned for the above
+ values. Some code acts as if its a sizetype and some as if its
+ integer_type_node. */
void
expand_ptrmemfunc_cst (cst, delta, idx, pfn, delta2)
if (!DECL_VIRTUAL_P (fn))
{
if (!flag_new_abi)
- *idx = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
+ *idx = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_int_2 (-1, -1));
else
*idx = NULL_TREE;
*pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
fn; the call will do the opposite adjustment. */
tree orig_class = DECL_VIRTUAL_CONTEXT (fn);
tree binfo = binfo_or_else (orig_class, fn_class);
- *delta = size_binop (PLUS_EXPR, *delta, BINFO_OFFSET (binfo));
+ *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
+ *delta, BINFO_OFFSET (binfo)));
if (!flag_new_abi)
{
/* Map everything down one to make room for the null PMF. */
- *idx = size_binop (PLUS_EXPR, DECL_VINDEX (fn), integer_one_node);
+ *idx = fold (build (PLUS_EXPR, integer_type_node,
+ DECL_VINDEX (fn), integer_one_node));
*pfn = NULL_TREE;
}
else
/* Under the new ABI, we set PFN to twice the index, plus
one. */
*idx = NULL_TREE;
- *pfn = size_binop (MULT_EXPR, DECL_VINDEX (fn), integer_two_node);
- *pfn = size_binop (PLUS_EXPR, *pfn, integer_one_node);
- *pfn = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
+ *pfn = fold (build (MULT_EXPR, integer_type_node,
+ DECL_VINDEX (fn), integer_two_node));
+ *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn,
+ integer_one_node));
+ *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
+ *pfn));
}
/* Offset from an object of PTR_CLASS to the vptr for ORIG_CLASS. */
- *delta2 = size_binop (PLUS_EXPR, *delta,
- get_vfield_offset (TYPE_BINFO (orig_class)));
+ *delta2 = fold (build (PLUS_EXPR, integer_type_node, *delta,
+ get_vfield_offset (TYPE_BINFO (orig_class))));
}
}
tree copy_size
= size_binop (MIN_EXPR,
make_tree (sizetype, size),
- convert (sizetype,
- build_int_2 (TREE_STRING_LENGTH (exp), 0)));
+ size_int (TREE_STRING_LENGTH (exp)));
rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
VOIDmode, 0);
rtx label = 0;
rtx offset_rtx;
if (contains_placeholder_p (offset))
- offset = build (WITH_RECORD_EXPR, sizetype,
+ offset = build (WITH_RECORD_EXPR, bitsizetype,
offset, make_tree (TREE_TYPE (exp), target));
offset = size_binop (EXACT_DIV_EXPR, offset,
- size_int (BITS_PER_UNIT));
+ bitsize_int (BITS_PER_UNIT));
+ offset = convert (sizetype, offset);
offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
if (GET_CODE (to_rtx) != MEM)
loop = expand_start_loop (0);
/* Assign value to element index. */
- position = size_binop (EXACT_DIV_EXPR, TYPE_SIZE (elttype),
- size_int (BITS_PER_UNIT));
- position = size_binop (MULT_EXPR,
- size_binop (MINUS_EXPR, index,
- TYPE_MIN_VALUE (domain)),
- position);
+ position
+ = convert (ssizetype,
+ fold (build (MINUS_EXPR, TREE_TYPE (index),
+ index, TYPE_MIN_VALUE (domain))));
+ position = size_binop (MULT_EXPR, position,
+ convert (ssizetype,
+ TYPE_SIZE_UNIT (elttype)));
+
pos_rtx = expand_expr (position, 0, VOIDmode, 0);
addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
xtarget = change_address (target, mode, addr);
tree position;
if (index == 0)
- index = size_int (i);
+ index = ssize_int (1);
if (minelt)
- index = size_binop (MINUS_EXPR, index,
- TYPE_MIN_VALUE (domain));
- position = size_binop (EXACT_DIV_EXPR, TYPE_SIZE (elttype),
- size_int (BITS_PER_UNIT));
- position = size_binop (MULT_EXPR, index, position);
+ index = convert (ssizetype,
+ fold (build (MINUS_EXPR, index,
+ TYPE_MIN_VALUE (domain))));
+ position = size_binop (MULT_EXPR, index,
+ convert (ssizetype,
+ TYPE_SIZE_UNIT (elttype)));
pos_rtx = expand_expr (position, 0, VOIDmode, 0);
addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
xtarget = change_address (target, mode, addr);
domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
bitlength = size_binop (PLUS_EXPR,
- size_binop (MINUS_EXPR, domain_max, domain_min),
- size_one_node);
+ size_diffop (domain_max, domain_min),
+ ssize_int (1));
if (nbytes < 0 || TREE_CODE (bitlength) != INTEGER_CST)
abort ();
tree orig_exp = exp;
tree size_tree = 0;
enum machine_mode mode = VOIDmode;
- tree offset = integer_zero_node;
+ tree offset = size_zero_node;
unsigned int alignment = BIGGEST_ALIGNMENT;
if (TREE_CODE (exp) == COMPONENT_REF)
tree pos = (TREE_CODE (exp) == COMPONENT_REF
? DECL_FIELD_BITPOS (TREE_OPERAND (exp, 1))
: TREE_OPERAND (exp, 2));
- tree constant = integer_zero_node, var = pos;
+ tree constant = bitsize_int (0), var = pos;
/* If this field hasn't been filled in yet, don't go
past it. This should only happen when folding expressions
&& TREE_CODE (TREE_OPERAND (pos, 1)) == INTEGER_CST)
constant = TREE_OPERAND (pos, 1), var = TREE_OPERAND (pos, 0);
else if (TREE_CODE (pos) == INTEGER_CST)
- constant = pos, var = integer_zero_node;
+ constant = pos, var = bitsize_int (0);
*pbitpos += TREE_INT_CST_LOW (constant);
- offset = size_binop (PLUS_EXPR, offset,
- size_binop (EXACT_DIV_EXPR, var,
- size_int (BITS_PER_UNIT)));
+ offset
+ = size_binop (PLUS_EXPR, offset,
+ convert (sizetype,
+ size_binop (EXACT_DIV_EXPR, var,
+ bitsize_int (BITS_PER_UNIT))));
}
else if (TREE_CODE (exp) == ARRAY_REF)
it overflowed. In either case, redo the multiplication
against the size in units. This is especially important
in the non-constant case to avoid a division at runtime. */
- xindex = fold (build (MULT_EXPR, ssizetype, index,
- convert (ssizetype,
- TYPE_SIZE_UNIT (TREE_TYPE (exp)))));
+ xindex
+ = fold (build (MULT_EXPR, ssizetype, index,
+ convert (ssizetype,
+ TYPE_SIZE_UNIT (TREE_TYPE (exp)))));
if (contains_placeholder_p (xindex))
- xindex = build (WITH_RECORD_EXPR, sizetype, xindex, exp);
+ xindex = build (WITH_RECORD_EXPR, ssizetype, xindex, exp);
- offset = size_binop (PLUS_EXPR, offset, xindex);
+ offset
+ = size_binop (PLUS_EXPR, offset, convert (sizetype, xindex));
}
}
else if (TREE_CODE (exp) != NON_LVALUE_EXPR
tree array = TREE_OPERAND (exp, 0);
tree domain = TYPE_DOMAIN (TREE_TYPE (array));
tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
- tree index = TREE_OPERAND (exp, 1);
- tree index_type = TREE_TYPE (index);
+ tree index = convert (sizetype, TREE_OPERAND (exp, 1));
HOST_WIDE_INT i;
/* Optimize the special-case of a zero lower bound.
with constant folding. (E.g. suppose the lower bound is 1,
and its mode is QI. Without the conversion, (ARRAY
+(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
- +INDEX), which becomes (ARRAY+255+INDEX). Oops!)
-
- But sizetype isn't quite right either (especially if
- the lowbound is negative). FIXME */
+ +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
if (! integer_zerop (low_bound))
- index = fold (build (MINUS_EXPR, index_type, index,
- convert (sizetype, low_bound)));
+ index = size_diffop (index, convert (sizetype, low_bound));
/* Fold an expression like: "foo"[2].
This is not done in fold so it won't happen inside &.
tree array = TREE_OPERAND (exp, 0);
tree domain = TYPE_DOMAIN (TREE_TYPE (array));
tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
- tree index = TREE_OPERAND (exp, 1);
- tree index_type = TREE_TYPE (index);
+ tree index = convert (sizetype, TREE_OPERAND (exp, 1));
HOST_WIDE_INT i;
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
with constant folding. (E.g. suppose the lower bound is 1,
and its mode is QI. Without the conversion, (ARRAY
+(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
- +INDEX), which becomes (ARRAY+255+INDEX). Oops!)
-
- But sizetype isn't quite right either (especially if
- the lowbound is negative). FIXME */
+ +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
if (! integer_zerop (low_bound))
- index = fold (build (MINUS_EXPR, index_type, index,
- convert (sizetype, low_bound)));
+ index = size_diffop (index, convert (sizetype, low_bound));
/* If this is a constant index into a constant array,
just get the value from the array. Handle both the cases when
return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
}
\f
-/* Return the tree node and offset if a given argument corresponds to
- a string constant. */
+/* Return the tree node if a ARG corresponds to a string constant or zero
+ if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
+ in bytes within the string that ARG is accessing. The type of the
+ offset will be `sizetype'. */
tree
string_constant (arg, ptr_offset)
if (TREE_CODE (arg) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
{
- *ptr_offset = integer_zero_node;
+ *ptr_offset = size_zero_node;
return TREE_OPERAND (arg, 0);
}
else if (TREE_CODE (arg) == PLUS_EXPR)
if (TREE_CODE (arg0) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
{
- *ptr_offset = arg1;
+ *ptr_offset = convert (sizetype, arg1);
return TREE_OPERAND (arg0, 0);
}
else if (TREE_CODE (arg1) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
{
- *ptr_offset = arg0;
+ *ptr_offset = convert (sizetype, arg0);
return TREE_OPERAND (arg1, 0);
}
}
\f
#ifdef TREE_CODE /* Don't lose if tree.h not included. */
/* Structure to record the size of a sequence of arguments
- as the sum of a tree-expression and a constant. */
+ as the sum of a tree-expression and a constant. This structure is
+ also used to store offsets from the stack, which might be negative,
+ so the variable part must be ssizetype, not sizetype. */
struct args_size
{
if (TREE_CODE (dec) == INTEGER_CST) \
(TO).constant -= TREE_INT_CST_LOW (dec); \
else if ((TO).var == 0) \
- (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \
+ (TO).var = size_binop (MINUS_EXPR, ssize_int (0), dec); \
else \
(TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
+/* Convert the implicit sum in a `struct args_size' into a tree
+ of type ssizetype. */
+#define ARGS_SIZE_TREE(SIZE) \
+((SIZE).var == 0 ? ssize_int ((SIZE).constant) \
+ : size_binop (PLUS_EXPR, (SIZE).var, ssize_int ((SIZE).constant)))
+
/* Convert the implicit sum in a `struct args_size' into an rtx. */
-#define ARGS_SIZE_RTX(SIZE) \
-((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \
- : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \
- size_int ((SIZE).constant)), \
- NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD))
-
-/* Convert the implicit sum in a `struct args_size' into a tree. */
-#define ARGS_SIZE_TREE(SIZE) \
-((SIZE).var == 0 ? size_int ((SIZE).constant) \
- : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant)))
+#define ARGS_SIZE_RTX(SIZE) \
+((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \
+ : expand_expr (ARGS_SIZE_TREE (SIZE), NULL_RTX, VOIDmode, \
+ EXPAND_MEMORY_USE_BAD))
/* Supply a default definition for FUNCTION_ARG_PADDING:
usually pad upward, but pad short args downward on
+Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * com.c (ffecom_arrayref_): Convert args to size_binop to proper type.
+ (ffecom_tree_canonize_ptr_): Don't use size_binop for non-sizes.
+ (ffecom_tree_canonize_ref_): Likewise.
+ (type_for_mode): Handle TImode.
+ * ste.c (ffeste_io_dofio_, ffeste_io_douio_): Use TYPE_SIZE_UNIT.
+ (ffeste_io_ciclist_): Likewise.
+
2000-02-23 Zack Weinberg <zack@wolery.cumb.org>
* com.c (ffecom_type_permanent_copy_): Delete unused function.
item,
size_binop (MULT_EXPR,
size_in_bytes (TREE_TYPE (array)),
- fold (build (MINUS_EXPR,
- tree_type_x,
- element,
- min))));
+ convert (sizetype,
+ fold (build (MINUS_EXPR,
+ tree_type_x,
+ element, min)))));
}
if (! want_ptr)
{
if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
{
/* An offset into COMMON. */
- *offset = size_binop (PLUS_EXPR,
- *offset,
- TREE_OPERAND (t, 1));
+ *offset = fold (build (PLUS_EXPR, TREE_TYPE (*offset),
+ *offset, TREE_OPERAND (t, 1)));
/* Convert offset (presumably in bytes) into canonical units
(presumably bits). */
- *offset = size_binop (MULT_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (t))),
- *offset);
+ *offset = fold (build (MULT_EXPR, TREE_TYPE (*offset),
+ TYPE_SIZE (TREE_TYPE (TREE_TYPE (t))),
+ *offset));
break;
}
/* Not a COMMON reference, so an unrecognized pattern. */
|| (*decl == error_mark_node))
return;
- *offset = size_binop (MULT_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))),
- size_binop (MINUS_EXPR,
- element,
- TYPE_MIN_VALUE
- (TYPE_DOMAIN
- (TREE_TYPE (array)))));
-
- *offset = size_binop (PLUS_EXPR,
- init_offset,
+ *offset
+ = size_binop (MULT_EXPR,
+ TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))),
+ convert (sizetype,
+ fold (build (MINUS_EXPR, TREE_TYPE (element),
+ element,
+ TYPE_MIN_VALUE
+ (TYPE_DOMAIN
+ (TREE_TYPE (array)))))));;
+
+ *offset = size_binop (PLUS_EXPR, convert (sizetype, init_offset),
*offset);
*size = TYPE_SIZE (TREE_TYPE (t));
if (mode == TYPE_MODE (long_long_integer_type_node))
return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
+#if HOST_BITS_PER_WIDE_INT >= 64
+ if (mode == TYPE_MODE (intTI_type_node))
+ return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
+#endif
+
if (mode == TYPE_MODE (float_type_node))
return float_type_node;
/* ste.c -- Implementation File (module.c template V1.0)
- Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1996, 2000 Free Software Foundation, Inc.
Contributed by James Craig Burley.
This file is part of GNU Fortran.
if (size == NULL_TREE) /* Already filled in for CHARACTER type. */
{ /* "(ftnlen) sizeof(type)" */
size = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (ffecom_tree_type[bt][kt]),
- size_int (TYPE_PRECISION (char_type_node)));
+ TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
#if 0 /* Assume that while it is possible that char * is wider than
ftnlen, no object in Fortran space can get big enough for its
size to be wider than ftnlen. I really hope nobody wastes
= is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
else
{
- num_elements = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
- size);
- num_elements = size_binop (CEIL_DIV_EXPR,
- num_elements,
- size_int (TYPE_PRECISION
- (char_type_node)));
+ num_elements
+ = size_binop (CEIL_DIV_EXPR,
+ TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+ convert (sizetype, size));
+ num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
num_elements = convert (ffecom_f2c_ftnlen_type_node,
num_elements);
}
if (size == NULL_TREE) /* Already filled in for CHARACTER type. */
{ /* "(ftnlen) sizeof(type)" */
size = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (ffecom_tree_type[bt][kt]),
- size_int (TYPE_PRECISION (char_type_node)));
+ TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
#if 0 /* Assume that while it is possible that char * is wider than
ftnlen, no object in Fortran space can get big enough for its
size to be wider than ftnlen. I really hope nobody wastes
num_elements = ffecom_integer_one_node;
else
{
- num_elements = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
- size);
- num_elements = size_binop (CEIL_DIV_EXPR,
- num_elements,
- size_int (TYPE_PRECISION
- (char_type_node)));
+ num_elements
+ = size_binop (CEIL_DIV_EXPR,
+ TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+ convert (sizetype, size));
+ num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
num_elements = convert (ffecom_f2c_ftnlen_type_node,
num_elements);
}
if (size == NULL_TREE) /* Already filled in for CHARACTER type. */
{ /* "(ftnlen) sizeof(type)" */
size = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (ffecom_tree_type[bt][kt]),
- size_int (TYPE_PRECISION (char_type_node)));
+ TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
#if 0 /* Assume that while it is possible that char * is wider than
ftnlen, no object in Fortran space can get big enough for its
size to be wider than ftnlen. I really hope nobody wastes
= is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
else
{
- num_elements = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
- size);
+ num_elements
+ = size_binop (CEIL_DIV_EXPR,
+ TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+ convert (sizetype, size));
num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
- size_int (TYPE_PRECISION
- (char_type_node)));
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
num_elements = convert (ffecom_f2c_ftnlen_type_node,
num_elements);
}
else if (unitexp && unitlenexp)
{
/* An array, but all the info is constant, so compute now. */
- unitnuminit = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
- unitlenexp);
- unitnuminit = size_binop (CEIL_DIV_EXPR,
- unitnuminit,
- size_int (TYPE_PRECISION
- (char_type_node)));
+ unitnuminit
+ = size_binop (CEIL_DIV_EXPR,
+ TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (unitexp))),
+ convert (sizetype, unitlenexp));
+ unitnuminit = size_binop (CEIL_DIV_EXPR, unitnuminit,
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
unitnumexp = unitnuminit;
}
else
&& unitexp != error_mark_node
&& unitlenexp != error_mark_node)
{
- unitnumexp = size_binop (CEIL_DIV_EXPR,
- TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
- unitlenexp);
- unitnumexp = size_binop (CEIL_DIV_EXPR,
- unitnumexp,
- size_int (TYPE_PRECISION
- (char_type_node)));
+ unitnumexp
+ = size_binop (CEIL_DIV_EXPR,
+ TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (unitexp))),
+ convert (sizetype, unitlenexp));
+ unitnumexp = size_binop (CEIL_DIV_EXPR, unitnumexp,
+ size_int (TYPE_PRECISION (char_type_node)
+ / BITS_PER_UNIT));
ffeste_f2c_compile_ (unitnumfield, unitnumexp);
}
abort ();
}
- if (TREE_TYPE (arg1) == sizetype && hi == 0
- && low >= 0
- && (TYPE_MAX_VALUE (sizetype) == NULL
- || low <= TREE_INT_CST_LOW (TYPE_MAX_VALUE (sizetype)))
- && ! overflow
- && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
- t = size_int (low);
+ if (forsize && hi == 0 && low >= 0 && low < 1000)
+ return size_int_type_wide (low, TREE_TYPE (arg1));
else
{
t = build_int_2 (low, hi);
}
\f
/* Return an INTEGER_CST with value whose low-order HOST_BITS_PER_WIDE_INT
- bits are given by NUMBER.
+ bits are given by NUMBER and of the sizetype represented by KIND. */
- If BIT_P is nonzero, this represents a size in bit and the type of the
- result will be bitsizetype, othewise it represents a size in bytes and
- the type of the result will be sizetype. */
+tree
+size_int_wide (number, kind)
+ HOST_WIDE_INT number;
+ enum size_type_kind kind;
+{
+ return size_int_type_wide (number, sizetype_tab[(int) kind]);
+}
+
+/* Likewise, but the desired type is specified explicitly. */
tree
-size_int_wide (number, bit_p)
+size_int_type_wide (number, type)
HOST_WIDE_INT number;
- int bit_p;
+ tree type;
{
/* Type-size nodes already made for small sizes. */
- static tree size_table[2 * HOST_BITS_PER_WIDE_INT + 1][2];
+ static tree size_table[2 * HOST_BITS_PER_WIDE_INT + 1];
static int init_p = 0;
tree t;
if (number >= 0
&& number < (int) (sizeof size_table / sizeof size_table[0]) / 2)
{
- if (size_table[number][bit_p] != 0)
- return size_table[number][bit_p];
+ if (size_table[number] != 0)
+ for (t = size_table[number]; t != 0; t = TREE_CHAIN (t))
+ if (TREE_TYPE (t) == type)
+ return t;
if (! ggc_p)
{
}
t = build_int_2 (number, 0);
- TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
- size_table[number][bit_p] = t;
+ TREE_TYPE (t) = type;
+ TREE_CHAIN (t) = size_table[number];
+ size_table[number] = t;
if (! ggc_p)
pop_obstacks ();
return t;
}
- t = build_int_2 (number, 0);
- TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
+ t = build_int_2 (number, number < 0 ? -1 : 0);
+ TREE_TYPE (t) = type;
TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
return t;
}
-/* Combine operands OP1 and OP2 with arithmetic operation CODE.
- CODE is a tree code. Data type is taken from `sizetype',
+/* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
+ is a tree code. The type of the result is taken from the operands.
+ Both must be the same type integer type and it must be a size type.
If the operands are constant, so is the result. */
tree
enum tree_code code;
tree arg0, arg1;
{
+ tree type = TREE_TYPE (arg0);
+
+ if (type != TREE_TYPE (arg1)
+ || TREE_CODE (type) != INTEGER_TYPE || ! TYPE_IS_SIZETYPE (type))
+ abort ();
+
/* Handle the special case of two integer constants faster. */
if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
{
if (arg0 == error_mark_node || arg1 == error_mark_node)
return error_mark_node;
- return fold (build (code, sizetype, arg0, arg1));
+ return fold (build (code, type, arg0, arg1));
}
-/* Combine operands OP1 and OP2 with arithmetic operation CODE.
- CODE is a tree code. Data type is taken from `ssizetype',
- If the operands are constant, so is the result. */
+/* Given two values, either both of sizetype or both of bitsizetype,
+ compute the difference between the two values. Return the value
+ in signed type corresponding to the type of the operands. */
tree
-ssize_binop (code, arg0, arg1)
- enum tree_code code;
+size_diffop (arg0, arg1)
tree arg0, arg1;
{
- /* Handle the special case of two integer constants faster. */
- if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
- {
- /* And some specific cases even faster than that. */
- if (code == PLUS_EXPR && integer_zerop (arg0))
- return arg1;
- else if ((code == MINUS_EXPR || code == PLUS_EXPR)
- && integer_zerop (arg1))
- return arg0;
- else if (code == MULT_EXPR && integer_onep (arg0))
- return arg1;
+ tree type = TREE_TYPE (arg0);
+ tree ctype;
- /* Handle general case of two integer constants. We convert
- arg0 to ssizetype because int_const_binop uses its type for the
- return value. */
- arg0 = convert (ssizetype, arg0);
- return int_const_binop (code, arg0, arg1, 0, 0);
- }
-
- if (arg0 == error_mark_node || arg1 == error_mark_node)
- return error_mark_node;
+ if (TREE_TYPE (arg1) != type || TREE_CODE (type) != INTEGER_TYPE
+ || ! TYPE_IS_SIZETYPE (type))
+ abort ();
- return fold (build (code, ssizetype, arg0, arg1));
+ /* If the type is already signed, just do the simple thing. */
+ if (! TREE_UNSIGNED (type))
+ return size_binop (MINUS_EXPR, arg0, arg1);
+
+ ctype = (type == bitsizetype || type == ubitsizetype
+ ? sbitsizetype : ssizetype);
+
+ /* If either operand is not a constant, do the conversions to the signed
+ type and subtract. The hardware will do the right thing with any
+ overflow in the subtraction. */
+ if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
+ return size_binop (MINUS_EXPR, convert (ctype, arg0),
+ convert (ctype, arg1));
+
+ /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
+ Otherwise, subtract the other way, convert to CTYPE (we know that can't
+ overflow) and negate (which can't either). Special-case a result
+ of zero while we're here. */
+ if (tree_int_cst_equal (arg0, arg1))
+ return convert (ctype, integer_zero_node);
+ else if (tree_int_cst_lt (arg1, arg0))
+ return convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
+ else
+ return size_binop (MINUS_EXPR, convert (ctype, integer_zero_node),
+ convert (ctype, size_binop (MINUS_EXPR, arg1, arg0)));
}
\f
/* This structure is used to communicate arguments to fold_convert_1. */
if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
return t;
+ /* If we are trying to make a sizetype for a small integer, use
+ size_int to pick up cached types to reduce duplicate nodes. */
+ if (TREE_CODE (type) == INTEGER_CST && TYPE_IS_SIZETYPE (type)
+ && TREE_INT_CST_HIGH (arg1) == 0
+ && TREE_INT_CST_LOW (arg1) >= 0
+ && TREE_INT_CST_LOW (arg1) < 1000)
+ return size_int_type_wide (TREE_INT_CST_LOW (arg1), type);
+
/* Given an integer constant, make new constant with new type,
appropriately sign-extended or truncated. */
t = build_int_2 (TREE_INT_CST_LOW (arg1),
/* If these operations "cancel" each other, we have the main
optimizations of this pass, which occur when either constant is a
multiple of the other, in which case we replace this with either an
- operation or CODE or TCODE. */
- if ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
+ operation or CODE or TCODE. If we have an unsigned type that is
+ not a sizetype, we canot do this for division since it will change
+ the result if the original computation overflowed. */
+ if ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR
+ && (! TREE_UNSIGNED (ctype)
+ || (TREE_CODE (ctype) == INTEGER_TYPE
+ && TYPE_IS_SIZETYPE (ctype))))
|| (tcode == MULT_EXPR
&& code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
&& code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR))
#ifdef ARGS_GROW_DOWNWARD
current_function_arg_offset_rtx
= (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
- : expand_expr (size_binop (MINUS_EXPR, stack_args_size.var,
- size_int (-stack_args_size.constant)),
+ : expand_expr (size_diffop (stack_args_size.var,
+ size_int (-stack_args_size.constant)),
NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD));
#else
current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
{
initial_offset_ptr->var
= size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
- size_int (reg_parm_stack_space));
+ ssize_int (reg_parm_stack_space));
initial_offset_ptr->constant = 0;
}
else if (initial_offset_ptr->constant < reg_parm_stack_space)
if (initial_offset_ptr->var)
{
offset_ptr->constant = 0;
- offset_ptr->var = size_binop (MINUS_EXPR, integer_zero_node,
+ offset_ptr->var = size_binop (MINUS_EXPR, ssize_int (0),
initial_offset_ptr->var);
}
else
if (where_pad != downward)
pad_to_arg_alignment (offset_ptr, boundary, alignment_pad);
if (initial_offset_ptr->var)
- {
- arg_size_ptr->var = size_binop (MINUS_EXPR,
- size_binop (MINUS_EXPR,
- integer_zero_node,
- initial_offset_ptr->var),
- offset_ptr->var);
- }
+ arg_size_ptr->var = size_binop (MINUS_EXPR,
+ size_binop (MINUS_EXPR,
+ ssize_int (0),
+ initial_offset_ptr->var),
+ offset_ptr->var);
+
else
- {
- arg_size_ptr->constant = (- initial_offset_ptr->constant
- - offset_ptr->constant);
- }
+ arg_size_ptr->constant = (- initial_offset_ptr->constant
+ - offset_ptr->constant);
+
#else /* !ARGS_GROW_DOWNWARD */
pad_to_arg_alignment (initial_offset_ptr, boundary, alignment_pad);
*offset_ptr = *initial_offset_ptr;
boundary / BITS_PER_UNIT);
offset_ptr->constant = 0; /*?*/
if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
- alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, save_var);
+ alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
+ save_var);
}
else
{
}
}
#endif
-
-#ifdef ARGS_GROW_DOWNWARD
-static tree
-round_down (value, divisor)
- tree value;
- int divisor;
-{
- return size_binop (MULT_EXPR,
- size_binop (FLOOR_DIV_EXPR, value, size_int (divisor)),
- size_int (divisor));
-}
-#endif
\f
/* Walk the tree of blocks describing the binding levels within a function
and warn about uninitialized variables.
+Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * expr.c (build_java_ret): Pass proper type to size_binop.
+
2000-02-25 Anthony Green <green@cygnus.com>
* expr.c (build_class_init): Mark the decl to be ignored by
size_binop (CEIL_DIV_EXPR, \
(DECL_FIELD_BITPOS \
(TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (TREE_TYPE (A)))))), \
- size_int (BITS_PER_UNIT))
+ bitsize_int (BITS_PER_UNIT))
tree
decode_newarray_type (atype)
#include "toplev.h"
#include "ggc.h"
+/* Set to one when set_sizetype has been called. */
+static int sizetype_set;
+
+/* List of types created before set_sizetype has been called. We do not
+ make this a GGC root since we want these nodes to be reclaimed. */
+static tree early_type_list;
+
/* Data type for the expressions representing sizes of data types.
It is the first integer type laid out. */
-
-struct sizetype_tab sizetype_tab;
+tree sizetype_tab[(int) TYPE_KIND_LAST];
/* If nonzero, this is an upper limit on alignment of structure fields.
The value is measured in bits. */
else
error ("variable-size type declared outside of any function");
- return size_int (1);
+ return size_one_node;
}
if (immediate_size_expand)
return mode;
}
-/* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
+/* Return the value of VALUE, rounded up to a multiple of DIVISOR.
+ This can only be applied to objects of a sizetype. */
tree
round_up (value, divisor)
tree value;
int divisor;
{
- return size_binop (MULT_EXPR,
- size_binop (CEIL_DIV_EXPR, value, size_int (divisor)),
- size_int (divisor));
+ tree arg = size_int_type (divisor, TREE_TYPE (value));
+
+ return size_binop (MULT_EXPR, size_binop (CEIL_DIV_EXPR, value, arg), arg);
+}
+
+/* Likewise, but round down. */
+
+tree
+round_down (value, divisor)
+ tree value;
+ int divisor;
+{
+ tree arg = size_int_type (divisor, TREE_TYPE (value));
+
+ return size_binop (MULT_EXPR, size_binop (FLOOR_DIV_EXPR, value, arg), arg);
}
\f
/* Set the size, mode and alignment of a ..._DECL node.
else
{
if (const_size)
- var_size
- = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size));
+ var_size = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size));
+
TYPE_SIZE (rec) = var_size;
}
TYPE_BINFO_SIZE_UNIT (rec)
= convert (sizetype,
size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec),
- size_int (BITS_PER_UNIT)));
+ bitsize_int (BITS_PER_UNIT)));
}
{
/* The initial subtraction should happen in the original type so
that (possible) negative values are handled appropriately. */
length = size_binop (PLUS_EXPR, size_one_node,
- fold (build (MINUS_EXPR, TREE_TYPE (lb),
- ub, lb)));
+ convert (sizetype,
+ fold (build (MINUS_EXPR,
+ TREE_TYPE (lb),
+ ub, lb))));
/* If neither bound is a constant and sizetype is signed, make
sure the size is never negative. We should really do this
element_size = integer_one_node;
}
- TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size, length);
+ TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
+ convert (bitsizetype, length));
/* If we know the size of the element, calculate the total
size directly, rather than do some division thing below.
Note that we can't do this in the case where the size of
the elements is one bit since TYPE_SIZE_UNIT cannot be
set correctly in that case. */
- if (TYPE_SIZE_UNIT (element) != 0
- && element_size != integer_one_node)
+ if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
TYPE_SIZE_UNIT (type)
= size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
}
TYPE_SIZE_UNIT (type)
= convert (sizetype,
size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
- size_int (BITS_PER_UNIT)));
+ bitsize_int (BITS_PER_UNIT)));
/* Once again evaluate only once, either now or as soon as safe. */
if (TYPE_SIZE_UNIT (type) != 0
pop_obstacks ();
resume_momentary (old);
+
+ /* If this type is created before sizetype has been permanently set,
+ record it so set_sizetype can fix it up. */
+ if (! sizetype_set)
+ {
+ TREE_CHAIN (type) = early_type_list;
+ early_type_list = type;
+ }
}
\f
/* Create and return a type for signed integers of PRECISION bits. */
TYPE_PRECISION (type) = precision;
- /* Create the extreme values based on the number of bits. */
-
- TYPE_MIN_VALUE (type)
- = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
- ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
- (((HOST_WIDE_INT) (-1)
- << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
- ? precision - HOST_BITS_PER_WIDE_INT - 1
- : 0))));
- TYPE_MAX_VALUE (type)
- = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
- ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
- (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
- ? (((HOST_WIDE_INT) 1
- << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
- : 0));
-
- /* Give this type's extreme values this type as their type. */
-
- TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
- TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
-
- /* The first type made with this or `make_unsigned_type'
- is the type for size values. */
- if (sizetype == 0)
- set_sizetype (type);
-
- /* Lay out the type: set its alignment, size, etc. */
- layout_type (type);
+ fixup_signed_type (type);
return type;
}
TYPE_PRECISION (type) = precision;
- /* The first type made with this or `make_signed_type'
- is the type for size values. */
-
- if (sizetype == 0)
- {
- TREE_UNSIGNED (type) = 1;
- set_sizetype (type);
- }
-
fixup_unsigned_type (type);
return type;
}
+\f
+/* Initialize sizetype and bitsizetype to a reasonable and temporary
+ value to enable integer types to be created. */
+
+void
+initialize_sizetypes ()
+{
+ tree t = make_node (INTEGER_TYPE);
+
+ /* Set this so we do something reasonable for the build_int_2 calls
+ below. */
+ integer_type_node = t;
+
+ TYPE_MODE (t) = SImode;
+ TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
+ TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0);
+ TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0);
+ TREE_UNSIGNED (t) = 1;
+ TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
+ TYPE_MIN_VALUE (t) = build_int_2 (0, 0);
+
+ /* 1000 avoids problems with possible overflow and is certainly
+ larger than any size value we'd want to be storing. */
+ TYPE_MAX_VALUE (t) = build_int_2 (1000, 0);
+
+ /* These two must be different nodes because of the caching done in
+ size_int_wide. */
+ sizetype = t;
+ bitsizetype = copy_node (t);
+ integer_type_node = 0;
+}
/* Set sizetype to TYPE, and initialize *sizetype accordingly.
Also update the type of any standard type's sizes made so far. */
precision. */
int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
2 * HOST_BITS_PER_WIDE_INT);
+ unsigned int i;
+ tree t, next;
+
+ if (sizetype_set)
+ abort ();
- sizetype = type;
+ /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
+ sizetype = copy_node (type);
bitsizetype = make_node (INTEGER_TYPE);
TYPE_NAME (bitsizetype) = TYPE_NAME (type);
TYPE_PRECISION (bitsizetype) = precision;
{
usizetype = sizetype;
ubitsizetype = bitsizetype;
- ssizetype = make_signed_type (oprecision);
- sbitsizetype = make_signed_type (precision);
+ ssizetype = copy_node (make_signed_type (oprecision));
+ sbitsizetype = copy_node (make_signed_type (precision));
}
else
{
ssizetype = sizetype;
sbitsizetype = bitsizetype;
- usizetype = make_unsigned_type (oprecision);
- ubitsizetype = make_unsigned_type (precision);
+ usizetype = copy_node (make_unsigned_type (oprecision));
+ ubitsizetype = copy_node (make_unsigned_type (precision));
}
- TYPE_NAME (bitsizetype) = TYPE_NAME (sizetype);
+
+ TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type");
+
+ for (i = 0; i < sizeof sizetype_tab / sizeof sizetype_tab[0]; i++)
+ TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1;
ggc_add_tree_root ((tree *) &sizetype_tab,
sizeof sizetype_tab / sizeof (tree));
-}
+ /* Go down each of the types we already made and set the proper type
+ for the sizes in them. */
+ for (t = early_type_list; t != 0; t = next)
+ {
+ next = TREE_CHAIN (t);
+ TREE_CHAIN (t) = 0;
+
+ if (TREE_CODE (t) != INTEGER_TYPE)
+ abort ();
+
+ TREE_TYPE (TYPE_SIZE (t)) = bitsizetype;
+ TREE_TYPE (TYPE_SIZE_UNIT (t)) = sizetype;
+ }
+
+ early_type_list = 0;
+ sizetype_set = 1;
+}
+\f
/* Set the extreme values of TYPE based on its precision in bits,
then lay it out. Used when make_signed_type won't do
because the tree code is not INTEGER_TYPE.
/* Return the alignment of MODE. This will be bounded by 1 and
BIGGEST_ALIGNMENT. */
-unsigned get_mode_alignment (mode)
+unsigned int
+get_mode_alignment (mode)
enum machine_mode mode;
{
unsigned alignment = GET_MODE_UNIT_SIZE (mode);
-@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000 Free Software Foundation, Inc.
+@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000
+@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
The default is to round @var{computed} up to a multiple of @var{specified}.
+@findex ROUND_TYPE_SIZE_UNIT
+@item ROUND_TYPE_SIZE_UNIT (@var{type}, @var{computed}, @var{specified})
+Similar to @code{ROUND_TYPE_SIZE}, but sizes and alignments are
+specified in units (bytes). If you define @code{ROUND_TYPE_SIZE},
+you must also define this macro and they must be defined consistently
+with each other.
+
@findex ROUND_TYPE_ALIGN
@item ROUND_TYPE_ALIGN (@var{type}, @var{computed}, @var{specified})
Define this macro as an expression for the alignment of a type (given
static void set_type_quals PARAMS ((tree, int));
static void append_random_chars PARAMS ((char *));
static void mark_type_hash PARAMS ((void *));
-static void fix_sizetype PARAMS ((tree));
/* If non-null, these are language-specific helper functions for
unsave_expr_now. If present, LANG_UNSAVE is called before its
error_mark_node = make_node (ERROR_MARK);
TREE_TYPE (error_mark_node) = error_mark_node;
+ initialize_sizetypes ();
+
/* Define both `signed char' and `unsigned char'. */
signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
integer_type_node = make_signed_type (INT_TYPE_SIZE);
- /* Define an unsigned integer first. make_unsigned_type and make_signed_type
- both call set_sizetype for the first type that we create, and we want this
- to be large enough to hold the sizes of various types until we switch to
- the real sizetype. */
unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
}
-/* For type TYPE, fill in the proper type for TYPE_SIZE and TYPE_SIZE_UNIT. */
-
-static void
-fix_sizetype (type)
- tree type;
-{
- TREE_TYPE (TYPE_SIZE (type)) = bitsizetype;
- TREE_TYPE (TYPE_SIZE_UNIT (type)) = sizetype;
-}
-
/* Call this function after calling build_common_tree_nodes and set_sizetype.
- It will fix the previously made nodes to have proper references to
- sizetype, and it will create several other common tree nodes. */
+ It will create several other common tree nodes. */
void
build_common_tree_nodes_2 (short_double)
int short_double;
{
- fix_sizetype (signed_char_type_node);
- fix_sizetype (unsigned_char_type_node);
- fix_sizetype (char_type_node);
- fix_sizetype (short_integer_type_node);
- fix_sizetype (short_unsigned_type_node);
- fix_sizetype (integer_type_node);
- fix_sizetype (unsigned_type_node);
- fix_sizetype (long_unsigned_type_node);
- fix_sizetype (long_integer_type_node);
- fix_sizetype (long_long_integer_type_node);
- fix_sizetype (long_long_unsigned_type_node);
-
- fix_sizetype (intQI_type_node);
- fix_sizetype (intHI_type_node);
- fix_sizetype (intSI_type_node);
- fix_sizetype (intDI_type_node);
- fix_sizetype (intTI_type_node);
- fix_sizetype (unsigned_intQI_type_node);
- fix_sizetype (unsigned_intHI_type_node);
- fix_sizetype (unsigned_intSI_type_node);
- fix_sizetype (unsigned_intDI_type_node);
- fix_sizetype (unsigned_intTI_type_node);
-
integer_zero_node = build_int_2 (0, 0);
TREE_TYPE (integer_zero_node) = integer_type_node;
integer_one_node = build_int_2 (1, 0);
its size. */
#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
+/* In an INTEGER_TYPE, it means the type represents a size. We use this
+ both for validity checking and to permit optimziations that are unsafe
+ for other types. */
+#define TYPE_IS_SIZETYPE(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
+
/* Nonzero in a type considered volatile as a whole. */
#define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
extern tree make_signed_type PARAMS ((int));
extern tree make_unsigned_type PARAMS ((int));
+extern void initialize_sizetypes PARAMS ((void));
extern void set_sizetype PARAMS ((tree));
extern tree signed_or_unsigned_type PARAMS ((int, tree));
extern void fixup_unsigned_type PARAMS ((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));
+
+/* Define data structures, macros, and functions for handling sizes
+ and the various types used to represent sizes. */
+
+enum size_type_kind
+{
+ SIZETYPE, /* Normal representation of sizes in bytes. */
+ SSIZETYPE, /* Signed representation of sizes in bytes. */
+ USIZETYPE, /* Unsigned representation of sizes in bytes. */
+ BITSIZETYPE, /* Normal representation of sizes in bits. */
+ SBITSIZETYPE, /* Signed representation of sizes in bits. */
+ UBITSIZETYPE, /* Unsifgned representation of sizes in bits. */
+ TYPE_KIND_LAST};
+
+extern tree sizetype_tab[(int) TYPE_KIND_LAST];
+
+#define sizetype sizetype_tab[(int) SIZETYPE]
+#define bitsizetype sizetype_tab[(int) BITSIZETYPE]
+#define ssizetype sizetype_tab[(int) SSIZETYPE]
+#define usizetype sizetype_tab[(int) USIZETYPE]
+#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
+#define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]
+
extern tree size_binop PARAMS ((enum tree_code, tree, tree));
-extern tree ssize_binop PARAMS ((enum tree_code, tree, tree));
-extern tree size_int_wide PARAMS ((HOST_WIDE_INT, int));
+extern tree size_diffop PARAMS ((tree, tree));
+extern tree size_int_wide PARAMS ((HOST_WIDE_INT,
+ enum size_type_kind));
+extern tree size_int_type_wide PARAMS ((HOST_WIDE_INT, tree));
-#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), 0)
-#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), 1)
+#define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
+#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
+#define ssize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SSIZETYPE)
+#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
+#define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)
extern tree round_up PARAMS ((tree, int));
extern tree get_pending_sizes PARAMS ((void));
+ (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
+ (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
-struct sizetype_tab
-{
- tree xsizetype, xbitsizetype;
- tree xssizetype, xusizetype;
- tree xsbitsizetype, xubitsizetype;
-};
-
-extern struct sizetype_tab sizetype_tab;
-
-#define sizetype sizetype_tab.xsizetype
-#define bitsizetype sizetype_tab.xbitsizetype
-#define ssizetype sizetype_tab.xssizetype
-#define usizetype sizetype_tab.xusizetype
-#define sbitsizetype sizetype_tab.xsbitsizetype
-#define ubitsizetype sizetype_tab.xubitsizetype
-
/* If nonzero, an upper limit on alignment of structure fields, in bits. */
extern unsigned int maximum_field_alignment;
OSDN Git Service
