[gcc.git] / gcc / c-convert.c

/* Language-level data type conversion for GNU C.
   Copyright (C) 1987, 1988, 1991 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */


/* This file contains the functions for converting C expressions
   to different data types.  The only entry point is `convert'.
   Every language front end must have a `convert' function
   but what kind of conversions it does will depend on the language.  */

#include "config.h"
#include "tree.h"
#include "flags.h"

/* Change of width--truncation and extension of integers or reals--
   is represented with NOP_EXPR.  Proper functioning of many things
   assumes that no other conversions can be NOP_EXPRs.

   Conversion between integer and pointer is represented with CONVERT_EXPR.
   Converting integer to real uses FLOAT_EXPR
   and real to integer uses FIX_TRUNC_EXPR.

   Here is a list of all the functions that assume that widening and
   narrowing is always done with a NOP_EXPR:
     In c-convert.c, convert_to_integer.
     In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
     In expr.c: expand_expr, for operands of a MULT_EXPR.
     In fold-const.c: fold.
     In tree.c: get_narrower and get_unwidened.  */
\f
/* Subroutines of `convert'.  */

static tree
convert_to_pointer (type, expr)
     tree type, expr;
{
  register tree intype = TREE_TYPE (expr);
  register enum tree_code form = TREE_CODE (intype);
  
  if (integer_zerop (expr))
    {
      if (type == TREE_TYPE (null_pointer_node))
	return null_pointer_node;
      expr = build_int_2 (0, 0);
      TREE_TYPE (expr) = type;
      return expr;
    }

  if (form == POINTER_TYPE)
    return build1 (NOP_EXPR, type, expr);


  if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
    {
      if (type_precision (intype) == POINTER_SIZE)
	return build1 (CONVERT_EXPR, type, expr);
      expr = convert (type_for_size (POINTER_SIZE, 0), expr);
      if (TYPE_MODE (TREE_TYPE (expr)) != TYPE_MODE (type))
	/* There is supposed to be some integral type
	   that is the same width as a pointer.  */
	abort ();
      return convert_to_pointer (type, expr);
    }

  error ("cannot convert to a pointer type");

  return null_pointer_node;
}

static tree
convert_to_real (type, expr)
     tree type, expr;
{
  register enum tree_code form = TREE_CODE (TREE_TYPE (expr));

  if (form == REAL_TYPE)
    return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
		   type, expr);

  if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
    return build1 (FLOAT_EXPR, type, expr);

  if (form == POINTER_TYPE)
    error ("pointer value used where a float was expected");
  else
    error ("aggregate value used where a float was expected");

  {
    register tree tem = make_node (REAL_CST);
    TREE_TYPE (tem) = type;
    TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0");
    return tem;
  }
}
\f
/* The result of this is always supposed to be a newly created tree node
   not in use in any existing structure.  */

