2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Andy Vaught
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Since target arithmetic must be done on the host, there has to
23 be some way of evaluating arithmetic expressions as the host
24 would evaluate them. We use the GNU MP library and the MPFR
25 library to do arithmetic, and this file provides the interface. */
32 #include "target-memory.h"
34 /* MPFR does not have a direct replacement for mpz_set_f() from GMP.
35 It's easily implemented with a few calls though. */
38 gfc_mpfr_to_mpz (mpz_t z, mpfr_t x, locus *where)
42 if (mpfr_inf_p (x) || mpfr_nan_p (x))
44 gfc_error ("Conversion of an Infinity or Not-a-Number at %L "
50 e = mpfr_get_z_exp (z, x);
53 mpz_mul_2exp (z, z, e);
55 mpz_tdiv_q_2exp (z, z, -e);
59 /* Set the model number precision by the requested KIND. */
62 gfc_set_model_kind (int kind)
64 int index = gfc_validate_kind (BT_REAL, kind, false);
67 base2prec = gfc_real_kinds[index].digits;
68 if (gfc_real_kinds[index].radix != 2)
69 base2prec *= gfc_real_kinds[index].radix / 2;
70 mpfr_set_default_prec (base2prec);
74 /* Set the model number precision from mpfr_t x. */
77 gfc_set_model (mpfr_t x)
79 mpfr_set_default_prec (mpfr_get_prec (x));
83 /* Given an arithmetic error code, return a pointer to a string that
84 explains the error. */
87 gfc_arith_error (arith code)
94 p = _("Arithmetic OK at %L");
97 p = _("Arithmetic overflow at %L");
100 p = _("Arithmetic underflow at %L");
103 p = _("Arithmetic NaN at %L");
106 p = _("Division by zero at %L");
108 case ARITH_INCOMMENSURATE:
109 p = _("Array operands are incommensurate at %L");
111 case ARITH_ASYMMETRIC:
113 _("Integer outside symmetric range implied by Standard Fortran at %L");
116 gfc_internal_error ("gfc_arith_error(): Bad error code");
123 /* Get things ready to do math. */
126 gfc_arith_init_1 (void)
128 gfc_integer_info *int_info;
129 gfc_real_info *real_info;
133 mpfr_set_default_prec (128);
136 /* Convert the minimum and maximum values for each kind into their
137 GNU MP representation. */
138 for (int_info = gfc_integer_kinds; int_info->kind != 0; int_info++)
141 mpz_init (int_info->huge);
142 mpz_set_ui (int_info->huge, int_info->radix);
143 mpz_pow_ui (int_info->huge, int_info->huge, int_info->digits);
144 mpz_sub_ui (int_info->huge, int_info->huge, 1);
146 /* These are the numbers that are actually representable by the
147 target. For bases other than two, this needs to be changed. */
148 if (int_info->radix != 2)
149 gfc_internal_error ("Fix min_int calculation");
151 /* See PRs 13490 and 17912, related to integer ranges.
152 The pedantic_min_int exists for range checking when a program
153 is compiled with -pedantic, and reflects the belief that
154 Standard Fortran requires integers to be symmetrical, i.e.
155 every negative integer must have a representable positive
156 absolute value, and vice versa. */
158 mpz_init (int_info->pedantic_min_int);
159 mpz_neg (int_info->pedantic_min_int, int_info->huge);
161 mpz_init (int_info->min_int);
162 mpz_sub_ui (int_info->min_int, int_info->pedantic_min_int, 1);
165 mpfr_set_z (a, int_info->huge, GFC_RND_MODE);
166 mpfr_log10 (a, a, GFC_RND_MODE);
168 int_info->range = (int) mpfr_get_si (a, GFC_RND_MODE);
173 for (real_info = gfc_real_kinds; real_info->kind != 0; real_info++)
175 gfc_set_model_kind (real_info->kind);
180 /* huge(x) = (1 - b**(-p)) * b**(emax-1) * b */
182 mpfr_init (real_info->huge);
183 mpfr_set_ui (real_info->huge, 1, GFC_RND_MODE);
184 mpfr_set_ui (a, real_info->radix, GFC_RND_MODE);
185 mpfr_pow_si (a, a, -real_info->digits, GFC_RND_MODE);
186 mpfr_sub (real_info->huge, real_info->huge, a, GFC_RND_MODE);
189 mpfr_set_ui (a, real_info->radix, GFC_RND_MODE);
190 mpfr_pow_ui (a, a, real_info->max_exponent - 1, GFC_RND_MODE);
192 /* (1 - b**(-p)) * b**(emax-1) */
193 mpfr_mul (real_info->huge, real_info->huge, a, GFC_RND_MODE);
195 /* (1 - b**(-p)) * b**(emax-1) * b */
196 mpfr_mul_ui (real_info->huge, real_info->huge, real_info->radix,
199 /* tiny(x) = b**(emin-1) */
200 mpfr_init (real_info->tiny);
201 mpfr_set_ui (real_info->tiny, real_info->radix, GFC_RND_MODE);
202 mpfr_pow_si (real_info->tiny, real_info->tiny,
203 real_info->min_exponent - 1, GFC_RND_MODE);
205 /* subnormal (x) = b**(emin - digit) */
206 mpfr_init (real_info->subnormal);
207 mpfr_set_ui (real_info->subnormal, real_info->radix, GFC_RND_MODE);
208 mpfr_pow_si (real_info->subnormal, real_info->subnormal,
209 real_info->min_exponent - real_info->digits, GFC_RND_MODE);
211 /* epsilon(x) = b**(1-p) */
212 mpfr_init (real_info->epsilon);
213 mpfr_set_ui (real_info->epsilon, real_info->radix, GFC_RND_MODE);
214 mpfr_pow_si (real_info->epsilon, real_info->epsilon,
215 1 - real_info->digits, GFC_RND_MODE);
217 /* range(x) = int(min(log10(huge(x)), -log10(tiny)) */
218 mpfr_log10 (a, real_info->huge, GFC_RND_MODE);
219 mpfr_log10 (b, real_info->tiny, GFC_RND_MODE);
220 mpfr_neg (b, b, GFC_RND_MODE);
223 mpfr_min (a, a, b, GFC_RND_MODE);
225 real_info->range = (int) mpfr_get_si (a, GFC_RND_MODE);
227 /* precision(x) = int((p - 1) * log10(b)) + k */
228 mpfr_set_ui (a, real_info->radix, GFC_RND_MODE);
229 mpfr_log10 (a, a, GFC_RND_MODE);
230 mpfr_mul_ui (a, a, real_info->digits - 1, GFC_RND_MODE);
232 real_info->precision = (int) mpfr_get_si (a, GFC_RND_MODE);
234 /* If the radix is an integral power of 10, add one to the precision. */
235 for (i = 10; i <= real_info->radix; i *= 10)
236 if (i == real_info->radix)
237 real_info->precision++;
239 mpfr_clears (a, b, NULL);
244 /* Clean up, get rid of numeric constants. */
247 gfc_arith_done_1 (void)
249 gfc_integer_info *ip;
252 for (ip = gfc_integer_kinds; ip->kind; ip++)
254 mpz_clear (ip->min_int);
255 mpz_clear (ip->pedantic_min_int);
256 mpz_clear (ip->huge);
259 for (rp = gfc_real_kinds; rp->kind; rp++)
260 mpfr_clears (rp->epsilon, rp->huge, rp->tiny, rp->subnormal, NULL);
264 /* Given a wide character value and a character kind, determine whether
265 the character is representable for that kind. */
267 gfc_check_character_range (gfc_char_t c, int kind)
269 /* As wide characters are stored as 32-bit values, they're all
270 representable in UCS=4. */
275 return c <= 255 ? true : false;
281 /* Given an integer and a kind, make sure that the integer lies within
282 the range of the kind. Returns ARITH_OK, ARITH_ASYMMETRIC or
286 gfc_check_integer_range (mpz_t p, int kind)
291 i = gfc_validate_kind (BT_INTEGER, kind, false);
296 if (mpz_cmp (p, gfc_integer_kinds[i].pedantic_min_int) < 0)
297 result = ARITH_ASYMMETRIC;
301 if (gfc_option.flag_range_check == 0)
304 if (mpz_cmp (p, gfc_integer_kinds[i].min_int) < 0
305 || mpz_cmp (p, gfc_integer_kinds[i].huge) > 0)
306 result = ARITH_OVERFLOW;
312 /* Given a real and a kind, make sure that the real lies within the
313 range of the kind. Returns ARITH_OK, ARITH_OVERFLOW or
317 gfc_check_real_range (mpfr_t p, int kind)
323 i = gfc_validate_kind (BT_REAL, kind, false);
327 mpfr_abs (q, p, GFC_RND_MODE);
333 if (gfc_option.flag_range_check != 0)
334 retval = ARITH_OVERFLOW;
336 else if (mpfr_nan_p (p))
338 if (gfc_option.flag_range_check != 0)
341 else if (mpfr_sgn (q) == 0)
346 else if (mpfr_cmp (q, gfc_real_kinds[i].huge) > 0)
348 if (gfc_option.flag_range_check == 0)
349 mpfr_set_inf (p, mpfr_sgn (p));
351 retval = ARITH_OVERFLOW;
353 else if (mpfr_cmp (q, gfc_real_kinds[i].subnormal) < 0)
355 if (gfc_option.flag_range_check == 0)
357 if (mpfr_sgn (p) < 0)
359 mpfr_set_ui (p, 0, GFC_RND_MODE);
360 mpfr_set_si (q, -1, GFC_RND_MODE);
361 mpfr_copysign (p, p, q, GFC_RND_MODE);
364 mpfr_set_ui (p, 0, GFC_RND_MODE);
367 retval = ARITH_UNDERFLOW;
369 else if (mpfr_cmp (q, gfc_real_kinds[i].tiny) < 0)
374 /* Save current values of emin and emax. */
375 emin = mpfr_get_emin ();
376 emax = mpfr_get_emax ();
378 /* Set emin and emax for the current model number. */
379 en = gfc_real_kinds[i].min_exponent - gfc_real_kinds[i].digits + 1;
380 mpfr_set_emin ((mp_exp_t) en);
381 mpfr_set_emax ((mp_exp_t) gfc_real_kinds[i].max_exponent);
382 mpfr_subnormalize (q, 0, GFC_RND_MODE);
384 /* Reset emin and emax. */
385 mpfr_set_emin (emin);
386 mpfr_set_emax (emax);
388 /* Copy sign if needed. */
389 if (mpfr_sgn (p) < 0)
390 mpfr_neg (p, q, GMP_RNDN);
392 mpfr_set (p, q, GMP_RNDN);
401 /* Function to return a constant expression node of a given type and kind. */
404 gfc_constant_result (bt type, int kind, locus *where)
409 gfc_internal_error ("gfc_constant_result(): locus 'where' cannot be NULL");
411 result = gfc_get_expr ();
413 result->expr_type = EXPR_CONSTANT;
414 result->ts.type = type;
415 result->ts.kind = kind;
416 result->where = *where;
421 mpz_init (result->value.integer);
425 gfc_set_model_kind (kind);
426 mpfr_init (result->value.real);
430 gfc_set_model_kind (kind);
431 mpfr_init (result->value.complex.r);
432 mpfr_init (result->value.complex.i);
443 /* Low-level arithmetic functions. All of these subroutines assume
444 that all operands are of the same type and return an operand of the
445 same type. The other thing about these subroutines is that they
446 can fail in various ways -- overflow, underflow, division by zero,
447 zero raised to the zero, etc. */
450 gfc_arith_not (gfc_expr *op1, gfc_expr **resultp)
454 result = gfc_constant_result (BT_LOGICAL, op1->ts.kind, &op1->where);
455 result->value.logical = !op1->value.logical;
463 gfc_arith_and (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
467 result = gfc_constant_result (BT_LOGICAL, gfc_kind_max (op1, op2),
469 result->value.logical = op1->value.logical && op2->value.logical;
477 gfc_arith_or (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
481 result = gfc_constant_result (BT_LOGICAL, gfc_kind_max (op1, op2),
483 result->value.logical = op1->value.logical || op2->value.logical;
491 gfc_arith_eqv (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
495 result = gfc_constant_result (BT_LOGICAL, gfc_kind_max (op1, op2),
497 result->value.logical = op1->value.logical == op2->value.logical;
505 gfc_arith_neqv (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
509 result = gfc_constant_result (BT_LOGICAL, gfc_kind_max (op1, op2),
511 result->value.logical = op1->value.logical != op2->value.logical;
518 /* Make sure a constant numeric expression is within the range for
519 its type and kind. Note that there's also a gfc_check_range(),
520 but that one deals with the intrinsic RANGE function. */
523 gfc_range_check (gfc_expr *e)
531 rc = gfc_check_integer_range (e->value.integer, e->ts.kind);
535 rc = gfc_check_real_range (e->value.real, e->ts.kind);
536 if (rc == ARITH_UNDERFLOW)
537 mpfr_set_ui (e->value.real, 0, GFC_RND_MODE);
538 if (rc == ARITH_OVERFLOW)
539 mpfr_set_inf (e->value.real, mpfr_sgn (e->value.real));
541 mpfr_set_nan (e->value.real);
545 rc = gfc_check_real_range (e->value.complex.r, e->ts.kind);
546 if (rc == ARITH_UNDERFLOW)
547 mpfr_set_ui (e->value.complex.r, 0, GFC_RND_MODE);
548 if (rc == ARITH_OVERFLOW)
549 mpfr_set_inf (e->value.complex.r, mpfr_sgn (e->value.complex.r));
551 mpfr_set_nan (e->value.complex.r);
553 rc2 = gfc_check_real_range (e->value.complex.i, e->ts.kind);
554 if (rc == ARITH_UNDERFLOW)
555 mpfr_set_ui (e->value.complex.i, 0, GFC_RND_MODE);
556 if (rc == ARITH_OVERFLOW)
557 mpfr_set_inf (e->value.complex.i, mpfr_sgn (e->value.complex.i));
559 mpfr_set_nan (e->value.complex.i);
566 gfc_internal_error ("gfc_range_check(): Bad type");
573 /* Several of the following routines use the same set of statements to
574 check the validity of the result. Encapsulate the checking here. */
577 check_result (arith rc, gfc_expr *x, gfc_expr *r, gfc_expr **rp)
581 if (val == ARITH_UNDERFLOW)
583 if (gfc_option.warn_underflow)
584 gfc_warning (gfc_arith_error (val), &x->where);
588 if (val == ARITH_ASYMMETRIC)
590 gfc_warning (gfc_arith_error (val), &x->where);
603 /* It may seem silly to have a subroutine that actually computes the
604 unary plus of a constant, but it prevents us from making exceptions
605 in the code elsewhere. Used for unary plus and parenthesized
609 gfc_arith_identity (gfc_expr *op1, gfc_expr **resultp)
611 *resultp = gfc_copy_expr (op1);
617 gfc_arith_uminus (gfc_expr *op1, gfc_expr **resultp)
622 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
624 switch (op1->ts.type)
627 mpz_neg (result->value.integer, op1->value.integer);
631 mpfr_neg (result->value.real, op1->value.real, GFC_RND_MODE);
635 mpfr_neg (result->value.complex.r, op1->value.complex.r, GFC_RND_MODE);
636 mpfr_neg (result->value.complex.i, op1->value.complex.i, GFC_RND_MODE);
640 gfc_internal_error ("gfc_arith_uminus(): Bad basic type");
643 rc = gfc_range_check (result);
645 return check_result (rc, op1, result, resultp);
650 gfc_arith_plus (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
655 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
657 switch (op1->ts.type)
660 mpz_add (result->value.integer, op1->value.integer, op2->value.integer);
664 mpfr_add (result->value.real, op1->value.real, op2->value.real,
669 mpfr_add (result->value.complex.r, op1->value.complex.r,
670 op2->value.complex.r, GFC_RND_MODE);
672 mpfr_add (result->value.complex.i, op1->value.complex.i,
673 op2->value.complex.i, GFC_RND_MODE);
677 gfc_internal_error ("gfc_arith_plus(): Bad basic type");
680 rc = gfc_range_check (result);
682 return check_result (rc, op1, result, resultp);
687 gfc_arith_minus (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
692 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
694 switch (op1->ts.type)
697 mpz_sub (result->value.integer, op1->value.integer, op2->value.integer);
701 mpfr_sub (result->value.real, op1->value.real, op2->value.real,
706 mpfr_sub (result->value.complex.r, op1->value.complex.r,
707 op2->value.complex.r, GFC_RND_MODE);
709 mpfr_sub (result->value.complex.i, op1->value.complex.i,
710 op2->value.complex.i, GFC_RND_MODE);
714 gfc_internal_error ("gfc_arith_minus(): Bad basic type");
717 rc = gfc_range_check (result);
719 return check_result (rc, op1, result, resultp);
724 gfc_arith_times (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
730 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
732 switch (op1->ts.type)
735 mpz_mul (result->value.integer, op1->value.integer, op2->value.integer);
739 mpfr_mul (result->value.real, op1->value.real, op2->value.real,
744 gfc_set_model (op1->value.complex.r);
748 mpfr_mul (x, op1->value.complex.r, op2->value.complex.r, GFC_RND_MODE);
749 mpfr_mul (y, op1->value.complex.i, op2->value.complex.i, GFC_RND_MODE);
750 mpfr_sub (result->value.complex.r, x, y, GFC_RND_MODE);
752 mpfr_mul (x, op1->value.complex.r, op2->value.complex.i, GFC_RND_MODE);
753 mpfr_mul (y, op1->value.complex.i, op2->value.complex.r, GFC_RND_MODE);
754 mpfr_add (result->value.complex.i, x, y, GFC_RND_MODE);
756 mpfr_clears (x, y, NULL);
760 gfc_internal_error ("gfc_arith_times(): Bad basic type");
763 rc = gfc_range_check (result);
765 return check_result (rc, op1, result, resultp);
770 gfc_arith_divide (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
778 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
780 switch (op1->ts.type)
783 if (mpz_sgn (op2->value.integer) == 0)
789 mpz_tdiv_q (result->value.integer, op1->value.integer,
794 if (mpfr_sgn (op2->value.real) == 0 && gfc_option.flag_range_check == 1)
800 mpfr_div (result->value.real, op1->value.real, op2->value.real,
805 if (mpfr_sgn (op2->value.complex.r) == 0
806 && mpfr_sgn (op2->value.complex.i) == 0
807 && gfc_option.flag_range_check == 1)
813 gfc_set_model (op1->value.complex.r);
818 mpfr_mul (x, op2->value.complex.r, op2->value.complex.r, GFC_RND_MODE);
819 mpfr_mul (y, op2->value.complex.i, op2->value.complex.i, GFC_RND_MODE);
820 mpfr_add (div, x, y, GFC_RND_MODE);
822 mpfr_mul (x, op1->value.complex.r, op2->value.complex.r, GFC_RND_MODE);
823 mpfr_mul (y, op1->value.complex.i, op2->value.complex.i, GFC_RND_MODE);
824 mpfr_add (result->value.complex.r, x, y, GFC_RND_MODE);
825 mpfr_div (result->value.complex.r, result->value.complex.r, div,
828 mpfr_mul (x, op1->value.complex.i, op2->value.complex.r, GFC_RND_MODE);
829 mpfr_mul (y, op1->value.complex.r, op2->value.complex.i, GFC_RND_MODE);
830 mpfr_sub (result->value.complex.i, x, y, GFC_RND_MODE);
831 mpfr_div (result->value.complex.i, result->value.complex.i, div,
834 mpfr_clears (x, y, div, NULL);
838 gfc_internal_error ("gfc_arith_divide(): Bad basic type");
842 rc = gfc_range_check (result);
844 return check_result (rc, op1, result, resultp);
848 /* Compute the reciprocal of a complex number (guaranteed nonzero). */
851 complex_reciprocal (gfc_expr *op)
855 gfc_set_model (op->value.complex.r);
859 mpfr_mul (mod, op->value.complex.r, op->value.complex.r, GFC_RND_MODE);
860 mpfr_mul (tmp, op->value.complex.i, op->value.complex.i, GFC_RND_MODE);
861 mpfr_add (mod, mod, tmp, GFC_RND_MODE);
863 mpfr_div (op->value.complex.r, op->value.complex.r, mod, GFC_RND_MODE);
865 mpfr_neg (op->value.complex.i, op->value.complex.i, GFC_RND_MODE);
866 mpfr_div (op->value.complex.i, op->value.complex.i, mod, GFC_RND_MODE);
868 mpfr_clears (tmp, mod, NULL);
872 /* Raise a complex number to positive power (power > 0).
873 This function will modify the content of power.
875 Use Binary Method, which is not an optimal but a simple and reasonable
876 arithmetic. See section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
877 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
878 3rd Edition, 1998. */
881 complex_pow (gfc_expr *result, gfc_expr *base, mpz_t power)
883 mpfr_t x_r, x_i, tmp, re, im;
885 gfc_set_model (base->value.complex.r);
893 mpfr_set_ui (result->value.complex.r, 1, GFC_RND_MODE);
894 mpfr_set_ui (result->value.complex.i, 0, GFC_RND_MODE);
897 mpfr_set (x_r, base->value.complex.r, GFC_RND_MODE);
898 mpfr_set (x_i, base->value.complex.i, GFC_RND_MODE);
900 /* Macro for complex multiplication. We have to take care that
901 res_r/res_i and a_r/a_i can (and will) be the same variable. */
902 #define CMULT(res_r,res_i,a_r,a_i,b_r,b_i) \
903 mpfr_mul (re, a_r, b_r, GFC_RND_MODE), \
904 mpfr_mul (tmp, a_i, b_i, GFC_RND_MODE), \
905 mpfr_sub (re, re, tmp, GFC_RND_MODE), \
907 mpfr_mul (im, a_r, b_i, GFC_RND_MODE), \
908 mpfr_mul (tmp, a_i, b_r, GFC_RND_MODE), \
909 mpfr_add (res_i, im, tmp, GFC_RND_MODE), \
910 mpfr_set (res_r, re, GFC_RND_MODE)
912 #define res_r result->value.complex.r
913 #define res_i result->value.complex.i
915 /* for (; power > 0; x *= x) */
916 for (; mpz_cmp_si (power, 0) > 0; CMULT(x_r,x_i,x_r,x_i,x_r,x_i))
918 /* if (power & 1) res = res * x; */
919 if (mpz_congruent_ui_p (power, 1, 2))
920 CMULT(res_r,res_i,res_r,res_i,x_r,x_i);
923 mpz_fdiv_q_ui (power, power, 2);
930 mpfr_clears (x_r, x_i, tmp, re, im, NULL);
934 /* Raise a number to an integer power. */
937 gfc_arith_power (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
943 gcc_assert (op2->expr_type == EXPR_CONSTANT && op2->ts.type == BT_INTEGER);
946 result = gfc_constant_result (op1->ts.type, op1->ts.kind, &op1->where);
947 power_sign = mpz_sgn (op2->value.integer);
951 /* Handle something to the zeroth power. Since we're dealing
952 with integral exponents, there is no ambiguity in the
953 limiting procedure used to determine the value of 0**0. */
954 switch (op1->ts.type)
957 mpz_set_ui (result->value.integer, 1);
961 mpfr_set_ui (result->value.real, 1, GFC_RND_MODE);
965 mpfr_set_ui (result->value.complex.r, 1, GFC_RND_MODE);
966 mpfr_set_ui (result->value.complex.i, 0, GFC_RND_MODE);
970 gfc_internal_error ("gfc_arith_power(): Bad base");
975 switch (op1->ts.type)
981 /* First, we simplify the cases of op1 == 1, 0 or -1. */
982 if (mpz_cmp_si (op1->value.integer, 1) == 0)
985 mpz_set_si (result->value.integer, 1);
987 else if (mpz_cmp_si (op1->value.integer, 0) == 0)
989 /* 0**op2 == 0, if op2 > 0
990 0**op2 overflow, if op2 < 0 ; in that case, we
991 set the result to 0 and return ARITH_DIV0. */
992 mpz_set_si (result->value.integer, 0);
993 if (mpz_cmp_si (op2->value.integer, 0) < 0)
996 else if (mpz_cmp_si (op1->value.integer, -1) == 0)
998 /* (-1)**op2 == (-1)**(mod(op2,2)) */
999 unsigned int odd = mpz_fdiv_ui (op2->value.integer, 2);
1001 mpz_set_si (result->value.integer, -1);
1003 mpz_set_si (result->value.integer, 1);
1005 /* Then, we take care of op2 < 0. */
1006 else if (mpz_cmp_si (op2->value.integer, 0) < 0)
1008 /* if op2 < 0, op1**op2 == 0 because abs(op1) > 1. */
1009 mpz_set_si (result->value.integer, 0);
1011 else if (gfc_extract_int (op2, &power) != NULL)
1013 /* If op2 doesn't fit in an int, the exponentiation will
1014 overflow, because op2 > 0 and abs(op1) > 1. */
1016 int i = gfc_validate_kind (BT_INTEGER, result->ts.kind, false);
1018 if (gfc_option.flag_range_check)
1019 rc = ARITH_OVERFLOW;
1021 /* Still, we want to give the same value as the processor. */
1023 mpz_add_ui (max, gfc_integer_kinds[i].huge, 1);
1024 mpz_mul_ui (max, max, 2);
1025 mpz_powm (result->value.integer, op1->value.integer,
1026 op2->value.integer, max);
1030 mpz_pow_ui (result->value.integer, op1->value.integer, power);
1035 mpfr_pow_z (result->value.real, op1->value.real, op2->value.integer,
1043 /* Compute op1**abs(op2) */
1045 mpz_abs (apower, op2->value.integer);
1046 complex_pow (result, op1, apower);
1049 /* If (op2 < 0), compute the inverse. */
1051 complex_reciprocal (result);
1062 rc = gfc_range_check (result);
1064 return check_result (rc, op1, result, resultp);
1068 /* Concatenate two string constants. */
1071 gfc_arith_concat (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1076 gcc_assert (op1->ts.kind == op2->ts.kind);
1077 result = gfc_constant_result (BT_CHARACTER, op1->ts.kind,
1080 len = op1->value.character.length + op2->value.character.length;
1082 result->value.character.string = gfc_get_wide_string (len + 1);
1083 result->value.character.length = len;
1085 memcpy (result->value.character.string, op1->value.character.string,
1086 op1->value.character.length * sizeof (gfc_char_t));
1088 memcpy (&result->value.character.string[op1->value.character.length],
1089 op2->value.character.string,
1090 op2->value.character.length * sizeof (gfc_char_t));
1092 result->value.character.string[len] = '\0';
1099 /* Comparison between real values; returns 0 if (op1 .op. op2) is true.
1100 This function mimics mpfr_cmp but takes NaN into account. */
1103 compare_real (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1109 rc = mpfr_equal_p (op1->value.real, op2->value.real) ? 0 : 1;
1112 rc = mpfr_greater_p (op1->value.real, op2->value.real) ? 1 : -1;
1115 rc = mpfr_greaterequal_p (op1->value.real, op2->value.real) ? 1 : -1;
1118 rc = mpfr_less_p (op1->value.real, op2->value.real) ? -1 : 1;
1121 rc = mpfr_lessequal_p (op1->value.real, op2->value.real) ? -1 : 1;
1124 gfc_internal_error ("compare_real(): Bad operator");
1130 /* Comparison operators. Assumes that the two expression nodes
1131 contain two constants of the same type. The op argument is
1132 needed to handle NaN correctly. */
1135 gfc_compare_expr (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1139 switch (op1->ts.type)
1142 rc = mpz_cmp (op1->value.integer, op2->value.integer);
1146 rc = compare_real (op1, op2, op);
1150 rc = gfc_compare_string (op1, op2);
1154 rc = ((!op1->value.logical && op2->value.logical)
1155 || (op1->value.logical && !op2->value.logical));
1159 gfc_internal_error ("gfc_compare_expr(): Bad basic type");
1166 /* Compare a pair of complex numbers. Naturally, this is only for
1167 equality and inequality. */
1170 compare_complex (gfc_expr *op1, gfc_expr *op2)
1172 return (mpfr_equal_p (op1->value.complex.r, op2->value.complex.r)
1173 && mpfr_equal_p (op1->value.complex.i, op2->value.complex.i));
1177 /* Given two constant strings and the inverse collating sequence, compare the
1178 strings. We return -1 for a < b, 0 for a == b and 1 for a > b.
1179 We use the processor's default collating sequence. */
1182 gfc_compare_string (gfc_expr *a, gfc_expr *b)
1184 int len, alen, blen, i;
1187 alen = a->value.character.length;
1188 blen = b->value.character.length;
1190 len = MAX(alen, blen);
1192 for (i = 0; i < len; i++)
1194 ac = ((i < alen) ? a->value.character.string[i] : ' ');
1195 bc = ((i < blen) ? b->value.character.string[i] : ' ');
1203 /* Strings are equal */
1209 gfc_compare_with_Cstring (gfc_expr *a, const char *b, bool case_sensitive)
1211 int len, alen, blen, i;
1214 alen = a->value.character.length;
1217 len = MAX(alen, blen);
1219 for (i = 0; i < len; i++)
1221 ac = ((i < alen) ? a->value.character.string[i] : ' ');
1222 bc = ((i < blen) ? b[i] : ' ');
1224 if (!case_sensitive)
1236 /* Strings are equal */
1241 /* Specific comparison subroutines. */
1244 gfc_arith_eq (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1248 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1250 result->value.logical = (op1->ts.type == BT_COMPLEX)
1251 ? compare_complex (op1, op2)
1252 : (gfc_compare_expr (op1, op2, INTRINSIC_EQ) == 0);
1260 gfc_arith_ne (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1264 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1266 result->value.logical = (op1->ts.type == BT_COMPLEX)
1267 ? !compare_complex (op1, op2)
1268 : (gfc_compare_expr (op1, op2, INTRINSIC_EQ) != 0);
1276 gfc_arith_gt (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1280 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1282 result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_GT) > 0);
1290 gfc_arith_ge (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1294 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1296 result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_GE) >= 0);
1304 gfc_arith_lt (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1308 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1310 result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_LT) < 0);
1318 gfc_arith_le (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
1322 result = gfc_constant_result (BT_LOGICAL, gfc_default_logical_kind,
1324 result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_LE) <= 0);
1332 reduce_unary (arith (*eval) (gfc_expr *, gfc_expr **), gfc_expr *op,
1335 gfc_constructor *c, *head;
1339 if (op->expr_type == EXPR_CONSTANT)
1340 return eval (op, result);
1343 head = gfc_copy_constructor (op->value.constructor);
1345 for (c = head; c; c = c->next)
1347 rc = reduce_unary (eval, c->expr, &r);
1352 gfc_replace_expr (c->expr, r);
1356 gfc_free_constructor (head);
1359 r = gfc_get_expr ();
1360 r->expr_type = EXPR_ARRAY;
1361 r->value.constructor = head;
1362 r->shape = gfc_copy_shape (op->shape, op->rank);
1364 r->ts = head->expr->ts;
1365 r->where = op->where;
1376 reduce_binary_ac (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1377 gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
1379 gfc_constructor *c, *head;
1383 head = gfc_copy_constructor (op1->value.constructor);
1386 for (c = head; c; c = c->next)
1388 if (c->expr->expr_type == EXPR_CONSTANT)
1389 rc = eval (c->expr, op2, &r);
1391 rc = reduce_binary_ac (eval, c->expr, op2, &r);
1396 gfc_replace_expr (c->expr, r);
1400 gfc_free_constructor (head);
1403 r = gfc_get_expr ();
1404 r->expr_type = EXPR_ARRAY;
1405 r->value.constructor = head;
1406 r->shape = gfc_copy_shape (op1->shape, op1->rank);
1408 r->ts = head->expr->ts;
1409 r->where = op1->where;
1410 r->rank = op1->rank;
1420 reduce_binary_ca (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1421 gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
1423 gfc_constructor *c, *head;
1427 head = gfc_copy_constructor (op2->value.constructor);
1430 for (c = head; c; c = c->next)
1432 if (c->expr->expr_type == EXPR_CONSTANT)
1433 rc = eval (op1, c->expr, &r);
1435 rc = reduce_binary_ca (eval, op1, c->expr, &r);
1440 gfc_replace_expr (c->expr, r);
1444 gfc_free_constructor (head);
1447 r = gfc_get_expr ();
1448 r->expr_type = EXPR_ARRAY;
1449 r->value.constructor = head;
1450 r->shape = gfc_copy_shape (op2->shape, op2->rank);
1452 r->ts = head->expr->ts;
1453 r->where = op2->where;
1454 r->rank = op2->rank;
1463 /* We need a forward declaration of reduce_binary. */
1464 static arith reduce_binary (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1465 gfc_expr *op1, gfc_expr *op2, gfc_expr **result);
1469 reduce_binary_aa (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1470 gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
1472 gfc_constructor *c, *d, *head;
1476 head = gfc_copy_constructor (op1->value.constructor);
1479 d = op2->value.constructor;
1481 if (gfc_check_conformance ("elemental binary operation", op1, op2)
1483 rc = ARITH_INCOMMENSURATE;
1486 for (c = head; c; c = c->next, d = d->next)
1490 rc = ARITH_INCOMMENSURATE;
1494 rc = reduce_binary (eval, c->expr, d->expr, &r);
1498 gfc_replace_expr (c->expr, r);
1502 rc = ARITH_INCOMMENSURATE;
1506 gfc_free_constructor (head);
1509 r = gfc_get_expr ();
1510 r->expr_type = EXPR_ARRAY;
1511 r->value.constructor = head;
1512 r->shape = gfc_copy_shape (op1->shape, op1->rank);
1514 r->ts = head->expr->ts;
1515 r->where = op1->where;
1516 r->rank = op1->rank;
1526 reduce_binary (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1527 gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
1529 if (op1->expr_type == EXPR_CONSTANT && op2->expr_type == EXPR_CONSTANT)
1530 return eval (op1, op2, result);
1532 if (op1->expr_type == EXPR_CONSTANT && op2->expr_type == EXPR_ARRAY)
1533 return reduce_binary_ca (eval, op1, op2, result);
1535 if (op1->expr_type == EXPR_ARRAY && op2->expr_type == EXPR_CONSTANT)
1536 return reduce_binary_ac (eval, op1, op2, result);
1538 return reduce_binary_aa (eval, op1, op2, result);
1544 arith (*f2)(gfc_expr *, gfc_expr **);
1545 arith (*f3)(gfc_expr *, gfc_expr *, gfc_expr **);
1549 /* High level arithmetic subroutines. These subroutines go into
1550 eval_intrinsic(), which can do one of several things to its
1551 operands. If the operands are incompatible with the intrinsic
1552 operation, we return a node pointing to the operands and hope that
1553 an operator interface is found during resolution.
1555 If the operands are compatible and are constants, then we try doing
1556 the arithmetic. We also handle the cases where either or both
1557 operands are array constructors. */
1560 eval_intrinsic (gfc_intrinsic_op op,
1561 eval_f eval, gfc_expr *op1, gfc_expr *op2)
1563 gfc_expr temp, *result;
1567 gfc_clear_ts (&temp.ts);
1573 if (op1->ts.type != BT_LOGICAL)
1576 temp.ts.type = BT_LOGICAL;
1577 temp.ts.kind = gfc_default_logical_kind;
1581 /* Logical binary operators */
1584 case INTRINSIC_NEQV:
1586 if (op1->ts.type != BT_LOGICAL || op2->ts.type != BT_LOGICAL)
1589 temp.ts.type = BT_LOGICAL;
1590 temp.ts.kind = gfc_default_logical_kind;
1595 case INTRINSIC_UPLUS:
1596 case INTRINSIC_UMINUS:
1597 if (!gfc_numeric_ts (&op1->ts))
1604 case INTRINSIC_PARENTHESES:
1609 /* Additional restrictions for ordering relations. */
1611 case INTRINSIC_GE_OS:
1613 case INTRINSIC_LT_OS:
1615 case INTRINSIC_LE_OS:
1617 case INTRINSIC_GT_OS:
1618 if (op1->ts.type == BT_COMPLEX || op2->ts.type == BT_COMPLEX)
1620 temp.ts.type = BT_LOGICAL;
1621 temp.ts.kind = gfc_default_logical_kind;
1627 case INTRINSIC_EQ_OS:
1629 case INTRINSIC_NE_OS:
1630 if (op1->ts.type == BT_CHARACTER && op2->ts.type == BT_CHARACTER)
1633 temp.ts.type = BT_LOGICAL;
1634 temp.ts.kind = gfc_default_logical_kind;
1636 /* If kind mismatch, exit and we'll error out later. */
1637 if (op1->ts.kind != op2->ts.kind)
1644 /* Numeric binary */
1645 case INTRINSIC_PLUS:
1646 case INTRINSIC_MINUS:
1647 case INTRINSIC_TIMES:
1648 case INTRINSIC_DIVIDE:
1649 case INTRINSIC_POWER:
1650 if (!gfc_numeric_ts (&op1->ts) || !gfc_numeric_ts (&op2->ts))
1653 /* Insert any necessary type conversions to make the operands
1656 temp.expr_type = EXPR_OP;
1657 gfc_clear_ts (&temp.ts);
1658 temp.value.op.op = op;
1660 temp.value.op.op1 = op1;
1661 temp.value.op.op2 = op2;
1663 gfc_type_convert_binary (&temp);
1665 if (op == INTRINSIC_EQ || op == INTRINSIC_NE
1666 || op == INTRINSIC_GE || op == INTRINSIC_GT
1667 || op == INTRINSIC_LE || op == INTRINSIC_LT
1668 || op == INTRINSIC_EQ_OS || op == INTRINSIC_NE_OS
1669 || op == INTRINSIC_GE_OS || op == INTRINSIC_GT_OS
1670 || op == INTRINSIC_LE_OS || op == INTRINSIC_LT_OS)
1672 temp.ts.type = BT_LOGICAL;
1673 temp.ts.kind = gfc_default_logical_kind;
1679 /* Character binary */
1680 case INTRINSIC_CONCAT:
1681 if (op1->ts.type != BT_CHARACTER || op2->ts.type != BT_CHARACTER
1682 || op1->ts.kind != op2->ts.kind)
1685 temp.ts.type = BT_CHARACTER;
1686 temp.ts.kind = op1->ts.kind;
1690 case INTRINSIC_USER:
1694 gfc_internal_error ("eval_intrinsic(): Bad operator");
1697 /* Try to combine the operators. */
1698 if (op == INTRINSIC_POWER && op2->ts.type != BT_INTEGER)
1701 if (op1->expr_type != EXPR_CONSTANT
1702 && (op1->expr_type != EXPR_ARRAY
1703 || !gfc_is_constant_expr (op1) || !gfc_expanded_ac (op1)))
1707 && op2->expr_type != EXPR_CONSTANT
1708 && (op2->expr_type != EXPR_ARRAY
1709 || !gfc_is_constant_expr (op2) || !gfc_expanded_ac (op2)))
1713 rc = reduce_unary (eval.f2, op1, &result);
1715 rc = reduce_binary (eval.f3, op1, op2, &result);
1718 { /* Something went wrong. */
1719 gfc_error (gfc_arith_error (rc), &op1->where);
1723 gfc_free_expr (op1);
1724 gfc_free_expr (op2);
1728 /* Create a run-time expression. */
1729 result = gfc_get_expr ();
1730 result->ts = temp.ts;
1732 result->expr_type = EXPR_OP;
1733 result->value.op.op = op;
1735 result->value.op.op1 = op1;
1736 result->value.op.op2 = op2;
1738 result->where = op1->where;
1744 /* Modify type of expression for zero size array. */
1747 eval_type_intrinsic0 (gfc_intrinsic_op iop, gfc_expr *op)
1750 gfc_internal_error ("eval_type_intrinsic0(): op NULL");
1755 case INTRINSIC_GE_OS:
1757 case INTRINSIC_LT_OS:
1759 case INTRINSIC_LE_OS:
1761 case INTRINSIC_GT_OS:
1763 case INTRINSIC_EQ_OS:
1765 case INTRINSIC_NE_OS:
1766 op->ts.type = BT_LOGICAL;
1767 op->ts.kind = gfc_default_logical_kind;
1778 /* Return nonzero if the expression is a zero size array. */
1781 gfc_zero_size_array (gfc_expr *e)
1783 if (e->expr_type != EXPR_ARRAY)
1786 return e->value.constructor == NULL;
1790 /* Reduce a binary expression where at least one of the operands
1791 involves a zero-length array. Returns NULL if neither of the
1792 operands is a zero-length array. */
1795 reduce_binary0 (gfc_expr *op1, gfc_expr *op2)
1797 if (gfc_zero_size_array (op1))
1799 gfc_free_expr (op2);
1803 if (gfc_zero_size_array (op2))
1805 gfc_free_expr (op1);
1814 eval_intrinsic_f2 (gfc_intrinsic_op op,
1815 arith (*eval) (gfc_expr *, gfc_expr **),
1816 gfc_expr *op1, gfc_expr *op2)
1823 if (gfc_zero_size_array (op1))
1824 return eval_type_intrinsic0 (op, op1);
1828 result = reduce_binary0 (op1, op2);
1830 return eval_type_intrinsic0 (op, result);
1834 return eval_intrinsic (op, f, op1, op2);
1839 eval_intrinsic_f3 (gfc_intrinsic_op op,
1840 arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
1841 gfc_expr *op1, gfc_expr *op2)
1846 result = reduce_binary0 (op1, op2);
1848 return eval_type_intrinsic0(op, result);
1851 return eval_intrinsic (op, f, op1, op2);
1856 gfc_parentheses (gfc_expr *op)
1858 if (gfc_is_constant_expr (op))
1861 return eval_intrinsic_f2 (INTRINSIC_PARENTHESES, gfc_arith_identity,
1866 gfc_uplus (gfc_expr *op)
1868 return eval_intrinsic_f2 (INTRINSIC_UPLUS, gfc_arith_identity, op, NULL);
1873 gfc_uminus (gfc_expr *op)
1875 return eval_intrinsic_f2 (INTRINSIC_UMINUS, gfc_arith_uminus, op, NULL);
1880 gfc_add (gfc_expr *op1, gfc_expr *op2)
1882 return eval_intrinsic_f3 (INTRINSIC_PLUS, gfc_arith_plus, op1, op2);
1887 gfc_subtract (gfc_expr *op1, gfc_expr *op2)
1889 return eval_intrinsic_f3 (INTRINSIC_MINUS, gfc_arith_minus, op1, op2);
1894 gfc_multiply (gfc_expr *op1, gfc_expr *op2)
1896 return eval_intrinsic_f3 (INTRINSIC_TIMES, gfc_arith_times, op1, op2);
1901 gfc_divide (gfc_expr *op1, gfc_expr *op2)
1903 return eval_intrinsic_f3 (INTRINSIC_DIVIDE, gfc_arith_divide, op1, op2);
1908 gfc_power (gfc_expr *op1, gfc_expr *op2)
1910 return eval_intrinsic_f3 (INTRINSIC_POWER, gfc_arith_power, op1, op2);
1915 gfc_concat (gfc_expr *op1, gfc_expr *op2)
1917 return eval_intrinsic_f3 (INTRINSIC_CONCAT, gfc_arith_concat, op1, op2);
1922 gfc_and (gfc_expr *op1, gfc_expr *op2)
1924 return eval_intrinsic_f3 (INTRINSIC_AND, gfc_arith_and, op1, op2);
1929 gfc_or (gfc_expr *op1, gfc_expr *op2)
1931 return eval_intrinsic_f3 (INTRINSIC_OR, gfc_arith_or, op1, op2);
1936 gfc_not (gfc_expr *op1)
1938 return eval_intrinsic_f2 (INTRINSIC_NOT, gfc_arith_not, op1, NULL);
1943 gfc_eqv (gfc_expr *op1, gfc_expr *op2)
1945 return eval_intrinsic_f3 (INTRINSIC_EQV, gfc_arith_eqv, op1, op2);
1950 gfc_neqv (gfc_expr *op1, gfc_expr *op2)
1952 return eval_intrinsic_f3 (INTRINSIC_NEQV, gfc_arith_neqv, op1, op2);
1957 gfc_eq (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1959 return eval_intrinsic_f3 (op, gfc_arith_eq, op1, op2);
1964 gfc_ne (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1966 return eval_intrinsic_f3 (op, gfc_arith_ne, op1, op2);
1971 gfc_gt (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1973 return eval_intrinsic_f3 (op, gfc_arith_gt, op1, op2);
1978 gfc_ge (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1980 return eval_intrinsic_f3 (op, gfc_arith_ge, op1, op2);
1985 gfc_lt (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1987 return eval_intrinsic_f3 (op, gfc_arith_lt, op1, op2);
1992 gfc_le (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
1994 return eval_intrinsic_f3 (op, gfc_arith_le, op1, op2);
1998 /* Convert an integer string to an expression node. */
2001 gfc_convert_integer (const char *buffer, int kind, int radix, locus *where)
2006 e = gfc_constant_result (BT_INTEGER, kind, where);
2007 /* A leading plus is allowed, but not by mpz_set_str. */
2008 if (buffer[0] == '+')
2012 mpz_set_str (e->value.integer, t, radix);
2018 /* Convert a real string to an expression node. */
2021 gfc_convert_real (const char *buffer, int kind, locus *where)
2025 e = gfc_constant_result (BT_REAL, kind, where);
2026 mpfr_set_str (e->value.real, buffer, 10, GFC_RND_MODE);
2032 /* Convert a pair of real, constant expression nodes to a single
2033 complex expression node. */
2036 gfc_convert_complex (gfc_expr *real, gfc_expr *imag, int kind)
2040 e = gfc_constant_result (BT_COMPLEX, kind, &real->where);
2041 mpfr_set (e->value.complex.r, real->value.real, GFC_RND_MODE);
2042 mpfr_set (e->value.complex.i, imag->value.real, GFC_RND_MODE);
2048 /******* Simplification of intrinsic functions with constant arguments *****/
2051 /* Deal with an arithmetic error. */
2054 arith_error (arith rc, gfc_typespec *from, gfc_typespec *to, locus *where)
2059 gfc_error ("Arithmetic OK converting %s to %s at %L",
2060 gfc_typename (from), gfc_typename (to), where);
2062 case ARITH_OVERFLOW:
2063 gfc_error ("Arithmetic overflow converting %s to %s at %L. This check "
2064 "can be disabled with the option -fno-range-check",
2065 gfc_typename (from), gfc_typename (to), where);
2067 case ARITH_UNDERFLOW:
2068 gfc_error ("Arithmetic underflow converting %s to %s at %L. This check "
2069 "can be disabled with the option -fno-range-check",
2070 gfc_typename (from), gfc_typename (to), where);
2073 gfc_error ("Arithmetic NaN converting %s to %s at %L. This check "
2074 "can be disabled with the option -fno-range-check",
2075 gfc_typename (from), gfc_typename (to), where);
2078 gfc_error ("Division by zero converting %s to %s at %L",
2079 gfc_typename (from), gfc_typename (to), where);
2081 case ARITH_INCOMMENSURATE:
2082 gfc_error ("Array operands are incommensurate converting %s to %s at %L",
2083 gfc_typename (from), gfc_typename (to), where);
2085 case ARITH_ASYMMETRIC:
2086 gfc_error ("Integer outside symmetric range implied by Standard Fortran"
2087 " converting %s to %s at %L",
2088 gfc_typename (from), gfc_typename (to), where);
2091 gfc_internal_error ("gfc_arith_error(): Bad error code");
2094 /* TODO: Do something about the error, i.e., throw exception, return
2099 /* Convert integers to integers. */
2102 gfc_int2int (gfc_expr *src, int kind)
2107 result = gfc_constant_result (BT_INTEGER, kind, &src->where);
2109 mpz_set (result->value.integer, src->value.integer);
2111 if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
2113 if (rc == ARITH_ASYMMETRIC)
2115 gfc_warning (gfc_arith_error (rc), &src->where);
2119 arith_error (rc, &src->ts, &result->ts, &src->where);
2120 gfc_free_expr (result);
2129 /* Convert integers to reals. */
2132 gfc_int2real (gfc_expr *src, int kind)
2137 result = gfc_constant_result (BT_REAL, kind, &src->where);
2139 mpfr_set_z (result->value.real, src->value.integer, GFC_RND_MODE);
2141 if ((rc = gfc_check_real_range (result->value.real, kind)) != ARITH_OK)
2143 arith_error (rc, &src->ts, &result->ts, &src->where);
2144 gfc_free_expr (result);
2152 /* Convert default integer to default complex. */
2155 gfc_int2complex (gfc_expr *src, int kind)
2160 result = gfc_constant_result (BT_COMPLEX, kind, &src->where);
2162 mpfr_set_z (result->value.complex.r, src->value.integer, GFC_RND_MODE);
2163 mpfr_set_ui (result->value.complex.i, 0, GFC_RND_MODE);
2165 if ((rc = gfc_check_real_range (result->value.complex.r, kind)) != ARITH_OK)
2167 arith_error (rc, &src->ts, &result->ts, &src->where);
2168 gfc_free_expr (result);
2176 /* Convert default real to default integer. */
2179 gfc_real2int (gfc_expr *src, int kind)
2184 result = gfc_constant_result (BT_INTEGER, kind, &src->where);
2186 gfc_mpfr_to_mpz (result->value.integer, src->value.real, &src->where);
2188 if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
2190 arith_error (rc, &src->ts, &result->ts, &src->where);
2191 gfc_free_expr (result);
2199 /* Convert real to real. */
2202 gfc_real2real (gfc_expr *src, int kind)
2207 result = gfc_constant_result (BT_REAL, kind, &src->where);
2209 mpfr_set (result->value.real, src->value.real, GFC_RND_MODE);
2211 rc = gfc_check_real_range (result->value.real, kind);
2213 if (rc == ARITH_UNDERFLOW)
2215 if (gfc_option.warn_underflow)
2216 gfc_warning (gfc_arith_error (rc), &src->where);
2217 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
2219 else if (rc != ARITH_OK)
2221 arith_error (rc, &src->ts, &result->ts, &src->where);
2222 gfc_free_expr (result);
2230 /* Convert real to complex. */
2233 gfc_real2complex (gfc_expr *src, int kind)
2238 result = gfc_constant_result (BT_COMPLEX, kind, &src->where);
2240 mpfr_set (result->value.complex.r, src->value.real, GFC_RND_MODE);
2241 mpfr_set_ui (result->value.complex.i, 0, GFC_RND_MODE);
2243 rc = gfc_check_real_range (result->value.complex.r, kind);
2245 if (rc == ARITH_UNDERFLOW)
2247 if (gfc_option.warn_underflow)
2248 gfc_warning (gfc_arith_error (rc), &src->where);
2249 mpfr_set_ui (result->value.complex.r, 0, GFC_RND_MODE);
2251 else if (rc != ARITH_OK)
2253 arith_error (rc, &src->ts, &result->ts, &src->where);
2254 gfc_free_expr (result);
2262 /* Convert complex to integer. */
2265 gfc_complex2int (gfc_expr *src, int kind)
2270 result = gfc_constant_result (BT_INTEGER, kind, &src->where);
2272 gfc_mpfr_to_mpz (result->value.integer, src->value.complex.r, &src->where);
2274 if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
2276 arith_error (rc, &src->ts, &result->ts, &src->where);
2277 gfc_free_expr (result);
2285 /* Convert complex to real. */
2288 gfc_complex2real (gfc_expr *src, int kind)
2293 result = gfc_constant_result (BT_REAL, kind, &src->where);
2295 mpfr_set (result->value.real, src->value.complex.r, GFC_RND_MODE);
2297 rc = gfc_check_real_range (result->value.real, kind);
2299 if (rc == ARITH_UNDERFLOW)
2301 if (gfc_option.warn_underflow)
2302 gfc_warning (gfc_arith_error (rc), &src->where);
2303 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
2307 arith_error (rc, &src->ts, &result->ts, &src->where);
2308 gfc_free_expr (result);
2316 /* Convert complex to complex. */
2319 gfc_complex2complex (gfc_expr *src, int kind)
2324 result = gfc_constant_result (BT_COMPLEX, kind, &src->where);
2326 mpfr_set (result->value.complex.r, src->value.complex.r, GFC_RND_MODE);
2327 mpfr_set (result->value.complex.i, src->value.complex.i, GFC_RND_MODE);
2329 rc = gfc_check_real_range (result->value.complex.r, kind);
2331 if (rc == ARITH_UNDERFLOW)
2333 if (gfc_option.warn_underflow)
2334 gfc_warning (gfc_arith_error (rc), &src->where);
2335 mpfr_set_ui (result->value.complex.r, 0, GFC_RND_MODE);
2337 else if (rc != ARITH_OK)
2339 arith_error (rc, &src->ts, &result->ts, &src->where);
2340 gfc_free_expr (result);
2344 rc = gfc_check_real_range (result->value.complex.i, kind);
2346 if (rc == ARITH_UNDERFLOW)
2348 if (gfc_option.warn_underflow)
2349 gfc_warning (gfc_arith_error (rc), &src->where);
2350 mpfr_set_ui (result->value.complex.i, 0, GFC_RND_MODE);
2352 else if (rc != ARITH_OK)
2354 arith_error (rc, &src->ts, &result->ts, &src->where);
2355 gfc_free_expr (result);
2363 /* Logical kind conversion. */
2366 gfc_log2log (gfc_expr *src, int kind)
2370 result = gfc_constant_result (BT_LOGICAL, kind, &src->where);
2371 result->value.logical = src->value.logical;
2377 /* Convert logical to integer. */
2380 gfc_log2int (gfc_expr *src, int kind)
2384 result = gfc_constant_result (BT_INTEGER, kind, &src->where);
2385 mpz_set_si (result->value.integer, src->value.logical);
2391 /* Convert integer to logical. */
2394 gfc_int2log (gfc_expr *src, int kind)
2398 result = gfc_constant_result (BT_LOGICAL, kind, &src->where);
2399 result->value.logical = (mpz_cmp_si (src->value.integer, 0) != 0);
2405 /* Helper function to set the representation in a Hollerith conversion.
2406 This assumes that the ts.type and ts.kind of the result have already
2410 hollerith2representation (gfc_expr *result, gfc_expr *src)
2412 int src_len, result_len;
2414 src_len = src->representation.length;
2415 result_len = gfc_target_expr_size (result);
2417 if (src_len > result_len)
2419 gfc_warning ("The Hollerith constant at %L is too long to convert to %s",
2420 &src->where, gfc_typename(&result->ts));
2423 result->representation.string = XCNEWVEC (char, result_len + 1);
2424 memcpy (result->representation.string, src->representation.string,
2425 MIN (result_len, src_len));
2427 if (src_len < result_len)
2428 memset (&result->representation.string[src_len], ' ', result_len - src_len);
2430 result->representation.string[result_len] = '\0'; /* For debugger */
2431 result->representation.length = result_len;
2435 /* Convert Hollerith to integer. The constant will be padded or truncated. */
2438 gfc_hollerith2int (gfc_expr *src, int kind)
2442 result = gfc_get_expr ();
2443 result->expr_type = EXPR_CONSTANT;
2444 result->ts.type = BT_INTEGER;
2445 result->ts.kind = kind;
2446 result->where = src->where;
2448 hollerith2representation (result, src);
2449 gfc_interpret_integer (kind, (unsigned char *) result->representation.string,
2450 result->representation.length, result->value.integer);
2456 /* Convert Hollerith to real. The constant will be padded or truncated. */
2459 gfc_hollerith2real (gfc_expr *src, int kind)
2464 len = src->value.character.length;
2466 result = gfc_get_expr ();
2467 result->expr_type = EXPR_CONSTANT;
2468 result->ts.type = BT_REAL;
2469 result->ts.kind = kind;
2470 result->where = src->where;
2472 hollerith2representation (result, src);
2473 gfc_interpret_float (kind, (unsigned char *) result->representation.string,
2474 result->representation.length, result->value.real);
2480 /* Convert Hollerith to complex. The constant will be padded or truncated. */
2483 gfc_hollerith2complex (gfc_expr *src, int kind)
2488 len = src->value.character.length;
2490 result = gfc_get_expr ();
2491 result->expr_type = EXPR_CONSTANT;
2492 result->ts.type = BT_COMPLEX;
2493 result->ts.kind = kind;
2494 result->where = src->where;
2496 hollerith2representation (result, src);
2497 gfc_interpret_complex (kind, (unsigned char *) result->representation.string,
2498 result->representation.length, result->value.complex.r,
2499 result->value.complex.i);
2505 /* Convert Hollerith to character. */
2508 gfc_hollerith2character (gfc_expr *src, int kind)
2512 result = gfc_copy_expr (src);
2513 result->ts.type = BT_CHARACTER;
2514 result->ts.kind = kind;
2516 result->value.character.length = result->representation.length;
2517 result->value.character.string
2518 = gfc_char_to_widechar (result->representation.string);
2524 /* Convert Hollerith to logical. The constant will be padded or truncated. */
2527 gfc_hollerith2logical (gfc_expr *src, int kind)
2532 len = src->value.character.length;
2534 result = gfc_get_expr ();
2535 result->expr_type = EXPR_CONSTANT;
2536 result->ts.type = BT_LOGICAL;
2537 result->ts.kind = kind;
2538 result->where = src->where;
2540 hollerith2representation (result, src);
2541 gfc_interpret_logical (kind, (unsigned char *) result->representation.string,
2542 result->representation.length, &result->value.logical);
2548 /* Returns an initializer whose value is one higher than the value of the
2549 LAST_INITIALIZER argument. If the argument is NULL, the
2550 initializers value will be set to zero. The initializer's kind
2551 will be set to gfc_c_int_kind.
2553 If -fshort-enums is given, the appropriate kind will be selected
2554 later after all enumerators have been parsed. A warning is issued
2555 here if an initializer exceeds gfc_c_int_kind. */
2558 gfc_enum_initializer (gfc_expr *last_initializer, locus where)
2562 result = gfc_get_expr ();
2563 result->expr_type = EXPR_CONSTANT;
2564 result->ts.type = BT_INTEGER;
2565 result->ts.kind = gfc_c_int_kind;
2566 result->where = where;
2568 mpz_init (result->value.integer);
2570 if (last_initializer != NULL)
2572 mpz_add_ui (result->value.integer, last_initializer->value.integer, 1);
2573 result->where = last_initializer->where;
2575 if (gfc_check_integer_range (result->value.integer,
2576 gfc_c_int_kind) != ARITH_OK)
2578 gfc_error ("Enumerator exceeds the C integer type at %C");
2584 /* Control comes here, if it's the very first enumerator and no
2585 initializer has been given. It will be initialized to zero. */
2586 mpz_set_si (result->value.integer, 0);