| 1 | /* Utility routines for data type conversion for GNU C.
|
|---|
| 2 | Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997,
|
|---|
| 3 | 1998 Free Software Foundation, Inc.
|
|---|
| 4 |
|
|---|
| 5 | This file is part of GCC.
|
|---|
| 6 |
|
|---|
| 7 | GCC is free software; you can redistribute it and/or modify it under
|
|---|
| 8 | the terms of the GNU General Public License as published by the Free
|
|---|
| 9 | Software Foundation; either version 2, or (at your option) any later
|
|---|
| 10 | version.
|
|---|
| 11 |
|
|---|
| 12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|---|
| 13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|---|
| 14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|---|
| 15 | for more details.
|
|---|
| 16 |
|
|---|
| 17 | You should have received a copy of the GNU General Public License
|
|---|
| 18 | along with GCC; see the file COPYING. If not, write to the Free
|
|---|
| 19 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|---|
| 20 | 02111-1307, USA. */
|
|---|
| 21 |
|
|---|
| 22 |
|
|---|
| 23 | /* These routines are somewhat language-independent utility function
|
|---|
| 24 | intended to be called by the language-specific convert () functions. */
|
|---|
| 25 |
|
|---|
| 26 | #include "config.h"
|
|---|
| 27 | #include "system.h"
|
|---|
| 28 | #include "tree.h"
|
|---|
| 29 | #include "flags.h"
|
|---|
| 30 | #include "convert.h"
|
|---|
| 31 | #include "toplev.h"
|
|---|
| 32 | #include "langhooks.h"
|
|---|
| 33 |
|
|---|
| 34 | /* Convert EXPR to some pointer or reference type TYPE.
|
|---|
| 35 |
|
|---|
| 36 | EXPR must be pointer, reference, integer, enumeral, or literal zero;
|
|---|
| 37 | in other cases error is called. */
|
|---|
| 38 |
|
|---|
| 39 | tree
|
|---|
| 40 | convert_to_pointer (type, expr)
|
|---|
| 41 | tree type, expr;
|
|---|
| 42 | {
|
|---|
| 43 | if (integer_zerop (expr))
|
|---|
| 44 | {
|
|---|
| 45 | expr = build_int_2 (0, 0);
|
|---|
| 46 | TREE_TYPE (expr) = type;
|
|---|
| 47 | return expr;
|
|---|
| 48 | }
|
|---|
| 49 |
|
|---|
| 50 | switch (TREE_CODE (TREE_TYPE (expr)))
|
|---|
| 51 | {
|
|---|
| 52 | case POINTER_TYPE:
|
|---|
| 53 | case REFERENCE_TYPE:
|
|---|
| 54 | return build1 (NOP_EXPR, type, expr);
|
|---|
| 55 |
|
|---|
| 56 | case INTEGER_TYPE:
|
|---|
| 57 | case ENUMERAL_TYPE:
|
|---|
| 58 | case BOOLEAN_TYPE:
|
|---|
| 59 | case CHAR_TYPE:
|
|---|
| 60 | if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE)
|
|---|
| 61 | return build1 (CONVERT_EXPR, type, expr);
|
|---|
| 62 |
|
|---|
| 63 | return
|
|---|
| 64 | convert_to_pointer (type,
|
|---|
| 65 | convert ((*lang_hooks.types.type_for_size)
|
|---|
| 66 | (POINTER_SIZE, 0), expr));
|
|---|
| 67 |
|
|---|
| 68 | default:
|
|---|
| 69 | error ("cannot convert to a pointer type");
|
|---|
| 70 | return convert_to_pointer (type, integer_zero_node);
|
|---|
| 71 | }
|
|---|
| 72 | }
|
|---|
| 73 |
|
|---|
| 74 | /* Convert EXPR to some floating-point type TYPE.
|
|---|
| 75 |
|
|---|
| 76 | EXPR must be float, integer, or enumeral;
|
|---|
| 77 | in other cases error is called. */
|
|---|
| 78 |
|
|---|
| 79 | tree
|
|---|
| 80 | convert_to_real (type, expr)
|
|---|
| 81 | tree type, expr;
|
|---|
| 82 | {
|
|---|
| 83 | switch (TREE_CODE (TREE_TYPE (expr)))
|
|---|
| 84 | {
|
|---|
| 85 | case REAL_TYPE:
|
|---|
| 86 | return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
|
|---|
| 87 | type, expr);
|
|---|
| 88 |
|
|---|
| 89 | case INTEGER_TYPE:
|
|---|
| 90 | case ENUMERAL_TYPE:
|
|---|
| 91 | case BOOLEAN_TYPE:
|
|---|
| 92 | case CHAR_TYPE:
|
|---|
| 93 | return build1 (FLOAT_EXPR, type, expr);
|
|---|
| 94 |
|
|---|
| 95 | case COMPLEX_TYPE:
|
|---|
| 96 | return convert (type,
|
|---|
| 97 | fold (build1 (REALPART_EXPR,
|
|---|
| 98 | TREE_TYPE (TREE_TYPE (expr)), expr)));
|
|---|
| 99 |
|
|---|
| 100 | case POINTER_TYPE:
|
|---|
| 101 | case REFERENCE_TYPE:
|
|---|
| 102 | error ("pointer value used where a floating point value was expected");
|
|---|
| 103 | return convert_to_real (type, integer_zero_node);
|
|---|
| 104 |
|
|---|
| 105 | default:
|
|---|
| 106 | error ("aggregate value used where a float was expected");
|
|---|
| 107 | return convert_to_real (type, integer_zero_node);
|
|---|
| 108 | }
|
|---|
| 109 | }
|
|---|
| 110 |
|
|---|
| 111 | /* Convert EXPR to some integer (or enum) type TYPE.
|
|---|
| 112 |
|
|---|
| 113 | EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
|
|---|
| 114 | vector; in other cases error is called.
|
|---|
| 115 |
|
|---|
| 116 | The result of this is always supposed to be a newly created tree node
|
|---|
| 117 | not in use in any existing structure. */
|
|---|
| 118 |
|
|---|
| 119 | tree
|
|---|
| 120 | convert_to_integer (type, expr)
|
|---|
| 121 | tree type, expr;
|
|---|
| 122 | {
|
|---|
| 123 | enum tree_code ex_form = TREE_CODE (expr);
|
|---|
| 124 | tree intype = TREE_TYPE (expr);
|
|---|
| 125 | unsigned int inprec = TYPE_PRECISION (intype);
|
|---|
| 126 | unsigned int outprec = TYPE_PRECISION (type);
|
|---|
| 127 |
|
|---|
| 128 | /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
|
|---|
| 129 | be. Consider `enum E = { a, b = (enum E) 3 };'. */
|
|---|
| 130 | if (!COMPLETE_TYPE_P (type))
|
|---|
| 131 | {
|
|---|
| 132 | error ("conversion to incomplete type");
|
|---|
| 133 | return error_mark_node;
|
|---|
| 134 | }
|
|---|
| 135 |
|
|---|
| 136 | switch (TREE_CODE (intype))
|
|---|
| 137 | {
|
|---|
| 138 | case POINTER_TYPE:
|
|---|
| 139 | case REFERENCE_TYPE:
|
|---|
| 140 | if (integer_zerop (expr))
|
|---|
| 141 | expr = integer_zero_node;
|
|---|
| 142 | else
|
|---|
| 143 | expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
|
|---|
| 144 | (POINTER_SIZE, 0), expr));
|
|---|
| 145 |
|
|---|
| 146 | return convert_to_integer (type, expr);
|
|---|
| 147 |
|
|---|
| 148 | case INTEGER_TYPE:
|
|---|
| 149 | case ENUMERAL_TYPE:
|
|---|
| 150 | case BOOLEAN_TYPE:
|
|---|
| 151 | case CHAR_TYPE:
|
|---|
| 152 | /* If this is a logical operation, which just returns 0 or 1, we can
|
|---|
| 153 | change the type of the expression. For some logical operations,
|
|---|
| 154 | we must also change the types of the operands to maintain type
|
|---|
| 155 | correctness. */
|
|---|
| 156 |
|
|---|
| 157 | if (TREE_CODE_CLASS (ex_form) == '<')
|
|---|
| 158 | {
|
|---|
| 159 | TREE_TYPE (expr) = type;
|
|---|
| 160 | return expr;
|
|---|
| 161 | }
|
|---|
| 162 |
|
|---|
| 163 | else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
|
|---|
| 164 | || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
|
|---|
| 165 | || ex_form == TRUTH_XOR_EXPR)
|
|---|
| 166 | {
|
|---|
| 167 | TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
|
|---|
| 168 | TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
|
|---|
| 169 | TREE_TYPE (expr) = type;
|
|---|
| 170 | return expr;
|
|---|
| 171 | }
|
|---|
| 172 |
|
|---|
| 173 | else if (ex_form == TRUTH_NOT_EXPR)
|
|---|
| 174 | {
|
|---|
| 175 | TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
|
|---|
| 176 | TREE_TYPE (expr) = type;
|
|---|
| 177 | return expr;
|
|---|
| 178 | }
|
|---|
| 179 |
|
|---|
| 180 | /* If we are widening the type, put in an explicit conversion.
|
|---|
| 181 | Similarly if we are not changing the width. After this, we know
|
|---|
| 182 | we are truncating EXPR. */
|
|---|
| 183 |
|
|---|
| 184 | else if (outprec >= inprec)
|
|---|
| 185 | return build1 (NOP_EXPR, type, expr);
|
|---|
| 186 |
|
|---|
| 187 | /* If TYPE is an enumeral type or a type with a precision less
|
|---|
| 188 | than the number of bits in its mode, do the conversion to the
|
|---|
| 189 | type corresponding to its mode, then do a nop conversion
|
|---|
| 190 | to TYPE. */
|
|---|
| 191 | else if (TREE_CODE (type) == ENUMERAL_TYPE
|
|---|
| 192 | || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
|
|---|
| 193 | return build1 (NOP_EXPR, type,
|
|---|
| 194 | convert ((*lang_hooks.types.type_for_mode)
|
|---|
| 195 | (TYPE_MODE (type), TREE_UNSIGNED (type)),
|
|---|
| 196 | expr));
|
|---|
| 197 |
|
|---|
| 198 | /* Here detect when we can distribute the truncation down past some
|
|---|
| 199 | arithmetic. For example, if adding two longs and converting to an
|
|---|
| 200 | int, we can equally well convert both to ints and then add.
|
|---|
| 201 | For the operations handled here, such truncation distribution
|
|---|
| 202 | is always safe.
|
|---|
| 203 | It is desirable in these cases:
|
|---|
| 204 | 1) when truncating down to full-word from a larger size
|
|---|
| 205 | 2) when truncating takes no work.
|
|---|
| 206 | 3) when at least one operand of the arithmetic has been extended
|
|---|
| 207 | (as by C's default conversions). In this case we need two conversions
|
|---|
| 208 | if we do the arithmetic as already requested, so we might as well
|
|---|
| 209 | truncate both and then combine. Perhaps that way we need only one.
|
|---|
| 210 |
|
|---|
| 211 | Note that in general we cannot do the arithmetic in a type
|
|---|
| 212 | shorter than the desired result of conversion, even if the operands
|
|---|
| 213 | are both extended from a shorter type, because they might overflow
|
|---|
| 214 | if combined in that type. The exceptions to this--the times when
|
|---|
| 215 | two narrow values can be combined in their narrow type even to
|
|---|
| 216 | make a wider result--are handled by "shorten" in build_binary_op. */
|
|---|
| 217 |
|
|---|
| 218 | switch (ex_form)
|
|---|
| 219 | {
|
|---|
| 220 | case RSHIFT_EXPR:
|
|---|
| 221 | /* We can pass truncation down through right shifting
|
|---|
| 222 | when the shift count is a nonpositive constant. */
|
|---|
| 223 | if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
|
|---|
| 224 | && tree_int_cst_lt (TREE_OPERAND (expr, 1),
|
|---|
| 225 | convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
|
|---|
| 226 | integer_one_node)))
|
|---|
| 227 | goto trunc1;
|
|---|
| 228 | break;
|
|---|
| 229 |
|
|---|
| 230 | case LSHIFT_EXPR:
|
|---|
| 231 | /* We can pass truncation down through left shifting
|
|---|
| 232 | when the shift count is a nonnegative constant and
|
|---|
| 233 | the target type is unsigned. */
|
|---|
| 234 | if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
|
|---|
| 235 | && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
|
|---|
| 236 | && TREE_UNSIGNED (type)
|
|---|
| 237 | && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
|
|---|
| 238 | {
|
|---|
| 239 | /* If shift count is less than the width of the truncated type,
|
|---|
| 240 | really shift. */
|
|---|
| 241 | if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
|
|---|
| 242 | /* In this case, shifting is like multiplication. */
|
|---|
| 243 | goto trunc1;
|
|---|
| 244 | else
|
|---|
| 245 | {
|
|---|
| 246 | /* If it is >= that width, result is zero.
|
|---|
| 247 | Handling this with trunc1 would give the wrong result:
|
|---|
| 248 | (int) ((long long) a << 32) is well defined (as 0)
|
|---|
| 249 | but (int) a << 32 is undefined and would get a
|
|---|
| 250 | warning. */
|
|---|
| 251 |
|
|---|
| 252 | tree t = convert_to_integer (type, integer_zero_node);
|
|---|
| 253 |
|
|---|
| 254 | /* If the original expression had side-effects, we must
|
|---|
| 255 | preserve it. */
|
|---|
| 256 | if (TREE_SIDE_EFFECTS (expr))
|
|---|
| 257 | return build (COMPOUND_EXPR, type, expr, t);
|
|---|
| 258 | else
|
|---|
| 259 | return t;
|
|---|
| 260 | }
|
|---|
| 261 | }
|
|---|
| 262 | break;
|
|---|
| 263 |
|
|---|
| 264 | case MAX_EXPR:
|
|---|
| 265 | case MIN_EXPR:
|
|---|
| 266 | case MULT_EXPR:
|
|---|
| 267 | {
|
|---|
| 268 | tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
|
|---|
| 269 | tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
|
|---|
| 270 |
|
|---|
| 271 | /* Don't distribute unless the output precision is at least as big
|
|---|
| 272 | as the actual inputs. Otherwise, the comparison of the
|
|---|
| 273 | truncated values will be wrong. */
|
|---|
| 274 | if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
|
|---|
| 275 | && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
|
|---|
| 276 | /* If signedness of arg0 and arg1 don't match,
|
|---|
| 277 | we can't necessarily find a type to compare them in. */
|
|---|
| 278 | && (TREE_UNSIGNED (TREE_TYPE (arg0))
|
|---|
| 279 | == TREE_UNSIGNED (TREE_TYPE (arg1))))
|
|---|
| 280 | goto trunc1;
|
|---|
| 281 | break;
|
|---|
| 282 | }
|
|---|
| 283 |
|
|---|
| 284 | case PLUS_EXPR:
|
|---|
| 285 | case MINUS_EXPR:
|
|---|
| 286 | case BIT_AND_EXPR:
|
|---|
| 287 | case BIT_IOR_EXPR:
|
|---|
| 288 | case BIT_XOR_EXPR:
|
|---|
| 289 | case BIT_ANDTC_EXPR:
|
|---|
| 290 | trunc1:
|
|---|
| 291 | {
|
|---|
| 292 | tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
|
|---|
| 293 | tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
|
|---|
| 294 |
|
|---|
| 295 | if (outprec >= BITS_PER_WORD
|
|---|
| 296 | || TRULY_NOOP_TRUNCATION (outprec, inprec)
|
|---|
| 297 | || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
|
|---|
| 298 | || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
|
|---|
| 299 | {
|
|---|
| 300 | /* Do the arithmetic in type TYPEX,
|
|---|
| 301 | then convert result to TYPE. */
|
|---|
| 302 | tree typex = type;
|
|---|
| 303 |
|
|---|
| 304 | /* Can't do arithmetic in enumeral types
|
|---|
| 305 | so use an integer type that will hold the values. */
|
|---|
| 306 | if (TREE_CODE (typex) == ENUMERAL_TYPE)
|
|---|
| 307 | typex = (*lang_hooks.types.type_for_size)
|
|---|
| 308 | (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
|
|---|
| 309 |
|
|---|
| 310 | /* But now perhaps TYPEX is as wide as INPREC.
|
|---|
| 311 | In that case, do nothing special here.
|
|---|
| 312 | (Otherwise would recurse infinitely in convert. */
|
|---|
| 313 | if (TYPE_PRECISION (typex) != inprec)
|
|---|
| 314 | {
|
|---|
| 315 | /* Don't do unsigned arithmetic where signed was wanted,
|
|---|
| 316 | or vice versa.
|
|---|
| 317 | Exception: if both of the original operands were
|
|---|
| 318 | unsigned then we can safely do the work as unsigned.
|
|---|
| 319 | Exception: shift operations take their type solely
|
|---|
| 320 | from the first argument.
|
|---|
| 321 | Exception: the LSHIFT_EXPR case above requires that
|
|---|
| 322 | we perform this operation unsigned lest we produce
|
|---|
| 323 | signed-overflow undefinedness.
|
|---|
| 324 | And we may need to do it as unsigned
|
|---|
| 325 | if we truncate to the original size. */
|
|---|
| 326 | if (TREE_UNSIGNED (TREE_TYPE (expr))
|
|---|
| 327 | || (TREE_UNSIGNED (TREE_TYPE (arg0))
|
|---|
| 328 | && (TREE_UNSIGNED (TREE_TYPE (arg1))
|
|---|
| 329 | || ex_form == LSHIFT_EXPR
|
|---|
| 330 | || ex_form == RSHIFT_EXPR
|
|---|
| 331 | || ex_form == LROTATE_EXPR
|
|---|
| 332 | || ex_form == RROTATE_EXPR))
|
|---|
| 333 | || ex_form == LSHIFT_EXPR)
|
|---|
| 334 | typex = (*lang_hooks.types.unsigned_type) (typex);
|
|---|
| 335 | else
|
|---|
| 336 | typex = (*lang_hooks.types.signed_type) (typex);
|
|---|
| 337 | return convert (type,
|
|---|
| 338 | fold (build (ex_form, typex,
|
|---|
| 339 | convert (typex, arg0),
|
|---|
| 340 | convert (typex, arg1),
|
|---|
| 341 | 0)));
|
|---|
| 342 | }
|
|---|
| 343 | }
|
|---|
| 344 | }
|
|---|
| 345 | break;
|
|---|
| 346 |
|
|---|
| 347 | case NEGATE_EXPR:
|
|---|
| 348 | case BIT_NOT_EXPR:
|
|---|
| 349 | /* This is not correct for ABS_EXPR,
|
|---|
| 350 | since we must test the sign before truncation. */
|
|---|
| 351 | {
|
|---|
| 352 | tree typex = type;
|
|---|
| 353 |
|
|---|
| 354 | /* Can't do arithmetic in enumeral types
|
|---|
| 355 | so use an integer type that will hold the values. */
|
|---|
| 356 | if (TREE_CODE (typex) == ENUMERAL_TYPE)
|
|---|
| 357 | typex = (*lang_hooks.types.type_for_size)
|
|---|
| 358 | (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
|
|---|
| 359 |
|
|---|
| 360 | /* But now perhaps TYPEX is as wide as INPREC.
|
|---|
| 361 | In that case, do nothing special here.
|
|---|
| 362 | (Otherwise would recurse infinitely in convert. */
|
|---|
| 363 | if (TYPE_PRECISION (typex) != inprec)
|
|---|
| 364 | {
|
|---|
| 365 | /* Don't do unsigned arithmetic where signed was wanted,
|
|---|
| 366 | or vice versa. */
|
|---|
| 367 | if (TREE_UNSIGNED (TREE_TYPE (expr)))
|
|---|
| 368 | typex = (*lang_hooks.types.unsigned_type) (typex);
|
|---|
| 369 | else
|
|---|
| 370 | typex = (*lang_hooks.types.signed_type) (typex);
|
|---|
| 371 | return convert (type,
|
|---|
| 372 | fold (build1 (ex_form, typex,
|
|---|
| 373 | convert (typex,
|
|---|
| 374 | TREE_OPERAND (expr, 0)))));
|
|---|
| 375 | }
|
|---|
| 376 | }
|
|---|
| 377 |
|
|---|
| 378 | case NOP_EXPR:
|
|---|
| 379 | /* Don't introduce a
|
|---|
| 380 | "can't convert between vector values of different size" error. */
|
|---|
| 381 | if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
|
|---|
| 382 | && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
|
|---|
| 383 | != GET_MODE_SIZE (TYPE_MODE (type))))
|
|---|
| 384 | break;
|
|---|
| 385 | /* If truncating after truncating, might as well do all at once.
|
|---|
| 386 | If truncating after extending, we may get rid of wasted work. */
|
|---|
| 387 | return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
|
|---|
| 388 |
|
|---|
| 389 | case COND_EXPR:
|
|---|
| 390 | /* It is sometimes worthwhile to push the narrowing down through
|
|---|
| 391 | the conditional and never loses. */
|
|---|
| 392 | return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
|
|---|
| 393 | convert (type, TREE_OPERAND (expr, 1)),
|
|---|
| 394 | convert (type, TREE_OPERAND (expr, 2))));
|
|---|
| 395 |
|
|---|
| 396 | default:
|
|---|
| 397 | break;
|
|---|
| 398 | }
|
|---|
| 399 |
|
|---|
| 400 | return build1 (NOP_EXPR, type, expr);
|
|---|
| 401 |
|
|---|
| 402 | case REAL_TYPE:
|
|---|
| 403 | return build1 (FIX_TRUNC_EXPR, type, expr);
|
|---|
| 404 |
|
|---|
| 405 | case COMPLEX_TYPE:
|
|---|
| 406 | return convert (type,
|
|---|
| 407 | fold (build1 (REALPART_EXPR,
|
|---|
| 408 | TREE_TYPE (TREE_TYPE (expr)), expr)));
|
|---|
| 409 |
|
|---|
| 410 | case VECTOR_TYPE:
|
|---|
| 411 | if (GET_MODE_SIZE (TYPE_MODE (type))
|
|---|
| 412 | != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
|
|---|
| 413 | {
|
|---|
| 414 | error ("can't convert between vector values of different size");
|
|---|
| 415 | return error_mark_node;
|
|---|
| 416 | }
|
|---|
| 417 | return build1 (NOP_EXPR, type, expr);
|
|---|
| 418 |
|
|---|
| 419 | default:
|
|---|
| 420 | error ("aggregate value used where an integer was expected");
|
|---|
| 421 | return convert (type, integer_zero_node);
|
|---|
| 422 | }
|
|---|
| 423 | }
|
|---|
| 424 |
|
|---|
| 425 | /* Convert EXPR to the complex type TYPE in the usual ways. */
|
|---|
| 426 |
|
|---|
| 427 | tree
|
|---|
| 428 | convert_to_complex (type, expr)
|
|---|
| 429 | tree type, expr;
|
|---|
| 430 | {
|
|---|
| 431 | tree subtype = TREE_TYPE (type);
|
|---|
| 432 |
|
|---|
| 433 | switch (TREE_CODE (TREE_TYPE (expr)))
|
|---|
| 434 | {
|
|---|
| 435 | case REAL_TYPE:
|
|---|
| 436 | case INTEGER_TYPE:
|
|---|
| 437 | case ENUMERAL_TYPE:
|
|---|
| 438 | case BOOLEAN_TYPE:
|
|---|
| 439 | case CHAR_TYPE:
|
|---|
| 440 | return build (COMPLEX_EXPR, type, convert (subtype, expr),
|
|---|
| 441 | convert (subtype, integer_zero_node));
|
|---|
| 442 |
|
|---|
| 443 | case COMPLEX_TYPE:
|
|---|
| 444 | {
|
|---|
| 445 | tree elt_type = TREE_TYPE (TREE_TYPE (expr));
|
|---|
| 446 |
|
|---|
| 447 | if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
|
|---|
| 448 | return expr;
|
|---|
| 449 | else if (TREE_CODE (expr) == COMPLEX_EXPR)
|
|---|
| 450 | return fold (build (COMPLEX_EXPR,
|
|---|
| 451 | type,
|
|---|
| 452 | convert (subtype, TREE_OPERAND (expr, 0)),
|
|---|
| 453 | convert (subtype, TREE_OPERAND (expr, 1))));
|
|---|
| 454 | else
|
|---|
| 455 | {
|
|---|
| 456 | expr = save_expr (expr);
|
|---|
| 457 | return
|
|---|
| 458 | fold (build (COMPLEX_EXPR,
|
|---|
| 459 | type, convert (subtype,
|
|---|
| 460 | fold (build1 (REALPART_EXPR,
|
|---|
| 461 | TREE_TYPE (TREE_TYPE (expr)),
|
|---|
| 462 | expr))),
|
|---|
| 463 | convert (subtype,
|
|---|
| 464 | fold (build1 (IMAGPART_EXPR,
|
|---|
| 465 | TREE_TYPE (TREE_TYPE (expr)),
|
|---|
| 466 | expr)))));
|
|---|
| 467 | }
|
|---|
| 468 | }
|
|---|
| 469 |
|
|---|
| 470 | case POINTER_TYPE:
|
|---|
| 471 | case REFERENCE_TYPE:
|
|---|
| 472 | error ("pointer value used where a complex was expected");
|
|---|
| 473 | return convert_to_complex (type, integer_zero_node);
|
|---|
| 474 |
|
|---|
| 475 | default:
|
|---|
| 476 | error ("aggregate value used where a complex was expected");
|
|---|
| 477 | return convert_to_complex (type, integer_zero_node);
|
|---|
| 478 | }
|
|---|
| 479 | }
|
|---|
| 480 |
|
|---|
| 481 | /* Convert EXPR to the vector type TYPE in the usual ways. */
|
|---|
| 482 |
|
|---|
| 483 | tree
|
|---|
| 484 | convert_to_vector (type, expr)
|
|---|
| 485 | tree type, expr;
|
|---|
| 486 | {
|
|---|
| 487 | switch (TREE_CODE (TREE_TYPE (expr)))
|
|---|
| 488 | {
|
|---|
| 489 | case INTEGER_TYPE:
|
|---|
| 490 | case VECTOR_TYPE:
|
|---|
| 491 | if (GET_MODE_SIZE (TYPE_MODE (type))
|
|---|
| 492 | != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
|
|---|
| 493 | {
|
|---|
| 494 | error ("can't convert between vector values of different size");
|
|---|
| 495 | return error_mark_node;
|
|---|
| 496 | }
|
|---|
| 497 | return build1 (NOP_EXPR, type, expr);
|
|---|
| 498 |
|
|---|
| 499 | default:
|
|---|
| 500 | error ("can't convert value to a vector");
|
|---|
| 501 | return convert_to_vector (type, integer_zero_node);
|
|---|
| 502 | }
|
|---|
| 503 | }
|
|---|