static tree
convert_to_integer (type, expr)
     tree type, expr;
{
  register tree intype = TREE_TYPE (expr);
  register enum tree_code form = TREE_CODE (intype);

  if (form == POINTER_TYPE)
    {
      if (integer_zerop (expr))
	expr = integer_zero_node;
      else
	expr = fold (build1 (CONVERT_EXPR,
			     type_for_size (POINTER_SIZE, 0), expr));
      intype = TREE_TYPE (expr);
      form = TREE_CODE (intype);
      if (intype == type)
	return expr;
    }

  if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
    {
      register unsigned outprec = TYPE_PRECISION (type);
      register unsigned inprec = TYPE_PRECISION (intype);
      register enum tree_code ex_form = TREE_CODE (expr);

      if (outprec >= inprec)
	return build1 (NOP_EXPR, type, expr);

/* Here detect when we can distribute the truncation down past some arithmetic.
   For example, if adding two longs and converting to an int,
   we can equally well convert both to ints and then add.
   For the operations handled here, such truncation distribution
   is always safe.
   It is desirable in these cases:
   1) when truncating down to full-word from a larger size
   2) when truncating takes no work.
   3) when at least one operand of the arithmetic has been extended
   (as by C's default conversions).  In this case we need two conversions
   if we do the arithmetic as already requested, so we might as well
   truncate both and then combine.  Perhaps that way we need only one.

   Note that in general we cannot do the arithmetic in a type
   shorter than the desired result of conversion, even if the operands
   are both extended from a shorter type, because they might overflow
   if combined in that type.  The exceptions to this--the times when
   two narrow values can be combined in their narrow type even to
   make a wider result--are handled by "shorten" in build_binary_op.  */

      switch (ex_form)
	{
	case RSHIFT_EXPR:
	  /* We can pass truncation down through right shifting
	     when the shift count is a negative constant.  */
	  if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
	      || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
	    break;
	  goto trunc1;

	case LSHIFT_EXPR:
	  /* We can pass truncation down through left shifting
	     when the shift count is a positive constant.  */
	  if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
	      || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
	    break;
	  /* In this case, shifting is like multiplication.  */
	  goto trunc1;

	case MAX_EXPR:
	case MIN_EXPR:
	case MULT_EXPR:
	  {
	    tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
	    tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);

	    /* Don't distribute unless the output precision is at least as big
	       as the actual inputs.  Otherwise, the comparison of the
	       truncated values will be wrong.  */
	    if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
		&& outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
		/* If signedness of arg0 and arg1 don't match,
		   we can't necessarily find a type to compare them in.  */
		&& (TREE_UNSIGNED (TREE_TYPE (arg0))
		    == TREE_UNSIGNED (TREE_TYPE (arg1))))
	      goto trunc1;
	    break;
	  }

	case PLUS_EXPR:
	case MINUS_EXPR:
	case BIT_AND_EXPR:
	case BIT_IOR_EXPR:
	case BIT_XOR_EXPR:
	case BIT_ANDTC_EXPR:
	trunc1:
	  {
	    tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
	    tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);

	    if (outprec >= BITS_PER_WORD
		|| TRULY_NOOP_TRUNCATION (outprec, inprec)
		|| inprec > TYPE_PRECISION (TREE_TYPE (arg0))
		|| inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
	      {
		/* Do the arithmetic in type TYPEX,
		   then convert result to TYPE.  */
		register tree typex = type;

		/* Can't do arithmetic in enumeral types
		   so use an integer type that will hold the values.  */
		if (TREE_CODE (typex) == ENUMERAL_TYPE)
		  typex = type_for_size (TYPE_PRECISION (typex),
					 TREE_UNSIGNED (typex));

		/* But now perhaps TYPEX is as wide as INPREC.
		   In that case, do nothing special here.
		   (Otherwise would recurse infinitely in convert.  */
		if (TYPE_PRECISION (typex) != inprec)
		  {
		    /* Don't do unsigned arithmetic where signed was wanted,
		       or vice versa.
		       Exception: if either of the original operands were
		       unsigned then can safely do the work as unsigned.
		       And we may need to do it as unsigned
		       if we truncate to the original size.  */
		    typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
			      || TREE_UNSIGNED (TREE_TYPE (arg0))
			      || TREE_UNSIGNED (TREE_TYPE (arg1)))
			     ? unsigned_type (typex) : signed_type (typex));
		    return convert (type,
				    build_binary_op (ex_form,
						     convert (typex, arg0),
						     convert (typex, arg1),
						     0));
		  }
	      }
	  }
	  break;

	case EQ_EXPR:
	case NE_EXPR:
	case GT_EXPR:
	case GE_EXPR:
	case LT_EXPR:
	case LE_EXPR:
	case TRUTH_AND_EXPR:
	case TRUTH_ANDIF_EXPR:
	case TRUTH_OR_EXPR:
	case TRUTH_ORIF_EXPR:
	case TRUTH_NOT_EXPR:
	  /* If we want result of comparison converted to a byte,
	     we can just regard it as a byte, since it is 0 or 1.  */
	  TREE_TYPE (expr) = type;
	  return expr;

	case NEGATE_EXPR:
	case BIT_NOT_EXPR:
	case ABS_EXPR:
	  {
	    register tree typex = type;

	    /* Can't do arithmetic in enumeral types
	       so use an integer type that will hold the values.  */
	    if (TREE_CODE (typex) == ENUMERAL_TYPE)
	      typex = type_for_size (TYPE_PRECISION (typex),
				     TREE_UNSIGNED (typex));

	    /* But now perhaps TYPEX is as wide as INPREC.
	       In that case, do nothing special here.
	       (Otherwise would recurse infinitely in convert.  */
	    if (TYPE_PRECISION (typex) != inprec)
	      {
		/* Don't do unsigned arithmetic where signed was wanted,
		   or vice versa.  */
		typex = (TREE_UNSIGNED (TREE_TYPE (expr))
			 ? unsigned_type (typex) : signed_type (typex));
		return convert (type,
				build_unary_op (ex_form,
						convert (typex, TREE_OPERAND (expr, 0)),
						1));
	      }
	  }

	case NOP_EXPR:
	  /* If truncating after truncating, might as well do all at once.
	     If truncating after extending, we may get rid of wasted work.  */
	  return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));

	case COND_EXPR:
	  /* Can treat the two alternative values like the operands
	     of an arithmetic expression.  */
	  {
	    tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
	    tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);

	    if (outprec >= BITS_PER_WORD
		|| TRULY_NOOP_TRUNCATION (outprec, inprec)
		|| inprec > TYPE_PRECISION (TREE_TYPE (arg1))
		|| inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
	      {
		/* Do the arithmetic in type TYPEX,
		   then convert result to TYPE.  */
		register tree typex = type;

		/* Can't do arithmetic in enumeral types
		   so use an integer type that will hold the values.  */
		if (TREE_CODE (typex) == ENUMERAL_TYPE)
		  typex = type_for_size (TYPE_PRECISION (typex),
					 TREE_UNSIGNED (typex));

		/* But now perhaps TYPEX is as wide as INPREC.
		   In that case, do nothing special here.
		   (Otherwise would recurse infinitely in convert.  */
		if (TYPE_PRECISION (typex) != inprec)
		  {
		    /* Don't do unsigned arithmetic where signed was wanted,
		       or vice versa.  */
		    typex = (TREE_UNSIGNED (TREE_TYPE (expr))
			     ? unsigned_type (typex) : signed_type (typex));
		    return convert (type,
				    fold (build (COND_EXPR, typex,
						 TREE_OPERAND (expr, 0),
						 convert (typex, arg1),
						 convert (typex, arg2))));
		  }
	      }
	  }
	}

      return build1 (NOP_EXPR, type, expr);
    }

  if (form == REAL_TYPE)
    return build1 (FIX_TRUNC_EXPR, type, expr);

  error ("aggregate value used where an integer was expected");

  {
    register tree tem = build_int_2 (0, 0);
    TREE_TYPE (tem) = type;
    return tem;
  }
}
\f
/* Create an expression whose value is that of EXPR,
   converted to type TYPE.  The TREE_TYPE of the value
   is always TYPE.  This function implements all reasonable
   conversions; callers should filter out those that are
   not permitted by the language being compiled.  */

tree
convert (type, expr)
     tree type, expr;
{
  register tree e = expr;
  register enum tree_code code = TREE_CODE (type);

  if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
    return expr;
  if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
    return error_mark_node;
  if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
    {
      error ("void value not ignored as it ought to be");
      return error_mark_node;
    }
  if (code == VOID_TYPE)
    return build1 (CONVERT_EXPR, type, e);
#if 0
  /* This is incorrect.  A truncation can't be stripped this way.
     Extensions will be stripped by the use of get_unwidened.  */
  if (TREE_CODE (expr) == NOP_EXPR)
    return convert (type, TREE_OPERAND (expr, 0));
#endif
  if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
    return fold (convert_to_integer (type, e));
  if (code == POINTER_TYPE)
    return fold (convert_to_pointer (type, e));
  if (code == REAL_TYPE)
    return fold (convert_to_real (type, e));

  error ("conversion to non-scalar type requested");
  return error_mark_node;
}
Commit	Line	Data
0e48b5a2 RS	1	/* Language-level data type conversion for GNU C.
	2	Copyright (C) 1987, 1988, 1991 Free Software Foundation, Inc.
	3
	4	This file is part of GNU CC.
	5
	6	GNU CC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU CC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU CC; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20
	21	/* This file contains the functions for converting C expressions
	22	to different data types. The only entry point is `convert'.
	23	Every language front end must have a `convert' function
	24	but what kind of conversions it does will depend on the language. */
	25
	26	#include "config.h"
	27	#include "tree.h"
	28	#include "flags.h"
	29
	30	/* Change of width--truncation and extension of integers or reals--
	31	is represented with NOP_EXPR. Proper functioning of many things
	32	assumes that no other conversions can be NOP_EXPRs.
	33
	34	Conversion between integer and pointer is represented with CONVERT_EXPR.
	35	Converting integer to real uses FLOAT_EXPR
	36	and real to integer uses FIX_TRUNC_EXPR.
	37
	38	Here is a list of all the functions that assume that widening and
	39	narrowing is always done with a NOP_EXPR:
	40	In c-convert.c, convert_to_integer.
	41	In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
	42	In expr.c: expand_expr, for operands of a MULT_EXPR.
	43	In fold-const.c: fold.
	44	In tree.c: get_narrower and get_unwidened. */
	45	\f
	46	/* Subroutines of `convert'. */
	47
	48	static tree
	49	convert_to_pointer (type, expr)
	50	tree type, expr;
	51	{
	52	register tree intype = TREE_TYPE (expr);
	53	register enum tree_code form = TREE_CODE (intype);
	54
	55	if (integer_zerop (expr))
	56	{
	57	if (type == TREE_TYPE (null_pointer_node))
	58	return null_pointer_node;
	59	expr = build_int_2 (0, 0);
	60	TREE_TYPE (expr) = type;
	61	return expr;
	62	}
	63
	64	if (form == POINTER_TYPE)
65	return build1 (NOP_EXPR, type, expr);
66
67
68	if (form == INTEGER_TYPE \|\| form == ENUMERAL_TYPE)
69	{
70	if (type_precision (intype) == POINTER_SIZE)
71	return build1 (CONVERT_EXPR, type, expr);
72	expr = convert (type_for_size (POINTER_SIZE, 0), expr);
73	if (TYPE_MODE (TREE_TYPE (expr)) != TYPE_MODE (type))
74	/* There is supposed to be some integral type
75	that is the same width as a pointer. */
76	abort ();
77	return convert_to_pointer (type, expr);
78	}
79
80	error ("cannot convert to a pointer type");
81
82	return null_pointer_node;
83	}
84
85	static tree
86	convert_to_real (type, expr)
87	tree type, expr;
88	{
89	register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
90
91	if (form == REAL_TYPE)
92	return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
93	type, expr);
94
95	if (form == INTEGER_TYPE \|\| form == ENUMERAL_TYPE)
96	return build1 (FLOAT_EXPR, type, expr);
97
98	if (form == POINTER_TYPE)
99	error ("pointer value used where a float was expected");
100	else
101	error ("aggregate value used where a float was expected");
102
103	{
104	register tree tem = make_node (REAL_CST);
105	TREE_TYPE (tem) = type;
106	TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0");
107	return tem;
108	}
109	}
110	\f
111	/* The result of this is always supposed to be a newly created tree node
112	not in use in any existing structure. */
113
114	static tree
115	convert_to_integer (type, expr)
116	tree type, expr;
117	{
118	register tree intype = TREE_TYPE (expr);
119	register enum tree_code form = TREE_CODE (intype);
120
121	if (form == POINTER_TYPE)
122	{
123	if (integer_zerop (expr))
124	expr = integer_zero_node;
125	else
126	expr = fold (build1 (CONVERT_EXPR,
127	type_for_size (POINTER_SIZE, 0), expr));
128	intype = TREE_TYPE (expr);
129	form = TREE_CODE (intype);
130	if (intype == type)
131	return expr;
132	}
133
134	if (form == INTEGER_TYPE \|\| form == ENUMERAL_TYPE)
135	{
136	register unsigned outprec = TYPE_PRECISION (type);
137	register unsigned inprec = TYPE_PRECISION (intype);
138	register enum tree_code ex_form = TREE_CODE (expr);
139
140	if (outprec >= inprec)
141	return build1 (NOP_EXPR, type, expr);
142
143	/* Here detect when we can distribute the truncation down past some arithmetic.
144	For example, if adding two longs and converting to an int,
145	we can equally well convert both to ints and then add.
146	For the operations handled here, such truncation distribution
147	is always safe.
148	It is desirable in these cases:
149	1) when truncating down to full-word from a larger size
150	2) when truncating takes no work.
151	3) when at least one operand of the arithmetic has been extended
152	(as by C's default conversions). In this case we need two conversions
153	if we do the arithmetic as already requested, so we might as well
154	truncate both and then combine. Perhaps that way we need only one.
155
156	Note that in general we cannot do the arithmetic in a type
157	shorter than the desired result of conversion, even if the operands
158	are both extended from a shorter type, because they might overflow
159	if combined in that type. The exceptions to this--the times when
160	two narrow values can be combined in their narrow type even to
161	make a wider result--are handled by "shorten" in build_binary_op. */
162
163	switch (ex_form)
164	{
165	case RSHIFT_EXPR:
166	/* We can pass truncation down through right shifting
167	when the shift count is a negative constant. */
168	if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
169	\|\| TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
170	break;
171	goto trunc1;
172
173	case LSHIFT_EXPR:
174	/* We can pass truncation down through left shifting
175	when the shift count is a positive constant. */
176	if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
177	\|\| TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
178	break;
179	/* In this case, shifting is like multiplication. */
180	goto trunc1;
181
182	case MAX_EXPR:
183	case MIN_EXPR:
184	case MULT_EXPR:
185	{
186	tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
187	tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
188
189	/* Don't distribute unless the output precision is at least as big
190	as the actual inputs. Otherwise, the comparison of the
191	truncated values will be wrong. */
192	if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
193	&& outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
194	/* If signedness of arg0 and arg1 don't match,
195	we can't necessarily find a type to compare them in. */
196	&& (TREE_UNSIGNED (TREE_TYPE (arg0))
197	== TREE_UNSIGNED (TREE_TYPE (arg1))))
198	goto trunc1;
199	break;
200	}
201
202	case PLUS_EXPR:
203	case MINUS_EXPR:
204	case BIT_AND_EXPR:
205	case BIT_IOR_EXPR:
206	case BIT_XOR_EXPR:
207	case BIT_ANDTC_EXPR:
208	trunc1:
209	{
210	tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
211	tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
212
213	if (outprec >= BITS_PER_WORD
214	\|\| TRULY_NOOP_TRUNCATION (outprec, inprec)
215	\|\| inprec > TYPE_PRECISION (TREE_TYPE (arg0))
216	\|\| inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
217	{
218	/* Do the arithmetic in type TYPEX,
219	then convert result to TYPE. */
220	register tree typex = type;
221
222	/* Can't do arithmetic in enumeral types
223	so use an integer type that will hold the values. */
224	if (TREE_CODE (typex) == ENUMERAL_TYPE)
225	typex = type_for_size (TYPE_PRECISION (typex),
226	TREE_UNSIGNED (typex));
227
228	/* But now perhaps TYPEX is as wide as INPREC.
229	In that case, do nothing special here.
230	(Otherwise would recurse infinitely in convert. */
231	if (TYPE_PRECISION (typex) != inprec)
232	{
233	/* Don't do unsigned arithmetic where signed was wanted,
234	or vice versa.
235	Exception: if either of the original operands were
236	unsigned then can safely do the work as unsigned.
237	And we may need to do it as unsigned
238	if we truncate to the original size. */
239	typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
240	\|\| TREE_UNSIGNED (TREE_TYPE (arg0))
241	\|\| TREE_UNSIGNED (TREE_TYPE (arg1)))
242	? unsigned_type (typex) : signed_type (typex));
243	return convert (type,
244	build_binary_op (ex_form,
245	convert (typex, arg0),
246	convert (typex, arg1),
247	0));
248	}
249	}
250	}
251	break;
252
253	case EQ_EXPR:
254	case NE_EXPR:
255	case GT_EXPR:
256	case GE_EXPR:
257	case LT_EXPR:
258	case LE_EXPR:
259	case TRUTH_AND_EXPR:
260	case TRUTH_ANDIF_EXPR:
261	case TRUTH_OR_EXPR:
262	case TRUTH_ORIF_EXPR:
263	case TRUTH_NOT_EXPR:
264	/* If we want result of comparison converted to a byte,
265	we can just regard it as a byte, since it is 0 or 1. */
266	TREE_TYPE (expr) = type;
267	return expr;
268
269	case NEGATE_EXPR:
270	case BIT_NOT_EXPR:
271	case ABS_EXPR:
272	{
273	register tree typex = type;
274
275	/* Can't do arithmetic in enumeral types
276	so use an integer type that will hold the values. */
277	if (TREE_CODE (typex) == ENUMERAL_TYPE)
278	typex = type_for_size (TYPE_PRECISION (typex),
279	TREE_UNSIGNED (typex));
280
281	/* But now perhaps TYPEX is as wide as INPREC.
282	In that case, do nothing special here.
283	(Otherwise would recurse infinitely in convert. */
284	if (TYPE_PRECISION (typex) != inprec)
285	{
286	/* Don't do unsigned arithmetic where signed was wanted,
287	or vice versa. */
288	typex = (TREE_UNSIGNED (TREE_TYPE (expr))
289	? unsigned_type (typex) : signed_type (typex));
290	return convert (type,
291	build_unary_op (ex_form,
292	convert (typex, TREE_OPERAND (expr, 0)),
293	1));
294	}
295	}
296
297	case NOP_EXPR:
298	/* If truncating after truncating, might as well do all at once.
299	If truncating after extending, we may get rid of wasted work. */
300	return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
301
302	case COND_EXPR:
303	/* Can treat the two alternative values like the operands
304	of an arithmetic expression. */
305	{
306	tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
307	tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
308
309	if (outprec >= BITS_PER_WORD
310	\|\| TRULY_NOOP_TRUNCATION (outprec, inprec)
311	\|\| inprec > TYPE_PRECISION (TREE_TYPE (arg1))
312	\|\| inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
313	{
314	/* Do the arithmetic in type TYPEX,
315	then convert result to TYPE. */
316	register tree typex = type;
317
318	/* Can't do arithmetic in enumeral types
319	so use an integer type that will hold the values. */
320	if (TREE_CODE (typex) == ENUMERAL_TYPE)
321	typex = type_for_size (TYPE_PRECISION (typex),
322	TREE_UNSIGNED (typex));
323
324	/* But now perhaps TYPEX is as wide as INPREC.
325	In that case, do nothing special here.
326	(Otherwise would recurse infinitely in convert. */
327	if (TYPE_PRECISION (typex) != inprec)
328	{
329	/* Don't do unsigned arithmetic where signed was wanted,
330	or vice versa. */
331	typex = (TREE_UNSIGNED (TREE_TYPE (expr))
332	? unsigned_type (typex) : signed_type (typex));
333	return convert (type,
334	fold (build (COND_EXPR, typex,
335	TREE_OPERAND (expr, 0),
336	convert (typex, arg1),
337	convert (typex, arg2))));
338	}
339	}
340	}
341	}
342
343	return build1 (NOP_EXPR, type, expr);
344	}
345
346	if (form == REAL_TYPE)
347	return build1 (FIX_TRUNC_EXPR, type, expr);
348
349	error ("aggregate value used where an integer was expected");
350
351	{
352	register tree tem = build_int_2 (0, 0);
353	TREE_TYPE (tem) = type;
354	return tem;
355	}
356	}
357	\f
358	/* Create an expression whose value is that of EXPR,
359	converted to type TYPE. The TREE_TYPE of the value
360	is always TYPE. This function implements all reasonable
361	conversions; callers should filter out those that are
362	not permitted by the language being compiled. */
363
364	tree
365	convert (type, expr)
366	tree type, expr;
367	{
368	register tree e = expr;
369	register enum tree_code code = TREE_CODE (type);
370
371	if (type == TREE_TYPE (expr) \|\| TREE_CODE (expr) == ERROR_MARK)
372	return expr;
373	if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
374	return error_mark_node;
375	if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
376	{
377	error ("void value not ignored as it ought to be");
378	return error_mark_node;
379	}
380	if (code == VOID_TYPE)
381	return build1 (CONVERT_EXPR, type, e);
382	#if 0
383	/* This is incorrect. A truncation can't be stripped this way.
384	Extensions will be stripped by the use of get_unwidened. */
385	if (TREE_CODE (expr) == NOP_EXPR)
386	return convert (type, TREE_OPERAND (expr, 0));
387	#endif
388	if (code == INTEGER_TYPE \|\| code == ENUMERAL_TYPE)
389	return fold (convert_to_integer (type, e));
390	if (code == POINTER_TYPE)
391	return fold (convert_to_pointer (type, e));
392	if (code == REAL_TYPE)
393	return fold (convert_to_real (type, e));
394
395	error ("conversion to non-scalar type requested");
396	return error_mark_node;
397	}