aboutsummaryrefslogtreecommitdiff
path: root/gcc/ch
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/ch')
-rw-r--r--gcc/ch/ChangeLog14
-rw-r--r--gcc/ch/actions.c72
-rw-r--r--gcc/ch/convert.c22
-rw-r--r--gcc/ch/expr.c23
-rw-r--r--gcc/ch/tree.c9
-rw-r--r--gcc/ch/typeck.c54
6 files changed, 113 insertions, 81 deletions
diff --git a/gcc/ch/ChangeLog b/gcc/ch/ChangeLog
index e8501c9..35df1ba 100644
--- a/gcc/ch/ChangeLog
+++ b/gcc/ch/ChangeLog
@@ -1,3 +1,17 @@
+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.
diff --git a/gcc/ch/actions.c b/gcc/ch/actions.c
index b07a532..c97c1b6 100644
--- a/gcc/ch/actions.c
+++ b/gcc/ch/actions.c
@@ -1,5 +1,6 @@
/* 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.
@@ -466,13 +467,12 @@ check_non_null (expr)
return expr;
}
-/*
- * 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;
@@ -558,10 +558,10 @@ chill_convert_for_assignment (type, expr, place)
}
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)
{
@@ -569,6 +569,7 @@ chill_convert_for_assignment (type, expr, place)
tree new_list = NULL_TREE;
long index;
tree element;
+
for (element = TREE_OPERAND (result, 1);
element != NULL_TREE;
element = TREE_CHAIN (element))
@@ -579,18 +580,21 @@ chill_convert_for_assignment (type, expr, place)
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:
@@ -1697,11 +1701,12 @@ chill_expand_assignment (lhs, modifycode, rhs)
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)
@@ -1750,19 +1755,22 @@ chill_expand_assignment (lhs, modifycode, rhs)
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;
@@ -1812,7 +1820,7 @@ expand_varying_length_assignment (lhs, rhs)
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));
}
diff --git a/gcc/ch/convert.c b/gcc/ch/convert.c
index 80405da..dcea057 100644
--- a/gcc/ch/convert.c
+++ b/gcc/ch/convert.c
@@ -1,5 +1,6 @@
/* 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.
@@ -858,14 +859,12 @@ digest_array_tuple (type, init, allow_missing_elements)
}
/* 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)
@@ -1058,16 +1057,17 @@ convert (type, expr)
{
/* 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)
{
diff --git a/gcc/ch/expr.c b/gcc/ch/expr.c
index 13e5bd8..b4bdf35 100644
--- a/gcc/ch/expr.c
+++ b/gcc/ch/expr.c
@@ -1,6 +1,7 @@
/* 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.
@@ -2264,8 +2265,9 @@ build_chill_sizeof (type)
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
@@ -3344,9 +3346,9 @@ build_concat_expr (op0, op1)
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
@@ -4250,15 +4252,16 @@ build_chill_repetition_op (count_op, string)
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;
}
diff --git a/gcc/ch/tree.c b/gcc/ch/tree.c
index 88fd5ff..53485db 100644
--- a/gcc/ch/tree.c
+++ b/gcc/ch/tree.c
@@ -1,5 +1,6 @@
/* 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.
@@ -65,9 +66,9 @@ build_string_type (elt_type, length)
/* 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;
@@ -289,7 +290,9 @@ discrete_count (t)
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);
}
diff --git a/gcc/ch/typeck.c b/gcc/ch/typeck.c
index 5082b78..8c74896 100644
--- a/gcc/ch/typeck.c
+++ b/gcc/ch/typeck.c
@@ -1,5 +1,6 @@
/* 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.
@@ -215,17 +216,17 @@ build_chill_slice (array, min_value, length)
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);
@@ -408,13 +409,15 @@ build_chill_slice_with_range (array, min_value, max_value)
&& 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;
@@ -450,9 +453,10 @@ build_chill_slice_with_length (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,
@@ -1208,22 +1212,22 @@ build_chill_cast (type, expr)
return expr;
}
-/*
- * 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,
@@ -3371,9 +3375,9 @@ smash_dummy_type (type)
{
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)