Commit 7a18b933 by Nathan Sidwell Committed by Nathan Sidwell

cp-tree.h (finish_sizeof, [...]): Remove.

cp:
	* cp-tree.h (finish_sizeof, finish_alignof): Remove.
	(expr_sizeof): Replace with ...
	(cxx_sizeof_or_alignof_expr): ... here.
	(cxx_sizeof_or_alignof_type): Make complain parameter a bool.
	* parser.c (cp_parser_unary_expression): Commonize alignof and
	sizeof handling.
	* pt.c (tsubst_copy_and_build): Adjust alignof and sizeof
	substitution.
	* semantics.c (finish_sizeof, finish_alignof): Remove.
	* typeck.c (cxx_sizeof_or_alignof_type): Complain parameter
	becomes bool. Set TREE_READONLY.
	(expr_sizeof): Replace with ...
	(cxx_sizeof_or_alignof_expr): ... here. Clear TREE_SIDE_EFFECTS.

From-SVN: r71054
parent b379a593
2003-09-04 Nathan Sidwell <nathan@codesourcery.com>
* cp-tree.h (finish_sizeof, finish_alignof): Remove.
(expr_sizeof): Replace with ...
(cxx_sizeof_or_alignof_expr): ... here.
(cxx_sizeof_or_alignof_type): Make complain parameter a bool.
* parser.c (cp_parser_unary_expression): Commonize alignof and
sizeof handling.
* pt.c (tsubst_copy_and_build): Adjust alignof and sizeof
substitution.
* semantics.c (finish_sizeof, finish_alignof): Remove.
* typeck.c (cxx_sizeof_or_alignof_type): Complain parameter
becomes bool. Set TREE_READONLY.
(expr_sizeof): Replace with ...
(cxx_sizeof_or_alignof_expr): ... here. Clear TREE_SIDE_EFFECTS.
2003-09-04 Mark Mitchell <mark@codesourcery.com> 2003-09-04 Mark Mitchell <mark@codesourcery.com>
Remove cast-as-lvalue extension. Remove cast-as-lvalue extension.
......
...@@ -4137,8 +4137,6 @@ extern tree finish_id_expression (tree, tree, tree, ...@@ -4137,8 +4137,6 @@ extern tree finish_id_expression (tree, tree, tree,
bool, bool, bool *, bool, bool, bool *,
const char **); const char **);
extern tree finish_typeof (tree); extern tree finish_typeof (tree);
extern tree finish_sizeof (tree);
extern tree finish_alignof (tree);
extern void finish_decl_cleanup (tree, tree); extern void finish_decl_cleanup (tree, tree);
extern void finish_eh_cleanup (tree); extern void finish_eh_cleanup (tree);
extern void expand_body (tree); extern void expand_body (tree);
...@@ -4248,8 +4246,8 @@ extern bool comptypes (tree, tree, int); ...@@ -4248,8 +4246,8 @@ extern bool comptypes (tree, tree, int);
extern bool compparms (tree, tree); extern bool compparms (tree, tree);
extern int comp_cv_qualification (tree, tree); extern int comp_cv_qualification (tree, tree);
extern int comp_cv_qual_signature (tree, tree); extern int comp_cv_qual_signature (tree, tree);
extern tree expr_sizeof (tree); extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code);
extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, int); extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool);
#define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false) #define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false)
extern tree inline_conversion (tree); extern tree inline_conversion (tree);
extern tree decay_conversion (tree); extern tree decay_conversion (tree);
......
...@@ -3969,32 +3969,21 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p) ...@@ -3969,32 +3969,21 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p)
switch (keyword) switch (keyword)
{ {
case RID_ALIGNOF: case RID_ALIGNOF:
{
/* Consume the `alignof' token. */
cp_lexer_consume_token (parser->lexer);
/* Parse the operand. */
return finish_alignof (cp_parser_sizeof_operand
(parser, keyword));
}
case RID_SIZEOF: case RID_SIZEOF:
{ {
tree operand; tree operand;
enum tree_code op;
/* Consume the `sizeof' token. */ op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
/* Consume the token. */
cp_lexer_consume_token (parser->lexer); cp_lexer_consume_token (parser->lexer);
/* Parse the operand. */ /* Parse the operand. */
operand = cp_parser_sizeof_operand (parser, keyword); operand = cp_parser_sizeof_operand (parser, keyword);
/* If the type of the operand cannot be determined build a if (TYPE_P (operand))
SIZEOF_EXPR. */ return cxx_sizeof_or_alignof_type (operand, op, true);
if (TYPE_P (operand)
? dependent_type_p (operand)
: type_dependent_expression_p (operand))
return build_min (SIZEOF_EXPR, size_type_node, operand);
/* Otherwise, compute the constant value. */
else else
return finish_sizeof (operand); return cxx_sizeof_or_alignof_expr (operand, op);
} }
case RID_NEW: case RID_NEW:
......
...@@ -8048,10 +8048,10 @@ tsubst_copy_and_build (tree t, ...@@ -8048,10 +8048,10 @@ tsubst_copy_and_build (tree t,
op1 = RECUR (op1); op1 = RECUR (op1);
--skip_evaluation; --skip_evaluation;
} }
if (TREE_CODE (t) == SIZEOF_EXPR) if (TYPE_P (op1))
return finish_sizeof (op1); return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
else else
return finish_alignof (op1); return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
case MODOP_EXPR: case MODOP_EXPR:
return build_x_modify_expr return build_x_modify_expr
......
...@@ -2668,26 +2668,6 @@ finish_typeof (tree expr) ...@@ -2668,26 +2668,6 @@ finish_typeof (tree expr)
return type; return type;
} }
/* Compute the value of the `sizeof' operator. */
tree
finish_sizeof (tree t)
{
return TYPE_P (t) ? cxx_sizeof (t) : expr_sizeof (t);
}
/* Implement the __alignof keyword: Return the minimum required
alignment of T, measured in bytes. */
tree
finish_alignof (tree t)
{
if (processing_template_decl)
return build_min (ALIGNOF_EXPR, size_type_node, t);
return TYPE_P (t) ? cxx_alignof (t) : c_alignof_expr (t);
}
/* Generate RTL for the statement T, and its substatements, and any /* Generate RTL for the statement T, and its substatements, and any
other statements at its nesting level. */ other statements at its nesting level. */
......
...@@ -1177,16 +1177,26 @@ compparms (tree parms1, tree parms2) ...@@ -1177,16 +1177,26 @@ compparms (tree parms1, tree parms2)
} }
/* Process a sizeof or alignof expression where the operand is a
type. */
tree tree
cxx_sizeof_or_alignof_type (tree type, enum tree_code op, int complain) cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
{ {
enum tree_code type_code; enum tree_code type_code;
tree value; tree value;
const char *op_name; const char *op_name;
my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720); my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
if (type == error_mark_node)
return error_mark_node;
if (processing_template_decl) if (processing_template_decl)
return build_min (op, size_type_node, type); {
value = build_min (op, size_type_node, type);
TREE_READONLY (value) = 1;
return value;
}
op_name = operator_name_info[(int) op].name; op_name = operator_name_info[(int) op].name;
...@@ -1205,30 +1215,46 @@ cxx_sizeof_or_alignof_type (tree type, enum tree_code op, int complain) ...@@ -1205,30 +1215,46 @@ cxx_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
return value; return value;
} }
/* Process a sizeof or alignof expression where the operand is an
expression. */
tree tree
expr_sizeof (tree e) cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
{ {
const char *op_name = operator_name_info[(int) op].name;
if (e == error_mark_node)
return error_mark_node;
if (processing_template_decl) if (processing_template_decl)
return build_min (SIZEOF_EXPR, size_type_node, e); {
e = build_min (op, size_type_node, e);
TREE_SIDE_EFFECTS (e) = 0;
TREE_READONLY (e) = 1;
return e;
}
if (TREE_CODE (e) == COMPONENT_REF if (TREE_CODE (e) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
error ("sizeof applied to a bit-field");
if (is_overloaded_fn (e))
{ {
pedwarn ("ISO C++ forbids applying `sizeof' to an expression of function type"); error ("invalid application of `%s' to a bit-field", op_name);
return c_sizeof (char_type_node); e = char_type_node;
}
else if (is_overloaded_fn (e))
{
pedwarn ("ISO C++ forbids applying `%s' to an expression of function type", op_name);
e = char_type_node;
} }
else if (type_unknown_p (e)) else if (type_unknown_p (e))
{ {
cxx_incomplete_type_error (e, TREE_TYPE (e)); cxx_incomplete_type_error (e, TREE_TYPE (e));
return c_sizeof (char_type_node); e = char_type_node;
} }
else
if (e == error_mark_node) e = TREE_TYPE (e);
return e;
return cxx_sizeof_or_alignof_type (e, op, true);
return cxx_sizeof (TREE_TYPE (e));
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment