1 /* Simplify intrinsic functions at compile-time.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 Free Software Foundation, Inc.
4 Contributed by Andy Vaught & Katherine Holcomb
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/>. */
27 #include "intrinsic.h"
28 #include "target-memory.h"
29 #include "constructor.h"
30 #include "version.h" /* For version_string. */
33 gfc_expr gfc_bad_expr;
36 /* Note that 'simplification' is not just transforming expressions.
37 For functions that are not simplified at compile time, range
38 checking is done if possible.
40 The return convention is that each simplification function returns:
42 A new expression node corresponding to the simplified arguments.
43 The original arguments are destroyed by the caller, and must not
44 be a part of the new expression.
46 NULL pointer indicating that no simplification was possible and
47 the original expression should remain intact.
49 An expression pointer to gfc_bad_expr (a static placeholder)
50 indicating that some error has prevented simplification. The
51 error is generated within the function and should be propagated
54 By the time a simplification function gets control, it has been
55 decided that the function call is really supposed to be the
56 intrinsic. No type checking is strictly necessary, since only
57 valid types will be passed on. On the other hand, a simplification
58 subroutine may have to look at the type of an argument as part of
61 Array arguments are only passed to these subroutines that implement
62 the simplification of transformational intrinsics.
64 The functions in this file don't have much comment with them, but
65 everything is reasonably straight-forward. The Standard, chapter 13
66 is the best comment you'll find for this file anyway. */
68 /* Range checks an expression node. If all goes well, returns the
69 node, otherwise returns &gfc_bad_expr and frees the node. */
72 range_check (gfc_expr *result, const char *name)
77 if (result->expr_type != EXPR_CONSTANT)
80 switch (gfc_range_check (result))
86 gfc_error ("Result of %s overflows its kind at %L", name,
91 gfc_error ("Result of %s underflows its kind at %L", name,
96 gfc_error ("Result of %s is NaN at %L", name, &result->where);
100 gfc_error ("Result of %s gives range error for its kind at %L", name,
105 gfc_free_expr (result);
106 return &gfc_bad_expr;
110 /* A helper function that gets an optional and possibly missing
111 kind parameter. Returns the kind, -1 if something went wrong. */
114 get_kind (bt type, gfc_expr *k, const char *name, int default_kind)
121 if (k->expr_type != EXPR_CONSTANT)
123 gfc_error ("KIND parameter of %s at %L must be an initialization "
124 "expression", name, &k->where);
128 if (gfc_extract_int (k, &kind) != NULL
129 || gfc_validate_kind (type, kind, true) < 0)
131 gfc_error ("Invalid KIND parameter of %s at %L", name, &k->where);
139 /* Converts an mpz_t signed variable into an unsigned one, assuming
140 two's complement representations and a binary width of bitsize.
141 The conversion is a no-op unless x is negative; otherwise, it can
142 be accomplished by masking out the high bits. */
145 convert_mpz_to_unsigned (mpz_t x, int bitsize)
151 /* Confirm that no bits above the signed range are unset. */
152 gcc_assert (mpz_scan0 (x, bitsize-1) == ULONG_MAX);
154 mpz_init_set_ui (mask, 1);
155 mpz_mul_2exp (mask, mask, bitsize);
156 mpz_sub_ui (mask, mask, 1);
158 mpz_and (x, x, mask);
164 /* Confirm that no bits above the signed range are set. */
165 gcc_assert (mpz_scan1 (x, bitsize-1) == ULONG_MAX);
170 /* Converts an mpz_t unsigned variable into a signed one, assuming
171 two's complement representations and a binary width of bitsize.
172 If the bitsize-1 bit is set, this is taken as a sign bit and
173 the number is converted to the corresponding negative number. */
176 convert_mpz_to_signed (mpz_t x, int bitsize)
180 /* Confirm that no bits above the unsigned range are set. */
181 gcc_assert (mpz_scan1 (x, bitsize) == ULONG_MAX);
183 if (mpz_tstbit (x, bitsize - 1) == 1)
185 mpz_init_set_ui (mask, 1);
186 mpz_mul_2exp (mask, mask, bitsize);
187 mpz_sub_ui (mask, mask, 1);
189 /* We negate the number by hand, zeroing the high bits, that is
190 make it the corresponding positive number, and then have it
191 negated by GMP, giving the correct representation of the
194 mpz_add_ui (x, x, 1);
195 mpz_and (x, x, mask);
204 /* In-place convert BOZ to REAL of the specified kind. */
207 convert_boz (gfc_expr *x, int kind)
209 if (x && x->ts.type == BT_INTEGER && x->is_boz)
216 if (!gfc_convert_boz (x, &ts))
217 return &gfc_bad_expr;
224 /* Test that the expression is an constant array. */
227 is_constant_array_expr (gfc_expr *e)
234 if (e->expr_type != EXPR_ARRAY || !gfc_is_constant_expr (e))
237 for (c = gfc_constructor_first (e->value.constructor);
238 c; c = gfc_constructor_next (c))
239 if (c->expr->expr_type != EXPR_CONSTANT
240 && c->expr->expr_type != EXPR_STRUCTURE)
247 /* Initialize a transformational result expression with a given value. */
250 init_result_expr (gfc_expr *e, int init, gfc_expr *array)
252 if (e && e->expr_type == EXPR_ARRAY)
254 gfc_constructor *ctor = gfc_constructor_first (e->value.constructor);
257 init_result_expr (ctor->expr, init, array);
258 ctor = gfc_constructor_next (ctor);
261 else if (e && e->expr_type == EXPR_CONSTANT)
263 int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
270 e->value.logical = (init ? 1 : 0);
275 mpz_set (e->value.integer, gfc_integer_kinds[i].min_int);
276 else if (init == INT_MAX)
277 mpz_set (e->value.integer, gfc_integer_kinds[i].huge);
279 mpz_set_si (e->value.integer, init);
285 mpfr_set (e->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
286 mpfr_neg (e->value.real, e->value.real, GFC_RND_MODE);
288 else if (init == INT_MAX)
289 mpfr_set (e->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
291 mpfr_set_si (e->value.real, init, GFC_RND_MODE);
295 mpc_set_si (e->value.complex, init, GFC_MPC_RND_MODE);
301 gfc_expr *len = gfc_simplify_len (array, NULL);
302 gfc_extract_int (len, &length);
303 string = gfc_get_wide_string (length + 1);
304 gfc_wide_memset (string, 0, length);
306 else if (init == INT_MAX)
308 gfc_expr *len = gfc_simplify_len (array, NULL);
309 gfc_extract_int (len, &length);
310 string = gfc_get_wide_string (length + 1);
311 gfc_wide_memset (string, 255, length);
316 string = gfc_get_wide_string (1);
319 string[length] = '\0';
320 e->value.character.length = length;
321 e->value.character.string = string;
333 /* Helper function for gfc_simplify_dot_product() and gfc_simplify_matmul. */
336 compute_dot_product (gfc_expr *matrix_a, int stride_a, int offset_a,
337 gfc_expr *matrix_b, int stride_b, int offset_b)
339 gfc_expr *result, *a, *b;
341 result = gfc_get_constant_expr (matrix_a->ts.type, matrix_a->ts.kind,
343 init_result_expr (result, 0, NULL);
345 a = gfc_constructor_lookup_expr (matrix_a->value.constructor, offset_a);
346 b = gfc_constructor_lookup_expr (matrix_b->value.constructor, offset_b);
349 /* Copying of expressions is required as operands are free'd
350 by the gfc_arith routines. */
351 switch (result->ts.type)
354 result = gfc_or (result,
355 gfc_and (gfc_copy_expr (a),
362 result = gfc_add (result,
363 gfc_multiply (gfc_copy_expr (a),
371 offset_a += stride_a;
372 a = gfc_constructor_lookup_expr (matrix_a->value.constructor, offset_a);
374 offset_b += stride_b;
375 b = gfc_constructor_lookup_expr (matrix_b->value.constructor, offset_b);
382 /* Build a result expression for transformational intrinsics,
386 transformational_result (gfc_expr *array, gfc_expr *dim, bt type,
387 int kind, locus* where)
392 if (!dim || array->rank == 1)
393 return gfc_get_constant_expr (type, kind, where);
395 result = gfc_get_array_expr (type, kind, where);
396 result->shape = gfc_copy_shape_excluding (array->shape, array->rank, dim);
397 result->rank = array->rank - 1;
399 /* gfc_array_size() would count the number of elements in the constructor,
400 we have not built those yet. */
402 for (i = 0; i < result->rank; ++i)
403 nelem *= mpz_get_ui (result->shape[i]);
405 for (i = 0; i < nelem; ++i)
407 gfc_constructor_append_expr (&result->value.constructor,
408 gfc_get_constant_expr (type, kind, where),
416 typedef gfc_expr* (*transformational_op)(gfc_expr*, gfc_expr*);
418 /* Wrapper function, implements 'op1 += 1'. Only called if MASK
419 of COUNT intrinsic is .TRUE..
421 Interface and implimentation mimics arith functions as
422 gfc_add, gfc_multiply, etc. */
424 static gfc_expr* gfc_count (gfc_expr *op1, gfc_expr *op2)
428 gcc_assert (op1->ts.type == BT_INTEGER);
429 gcc_assert (op2->ts.type == BT_LOGICAL);
430 gcc_assert (op2->value.logical);
432 result = gfc_copy_expr (op1);
433 mpz_add_ui (result->value.integer, result->value.integer, 1);
441 /* Transforms an ARRAY with operation OP, according to MASK, to a
442 scalar RESULT. E.g. called if
444 REAL, PARAMETER :: array(n, m) = ...
445 REAL, PARAMETER :: s = SUM(array)
447 where OP == gfc_add(). */
450 simplify_transformation_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *mask,
451 transformational_op op)
454 gfc_constructor *array_ctor, *mask_ctor;
456 /* Shortcut for constant .FALSE. MASK. */
458 && mask->expr_type == EXPR_CONSTANT
459 && !mask->value.logical)
462 array_ctor = gfc_constructor_first (array->value.constructor);
464 if (mask && mask->expr_type == EXPR_ARRAY)
465 mask_ctor = gfc_constructor_first (mask->value.constructor);
469 a = array_ctor->expr;
470 array_ctor = gfc_constructor_next (array_ctor);
472 /* A constant MASK equals .TRUE. here and can be ignored. */
476 mask_ctor = gfc_constructor_next (mask_ctor);
477 if (!m->value.logical)
481 result = op (result, gfc_copy_expr (a));
487 /* Transforms an ARRAY with operation OP, according to MASK, to an
488 array RESULT. E.g. called if
490 REAL, PARAMETER :: array(n, m) = ...
491 REAL, PARAMETER :: s(n) = PROD(array, DIM=1)
493 where OP == gfc_multiply(). The result might be post processed using post_op. */
496 simplify_transformation_to_array (gfc_expr *result, gfc_expr *array, gfc_expr *dim,
497 gfc_expr *mask, transformational_op op,
498 transformational_op post_op)
501 int done, i, n, arraysize, resultsize, dim_index, dim_extent, dim_stride;
502 gfc_expr **arrayvec, **resultvec, **base, **src, **dest;
503 gfc_constructor *array_ctor, *mask_ctor, *result_ctor;
505 int count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
506 sstride[GFC_MAX_DIMENSIONS], dstride[GFC_MAX_DIMENSIONS],
507 tmpstride[GFC_MAX_DIMENSIONS];
509 /* Shortcut for constant .FALSE. MASK. */
511 && mask->expr_type == EXPR_CONSTANT
512 && !mask->value.logical)
515 /* Build an indexed table for array element expressions to minimize
516 linked-list traversal. Masked elements are set to NULL. */
517 gfc_array_size (array, &size);
518 arraysize = mpz_get_ui (size);
520 arrayvec = (gfc_expr**) gfc_getmem (sizeof (gfc_expr*) * arraysize);
522 array_ctor = gfc_constructor_first (array->value.constructor);
524 if (mask && mask->expr_type == EXPR_ARRAY)
525 mask_ctor = gfc_constructor_first (mask->value.constructor);
527 for (i = 0; i < arraysize; ++i)
529 arrayvec[i] = array_ctor->expr;
530 array_ctor = gfc_constructor_next (array_ctor);
534 if (!mask_ctor->expr->value.logical)
537 mask_ctor = gfc_constructor_next (mask_ctor);
541 /* Same for the result expression. */
542 gfc_array_size (result, &size);
543 resultsize = mpz_get_ui (size);
546 resultvec = (gfc_expr**) gfc_getmem (sizeof (gfc_expr*) * resultsize);
547 result_ctor = gfc_constructor_first (result->value.constructor);
548 for (i = 0; i < resultsize; ++i)
550 resultvec[i] = result_ctor->expr;
551 result_ctor = gfc_constructor_next (result_ctor);
554 gfc_extract_int (dim, &dim_index);
555 dim_index -= 1; /* zero-base index */
559 for (i = 0, n = 0; i < array->rank; ++i)
562 tmpstride[i] = (i == 0) ? 1 : tmpstride[i-1] * mpz_get_si (array->shape[i-1]);
565 dim_extent = mpz_get_si (array->shape[i]);
566 dim_stride = tmpstride[i];
570 extent[n] = mpz_get_si (array->shape[i]);
571 sstride[n] = tmpstride[i];
572 dstride[n] = (n == 0) ? 1 : dstride[n-1] * extent[n-1];
581 for (src = base, n = 0; n < dim_extent; src += dim_stride, ++n)
583 *dest = op (*dest, gfc_copy_expr (*src));
590 while (!done && count[n] == extent[n])
593 base -= sstride[n] * extent[n];
594 dest -= dstride[n] * extent[n];
597 if (n < result->rank)
608 /* Place updated expression in result constructor. */
609 result_ctor = gfc_constructor_first (result->value.constructor);
610 for (i = 0; i < resultsize; ++i)
613 result_ctor->expr = post_op (result_ctor->expr, resultvec[i]);
615 result_ctor->expr = resultvec[i];
616 result_ctor = gfc_constructor_next (result_ctor);
620 gfc_free (resultvec);
626 simplify_transformation (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
627 int init_val, transformational_op op)
631 if (!is_constant_array_expr (array)
632 || !gfc_is_constant_expr (dim))
636 && !is_constant_array_expr (mask)
637 && mask->expr_type != EXPR_CONSTANT)
640 result = transformational_result (array, dim, array->ts.type,
641 array->ts.kind, &array->where);
642 init_result_expr (result, init_val, NULL);
644 return !dim || array->rank == 1 ?
645 simplify_transformation_to_scalar (result, array, mask, op) :
646 simplify_transformation_to_array (result, array, dim, mask, op, NULL);
650 /********************** Simplification functions *****************************/
653 gfc_simplify_abs (gfc_expr *e)
657 if (e->expr_type != EXPR_CONSTANT)
663 result = gfc_get_constant_expr (BT_INTEGER, e->ts.kind, &e->where);
664 mpz_abs (result->value.integer, e->value.integer);
665 return range_check (result, "IABS");
668 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
669 mpfr_abs (result->value.real, e->value.real, GFC_RND_MODE);
670 return range_check (result, "ABS");
673 gfc_set_model_kind (e->ts.kind);
674 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
675 mpc_abs (result->value.real, e->value.complex, GFC_RND_MODE);
676 return range_check (result, "CABS");
679 gfc_internal_error ("gfc_simplify_abs(): Bad type");
685 simplify_achar_char (gfc_expr *e, gfc_expr *k, const char *name, bool ascii)
689 bool too_large = false;
691 if (e->expr_type != EXPR_CONSTANT)
694 kind = get_kind (BT_CHARACTER, k, name, gfc_default_character_kind);
696 return &gfc_bad_expr;
698 if (mpz_cmp_si (e->value.integer, 0) < 0)
700 gfc_error ("Argument of %s function at %L is negative", name,
702 return &gfc_bad_expr;
705 if (ascii && gfc_option.warn_surprising
706 && mpz_cmp_si (e->value.integer, 127) > 0)
707 gfc_warning ("Argument of %s function at %L outside of range [0,127]",
710 if (kind == 1 && mpz_cmp_si (e->value.integer, 255) > 0)
715 mpz_init_set_ui (t, 2);
716 mpz_pow_ui (t, t, 32);
717 mpz_sub_ui (t, t, 1);
718 if (mpz_cmp (e->value.integer, t) > 0)
725 gfc_error ("Argument of %s function at %L is too large for the "
726 "collating sequence of kind %d", name, &e->where, kind);
727 return &gfc_bad_expr;
730 result = gfc_get_character_expr (kind, &e->where, NULL, 1);
731 result->value.character.string[0] = mpz_get_ui (e->value.integer);
738 /* We use the processor's collating sequence, because all
739 systems that gfortran currently works on are ASCII. */
742 gfc_simplify_achar (gfc_expr *e, gfc_expr *k)
744 return simplify_achar_char (e, k, "ACHAR", true);
749 gfc_simplify_acos (gfc_expr *x)
753 if (x->expr_type != EXPR_CONSTANT)
759 if (mpfr_cmp_si (x->value.real, 1) > 0
760 || mpfr_cmp_si (x->value.real, -1) < 0)
762 gfc_error ("Argument of ACOS at %L must be between -1 and 1",
764 return &gfc_bad_expr;
766 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
767 mpfr_acos (result->value.real, x->value.real, GFC_RND_MODE);
771 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
772 mpc_acos (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
776 gfc_internal_error ("in gfc_simplify_acos(): Bad type");
779 return range_check (result, "ACOS");
783 gfc_simplify_acosh (gfc_expr *x)
787 if (x->expr_type != EXPR_CONSTANT)
793 if (mpfr_cmp_si (x->value.real, 1) < 0)
795 gfc_error ("Argument of ACOSH at %L must not be less than 1",
797 return &gfc_bad_expr;
800 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
801 mpfr_acosh (result->value.real, x->value.real, GFC_RND_MODE);
805 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
806 mpc_acosh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
810 gfc_internal_error ("in gfc_simplify_acosh(): Bad type");
813 return range_check (result, "ACOSH");
817 gfc_simplify_adjustl (gfc_expr *e)
823 if (e->expr_type != EXPR_CONSTANT)
826 len = e->value.character.length;
828 for (count = 0, i = 0; i < len; ++i)
830 ch = e->value.character.string[i];
836 result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, len);
837 for (i = 0; i < len - count; ++i)
838 result->value.character.string[i] = e->value.character.string[count + i];
845 gfc_simplify_adjustr (gfc_expr *e)
851 if (e->expr_type != EXPR_CONSTANT)
854 len = e->value.character.length;
856 for (count = 0, i = len - 1; i >= 0; --i)
858 ch = e->value.character.string[i];
864 result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, len);
865 for (i = 0; i < count; ++i)
866 result->value.character.string[i] = ' ';
868 for (i = count; i < len; ++i)
869 result->value.character.string[i] = e->value.character.string[i - count];
876 gfc_simplify_aimag (gfc_expr *e)
880 if (e->expr_type != EXPR_CONSTANT)
883 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
884 mpfr_set (result->value.real, mpc_imagref (e->value.complex), GFC_RND_MODE);
886 return range_check (result, "AIMAG");
891 gfc_simplify_aint (gfc_expr *e, gfc_expr *k)
893 gfc_expr *rtrunc, *result;
896 kind = get_kind (BT_REAL, k, "AINT", e->ts.kind);
898 return &gfc_bad_expr;
900 if (e->expr_type != EXPR_CONSTANT)
903 rtrunc = gfc_copy_expr (e);
904 mpfr_trunc (rtrunc->value.real, e->value.real);
906 result = gfc_real2real (rtrunc, kind);
908 gfc_free_expr (rtrunc);
910 return range_check (result, "AINT");
915 gfc_simplify_all (gfc_expr *mask, gfc_expr *dim)
917 return simplify_transformation (mask, dim, NULL, true, gfc_and);
922 gfc_simplify_dint (gfc_expr *e)
924 gfc_expr *rtrunc, *result;
926 if (e->expr_type != EXPR_CONSTANT)
929 rtrunc = gfc_copy_expr (e);
930 mpfr_trunc (rtrunc->value.real, e->value.real);
932 result = gfc_real2real (rtrunc, gfc_default_double_kind);
934 gfc_free_expr (rtrunc);
936 return range_check (result, "DINT");
941 gfc_simplify_anint (gfc_expr *e, gfc_expr *k)
946 kind = get_kind (BT_REAL, k, "ANINT", e->ts.kind);
948 return &gfc_bad_expr;
950 if (e->expr_type != EXPR_CONSTANT)
953 result = gfc_get_constant_expr (e->ts.type, kind, &e->where);
954 mpfr_round (result->value.real, e->value.real);
956 return range_check (result, "ANINT");
961 gfc_simplify_and (gfc_expr *x, gfc_expr *y)
966 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
969 kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
974 result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
975 mpz_and (result->value.integer, x->value.integer, y->value.integer);
976 return range_check (result, "AND");
979 return gfc_get_logical_expr (kind, &x->where,
980 x->value.logical && y->value.logical);
989 gfc_simplify_any (gfc_expr *mask, gfc_expr *dim)
991 return simplify_transformation (mask, dim, NULL, false, gfc_or);
996 gfc_simplify_dnint (gfc_expr *e)
1000 if (e->expr_type != EXPR_CONSTANT)
1003 result = gfc_get_constant_expr (BT_REAL, gfc_default_double_kind, &e->where);
1004 mpfr_round (result->value.real, e->value.real);
1006 return range_check (result, "DNINT");
1011 gfc_simplify_asin (gfc_expr *x)
1015 if (x->expr_type != EXPR_CONSTANT)
1021 if (mpfr_cmp_si (x->value.real, 1) > 0
1022 || mpfr_cmp_si (x->value.real, -1) < 0)
1024 gfc_error ("Argument of ASIN at %L must be between -1 and 1",
1026 return &gfc_bad_expr;
1028 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1029 mpfr_asin (result->value.real, x->value.real, GFC_RND_MODE);
1033 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1034 mpc_asin (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1038 gfc_internal_error ("in gfc_simplify_asin(): Bad type");
1041 return range_check (result, "ASIN");
1046 gfc_simplify_asinh (gfc_expr *x)
1050 if (x->expr_type != EXPR_CONSTANT)
1053 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1058 mpfr_asinh (result->value.real, x->value.real, GFC_RND_MODE);
1062 mpc_asinh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1066 gfc_internal_error ("in gfc_simplify_asinh(): Bad type");
1069 return range_check (result, "ASINH");
1074 gfc_simplify_atan (gfc_expr *x)
1078 if (x->expr_type != EXPR_CONSTANT)
1081 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1086 mpfr_atan (result->value.real, x->value.real, GFC_RND_MODE);
1090 mpc_atan (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1094 gfc_internal_error ("in gfc_simplify_atan(): Bad type");
1097 return range_check (result, "ATAN");
1102 gfc_simplify_atanh (gfc_expr *x)
1106 if (x->expr_type != EXPR_CONSTANT)
1112 if (mpfr_cmp_si (x->value.real, 1) >= 0
1113 || mpfr_cmp_si (x->value.real, -1) <= 0)
1115 gfc_error ("Argument of ATANH at %L must be inside the range -1 "
1117 return &gfc_bad_expr;
1119 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1120 mpfr_atanh (result->value.real, x->value.real, GFC_RND_MODE);
1124 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1125 mpc_atanh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1129 gfc_internal_error ("in gfc_simplify_atanh(): Bad type");
1132 return range_check (result, "ATANH");
1137 gfc_simplify_atan2 (gfc_expr *y, gfc_expr *x)
1141 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
1144 if (mpfr_sgn (y->value.real) == 0 && mpfr_sgn (x->value.real) == 0)
1146 gfc_error ("If first argument of ATAN2 %L is zero, then the "
1147 "second argument must not be zero", &x->where);
1148 return &gfc_bad_expr;
1151 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1152 mpfr_atan2 (result->value.real, y->value.real, x->value.real, GFC_RND_MODE);
1154 return range_check (result, "ATAN2");
1159 gfc_simplify_bessel_j0 (gfc_expr *x)
1163 if (x->expr_type != EXPR_CONSTANT)
1166 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1167 mpfr_j0 (result->value.real, x->value.real, GFC_RND_MODE);
1169 return range_check (result, "BESSEL_J0");
1174 gfc_simplify_bessel_j1 (gfc_expr *x)
1178 if (x->expr_type != EXPR_CONSTANT)
1181 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1182 mpfr_j1 (result->value.real, x->value.real, GFC_RND_MODE);
1184 return range_check (result, "BESSEL_J1");
1189 gfc_simplify_bessel_jn (gfc_expr *order, gfc_expr *x)
1194 if (x->expr_type != EXPR_CONSTANT || order->expr_type != EXPR_CONSTANT)
1197 n = mpz_get_si (order->value.integer);
1198 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1199 mpfr_jn (result->value.real, n, x->value.real, GFC_RND_MODE);
1201 return range_check (result, "BESSEL_JN");
1205 /* Simplify transformational form of JN and YN. */
1208 gfc_simplify_bessel_n2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x,
1215 mpfr_t x2rev, last1, last2;
1217 if (x->expr_type != EXPR_CONSTANT || order1->expr_type != EXPR_CONSTANT
1218 || order2->expr_type != EXPR_CONSTANT)
1221 n1 = mpz_get_si (order1->value.integer);
1222 n2 = mpz_get_si (order2->value.integer);
1223 result = gfc_get_array_expr (x->ts.type, x->ts.kind, &x->where);
1225 result->shape = gfc_get_shape (1);
1226 mpz_init_set_ui (result->shape[0], MAX (n2-n1+1, 0));
1231 /* Special case: x == 0; it is J0(0.0) == 1, JN(N > 0, 0.0) == 0; and
1232 YN(N, 0.0) = -Inf. */
1234 if (mpfr_cmp_ui (x->value.real, 0.0) == 0)
1236 if (!jn && gfc_option.flag_range_check)
1238 gfc_error ("Result of BESSEL_YN is -INF at %L", &result->where);
1239 gfc_free_expr (result);
1240 return &gfc_bad_expr;
1245 e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1246 mpfr_set_ui (e->value.real, 1, GFC_RND_MODE);
1247 gfc_constructor_append_expr (&result->value.constructor, e,
1252 for (i = n1; i <= n2; i++)
1254 e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1256 mpfr_set_ui (e->value.real, 0, GFC_RND_MODE);
1258 mpfr_set_inf (e->value.real, -1);
1259 gfc_constructor_append_expr (&result->value.constructor, e,
1266 /* Use the faster but more verbose recurrence algorithm. Bessel functions
1267 are stable for downward recursion and Neumann functions are stable
1268 for upward recursion. It is
1270 J(N-1, x) = x2rev * N * J(N, x) - J(N+1, x),
1271 Y(N+1, x) = x2rev * N * Y(N, x) - Y(N-1, x).
1272 Cf. http://dlmf.nist.gov/10.74#iv and http://dlmf.nist.gov/10.6#E1 */
1274 gfc_set_model_kind (x->ts.kind);
1276 /* Get first recursion anchor. */
1280 mpfr_jn (last1, n2, x->value.real, GFC_RND_MODE);
1282 mpfr_yn (last1, n1, x->value.real, GFC_RND_MODE);
1284 e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1285 mpfr_set (e->value.real, last1, GFC_RND_MODE);
1286 if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
1290 gfc_free_expr (result);
1291 return &gfc_bad_expr;
1293 gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
1301 /* Get second recursion anchor. */
1305 mpfr_jn (last2, n2-1, x->value.real, GFC_RND_MODE);
1307 mpfr_yn (last2, n1+1, x->value.real, GFC_RND_MODE);
1309 e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1310 mpfr_set (e->value.real, last2, GFC_RND_MODE);
1311 if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
1316 gfc_free_expr (result);
1317 return &gfc_bad_expr;
1320 gfc_constructor_insert_expr (&result->value.constructor, e, &x->where, -2);
1322 gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
1331 /* Start actual recursion. */
1334 mpfr_ui_div (x2rev, 2, x->value.real, GFC_RND_MODE);
1336 for (i = 2; i <= n2-n1; i++)
1338 e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1340 /* Special case: For YN, if the previous N gave -INF, set
1341 also N+1 to -INF. */
1342 if (!jn && !gfc_option.flag_range_check && mpfr_inf_p (last2))
1344 mpfr_set_inf (e->value.real, -1);
1345 gfc_constructor_append_expr (&result->value.constructor, e,
1350 mpfr_mul_si (e->value.real, x2rev, jn ? (n2-i+1) : (n1+i-1),
1352 mpfr_mul (e->value.real, e->value.real, last2, GFC_RND_MODE);
1353 mpfr_sub (e->value.real, e->value.real, last1, GFC_RND_MODE);
1355 if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
1359 gfc_constructor_insert_expr (&result->value.constructor, e, &x->where,
1362 gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
1364 mpfr_set (last1, last2, GFC_RND_MODE);
1365 mpfr_set (last2, e->value.real, GFC_RND_MODE);
1378 gfc_free_expr (result);
1379 return &gfc_bad_expr;
1384 gfc_simplify_bessel_jn2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x)
1386 return gfc_simplify_bessel_n2 (order1, order2, x, true);
1391 gfc_simplify_bessel_y0 (gfc_expr *x)
1395 if (x->expr_type != EXPR_CONSTANT)
1398 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1399 mpfr_y0 (result->value.real, x->value.real, GFC_RND_MODE);
1401 return range_check (result, "BESSEL_Y0");
1406 gfc_simplify_bessel_y1 (gfc_expr *x)
1410 if (x->expr_type != EXPR_CONSTANT)
1413 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1414 mpfr_y1 (result->value.real, x->value.real, GFC_RND_MODE);
1416 return range_check (result, "BESSEL_Y1");
1421 gfc_simplify_bessel_yn (gfc_expr *order, gfc_expr *x)
1426 if (x->expr_type != EXPR_CONSTANT || order->expr_type != EXPR_CONSTANT)
1429 n = mpz_get_si (order->value.integer);
1430 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1431 mpfr_yn (result->value.real, n, x->value.real, GFC_RND_MODE);
1433 return range_check (result, "BESSEL_YN");
1438 gfc_simplify_bessel_yn2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x)
1440 return gfc_simplify_bessel_n2 (order1, order2, x, false);
1445 gfc_simplify_bit_size (gfc_expr *e)
1447 int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
1448 return gfc_get_int_expr (e->ts.kind, &e->where,
1449 gfc_integer_kinds[i].bit_size);
1454 gfc_simplify_btest (gfc_expr *e, gfc_expr *bit)
1458 if (e->expr_type != EXPR_CONSTANT || bit->expr_type != EXPR_CONSTANT)
1461 if (gfc_extract_int (bit, &b) != NULL || b < 0)
1462 return gfc_get_logical_expr (gfc_default_logical_kind, &e->where, false);
1464 return gfc_get_logical_expr (gfc_default_logical_kind, &e->where,
1465 mpz_tstbit (e->value.integer, b));
1470 compare_bitwise (gfc_expr *i, gfc_expr *j)
1475 gcc_assert (i->ts.type == BT_INTEGER);
1476 gcc_assert (j->ts.type == BT_INTEGER);
1478 mpz_init_set (x, i->value.integer);
1479 k = gfc_validate_kind (i->ts.type, i->ts.kind, false);
1480 convert_mpz_to_unsigned (x, gfc_integer_kinds[k].bit_size);
1482 mpz_init_set (y, j->value.integer);
1483 k = gfc_validate_kind (j->ts.type, j->ts.kind, false);
1484 convert_mpz_to_unsigned (y, gfc_integer_kinds[k].bit_size);
1486 res = mpz_cmp (x, y);
1494 gfc_simplify_bge (gfc_expr *i, gfc_expr *j)
1496 if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
1499 return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
1500 compare_bitwise (i, j) >= 0);
1505 gfc_simplify_bgt (gfc_expr *i, gfc_expr *j)
1507 if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
1510 return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
1511 compare_bitwise (i, j) > 0);
1516 gfc_simplify_ble (gfc_expr *i, gfc_expr *j)
1518 if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
1521 return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
1522 compare_bitwise (i, j) <= 0);
1527 gfc_simplify_blt (gfc_expr *i, gfc_expr *j)
1529 if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
1532 return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
1533 compare_bitwise (i, j) < 0);
1538 gfc_simplify_ceiling (gfc_expr *e, gfc_expr *k)
1540 gfc_expr *ceil, *result;
1543 kind = get_kind (BT_INTEGER, k, "CEILING", gfc_default_integer_kind);
1545 return &gfc_bad_expr;
1547 if (e->expr_type != EXPR_CONSTANT)
1550 ceil = gfc_copy_expr (e);
1551 mpfr_ceil (ceil->value.real, e->value.real);
1553 result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
1554 gfc_mpfr_to_mpz (result->value.integer, ceil->value.real, &e->where);
1556 gfc_free_expr (ceil);
1558 return range_check (result, "CEILING");
1563 gfc_simplify_char (gfc_expr *e, gfc_expr *k)
1565 return simplify_achar_char (e, k, "CHAR", false);
1569 /* Common subroutine for simplifying CMPLX, COMPLEX and DCMPLX. */
1572 simplify_cmplx (const char *name, gfc_expr *x, gfc_expr *y, int kind)
1576 if (convert_boz (x, kind) == &gfc_bad_expr)
1577 return &gfc_bad_expr;
1579 if (convert_boz (y, kind) == &gfc_bad_expr)
1580 return &gfc_bad_expr;
1582 if (x->expr_type != EXPR_CONSTANT
1583 || (y != NULL && y->expr_type != EXPR_CONSTANT))
1586 result = gfc_get_constant_expr (BT_COMPLEX, kind, &x->where);
1591 mpc_set_z (result->value.complex, x->value.integer, GFC_MPC_RND_MODE);
1595 mpc_set_fr (result->value.complex, x->value.real, GFC_RND_MODE);
1599 mpc_set (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1603 gfc_internal_error ("gfc_simplify_dcmplx(): Bad type (x)");
1607 return range_check (result, name);
1612 mpfr_set_z (mpc_imagref (result->value.complex),
1613 y->value.integer, GFC_RND_MODE);
1617 mpfr_set (mpc_imagref (result->value.complex),
1618 y->value.real, GFC_RND_MODE);
1622 gfc_internal_error ("gfc_simplify_dcmplx(): Bad type (y)");
1625 return range_check (result, name);
1630 gfc_simplify_cmplx (gfc_expr *x, gfc_expr *y, gfc_expr *k)
1634 kind = get_kind (BT_REAL, k, "CMPLX", gfc_default_complex_kind);
1636 return &gfc_bad_expr;
1638 return simplify_cmplx ("CMPLX", x, y, kind);
1643 gfc_simplify_complex (gfc_expr *x, gfc_expr *y)
1647 if (x->ts.type == BT_INTEGER && y->ts.type == BT_INTEGER)
1648 kind = gfc_default_complex_kind;
1649 else if (x->ts.type == BT_REAL || y->ts.type == BT_INTEGER)
1651 else if (x->ts.type == BT_INTEGER || y->ts.type == BT_REAL)
1653 else if (x->ts.type == BT_REAL && y->ts.type == BT_REAL)
1654 kind = (x->ts.kind > y->ts.kind) ? x->ts.kind : y->ts.kind;
1658 return simplify_cmplx ("COMPLEX", x, y, kind);
1663 gfc_simplify_conjg (gfc_expr *e)
1667 if (e->expr_type != EXPR_CONSTANT)
1670 result = gfc_copy_expr (e);
1671 mpc_conj (result->value.complex, result->value.complex, GFC_MPC_RND_MODE);
1673 return range_check (result, "CONJG");
1678 gfc_simplify_cos (gfc_expr *x)
1682 if (x->expr_type != EXPR_CONSTANT)
1685 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1690 mpfr_cos (result->value.real, x->value.real, GFC_RND_MODE);
1694 gfc_set_model_kind (x->ts.kind);
1695 mpc_cos (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1699 gfc_internal_error ("in gfc_simplify_cos(): Bad type");
1702 return range_check (result, "COS");
1707 gfc_simplify_cosh (gfc_expr *x)
1711 if (x->expr_type != EXPR_CONSTANT)
1714 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1719 mpfr_cosh (result->value.real, x->value.real, GFC_RND_MODE);
1723 mpc_cosh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
1730 return range_check (result, "COSH");
1735 gfc_simplify_count (gfc_expr *mask, gfc_expr *dim, gfc_expr *kind)
1739 if (!is_constant_array_expr (mask)
1740 || !gfc_is_constant_expr (dim)
1741 || !gfc_is_constant_expr (kind))
1744 result = transformational_result (mask, dim,
1746 get_kind (BT_INTEGER, kind, "COUNT",
1747 gfc_default_integer_kind),
1750 init_result_expr (result, 0, NULL);
1752 /* Passing MASK twice, once as data array, once as mask.
1753 Whenever gfc_count is called, '1' is added to the result. */
1754 return !dim || mask->rank == 1 ?
1755 simplify_transformation_to_scalar (result, mask, mask, gfc_count) :
1756 simplify_transformation_to_array (result, mask, dim, mask, gfc_count, NULL);
1761 gfc_simplify_dcmplx (gfc_expr *x, gfc_expr *y)
1763 return simplify_cmplx ("DCMPLX", x, y, gfc_default_double_kind);
1768 gfc_simplify_dble (gfc_expr *e)
1770 gfc_expr *result = NULL;
1772 if (e->expr_type != EXPR_CONSTANT)
1775 if (convert_boz (e, gfc_default_double_kind) == &gfc_bad_expr)
1776 return &gfc_bad_expr;
1778 result = gfc_convert_constant (e, BT_REAL, gfc_default_double_kind);
1779 if (result == &gfc_bad_expr)
1780 return &gfc_bad_expr;
1782 return range_check (result, "DBLE");
1787 gfc_simplify_digits (gfc_expr *x)
1791 i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
1796 digits = gfc_integer_kinds[i].digits;
1801 digits = gfc_real_kinds[i].digits;
1808 return gfc_get_int_expr (gfc_default_integer_kind, NULL, digits);
1813 gfc_simplify_dim (gfc_expr *x, gfc_expr *y)
1818 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
1821 kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
1822 result = gfc_get_constant_expr (x->ts.type, kind, &x->where);
1827 if (mpz_cmp (x->value.integer, y->value.integer) > 0)
1828 mpz_sub (result->value.integer, x->value.integer, y->value.integer);
1830 mpz_set_ui (result->value.integer, 0);
1835 if (mpfr_cmp (x->value.real, y->value.real) > 0)
1836 mpfr_sub (result->value.real, x->value.real, y->value.real,
1839 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
1844 gfc_internal_error ("gfc_simplify_dim(): Bad type");
1847 return range_check (result, "DIM");
1852 gfc_simplify_dot_product (gfc_expr *vector_a, gfc_expr *vector_b)
1854 if (!is_constant_array_expr (vector_a)
1855 || !is_constant_array_expr (vector_b))
1858 gcc_assert (vector_a->rank == 1);
1859 gcc_assert (vector_b->rank == 1);
1860 gcc_assert (gfc_compare_types (&vector_a->ts, &vector_b->ts));
1862 return compute_dot_product (vector_a, 1, 0, vector_b, 1, 0);
1867 gfc_simplify_dprod (gfc_expr *x, gfc_expr *y)
1869 gfc_expr *a1, *a2, *result;
1871 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
1874 a1 = gfc_real2real (x, gfc_default_double_kind);
1875 a2 = gfc_real2real (y, gfc_default_double_kind);
1877 result = gfc_get_constant_expr (BT_REAL, gfc_default_double_kind, &x->where);
1878 mpfr_mul (result->value.real, a1->value.real, a2->value.real, GFC_RND_MODE);
1883 return range_check (result, "DPROD");
1888 simplify_dshift (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg,
1892 int i, k, size, shift;
1894 if (arg1->expr_type != EXPR_CONSTANT || arg2->expr_type != EXPR_CONSTANT
1895 || shiftarg->expr_type != EXPR_CONSTANT)
1898 k = gfc_validate_kind (BT_INTEGER, arg1->ts.kind, false);
1899 size = gfc_integer_kinds[k].bit_size;
1901 if (gfc_extract_int (shiftarg, &shift) != NULL)
1903 gfc_error ("Invalid SHIFT argument of DSHIFTL at %L", &shiftarg->where);
1904 return &gfc_bad_expr;
1907 gcc_assert (shift >= 0 && shift <= size);
1909 /* DSHIFTR(I,J,SHIFT) = DSHIFTL(I,J,SIZE-SHIFT). */
1911 shift = size - shift;
1913 result = gfc_get_constant_expr (BT_INTEGER, arg1->ts.kind, &arg1->where);
1914 mpz_set_ui (result->value.integer, 0);
1916 for (i = 0; i < shift; i++)
1917 if (mpz_tstbit (arg2->value.integer, size - shift + i))
1918 mpz_setbit (result->value.integer, i);
1920 for (i = 0; i < size - shift; i++)
1921 if (mpz_tstbit (arg1->value.integer, i))
1922 mpz_setbit (result->value.integer, shift + i);
1924 /* Convert to a signed value. */
1925 convert_mpz_to_signed (result->value.integer, size);
1932 gfc_simplify_dshiftr (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg)
1934 return simplify_dshift (arg1, arg2, shiftarg, true);
1939 gfc_simplify_dshiftl (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg)
1941 return simplify_dshift (arg1, arg2, shiftarg, false);
1946 gfc_simplify_erf (gfc_expr *x)
1950 if (x->expr_type != EXPR_CONSTANT)
1953 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1954 mpfr_erf (result->value.real, x->value.real, GFC_RND_MODE);
1956 return range_check (result, "ERF");
1961 gfc_simplify_erfc (gfc_expr *x)
1965 if (x->expr_type != EXPR_CONSTANT)
1968 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
1969 mpfr_erfc (result->value.real, x->value.real, GFC_RND_MODE);
1971 return range_check (result, "ERFC");
1975 /* Helper functions to simplify ERFC_SCALED(x) = ERFC(x) * EXP(X**2). */
1977 #define MAX_ITER 200
1978 #define ARG_LIMIT 12
1980 /* Calculate ERFC_SCALED directly by its definition:
1982 ERFC_SCALED(x) = ERFC(x) * EXP(X**2)
1984 using a large precision for intermediate results. This is used for all
1985 but large values of the argument. */
1987 fullprec_erfc_scaled (mpfr_t res, mpfr_t arg)
1992 prec = mpfr_get_default_prec ();
1993 mpfr_set_default_prec (10 * prec);
1998 mpfr_set (a, arg, GFC_RND_MODE);
1999 mpfr_sqr (b, a, GFC_RND_MODE);
2000 mpfr_exp (b, b, GFC_RND_MODE);
2001 mpfr_erfc (a, a, GFC_RND_MODE);
2002 mpfr_mul (a, a, b, GFC_RND_MODE);
2004 mpfr_set (res, a, GFC_RND_MODE);
2005 mpfr_set_default_prec (prec);
2011 /* Calculate ERFC_SCALED using a power series expansion in 1/arg:
2013 ERFC_SCALED(x) = 1 / (x * sqrt(pi))
2014 * (1 + Sum_n (-1)**n * (1 * 3 * 5 * ... * (2n-1))
2017 This is used for large values of the argument. Intermediate calculations
2018 are performed with twice the precision. We don't do a fixed number of
2019 iterations of the sum, but stop when it has converged to the required
2022 asympt_erfc_scaled (mpfr_t res, mpfr_t arg)
2024 mpfr_t sum, x, u, v, w, oldsum, sumtrunc;
2029 prec = mpfr_get_default_prec ();
2030 mpfr_set_default_prec (2 * prec);
2040 mpfr_init (sumtrunc);
2041 mpfr_set_prec (oldsum, prec);
2042 mpfr_set_prec (sumtrunc, prec);
2044 mpfr_set (x, arg, GFC_RND_MODE);
2045 mpfr_set_ui (sum, 1, GFC_RND_MODE);
2046 mpz_set_ui (num, 1);
2048 mpfr_set (u, x, GFC_RND_MODE);
2049 mpfr_sqr (u, u, GFC_RND_MODE);
2050 mpfr_mul_ui (u, u, 2, GFC_RND_MODE);
2051 mpfr_pow_si (u, u, -1, GFC_RND_MODE);
2053 for (i = 1; i < MAX_ITER; i++)
2055 mpfr_set (oldsum, sum, GFC_RND_MODE);
2057 mpz_mul_ui (num, num, 2 * i - 1);
2060 mpfr_set (w, u, GFC_RND_MODE);
2061 mpfr_pow_ui (w, w, i, GFC_RND_MODE);
2063 mpfr_set_z (v, num, GFC_RND_MODE);
2064 mpfr_mul (v, v, w, GFC_RND_MODE);
2066 mpfr_add (sum, sum, v, GFC_RND_MODE);
2068 mpfr_set (sumtrunc, sum, GFC_RND_MODE);
2069 if (mpfr_cmp (sumtrunc, oldsum) == 0)
2073 /* We should have converged by now; otherwise, ARG_LIMIT is probably
2075 gcc_assert (i < MAX_ITER);
2077 /* Divide by x * sqrt(Pi). */
2078 mpfr_const_pi (u, GFC_RND_MODE);
2079 mpfr_sqrt (u, u, GFC_RND_MODE);
2080 mpfr_mul (u, u, x, GFC_RND_MODE);
2081 mpfr_div (sum, sum, u, GFC_RND_MODE);
2083 mpfr_set (res, sum, GFC_RND_MODE);
2084 mpfr_set_default_prec (prec);
2086 mpfr_clears (sum, x, u, v, w, oldsum, sumtrunc, NULL);
2092 gfc_simplify_erfc_scaled (gfc_expr *x)
2096 if (x->expr_type != EXPR_CONSTANT)
2099 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
2100 if (mpfr_cmp_d (x->value.real, ARG_LIMIT) >= 0)
2101 asympt_erfc_scaled (result->value.real, x->value.real);
2103 fullprec_erfc_scaled (result->value.real, x->value.real);
2105 return range_check (result, "ERFC_SCALED");
2113 gfc_simplify_epsilon (gfc_expr *e)
2118 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
2120 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
2121 mpfr_set (result->value.real, gfc_real_kinds[i].epsilon, GFC_RND_MODE);
2123 return range_check (result, "EPSILON");
2128 gfc_simplify_exp (gfc_expr *x)
2132 if (x->expr_type != EXPR_CONSTANT)
2135 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
2140 mpfr_exp (result->value.real, x->value.real, GFC_RND_MODE);
2144 gfc_set_model_kind (x->ts.kind);
2145 mpc_exp (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
2149 gfc_internal_error ("in gfc_simplify_exp(): Bad type");
2152 return range_check (result, "EXP");
2157 gfc_simplify_exponent (gfc_expr *x)
2162 if (x->expr_type != EXPR_CONSTANT)
2165 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
2168 gfc_set_model (x->value.real);
2170 if (mpfr_sgn (x->value.real) == 0)
2172 mpz_set_ui (result->value.integer, 0);
2176 i = (int) mpfr_get_exp (x->value.real);
2177 mpz_set_si (result->value.integer, i);
2179 return range_check (result, "EXPONENT");
2184 gfc_simplify_float (gfc_expr *a)
2188 if (a->expr_type != EXPR_CONSTANT)
2193 if (convert_boz (a, gfc_default_real_kind) == &gfc_bad_expr)
2194 return &gfc_bad_expr;
2196 result = gfc_copy_expr (a);
2199 result = gfc_int2real (a, gfc_default_real_kind);
2201 return range_check (result, "FLOAT");
2206 gfc_simplify_floor (gfc_expr *e, gfc_expr *k)
2212 kind = get_kind (BT_INTEGER, k, "FLOOR", gfc_default_integer_kind);
2214 gfc_internal_error ("gfc_simplify_floor(): Bad kind");
2216 if (e->expr_type != EXPR_CONSTANT)
2219 gfc_set_model_kind (kind);
2222 mpfr_floor (floor, e->value.real);
2224 result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
2225 gfc_mpfr_to_mpz (result->value.integer, floor, &e->where);
2229 return range_check (result, "FLOOR");
2234 gfc_simplify_fraction (gfc_expr *x)
2237 mpfr_t absv, exp, pow2;
2239 if (x->expr_type != EXPR_CONSTANT)
2242 result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
2244 if (mpfr_sgn (x->value.real) == 0)
2246 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
2250 gfc_set_model_kind (x->ts.kind);
2255 mpfr_abs (absv, x->value.real, GFC_RND_MODE);
2256 mpfr_log2 (exp, absv, GFC_RND_MODE);
2258 mpfr_trunc (exp, exp);
2259 mpfr_add_ui (exp, exp, 1, GFC_RND_MODE);
2261 mpfr_ui_pow (pow2, 2, exp, GFC_RND_MODE);
2263 mpfr_div (result->value.real, absv, pow2, GFC_RND_MODE);
2265 mpfr_clears (exp, absv, pow2, NULL);
2267 return range_check (result, "FRACTION");
2272 gfc_simplify_gamma (gfc_expr *x)
2276 if (x->expr_type != EXPR_CONSTANT)
2279 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
2280 mpfr_gamma (result->value.real, x->value.real, GFC_RND_MODE);
2282 return range_check (result, "GAMMA");
2287 gfc_simplify_huge (gfc_expr *e)
2292 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
2293 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
2298 mpz_set (result->value.integer, gfc_integer_kinds[i].huge);
2302 mpfr_set (result->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
2314 gfc_simplify_hypot (gfc_expr *x, gfc_expr *y)
2318 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2321 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
2322 mpfr_hypot (result->value.real, x->value.real, y->value.real, GFC_RND_MODE);
2323 return range_check (result, "HYPOT");
2327 /* We use the processor's collating sequence, because all
2328 systems that gfortran currently works on are ASCII. */
2331 gfc_simplify_iachar (gfc_expr *e, gfc_expr *kind)
2337 if (e->expr_type != EXPR_CONSTANT)
2340 if (e->value.character.length != 1)
2342 gfc_error ("Argument of IACHAR at %L must be of length one", &e->where);
2343 return &gfc_bad_expr;
2346 index = e->value.character.string[0];
2348 if (gfc_option.warn_surprising && index > 127)
2349 gfc_warning ("Argument of IACHAR function at %L outside of range 0..127",
2352 k = get_kind (BT_INTEGER, kind, "IACHAR", gfc_default_integer_kind);
2354 return &gfc_bad_expr;
2356 result = gfc_get_int_expr (k, &e->where, index);
2358 return range_check (result, "IACHAR");
2363 do_bit_and (gfc_expr *result, gfc_expr *e)
2365 gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
2366 gcc_assert (result->ts.type == BT_INTEGER
2367 && result->expr_type == EXPR_CONSTANT);
2369 mpz_and (result->value.integer, result->value.integer, e->value.integer);
2375 gfc_simplify_iall (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
2377 return simplify_transformation (array, dim, mask, -1, do_bit_and);
2382 do_bit_ior (gfc_expr *result, gfc_expr *e)
2384 gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
2385 gcc_assert (result->ts.type == BT_INTEGER
2386 && result->expr_type == EXPR_CONSTANT);
2388 mpz_ior (result->value.integer, result->value.integer, e->value.integer);
2394 gfc_simplify_iany (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
2396 return simplify_transformation (array, dim, mask, 0, do_bit_ior);
2401 gfc_simplify_iand (gfc_expr *x, gfc_expr *y)
2405 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2408 result = gfc_get_constant_expr (BT_INTEGER, x->ts.kind, &x->where);
2409 mpz_and (result->value.integer, x->value.integer, y->value.integer);
2411 return range_check (result, "IAND");
2416 gfc_simplify_ibclr (gfc_expr *x, gfc_expr *y)
2421 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2424 if (gfc_extract_int (y, &pos) != NULL || pos < 0)
2426 gfc_error ("Invalid second argument of IBCLR at %L", &y->where);
2427 return &gfc_bad_expr;
2430 k = gfc_validate_kind (x->ts.type, x->ts.kind, false);
2432 if (pos >= gfc_integer_kinds[k].bit_size)
2434 gfc_error ("Second argument of IBCLR exceeds bit size at %L",
2436 return &gfc_bad_expr;
2439 result = gfc_copy_expr (x);
2441 convert_mpz_to_unsigned (result->value.integer,
2442 gfc_integer_kinds[k].bit_size);
2444 mpz_clrbit (result->value.integer, pos);
2446 convert_mpz_to_signed (result->value.integer,
2447 gfc_integer_kinds[k].bit_size);
2454 gfc_simplify_ibits (gfc_expr *x, gfc_expr *y, gfc_expr *z)
2461 if (x->expr_type != EXPR_CONSTANT
2462 || y->expr_type != EXPR_CONSTANT
2463 || z->expr_type != EXPR_CONSTANT)
2466 if (gfc_extract_int (y, &pos) != NULL || pos < 0)
2468 gfc_error ("Invalid second argument of IBITS at %L", &y->where);
2469 return &gfc_bad_expr;
2472 if (gfc_extract_int (z, &len) != NULL || len < 0)
2474 gfc_error ("Invalid third argument of IBITS at %L", &z->where);
2475 return &gfc_bad_expr;
2478 k = gfc_validate_kind (BT_INTEGER, x->ts.kind, false);
2480 bitsize = gfc_integer_kinds[k].bit_size;
2482 if (pos + len > bitsize)
2484 gfc_error ("Sum of second and third arguments of IBITS exceeds "
2485 "bit size at %L", &y->where);
2486 return &gfc_bad_expr;
2489 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
2490 convert_mpz_to_unsigned (result->value.integer,
2491 gfc_integer_kinds[k].bit_size);
2493 bits = XCNEWVEC (int, bitsize);
2495 for (i = 0; i < bitsize; i++)
2498 for (i = 0; i < len; i++)
2499 bits[i] = mpz_tstbit (x->value.integer, i + pos);
2501 for (i = 0; i < bitsize; i++)
2504 mpz_clrbit (result->value.integer, i);
2505 else if (bits[i] == 1)
2506 mpz_setbit (result->value.integer, i);
2508 gfc_internal_error ("IBITS: Bad bit");
2513 convert_mpz_to_signed (result->value.integer,
2514 gfc_integer_kinds[k].bit_size);
2521 gfc_simplify_ibset (gfc_expr *x, gfc_expr *y)
2526 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2529 if (gfc_extract_int (y, &pos) != NULL || pos < 0)
2531 gfc_error ("Invalid second argument of IBSET at %L", &y->where);
2532 return &gfc_bad_expr;
2535 k = gfc_validate_kind (x->ts.type, x->ts.kind, false);
2537 if (pos >= gfc_integer_kinds[k].bit_size)
2539 gfc_error ("Second argument of IBSET exceeds bit size at %L",
2541 return &gfc_bad_expr;
2544 result = gfc_copy_expr (x);
2546 convert_mpz_to_unsigned (result->value.integer,
2547 gfc_integer_kinds[k].bit_size);
2549 mpz_setbit (result->value.integer, pos);
2551 convert_mpz_to_signed (result->value.integer,
2552 gfc_integer_kinds[k].bit_size);
2559 gfc_simplify_ichar (gfc_expr *e, gfc_expr *kind)
2565 if (e->expr_type != EXPR_CONSTANT)
2568 if (e->value.character.length != 1)
2570 gfc_error ("Argument of ICHAR at %L must be of length one", &e->where);
2571 return &gfc_bad_expr;
2574 index = e->value.character.string[0];
2576 k = get_kind (BT_INTEGER, kind, "ICHAR", gfc_default_integer_kind);
2578 return &gfc_bad_expr;
2580 result = gfc_get_int_expr (k, &e->where, index);
2582 return range_check (result, "ICHAR");
2587 gfc_simplify_ieor (gfc_expr *x, gfc_expr *y)
2591 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2594 result = gfc_get_constant_expr (BT_INTEGER, x->ts.kind, &x->where);
2595 mpz_xor (result->value.integer, x->value.integer, y->value.integer);
2597 return range_check (result, "IEOR");
2602 gfc_simplify_index (gfc_expr *x, gfc_expr *y, gfc_expr *b, gfc_expr *kind)
2605 int back, len, lensub;
2606 int i, j, k, count, index = 0, start;
2608 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT
2609 || ( b != NULL && b->expr_type != EXPR_CONSTANT))
2612 if (b != NULL && b->value.logical != 0)
2617 k = get_kind (BT_INTEGER, kind, "INDEX", gfc_default_integer_kind);
2619 return &gfc_bad_expr;
2621 result = gfc_get_constant_expr (BT_INTEGER, k, &x->where);
2623 len = x->value.character.length;
2624 lensub = y->value.character.length;
2628 mpz_set_si (result->value.integer, 0);
2636 mpz_set_si (result->value.integer, 1);
2639 else if (lensub == 1)
2641 for (i = 0; i < len; i++)
2643 for (j = 0; j < lensub; j++)
2645 if (y->value.character.string[j]
2646 == x->value.character.string[i])
2656 for (i = 0; i < len; i++)
2658 for (j = 0; j < lensub; j++)
2660 if (y->value.character.string[j]
2661 == x->value.character.string[i])
2666 for (k = 0; k < lensub; k++)
2668 if (y->value.character.string[k]
2669 == x->value.character.string[k + start])
2673 if (count == lensub)
2688 mpz_set_si (result->value.integer, len + 1);
2691 else if (lensub == 1)
2693 for (i = 0; i < len; i++)
2695 for (j = 0; j < lensub; j++)
2697 if (y->value.character.string[j]
2698 == x->value.character.string[len - i])
2700 index = len - i + 1;
2708 for (i = 0; i < len; i++)
2710 for (j = 0; j < lensub; j++)
2712 if (y->value.character.string[j]
2713 == x->value.character.string[len - i])
2716 if (start <= len - lensub)
2719 for (k = 0; k < lensub; k++)
2720 if (y->value.character.string[k]
2721 == x->value.character.string[k + start])
2724 if (count == lensub)
2741 mpz_set_si (result->value.integer, index);
2742 return range_check (result, "INDEX");
2747 simplify_intconv (gfc_expr *e, int kind, const char *name)
2749 gfc_expr *result = NULL;
2751 if (e->expr_type != EXPR_CONSTANT)
2754 result = gfc_convert_constant (e, BT_INTEGER, kind);
2755 if (result == &gfc_bad_expr)
2756 return &gfc_bad_expr;
2758 return range_check (result, name);
2763 gfc_simplify_int (gfc_expr *e, gfc_expr *k)
2767 kind = get_kind (BT_INTEGER, k, "INT", gfc_default_integer_kind);
2769 return &gfc_bad_expr;
2771 return simplify_intconv (e, kind, "INT");
2775 gfc_simplify_int2 (gfc_expr *e)
2777 return simplify_intconv (e, 2, "INT2");
2782 gfc_simplify_int8 (gfc_expr *e)
2784 return simplify_intconv (e, 8, "INT8");
2789 gfc_simplify_long (gfc_expr *e)
2791 return simplify_intconv (e, 4, "LONG");
2796 gfc_simplify_ifix (gfc_expr *e)
2798 gfc_expr *rtrunc, *result;
2800 if (e->expr_type != EXPR_CONSTANT)
2803 rtrunc = gfc_copy_expr (e);
2804 mpfr_trunc (rtrunc->value.real, e->value.real);
2806 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
2808 gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real, &e->where);
2810 gfc_free_expr (rtrunc);
2812 return range_check (result, "IFIX");
2817 gfc_simplify_idint (gfc_expr *e)
2819 gfc_expr *rtrunc, *result;
2821 if (e->expr_type != EXPR_CONSTANT)
2824 rtrunc = gfc_copy_expr (e);
2825 mpfr_trunc (rtrunc->value.real, e->value.real);
2827 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
2829 gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real, &e->where);
2831 gfc_free_expr (rtrunc);
2833 return range_check (result, "IDINT");
2838 gfc_simplify_ior (gfc_expr *x, gfc_expr *y)
2842 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
2845 result = gfc_get_constant_expr (BT_INTEGER, x->ts.kind, &x->where);
2846 mpz_ior (result->value.integer, x->value.integer, y->value.integer);
2848 return range_check (result, "IOR");
2853 do_bit_xor (gfc_expr *result, gfc_expr *e)
2855 gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
2856 gcc_assert (result->ts.type == BT_INTEGER
2857 && result->expr_type == EXPR_CONSTANT);
2859 mpz_xor (result->value.integer, result->value.integer, e->value.integer);
2865 gfc_simplify_iparity (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
2867 return simplify_transformation (array, dim, mask, 0, do_bit_xor);
2873 gfc_simplify_is_iostat_end (gfc_expr *x)
2875 if (x->expr_type != EXPR_CONSTANT)
2878 return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
2879 mpz_cmp_si (x->value.integer,
2880 LIBERROR_END) == 0);
2885 gfc_simplify_is_iostat_eor (gfc_expr *x)
2887 if (x->expr_type != EXPR_CONSTANT)
2890 return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
2891 mpz_cmp_si (x->value.integer,
2892 LIBERROR_EOR) == 0);
2897 gfc_simplify_isnan (gfc_expr *x)
2899 if (x->expr_type != EXPR_CONSTANT)
2902 return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
2903 mpfr_nan_p (x->value.real));
2907 /* Performs a shift on its first argument. Depending on the last
2908 argument, the shift can be arithmetic, i.e. with filling from the
2909 left like in the SHIFTA intrinsic. */
2911 simplify_shift (gfc_expr *e, gfc_expr *s, const char *name,
2912 bool arithmetic, int direction)
2915 int ashift, *bits, i, k, bitsize, shift;
2917 if (e->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
2919 if (gfc_extract_int (s, &shift) != NULL)
2921 gfc_error ("Invalid second argument of %s at %L", name, &s->where);
2922 return &gfc_bad_expr;
2925 k = gfc_validate_kind (BT_INTEGER, e->ts.kind, false);
2926 bitsize = gfc_integer_kinds[k].bit_size;
2928 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
2932 mpz_set (result->value.integer, e->value.integer);
2936 if (direction > 0 && shift < 0)
2938 /* Left shift, as in SHIFTL. */
2939 gfc_error ("Second argument of %s is negative at %L", name, &e->where);
2940 return &gfc_bad_expr;
2942 else if (direction < 0)
2944 /* Right shift, as in SHIFTR or SHIFTA. */
2947 gfc_error ("Second argument of %s is negative at %L",
2949 return &gfc_bad_expr;
2955 ashift = (shift >= 0 ? shift : -shift);
2957 if (ashift > bitsize)
2959 gfc_error ("Magnitude of second argument of %s exceeds bit size "
2960 "at %L", name, &e->where);
2961 return &gfc_bad_expr;
2964 bits = XCNEWVEC (int, bitsize);
2966 for (i = 0; i < bitsize; i++)
2967 bits[i] = mpz_tstbit (e->value.integer, i);
2972 for (i = 0; i < shift; i++)
2973 mpz_clrbit (result->value.integer, i);
2975 for (i = 0; i < bitsize - shift; i++)
2978 mpz_clrbit (result->value.integer, i + shift);
2980 mpz_setbit (result->value.integer, i + shift);
2986 if (arithmetic && bits[bitsize - 1])
2987 for (i = bitsize - 1; i >= bitsize - ashift; i--)
2988 mpz_setbit (result->value.integer, i);
2990 for (i = bitsize - 1; i >= bitsize - ashift; i--)
2991 mpz_clrbit (result->value.integer, i);
2993 for (i = bitsize - 1; i >= ashift; i--)
2996 mpz_clrbit (result->value.integer, i - ashift);
2998 mpz_setbit (result->value.integer, i - ashift);
3002 convert_mpz_to_signed (result->value.integer, bitsize);
3010 gfc_simplify_ishft (gfc_expr *e, gfc_expr *s)
3012 return simplify_shift (e, s, "ISHFT", false, 0);
3017 gfc_simplify_lshift (gfc_expr *e, gfc_expr *s)
3019 return simplify_shift (e, s, "LSHIFT", false, 1);
3024 gfc_simplify_rshift (gfc_expr *e, gfc_expr *s)
3026 return simplify_shift (e, s, "RSHIFT", true, -1);
3031 gfc_simplify_shifta (gfc_expr *e, gfc_expr *s)
3033 return simplify_shift (e, s, "SHIFTA", true, -1);
3038 gfc_simplify_shiftl (gfc_expr *e, gfc_expr *s)
3040 return simplify_shift (e, s, "SHIFTL", false, 1);
3045 gfc_simplify_shiftr (gfc_expr *e, gfc_expr *s)
3047 return simplify_shift (e, s, "SHIFTR", false, -1);
3052 gfc_simplify_ishftc (gfc_expr *e, gfc_expr *s, gfc_expr *sz)
3055 int shift, ashift, isize, ssize, delta, k;
3058 if (e->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
3061 if (gfc_extract_int (s, &shift) != NULL)
3063 gfc_error ("Invalid second argument of ISHFTC at %L", &s->where);
3064 return &gfc_bad_expr;
3067 k = gfc_validate_kind (e->ts.type, e->ts.kind, false);
3068 isize = gfc_integer_kinds[k].bit_size;
3072 if (sz->expr_type != EXPR_CONSTANT)
3075 if (gfc_extract_int (sz, &ssize) != NULL || ssize <= 0)
3077 gfc_error ("Invalid third argument of ISHFTC at %L", &sz->where);
3078 return &gfc_bad_expr;
3083 gfc_error ("Magnitude of third argument of ISHFTC exceeds "
3084 "BIT_SIZE of first argument at %L", &s->where);
3085 return &gfc_bad_expr;
3099 gfc_error ("Magnitude of second argument of ISHFTC exceeds "
3100 "third argument at %L", &s->where);
3102 gfc_error ("Magnitude of second argument of ISHFTC exceeds "
3103 "BIT_SIZE of first argument at %L", &s->where);
3104 return &gfc_bad_expr;
3107 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
3109 mpz_set (result->value.integer, e->value.integer);
3114 convert_mpz_to_unsigned (result->value.integer, isize);
3116 bits = XCNEWVEC (int, ssize);
3118 for (i = 0; i < ssize; i++)
3119 bits[i] = mpz_tstbit (e->value.integer, i);
3121 delta = ssize - ashift;
3125 for (i = 0; i < delta; i++)
3128 mpz_clrbit (result->value.integer, i + shift);
3130 mpz_setbit (result->value.integer, i + shift);
3133 for (i = delta; i < ssize; i++)
3136 mpz_clrbit (result->value.integer, i - delta);
3138 mpz_setbit (result->value.integer, i - delta);
3143 for (i = 0; i < ashift; i++)
3146 mpz_clrbit (result->value.integer, i + delta);
3148 mpz_setbit (result->value.integer, i + delta);
3151 for (i = ashift; i < ssize; i++)
3154 mpz_clrbit (result->value.integer, i + shift);
3156 mpz_setbit (result->value.integer, i + shift);
3160 convert_mpz_to_signed (result->value.integer, isize);
3168 gfc_simplify_kind (gfc_expr *e)
3170 return gfc_get_int_expr (gfc_default_integer_kind, NULL, e->ts.kind);
3175 simplify_bound_dim (gfc_expr *array, gfc_expr *kind, int d, int upper,
3176 gfc_array_spec *as, gfc_ref *ref, bool coarray)
3178 gfc_expr *l, *u, *result;
3181 k = get_kind (BT_INTEGER, kind, upper ? "UBOUND" : "LBOUND",
3182 gfc_default_integer_kind);
3184 return &gfc_bad_expr;
3186 result = gfc_get_constant_expr (BT_INTEGER, k, &array->where);
3188 /* For non-variables, LBOUND(expr, DIM=n) = 1 and
3189 UBOUND(expr, DIM=n) = SIZE(expr, DIM=n). */
3190 if (!coarray && array->expr_type != EXPR_VARIABLE)
3194 gfc_expr* dim = result;
3195 mpz_set_si (dim->value.integer, d);
3197 result = gfc_simplify_size (array, dim, kind);
3198 gfc_free_expr (dim);
3203 mpz_set_si (result->value.integer, 1);
3208 /* Otherwise, we have a variable expression. */
3209 gcc_assert (array->expr_type == EXPR_VARIABLE);
3212 /* The last dimension of an assumed-size array is special. */
3213 if ((!coarray && d == as->rank && as->type == AS_ASSUMED_SIZE && !upper)
3214 || (coarray && d == as->rank + as->corank))
3216 if (as->lower[d-1]->expr_type == EXPR_CONSTANT)
3218 gfc_free_expr (result);
3219 return gfc_copy_expr (as->lower[d-1]);
3225 result = gfc_get_constant_expr (BT_INTEGER, k, &array->where);
3227 /* Then, we need to know the extent of the given dimension. */
3228 if (coarray || ref->u.ar.type == AR_FULL)
3233 if (l->expr_type != EXPR_CONSTANT || u == NULL
3234 || u->expr_type != EXPR_CONSTANT)
3237 if (mpz_cmp (l->value.integer, u->value.integer) > 0)
3241 mpz_set_si (result->value.integer, 0);
3243 mpz_set_si (result->value.integer, 1);
3247 /* Nonzero extent. */
3249 mpz_set (result->value.integer, u->value.integer);
3251 mpz_set (result->value.integer, l->value.integer);
3258 if (gfc_ref_dimen_size (&ref->u.ar, d-1, &result->value.integer, NULL)
3263 mpz_set_si (result->value.integer, (long int) 1);
3267 return range_check (result, upper ? "UBOUND" : "LBOUND");
3270 gfc_free_expr (result);
3276 simplify_bound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind, int upper)
3282 if (array->expr_type != EXPR_VARIABLE)
3289 /* Follow any component references. */
3290 as = array->symtree->n.sym->as;
3291 for (ref = array->ref; ref; ref = ref->next)
3296 switch (ref->u.ar.type)
3303 /* We're done because 'as' has already been set in the
3304 previous iteration. */
3321 as = ref->u.c.component->as;
3333 if (as && (as->type == AS_DEFERRED || as->type == AS_ASSUMED_SHAPE))
3338 /* Multi-dimensional bounds. */
3339 gfc_expr *bounds[GFC_MAX_DIMENSIONS];
3343 /* UBOUND(ARRAY) is not valid for an assumed-size array. */
3344 if (upper && as && as->type == AS_ASSUMED_SIZE)
3346 /* An error message will be emitted in
3347 check_assumed_size_reference (resolve.c). */
3348 return &gfc_bad_expr;
3351 /* Simplify the bounds for each dimension. */
3352 for (d = 0; d < array->rank; d++)
3354 bounds[d] = simplify_bound_dim (array, kind, d + 1, upper, as, ref,
3356 if (bounds[d] == NULL || bounds[d] == &gfc_bad_expr)
3360 for (j = 0; j < d; j++)
3361 gfc_free_expr (bounds[j]);
3366 /* Allocate the result expression. */
3367 k = get_kind (BT_INTEGER, kind, upper ? "UBOUND" : "LBOUND",
3368 gfc_default_integer_kind);
3370 return &gfc_bad_expr;
3372 e = gfc_get_array_expr (BT_INTEGER, k, &array->where);
3374 /* The result is a rank 1 array; its size is the rank of the first
3375 argument to {L,U}BOUND. */
3377 e->shape = gfc_get_shape (1);
3378 mpz_init_set_ui (e->shape[0], array->rank);
3380 /* Create the constructor for this array. */
3381 for (d = 0; d < array->rank; d++)
3382 gfc_constructor_append_expr (&e->value.constructor,
3383 bounds[d], &e->where);
3389 /* A DIM argument is specified. */
3390 if (dim->expr_type != EXPR_CONSTANT)
3393 d = mpz_get_si (dim->value.integer);
3395 if (d < 1 || d > array->rank
3396 || (d == array->rank && as && as->type == AS_ASSUMED_SIZE && upper))
3398 gfc_error ("DIM argument at %L is out of bounds", &dim->where);
3399 return &gfc_bad_expr;
3402 return simplify_bound_dim (array, kind, d, upper, as, ref, false);
3408 simplify_cobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind, int upper)
3414 if (array->expr_type != EXPR_VARIABLE)
3417 /* Follow any component references. */
3418 as = array->symtree->n.sym->as;
3419 for (ref = array->ref; ref; ref = ref->next)
3424 switch (ref->u.ar.type)
3427 if (ref->next == NULL)
3429 gcc_assert (ref->u.ar.as->corank > 0
3430 && ref->u.ar.as->rank == 0);
3438 /* We're done because 'as' has already been set in the
3439 previous iteration. */
3456 as = ref->u.c.component->as;
3468 if (as->type == AS_DEFERRED || as->type == AS_ASSUMED_SHAPE)
3473 /* Multi-dimensional cobounds. */
3474 gfc_expr *bounds[GFC_MAX_DIMENSIONS];
3478 /* Simplify the cobounds for each dimension. */
3479 for (d = 0; d < as->corank; d++)
3481 bounds[d] = simplify_bound_dim (array, kind, d + 1 + array->rank,
3482 upper, as, ref, true);
3483 if (bounds[d] == NULL || bounds[d] == &gfc_bad_expr)
3487 for (j = 0; j < d; j++)
3488 gfc_free_expr (bounds[j]);
3493 /* Allocate the result expression. */
3494 e = gfc_get_expr ();
3495 e->where = array->where;
3496 e->expr_type = EXPR_ARRAY;
3497 e->ts.type = BT_INTEGER;
3498 k = get_kind (BT_INTEGER, kind, upper ? "UCOBOUND" : "LCOBOUND",
3499 gfc_default_integer_kind);
3503 return &gfc_bad_expr;
3507 /* The result is a rank 1 array; its size is the rank of the first
3508 argument to {L,U}COBOUND. */
3510 e->shape = gfc_get_shape (1);
3511 mpz_init_set_ui (e->shape[0], as->corank);
3513 /* Create the constructor for this array. */
3514 for (d = 0; d < as->corank; d++)
3515 gfc_constructor_append_expr (&e->value.constructor,
3516 bounds[d], &e->where);
3521 /* A DIM argument is specified. */
3522 if (dim->expr_type != EXPR_CONSTANT)
3525 d = mpz_get_si (dim->value.integer);
3527 if (d < 1 || d > as->corank)
3529 gfc_error ("DIM argument at %L is out of bounds", &dim->where);
3530 return &gfc_bad_expr;
3533 return simplify_bound_dim (array, kind, d+array->rank, upper, as, ref, true);
3539 gfc_simplify_lbound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
3541 return simplify_bound (array, dim, kind, 0);
3546 gfc_simplify_lcobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
3549 /* return simplify_cobound (array, dim, kind, 0);*/
3551 e = simplify_cobound (array, dim, kind, 0);
3555 gfc_error ("Not yet implemented: LCOBOUND for coarray with non-constant "
3556 "cobounds at %L", &array->where);
3557 return &gfc_bad_expr;
3561 gfc_simplify_leadz (gfc_expr *e)
3563 unsigned long lz, bs;
3566 if (e->expr_type != EXPR_CONSTANT)
3569 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
3570 bs = gfc_integer_kinds[i].bit_size;
3571 if (mpz_cmp_si (e->value.integer, 0) == 0)
3573 else if (mpz_cmp_si (e->value.integer, 0) < 0)
3576 lz = bs - mpz_sizeinbase (e->value.integer, 2);
3578 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, lz);
3583 gfc_simplify_len (gfc_expr *e, gfc_expr *kind)
3586 int k = get_kind (BT_INTEGER, kind, "LEN", gfc_default_integer_kind);
3589 return &gfc_bad_expr;
3591 if (e->expr_type == EXPR_CONSTANT)
3593 result = gfc_get_constant_expr (BT_INTEGER, k, &e->where);
3594 mpz_set_si (result->value.integer, e->value.character.length);
3595 return range_check (result, "LEN");
3597 else if (e->ts.u.cl != NULL && e->ts.u.cl->length != NULL
3598 && e->ts.u.cl->length->expr_type == EXPR_CONSTANT
3599 && e->ts.u.cl->length->ts.type == BT_INTEGER)
3601 result = gfc_get_constant_expr (BT_INTEGER, k, &e->where);
3602 mpz_set (result->value.integer, e->ts.u.cl->length->value.integer);
3603 return range_check (result, "LEN");
3611 gfc_simplify_len_trim (gfc_expr *e, gfc_expr *kind)
3615 int k = get_kind (BT_INTEGER, kind, "LEN_TRIM", gfc_default_integer_kind);
3618 return &gfc_bad_expr;
3620 if (e->expr_type != EXPR_CONSTANT)
3623 len = e->value.character.length;
3624 for (count = 0, i = 1; i <= len; i++)
3625 if (e->value.character.string[len - i] == ' ')
3630 result = gfc_get_int_expr (k, &e->where, len - count);
3631 return range_check (result, "LEN_TRIM");
3635 gfc_simplify_lgamma (gfc_expr *x)
3640 if (x->expr_type != EXPR_CONSTANT)
3643 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
3644 mpfr_lgamma (result->value.real, &sg, x->value.real, GFC_RND_MODE);
3646 return range_check (result, "LGAMMA");
3651 gfc_simplify_lge (gfc_expr *a, gfc_expr *b)
3653 if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
3656 return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
3657 gfc_compare_string (a, b) >= 0);
3662 gfc_simplify_lgt (gfc_expr *a, gfc_expr *b)
3664 if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
3667 return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
3668 gfc_compare_string (a, b) > 0);
3673 gfc_simplify_lle (gfc_expr *a, gfc_expr *b)
3675 if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
3678 return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
3679 gfc_compare_string (a, b) <= 0);
3684 gfc_simplify_llt (gfc_expr *a, gfc_expr *b)
3686 if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
3689 return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
3690 gfc_compare_string (a, b) < 0);
3695 gfc_simplify_log (gfc_expr *x)
3699 if (x->expr_type != EXPR_CONSTANT)
3702 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
3707 if (mpfr_sgn (x->value.real) <= 0)
3709 gfc_error ("Argument of LOG at %L cannot be less than or equal "
3710 "to zero", &x->where);
3711 gfc_free_expr (result);
3712 return &gfc_bad_expr;
3715 mpfr_log (result->value.real, x->value.real, GFC_RND_MODE);
3719 if ((mpfr_sgn (mpc_realref (x->value.complex)) == 0)
3720 && (mpfr_sgn (mpc_imagref (x->value.complex)) == 0))
3722 gfc_error ("Complex argument of LOG at %L cannot be zero",
3724 gfc_free_expr (result);
3725 return &gfc_bad_expr;
3728 gfc_set_model_kind (x->ts.kind);
3729 mpc_log (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
3733 gfc_internal_error ("gfc_simplify_log: bad type");
3736 return range_check (result, "LOG");
3741 gfc_simplify_log10 (gfc_expr *x)
3745 if (x->expr_type != EXPR_CONSTANT)
3748 if (mpfr_sgn (x->value.real) <= 0)
3750 gfc_error ("Argument of LOG10 at %L cannot be less than or equal "
3751 "to zero", &x->where);
3752 return &gfc_bad_expr;
3755 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
3756 mpfr_log10 (result->value.real, x->value.real, GFC_RND_MODE);
3758 return range_check (result, "LOG10");
3763 gfc_simplify_logical (gfc_expr *e, gfc_expr *k)
3767 kind = get_kind (BT_LOGICAL, k, "LOGICAL", gfc_default_logical_kind);
3769 return &gfc_bad_expr;
3771 if (e->expr_type != EXPR_CONSTANT)
3774 return gfc_get_logical_expr (kind, &e->where, e->value.logical);
3779 gfc_simplify_matmul (gfc_expr *matrix_a, gfc_expr *matrix_b)
3782 int row, result_rows, col, result_columns;
3783 int stride_a, offset_a, stride_b, offset_b;
3785 if (!is_constant_array_expr (matrix_a)
3786 || !is_constant_array_expr (matrix_b))
3789 gcc_assert (gfc_compare_types (&matrix_a->ts, &matrix_b->ts));
3790 result = gfc_get_array_expr (matrix_a->ts.type,
3794 if (matrix_a->rank == 1 && matrix_b->rank == 2)
3797 result_columns = mpz_get_si (matrix_b->shape[0]);
3799 stride_b = mpz_get_si (matrix_b->shape[0]);
3802 result->shape = gfc_get_shape (result->rank);
3803 mpz_init_set_si (result->shape[0], result_columns);
3805 else if (matrix_a->rank == 2 && matrix_b->rank == 1)
3807 result_rows = mpz_get_si (matrix_b->shape[0]);
3809 stride_a = mpz_get_si (matrix_a->shape[0]);
3813 result->shape = gfc_get_shape (result->rank);
3814 mpz_init_set_si (result->shape[0], result_rows);
3816 else if (matrix_a->rank == 2 && matrix_b->rank == 2)
3818 result_rows = mpz_get_si (matrix_a->shape[0]);
3819 result_columns = mpz_get_si (matrix_b->shape[1]);
3820 stride_a = mpz_get_si (matrix_a->shape[1]);
3821 stride_b = mpz_get_si (matrix_b->shape[0]);
3824 result->shape = gfc_get_shape (result->rank);
3825 mpz_init_set_si (result->shape[0], result_rows);
3826 mpz_init_set_si (result->shape[1], result_columns);
3831 offset_a = offset_b = 0;
3832 for (col = 0; col < result_columns; ++col)
3836 for (row = 0; row < result_rows; ++row)
3838 gfc_expr *e = compute_dot_product (matrix_a, stride_a, offset_a,
3839 matrix_b, 1, offset_b);
3840 gfc_constructor_append_expr (&result->value.constructor,
3846 offset_b += stride_b;
3854 gfc_simplify_maskr (gfc_expr *i, gfc_expr *kind_arg)
3860 if (i->expr_type != EXPR_CONSTANT)
3863 kind = get_kind (BT_INTEGER, kind_arg, "MASKR", gfc_default_integer_kind);
3865 return &gfc_bad_expr;
3866 k = gfc_validate_kind (BT_INTEGER, kind, false);
3868 s = gfc_extract_int (i, &arg);
3871 result = gfc_get_constant_expr (BT_INTEGER, kind, &i->where);
3873 /* MASKR(n) = 2^n - 1 */
3874 mpz_set_ui (result->value.integer, 1);
3875 mpz_mul_2exp (result->value.integer, result->value.integer, arg);
3876 mpz_sub_ui (result->value.integer, result->value.integer, 1);
3878 convert_mpz_to_signed (result->value.integer, gfc_integer_kinds[k].bit_size);
3885 gfc_simplify_maskl (gfc_expr *i, gfc_expr *kind_arg)
3892 if (i->expr_type != EXPR_CONSTANT)
3895 kind = get_kind (BT_INTEGER, kind_arg, "MASKL", gfc_default_integer_kind);
3897 return &gfc_bad_expr;
3898 k = gfc_validate_kind (BT_INTEGER, kind, false);
3900 s = gfc_extract_int (i, &arg);
3903 result = gfc_get_constant_expr (BT_INTEGER, kind, &i->where);
3905 /* MASKL(n) = 2^bit_size - 2^(bit_size - n) */
3906 mpz_init_set_ui (z, 1);
3907 mpz_mul_2exp (z, z, gfc_integer_kinds[k].bit_size);
3908 mpz_set_ui (result->value.integer, 1);
3909 mpz_mul_2exp (result->value.integer, result->value.integer,
3910 gfc_integer_kinds[k].bit_size - arg);
3911 mpz_sub (result->value.integer, z, result->value.integer);
3914 convert_mpz_to_signed (result->value.integer, gfc_integer_kinds[k].bit_size);
3921 gfc_simplify_merge (gfc_expr *tsource, gfc_expr *fsource, gfc_expr *mask)
3923 if (tsource->expr_type != EXPR_CONSTANT
3924 || fsource->expr_type != EXPR_CONSTANT
3925 || mask->expr_type != EXPR_CONSTANT)
3928 return gfc_copy_expr (mask->value.logical ? tsource : fsource);
3933 gfc_simplify_merge_bits (gfc_expr *i, gfc_expr *j, gfc_expr *mask_expr)
3935 mpz_t arg1, arg2, mask;
3938 if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT
3939 || mask_expr->expr_type != EXPR_CONSTANT)
3942 result = gfc_get_constant_expr (BT_INTEGER, i->ts.kind, &i->where);
3944 /* Convert all argument to unsigned. */
3945 mpz_init_set (arg1, i->value.integer);
3946 mpz_init_set (arg2, j->value.integer);
3947 mpz_init_set (mask, mask_expr->value.integer);
3949 /* MERGE_BITS(I,J,MASK) = IOR (IAND (I, MASK), IAND (J, NOT (MASK))). */
3950 mpz_and (arg1, arg1, mask);
3951 mpz_com (mask, mask);
3952 mpz_and (arg2, arg2, mask);
3953 mpz_ior (result->value.integer, arg1, arg2);
3963 /* Selects between current value and extremum for simplify_min_max
3964 and simplify_minval_maxval. */
3966 min_max_choose (gfc_expr *arg, gfc_expr *extremum, int sign)
3968 switch (arg->ts.type)
3971 if (mpz_cmp (arg->value.integer,
3972 extremum->value.integer) * sign > 0)
3973 mpz_set (extremum->value.integer, arg->value.integer);
3977 /* We need to use mpfr_min and mpfr_max to treat NaN properly. */
3979 mpfr_max (extremum->value.real, extremum->value.real,
3980 arg->value.real, GFC_RND_MODE);
3982 mpfr_min (extremum->value.real, extremum->value.real,
3983 arg->value.real, GFC_RND_MODE);
3987 #define LENGTH(x) ((x)->value.character.length)
3988 #define STRING(x) ((x)->value.character.string)
3989 if (LENGTH(extremum) < LENGTH(arg))
3991 gfc_char_t *tmp = STRING(extremum);
3993 STRING(extremum) = gfc_get_wide_string (LENGTH(arg) + 1);
3994 memcpy (STRING(extremum), tmp,
3995 LENGTH(extremum) * sizeof (gfc_char_t));
3996 gfc_wide_memset (&STRING(extremum)[LENGTH(extremum)], ' ',
3997 LENGTH(arg) - LENGTH(extremum));
3998 STRING(extremum)[LENGTH(arg)] = '\0'; /* For debugger */
3999 LENGTH(extremum) = LENGTH(arg);
4003 if (gfc_compare_string (arg, extremum) * sign > 0)
4005 gfc_free (STRING(extremum));
4006 STRING(extremum) = gfc_get_wide_string (LENGTH(extremum) + 1);
4007 memcpy (STRING(extremum), STRING(arg),
4008 LENGTH(arg) * sizeof (gfc_char_t));
4009 gfc_wide_memset (&STRING(extremum)[LENGTH(arg)], ' ',
4010 LENGTH(extremum) - LENGTH(arg));
4011 STRING(extremum)[LENGTH(extremum)] = '\0'; /* For debugger */
4018 gfc_internal_error ("simplify_min_max(): Bad type in arglist");
4023 /* This function is special since MAX() can take any number of
4024 arguments. The simplified expression is a rewritten version of the
4025 argument list containing at most one constant element. Other
4026 constant elements are deleted. Because the argument list has
4027 already been checked, this function always succeeds. sign is 1 for
4028 MAX(), -1 for MIN(). */
4031 simplify_min_max (gfc_expr *expr, int sign)
4033 gfc_actual_arglist *arg, *last, *extremum;
4034 gfc_intrinsic_sym * specific;
4038 specific = expr->value.function.isym;
4040 arg = expr->value.function.actual;
4042 for (; arg; last = arg, arg = arg->next)
4044 if (arg->expr->expr_type != EXPR_CONSTANT)
4047 if (extremum == NULL)
4053 min_max_choose (arg->expr, extremum->expr, sign);
4055 /* Delete the extra constant argument. */
4057 expr->value.function.actual = arg->next;
4059 last->next = arg->next;
4062 gfc_free_actual_arglist (arg);
4066 /* If there is one value left, replace the function call with the
4068 if (expr->value.function.actual->next != NULL)
4071 /* Convert to the correct type and kind. */
4072 if (expr->ts.type != BT_UNKNOWN)
4073 return gfc_convert_constant (expr->value.function.actual->expr,
4074 expr->ts.type, expr->ts.kind);
4076 if (specific->ts.type != BT_UNKNOWN)
4077 return gfc_convert_constant (expr->value.function.actual->expr,
4078 specific->ts.type, specific->ts.kind);
4080 return gfc_copy_expr (expr->value.function.actual->expr);
4085 gfc_simplify_min (gfc_expr *e)
4087 return simplify_min_max (e, -1);
4092 gfc_simplify_max (gfc_expr *e)
4094 return simplify_min_max (e, 1);
4098 /* This is a simplified version of simplify_min_max to provide
4099 simplification of minval and maxval for a vector. */
4102 simplify_minval_maxval (gfc_expr *expr, int sign)
4104 gfc_constructor *c, *extremum;
4105 gfc_intrinsic_sym * specific;
4108 specific = expr->value.function.isym;
4110 for (c = gfc_constructor_first (expr->value.constructor);
4111 c; c = gfc_constructor_next (c))
4113 if (c->expr->expr_type != EXPR_CONSTANT)
4116 if (extremum == NULL)
4122 min_max_choose (c->expr, extremum->expr, sign);
4125 if (extremum == NULL)
4128 /* Convert to the correct type and kind. */
4129 if (expr->ts.type != BT_UNKNOWN)
4130 return gfc_convert_constant (extremum->expr,
4131 expr->ts.type, expr->ts.kind);
4133 if (specific->ts.type != BT_UNKNOWN)
4134 return gfc_convert_constant (extremum->expr,
4135 specific->ts.type, specific->ts.kind);
4137 return gfc_copy_expr (extremum->expr);
4142 gfc_simplify_minval (gfc_expr *array, gfc_expr* dim, gfc_expr *mask)
4144 if (array->expr_type != EXPR_ARRAY || array->rank != 1 || dim || mask)
4147 return simplify_minval_maxval (array, -1);
4152 gfc_simplify_maxval (gfc_expr *array, gfc_expr* dim, gfc_expr *mask)
4154 if (array->expr_type != EXPR_ARRAY || array->rank != 1 || dim || mask)
4157 return simplify_minval_maxval (array, 1);
4162 gfc_simplify_maxexponent (gfc_expr *x)
4164 int i = gfc_validate_kind (BT_REAL, x->ts.kind, false);
4165 return gfc_get_int_expr (gfc_default_integer_kind, &x->where,
4166 gfc_real_kinds[i].max_exponent);
4171 gfc_simplify_minexponent (gfc_expr *x)
4173 int i = gfc_validate_kind (BT_REAL, x->ts.kind, false);
4174 return gfc_get_int_expr (gfc_default_integer_kind, &x->where,
4175 gfc_real_kinds[i].min_exponent);
4180 gfc_simplify_mod (gfc_expr *a, gfc_expr *p)
4186 if (a->expr_type != EXPR_CONSTANT || p->expr_type != EXPR_CONSTANT)
4189 kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind;
4190 result = gfc_get_constant_expr (a->ts.type, kind, &a->where);
4195 if (mpz_cmp_ui (p->value.integer, 0) == 0)
4197 /* Result is processor-dependent. */
4198 gfc_error ("Second argument MOD at %L is zero", &a->where);
4199 gfc_free_expr (result);
4200 return &gfc_bad_expr;
4202 mpz_tdiv_r (result->value.integer, a->value.integer, p->value.integer);
4206 if (mpfr_cmp_ui (p->value.real, 0) == 0)
4208 /* Result is processor-dependent. */
4209 gfc_error ("Second argument of MOD at %L is zero", &p->where);
4210 gfc_free_expr (result);
4211 return &gfc_bad_expr;
4214 gfc_set_model_kind (kind);
4216 mpfr_div (tmp, a->value.real, p->value.real, GFC_RND_MODE);
4217 mpfr_trunc (tmp, tmp);
4218 mpfr_mul (tmp, tmp, p->value.real, GFC_RND_MODE);
4219 mpfr_sub (result->value.real, a->value.real, tmp, GFC_RND_MODE);
4224 gfc_internal_error ("gfc_simplify_mod(): Bad arguments");
4227 return range_check (result, "MOD");
4232 gfc_simplify_modulo (gfc_expr *a, gfc_expr *p)
4238 if (a->expr_type != EXPR_CONSTANT || p->expr_type != EXPR_CONSTANT)
4241 kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind;
4242 result = gfc_get_constant_expr (a->ts.type, kind, &a->where);
4247 if (mpz_cmp_ui (p->value.integer, 0) == 0)
4249 /* Result is processor-dependent. This processor just opts
4250 to not handle it at all. */
4251 gfc_error ("Second argument of MODULO at %L is zero", &a->where);
4252 gfc_free_expr (result);
4253 return &gfc_bad_expr;
4255 mpz_fdiv_r (result->value.integer, a->value.integer, p->value.integer);
4260 if (mpfr_cmp_ui (p->value.real, 0) == 0)
4262 /* Result is processor-dependent. */
4263 gfc_error ("Second argument of MODULO at %L is zero", &p->where);
4264 gfc_free_expr (result);
4265 return &gfc_bad_expr;
4268 gfc_set_model_kind (kind);
4270 mpfr_div (tmp, a->value.real, p->value.real, GFC_RND_MODE);
4271 mpfr_floor (tmp, tmp);
4272 mpfr_mul (tmp, tmp, p->value.real, GFC_RND_MODE);
4273 mpfr_sub (result->value.real, a->value.real, tmp, GFC_RND_MODE);
4278 gfc_internal_error ("gfc_simplify_modulo(): Bad arguments");
4281 return range_check (result, "MODULO");
4285 /* Exists for the sole purpose of consistency with other intrinsics. */
4287 gfc_simplify_mvbits (gfc_expr *f ATTRIBUTE_UNUSED,
4288 gfc_expr *fp ATTRIBUTE_UNUSED,
4289 gfc_expr *l ATTRIBUTE_UNUSED,
4290 gfc_expr *to ATTRIBUTE_UNUSED,
4291 gfc_expr *tp ATTRIBUTE_UNUSED)
4298 gfc_simplify_nearest (gfc_expr *x, gfc_expr *s)
4301 mp_exp_t emin, emax;
4304 if (x->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
4307 if (mpfr_sgn (s->value.real) == 0)
4309 gfc_error ("Second argument of NEAREST at %L shall not be zero",
4311 return &gfc_bad_expr;
4314 result = gfc_copy_expr (x);
4316 /* Save current values of emin and emax. */
4317 emin = mpfr_get_emin ();
4318 emax = mpfr_get_emax ();
4320 /* Set emin and emax for the current model number. */
4321 kind = gfc_validate_kind (BT_REAL, x->ts.kind, 0);
4322 mpfr_set_emin ((mp_exp_t) gfc_real_kinds[kind].min_exponent -
4323 mpfr_get_prec(result->value.real) + 1);
4324 mpfr_set_emax ((mp_exp_t) gfc_real_kinds[kind].max_exponent - 1);
4325 mpfr_check_range (result->value.real, 0, GMP_RNDU);
4327 if (mpfr_sgn (s->value.real) > 0)
4329 mpfr_nextabove (result->value.real);
4330 mpfr_subnormalize (result->value.real, 0, GMP_RNDU);
4334 mpfr_nextbelow (result->value.real);
4335 mpfr_subnormalize (result->value.real, 0, GMP_RNDD);
4338 mpfr_set_emin (emin);
4339 mpfr_set_emax (emax);
4341 /* Only NaN can occur. Do not use range check as it gives an
4342 error for denormal numbers. */
4343 if (mpfr_nan_p (result->value.real) && gfc_option.flag_range_check)
4345 gfc_error ("Result of NEAREST is NaN at %L", &result->where);
4346 gfc_free_expr (result);
4347 return &gfc_bad_expr;
4355 simplify_nint (const char *name, gfc_expr *e, gfc_expr *k)
4357 gfc_expr *itrunc, *result;
4360 kind = get_kind (BT_INTEGER, k, name, gfc_default_integer_kind);
4362 return &gfc_bad_expr;
4364 if (e->expr_type != EXPR_CONSTANT)
4367 itrunc = gfc_copy_expr (e);
4368 mpfr_round (itrunc->value.real, e->value.real);
4370 result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
4371 gfc_mpfr_to_mpz (result->value.integer, itrunc->value.real, &e->where);
4373 gfc_free_expr (itrunc);
4375 return range_check (result, name);
4380 gfc_simplify_new_line (gfc_expr *e)
4384 result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, 1);
4385 result->value.character.string[0] = '\n';
4392 gfc_simplify_nint (gfc_expr *e, gfc_expr *k)
4394 return simplify_nint ("NINT", e, k);
4399 gfc_simplify_idnint (gfc_expr *e)
4401 return simplify_nint ("IDNINT", e, NULL);
4406 add_squared (gfc_expr *result, gfc_expr *e)
4410 gcc_assert (e->ts.type == BT_REAL && e->expr_type == EXPR_CONSTANT);
4411 gcc_assert (result->ts.type == BT_REAL
4412 && result->expr_type == EXPR_CONSTANT);
4414 gfc_set_model_kind (result->ts.kind);
4416 mpfr_pow_ui (tmp, e->value.real, 2, GFC_RND_MODE);
4417 mpfr_add (result->value.real, result->value.real, tmp,
4426 do_sqrt (gfc_expr *result, gfc_expr *e)
4428 gcc_assert (e->ts.type == BT_REAL && e->expr_type == EXPR_CONSTANT);
4429 gcc_assert (result->ts.type == BT_REAL
4430 && result->expr_type == EXPR_CONSTANT);
4432 mpfr_set (result->value.real, e->value.real, GFC_RND_MODE);
4433 mpfr_sqrt (result->value.real, result->value.real, GFC_RND_MODE);
4439 gfc_simplify_norm2 (gfc_expr *e, gfc_expr *dim)
4443 if (!is_constant_array_expr (e)
4444 || (dim != NULL && !gfc_is_constant_expr (dim)))
4447 result = transformational_result (e, dim, e->ts.type, e->ts.kind, &e->where);
4448 init_result_expr (result, 0, NULL);
4450 if (!dim || e->rank == 1)
4452 result = simplify_transformation_to_scalar (result, e, NULL,
4454 mpfr_sqrt (result->value.real, result->value.real, GFC_RND_MODE);
4457 result = simplify_transformation_to_array (result, e, dim, NULL,
4458 add_squared, &do_sqrt);
4465 gfc_simplify_not (gfc_expr *e)
4469 if (e->expr_type != EXPR_CONSTANT)
4472 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
4473 mpz_com (result->value.integer, e->value.integer);
4475 return range_check (result, "NOT");
4480 gfc_simplify_null (gfc_expr *mold)
4486 result = gfc_copy_expr (mold);
4487 result->expr_type = EXPR_NULL;
4490 result = gfc_get_null_expr (NULL);
4497 gfc_simplify_num_images (void)
4501 if (gfc_option.coarray == GFC_FCOARRAY_NONE)
4503 gfc_fatal_error ("Coarrays disabled at %C, use -fcoarray= to enable");
4504 return &gfc_bad_expr;
4507 /* FIXME: gfc_current_locus is wrong. */
4508 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
4509 &gfc_current_locus);
4510 mpz_set_si (result->value.integer, 1);
4516 gfc_simplify_or (gfc_expr *x, gfc_expr *y)
4521 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
4524 kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
4529 result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
4530 mpz_ior (result->value.integer, x->value.integer, y->value.integer);
4531 return range_check (result, "OR");
4534 return gfc_get_logical_expr (kind, &x->where,
4535 x->value.logical || y->value.logical);
4543 gfc_simplify_pack (gfc_expr *array, gfc_expr *mask, gfc_expr *vector)
4546 gfc_constructor *array_ctor, *mask_ctor, *vector_ctor;
4548 if (!is_constant_array_expr(array)
4549 || !is_constant_array_expr(vector)
4550 || (!gfc_is_constant_expr (mask)
4551 && !is_constant_array_expr(mask)))
4554 result = gfc_get_array_expr (array->ts.type, array->ts.kind, &array->where);
4555 if (array->ts.type == BT_DERIVED)
4556 result->ts.u.derived = array->ts.u.derived;
4558 array_ctor = gfc_constructor_first (array->value.constructor);
4559 vector_ctor = vector
4560 ? gfc_constructor_first (vector->value.constructor)
4563 if (mask->expr_type == EXPR_CONSTANT
4564 && mask->value.logical)
4566 /* Copy all elements of ARRAY to RESULT. */
4569 gfc_constructor_append_expr (&result->value.constructor,
4570 gfc_copy_expr (array_ctor->expr),
4573 array_ctor = gfc_constructor_next (array_ctor);
4574 vector_ctor = gfc_constructor_next (vector_ctor);
4577 else if (mask->expr_type == EXPR_ARRAY)
4579 /* Copy only those elements of ARRAY to RESULT whose
4580 MASK equals .TRUE.. */
4581 mask_ctor = gfc_constructor_first (mask->value.constructor);
4584 if (mask_ctor->expr->value.logical)
4586 gfc_constructor_append_expr (&result->value.constructor,
4587 gfc_copy_expr (array_ctor->expr),
4589 vector_ctor = gfc_constructor_next (vector_ctor);
4592 array_ctor = gfc_constructor_next (array_ctor);
4593 mask_ctor = gfc_constructor_next (mask_ctor);
4597 /* Append any left-over elements from VECTOR to RESULT. */
4600 gfc_constructor_append_expr (&result->value.constructor,
4601 gfc_copy_expr (vector_ctor->expr),
4603 vector_ctor = gfc_constructor_next (vector_ctor);
4606 result->shape = gfc_get_shape (1);
4607 gfc_array_size (result, &result->shape[0]);
4609 if (array->ts.type == BT_CHARACTER)
4610 result->ts.u.cl = array->ts.u.cl;
4617 do_xor (gfc_expr *result, gfc_expr *e)
4619 gcc_assert (e->ts.type == BT_LOGICAL && e->expr_type == EXPR_CONSTANT);
4620 gcc_assert (result->ts.type == BT_LOGICAL
4621 && result->expr_type == EXPR_CONSTANT);
4623 result->value.logical = result->value.logical != e->value.logical;
4630 gfc_simplify_parity (gfc_expr *e, gfc_expr *dim)
4632 return simplify_transformation (e, dim, NULL, 0, do_xor);
4637 gfc_simplify_popcnt (gfc_expr *e)
4642 if (e->expr_type != EXPR_CONSTANT)
4645 k = gfc_validate_kind (e->ts.type, e->ts.kind, false);
4647 /* Convert argument to unsigned, then count the '1' bits. */
4648 mpz_init_set (x, e->value.integer);
4649 convert_mpz_to_unsigned (x, gfc_integer_kinds[k].bit_size);
4650 res = mpz_popcount (x);
4653 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, res);
4658 gfc_simplify_poppar (gfc_expr *e)
4664 if (e->expr_type != EXPR_CONSTANT)
4667 popcnt = gfc_simplify_popcnt (e);
4668 gcc_assert (popcnt);
4670 s = gfc_extract_int (popcnt, &i);
4673 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i % 2);
4678 gfc_simplify_precision (gfc_expr *e)
4680 int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
4681 return gfc_get_int_expr (gfc_default_integer_kind, &e->where,
4682 gfc_real_kinds[i].precision);
4687 gfc_simplify_product (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
4689 return simplify_transformation (array, dim, mask, 1, gfc_multiply);
4694 gfc_simplify_radix (gfc_expr *e)
4697 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
4702 i = gfc_integer_kinds[i].radix;
4706 i = gfc_real_kinds[i].radix;
4713 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i);
4718 gfc_simplify_range (gfc_expr *e)
4721 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
4726 i = gfc_integer_kinds[i].range;
4731 i = gfc_real_kinds[i].range;
4738 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i);
4743 gfc_simplify_real (gfc_expr *e, gfc_expr *k)
4745 gfc_expr *result = NULL;
4748 if (e->ts.type == BT_COMPLEX)
4749 kind = get_kind (BT_REAL, k, "REAL", e->ts.kind);
4751 kind = get_kind (BT_REAL, k, "REAL", gfc_default_real_kind);
4754 return &gfc_bad_expr;
4756 if (e->expr_type != EXPR_CONSTANT)
4759 if (convert_boz (e, kind) == &gfc_bad_expr)
4760 return &gfc_bad_expr;
4762 result = gfc_convert_constant (e, BT_REAL, kind);
4763 if (result == &gfc_bad_expr)
4764 return &gfc_bad_expr;
4766 return range_check (result, "REAL");
4771 gfc_simplify_realpart (gfc_expr *e)
4775 if (e->expr_type != EXPR_CONSTANT)
4778 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
4779 mpc_real (result->value.real, e->value.complex, GFC_RND_MODE);
4781 return range_check (result, "REALPART");
4785 gfc_simplify_repeat (gfc_expr *e, gfc_expr *n)
4788 int i, j, len, ncop, nlen;
4790 bool have_length = false;
4792 /* If NCOPIES isn't a constant, there's nothing we can do. */
4793 if (n->expr_type != EXPR_CONSTANT)
4796 /* If NCOPIES is negative, it's an error. */
4797 if (mpz_sgn (n->value.integer) < 0)
4799 gfc_error ("Argument NCOPIES of REPEAT intrinsic is negative at %L",
4801 return &gfc_bad_expr;
4804 /* If we don't know the character length, we can do no more. */
4805 if (e->ts.u.cl && e->ts.u.cl->length
4806 && e->ts.u.cl->length->expr_type == EXPR_CONSTANT)
4808 len = mpz_get_si (e->ts.u.cl->length->value.integer);
4811 else if (e->expr_type == EXPR_CONSTANT
4812 && (e->ts.u.cl == NULL || e->ts.u.cl->length == NULL))
4814 len = e->value.character.length;
4819 /* If the source length is 0, any value of NCOPIES is valid
4820 and everything behaves as if NCOPIES == 0. */
4823 mpz_set_ui (ncopies, 0);
4825 mpz_set (ncopies, n->value.integer);
4827 /* Check that NCOPIES isn't too large. */
4833 /* Compute the maximum value allowed for NCOPIES: huge(cl) / len. */
4835 i = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false);
4839 mpz_tdiv_q (max, gfc_integer_kinds[i].huge,
4840 e->ts.u.cl->length->value.integer);
4844 mpz_init_set_si (mlen, len);
4845 mpz_tdiv_q (max, gfc_integer_kinds[i].huge, mlen);
4849 /* The check itself. */
4850 if (mpz_cmp (ncopies, max) > 0)
4853 mpz_clear (ncopies);
4854 gfc_error ("Argument NCOPIES of REPEAT intrinsic is too large at %L",
4856 return &gfc_bad_expr;
4861 mpz_clear (ncopies);
4863 /* For further simplification, we need the character string to be
4865 if (e->expr_type != EXPR_CONSTANT)
4869 (e->ts.u.cl->length &&
4870 mpz_sgn (e->ts.u.cl->length->value.integer)) != 0)
4872 const char *res = gfc_extract_int (n, &ncop);
4873 gcc_assert (res == NULL);
4878 len = e->value.character.length;
4881 result = gfc_get_constant_expr (BT_CHARACTER, e->ts.kind, &e->where);
4884 return gfc_get_character_expr (e->ts.kind, &e->where, NULL, 0);
4886 len = e->value.character.length;
4889 result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, nlen);
4890 for (i = 0; i < ncop; i++)
4891 for (j = 0; j < len; j++)
4892 result->value.character.string[j+i*len]= e->value.character.string[j];
4894 result->value.character.string[nlen] = '\0'; /* For debugger */
4899 /* This one is a bear, but mainly has to do with shuffling elements. */
4902 gfc_simplify_reshape (gfc_expr *source, gfc_expr *shape_exp,
4903 gfc_expr *pad, gfc_expr *order_exp)
4905 int order[GFC_MAX_DIMENSIONS], shape[GFC_MAX_DIMENSIONS];
4906 int i, rank, npad, x[GFC_MAX_DIMENSIONS];
4910 gfc_expr *e, *result;
4912 /* Check that argument expression types are OK. */
4913 if (!is_constant_array_expr (source)
4914 || !is_constant_array_expr (shape_exp)
4915 || !is_constant_array_expr (pad)
4916 || !is_constant_array_expr (order_exp))
4919 /* Proceed with simplification, unpacking the array. */
4926 e = gfc_constructor_lookup_expr (shape_exp->value.constructor, rank);
4930 gfc_extract_int (e, &shape[rank]);
4932 gcc_assert (rank >= 0 && rank < GFC_MAX_DIMENSIONS);
4933 gcc_assert (shape[rank] >= 0);
4938 gcc_assert (rank > 0);
4940 /* Now unpack the order array if present. */
4941 if (order_exp == NULL)
4943 for (i = 0; i < rank; i++)
4948 for (i = 0; i < rank; i++)
4951 for (i = 0; i < rank; i++)
4953 e = gfc_constructor_lookup_expr (order_exp->value.constructor, i);
4956 gfc_extract_int (e, &order[i]);
4958 gcc_assert (order[i] >= 1 && order[i] <= rank);
4960 gcc_assert (x[order[i]] == 0);
4965 /* Count the elements in the source and padding arrays. */
4970 gfc_array_size (pad, &size);
4971 npad = mpz_get_ui (size);
4975 gfc_array_size (source, &size);
4976 nsource = mpz_get_ui (size);
4979 /* If it weren't for that pesky permutation we could just loop
4980 through the source and round out any shortage with pad elements.
4981 But no, someone just had to have the compiler do something the
4982 user should be doing. */
4984 for (i = 0; i < rank; i++)
4987 result = gfc_get_array_expr (source->ts.type, source->ts.kind,
4989 if (source->ts.type == BT_DERIVED)
4990 result->ts.u.derived = source->ts.u.derived;
4991 result->rank = rank;
4992 result->shape = gfc_get_shape (rank);
4993 for (i = 0; i < rank; i++)
4994 mpz_init_set_ui (result->shape[i], shape[i]);
4996 while (nsource > 0 || npad > 0)
4998 /* Figure out which element to extract. */
4999 mpz_set_ui (index, 0);
5001 for (i = rank - 1; i >= 0; i--)
5003 mpz_add_ui (index, index, x[order[i]]);
5005 mpz_mul_ui (index, index, shape[order[i - 1]]);
5008 if (mpz_cmp_ui (index, INT_MAX) > 0)
5009 gfc_internal_error ("Reshaped array too large at %C");
5011 j = mpz_get_ui (index);
5014 e = gfc_constructor_lookup_expr (source->value.constructor, j);
5017 gcc_assert (npad > 0);
5021 e = gfc_constructor_lookup_expr (pad->value.constructor, j);
5025 gfc_constructor_append_expr (&result->value.constructor,
5026 gfc_copy_expr (e), &e->where);
5028 /* Calculate the next element. */
5032 if (++x[i] < shape[i])
5048 gfc_simplify_rrspacing (gfc_expr *x)
5054 if (x->expr_type != EXPR_CONSTANT)
5057 i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
5059 result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
5060 mpfr_abs (result->value.real, x->value.real, GFC_RND_MODE);
5062 /* Special case x = -0 and 0. */
5063 if (mpfr_sgn (result->value.real) == 0)
5065 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
5069 /* | x * 2**(-e) | * 2**p. */
5070 e = - (long int) mpfr_get_exp (x->value.real);
5071 mpfr_mul_2si (result->value.real, result->value.real, e, GFC_RND_MODE);
5073 p = (long int) gfc_real_kinds[i].digits;
5074 mpfr_mul_2si (result->value.real, result->value.real, p, GFC_RND_MODE);
5076 return range_check (result, "RRSPACING");
5081 gfc_simplify_scale (gfc_expr *x, gfc_expr *i)
5083 int k, neg_flag, power, exp_range;
5084 mpfr_t scale, radix;
5087 if (x->expr_type != EXPR_CONSTANT || i->expr_type != EXPR_CONSTANT)
5090 result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
5092 if (mpfr_sgn (x->value.real) == 0)
5094 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
5098 k = gfc_validate_kind (BT_REAL, x->ts.kind, false);
5100 exp_range = gfc_real_kinds[k].max_exponent - gfc_real_kinds[k].min_exponent;
5102 /* This check filters out values of i that would overflow an int. */
5103 if (mpz_cmp_si (i->value.integer, exp_range + 2) > 0
5104 || mpz_cmp_si (i->value.integer, -exp_range - 2) < 0)
5106 gfc_error ("Result of SCALE overflows its kind at %L", &result->where);
5107 gfc_free_expr (result);
5108 return &gfc_bad_expr;
5111 /* Compute scale = radix ** power. */
5112 power = mpz_get_si (i->value.integer);
5122 gfc_set_model_kind (x->ts.kind);
5125 mpfr_set_ui (radix, gfc_real_kinds[k].radix, GFC_RND_MODE);
5126 mpfr_pow_ui (scale, radix, power, GFC_RND_MODE);
5129 mpfr_div (result->value.real, x->value.real, scale, GFC_RND_MODE);
5131 mpfr_mul (result->value.real, x->value.real, scale, GFC_RND_MODE);
5133 mpfr_clears (scale, radix, NULL);
5135 return range_check (result, "SCALE");
5139 /* Variants of strspn and strcspn that operate on wide characters. */
5142 wide_strspn (const gfc_char_t *s1, const gfc_char_t *s2)
5145 const gfc_char_t *c;
5149 for (c = s2; *c; c++)
5163 wide_strcspn (const gfc_char_t *s1, const gfc_char_t *s2)
5166 const gfc_char_t *c;
5170 for (c = s2; *c; c++)
5185 gfc_simplify_scan (gfc_expr *e, gfc_expr *c, gfc_expr *b, gfc_expr *kind)
5190 size_t indx, len, lenc;
5191 int k = get_kind (BT_INTEGER, kind, "SCAN", gfc_default_integer_kind);
5194 return &gfc_bad_expr;
5196 if (e->expr_type != EXPR_CONSTANT || c->expr_type != EXPR_CONSTANT)
5199 if (b != NULL && b->value.logical != 0)
5204 len = e->value.character.length;
5205 lenc = c->value.character.length;
5207 if (len == 0 || lenc == 0)
5215 indx = wide_strcspn (e->value.character.string,
5216 c->value.character.string) + 1;
5223 for (indx = len; indx > 0; indx--)
5225 for (i = 0; i < lenc; i++)
5227 if (c->value.character.string[i]
5228 == e->value.character.string[indx - 1])
5237 result = gfc_get_int_expr (k, &e->where, indx);
5238 return range_check (result, "SCAN");
5243 gfc_simplify_selected_char_kind (gfc_expr *e)
5247 if (e->expr_type != EXPR_CONSTANT)
5250 if (gfc_compare_with_Cstring (e, "ascii", false) == 0
5251 || gfc_compare_with_Cstring (e, "default", false) == 0)
5253 else if (gfc_compare_with_Cstring (e, "iso_10646", false) == 0)
5258 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
5263 gfc_simplify_selected_int_kind (gfc_expr *e)
5267 if (e->expr_type != EXPR_CONSTANT || gfc_extract_int (e, &range) != NULL)
5272 for (i = 0; gfc_integer_kinds[i].kind != 0; i++)
5273 if (gfc_integer_kinds[i].range >= range
5274 && gfc_integer_kinds[i].kind < kind)
5275 kind = gfc_integer_kinds[i].kind;
5277 if (kind == INT_MAX)
5280 return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
5285 gfc_simplify_selected_real_kind (gfc_expr *p, gfc_expr *q, gfc_expr *rdx)
5287 int range, precision, radix, i, kind, found_precision, found_range,
5289 locus *loc = &gfc_current_locus;
5295 if (p->expr_type != EXPR_CONSTANT
5296 || gfc_extract_int (p, &precision) != NULL)
5305 if (q->expr_type != EXPR_CONSTANT
5306 || gfc_extract_int (q, &range) != NULL)
5317 if (rdx->expr_type != EXPR_CONSTANT
5318 || gfc_extract_int (rdx, &radix) != NULL)
5326 found_precision = 0;
5330 for (i = 0; gfc_real_kinds[i].kind != 0; i++)
5332 if (gfc_real_kinds[i].precision >= precision)
5333 found_precision = 1;
5335 if (gfc_real_kinds[i].range >= range)
5338 if (gfc_real_kinds[i].radix >= radix)
5341 if (gfc_real_kinds[i].precision >= precision
5342 && gfc_real_kinds[i].range >= range
5343 && gfc_real_kinds[i].radix >= radix && gfc_real_kinds[i].kind < kind)
5344 kind = gfc_real_kinds[i].kind;
5347 if (kind == INT_MAX)
5349 if (found_radix && found_range && !found_precision)
5351 else if (found_radix && found_precision && !found_range)
5353 else if (found_radix && !found_precision && !found_range)
5355 else if (found_radix)
5361 return gfc_get_int_expr (gfc_default_integer_kind, loc, kind);
5366 gfc_simplify_set_exponent (gfc_expr *x, gfc_expr *i)
5369 mpfr_t exp, absv, log2, pow2, frac;
5372 if (x->expr_type != EXPR_CONSTANT || i->expr_type != EXPR_CONSTANT)
5375 result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
5377 if (mpfr_sgn (x->value.real) == 0)
5379 mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
5383 gfc_set_model_kind (x->ts.kind);
5390 mpfr_abs (absv, x->value.real, GFC_RND_MODE);
5391 mpfr_log2 (log2, absv, GFC_RND_MODE);
5393 mpfr_trunc (log2, log2);
5394 mpfr_add_ui (exp, log2, 1, GFC_RND_MODE);
5396 /* Old exponent value, and fraction. */
5397 mpfr_ui_pow (pow2, 2, exp, GFC_RND_MODE);
5399 mpfr_div (frac, absv, pow2, GFC_RND_MODE);
5402 exp2 = (unsigned long) mpz_get_d (i->value.integer);
5403 mpfr_mul_2exp (result->value.real, frac, exp2, GFC_RND_MODE);
5405 mpfr_clears (absv, log2, pow2, frac, NULL);
5407 return range_check (result, "SET_EXPONENT");
5412 gfc_simplify_shape (gfc_expr *source)
5414 mpz_t shape[GFC_MAX_DIMENSIONS];
5415 gfc_expr *result, *e, *f;
5420 if (source->rank == 0)
5421 return gfc_get_array_expr (BT_INTEGER, gfc_default_integer_kind,
5424 result = gfc_get_array_expr (BT_INTEGER, gfc_default_integer_kind,
5427 if (source->expr_type == EXPR_VARIABLE)
5429 ar = gfc_find_array_ref (source);
5430 t = gfc_array_ref_shape (ar, shape);
5432 else if (source->shape)
5435 for (n = 0; n < source->rank; n++)
5437 mpz_init (shape[n]);
5438 mpz_set (shape[n], source->shape[n]);
5444 for (n = 0; n < source->rank; n++)
5446 e = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
5451 mpz_set (e->value.integer, shape[n]);
5452 mpz_clear (shape[n]);
5456 mpz_set_ui (e->value.integer, n + 1);
5458 f = gfc_simplify_size (source, e, NULL);
5462 gfc_free_expr (result);
5469 gfc_constructor_append_expr (&result->value.constructor, e, NULL);
5477 gfc_simplify_size (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
5481 int k = get_kind (BT_INTEGER, kind, "SIZE", gfc_default_integer_kind);
5484 return &gfc_bad_expr;
5486 /* For unary operations, the size of the result is given by the size
5487 of the operand. For binary ones, it's the size of the first operand
5488 unless it is scalar, then it is the size of the second. */
5489 if (array->expr_type == EXPR_OP && !array->value.op.uop)
5491 gfc_expr* replacement;
5492 gfc_expr* simplified;
5494 switch (array->value.op.op)
5496 /* Unary operations. */
5498 case INTRINSIC_UPLUS:
5499 case INTRINSIC_UMINUS:
5500 replacement = array->value.op.op1;
5503 /* Binary operations. If any one of the operands is scalar, take
5504 the other one's size. If both of them are arrays, it does not
5505 matter -- try to find one with known shape, if possible. */
5507 if (array->value.op.op1->rank == 0)
5508 replacement = array->value.op.op2;
5509 else if (array->value.op.op2->rank == 0)
5510 replacement = array->value.op.op1;
5513 simplified = gfc_simplify_size (array->value.op.op1, dim, kind);
5517 replacement = array->value.op.op2;
5522 /* Try to reduce it directly if possible. */
5523 simplified = gfc_simplify_size (replacement, dim, kind);
5525 /* Otherwise, we build a new SIZE call. This is hopefully at least
5526 simpler than the original one. */
5528 simplified = gfc_build_intrinsic_call ("size", array->where, 3,
5529 gfc_copy_expr (replacement),
5530 gfc_copy_expr (dim),
5531 gfc_copy_expr (kind));
5538 if (gfc_array_size (array, &size) == FAILURE)
5543 if (dim->expr_type != EXPR_CONSTANT)
5546 d = mpz_get_ui (dim->value.integer) - 1;
5547 if (gfc_array_dimen_size (array, d, &size) == FAILURE)
5551 return gfc_get_int_expr (k, &array->where, mpz_get_si (size));
5556 gfc_simplify_sign (gfc_expr *x, gfc_expr *y)
5560 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
5563 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
5568 mpz_abs (result->value.integer, x->value.integer);
5569 if (mpz_sgn (y->value.integer) < 0)
5570 mpz_neg (result->value.integer, result->value.integer);
5574 if (gfc_option.flag_sign_zero)
5575 mpfr_copysign (result->value.real, x->value.real, y->value.real,
5578 mpfr_setsign (result->value.real, x->value.real,
5579 mpfr_sgn (y->value.real) < 0 ? 1 : 0, GFC_RND_MODE);
5583 gfc_internal_error ("Bad type in gfc_simplify_sign");
5591 gfc_simplify_sin (gfc_expr *x)
5595 if (x->expr_type != EXPR_CONSTANT)
5598 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
5603 mpfr_sin (result->value.real, x->value.real, GFC_RND_MODE);
5607 gfc_set_model (x->value.real);
5608 mpc_sin (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
5612 gfc_internal_error ("in gfc_simplify_sin(): Bad type");
5615 return range_check (result, "SIN");
5620 gfc_simplify_sinh (gfc_expr *x)
5624 if (x->expr_type != EXPR_CONSTANT)
5627 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
5632 mpfr_sinh (result->value.real, x->value.real, GFC_RND_MODE);
5636 mpc_sinh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
5643 return range_check (result, "SINH");
5647 /* The argument is always a double precision real that is converted to
5648 single precision. TODO: Rounding! */
5651 gfc_simplify_sngl (gfc_expr *a)
5655 if (a->expr_type != EXPR_CONSTANT)
5658 result = gfc_real2real (a, gfc_default_real_kind);
5659 return range_check (result, "SNGL");
5664 gfc_simplify_spacing (gfc_expr *x)
5670 if (x->expr_type != EXPR_CONSTANT)
5673 i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
5675 result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
5677 /* Special case x = 0 and -0. */
5678 mpfr_abs (result->value.real, x->value.real, GFC_RND_MODE);
5679 if (mpfr_sgn (result->value.real) == 0)
5681 mpfr_set (result->value.real, gfc_real_kinds[i].tiny, GFC_RND_MODE);
5685 /* In the Fortran 95 standard, the result is b**(e - p) where b, e, and p
5686 are the radix, exponent of x, and precision. This excludes the
5687 possibility of subnormal numbers. Fortran 2003 states the result is
5688 b**max(e - p, emin - 1). */
5690 ep = (long int) mpfr_get_exp (x->value.real) - gfc_real_kinds[i].digits;
5691 en = (long int) gfc_real_kinds[i].min_exponent - 1;
5692 en = en > ep ? en : ep;
5694 mpfr_set_ui (result->value.real, 1, GFC_RND_MODE);
5695 mpfr_mul_2si (result->value.real, result->value.real, en, GFC_RND_MODE);
5697 return range_check (result, "SPACING");
5702 gfc_simplify_spread (gfc_expr *source, gfc_expr *dim_expr, gfc_expr *ncopies_expr)
5704 gfc_expr *result = 0L;
5705 int i, j, dim, ncopies;
5708 if ((!gfc_is_constant_expr (source)
5709 && !is_constant_array_expr (source))
5710 || !gfc_is_constant_expr (dim_expr)
5711 || !gfc_is_constant_expr (ncopies_expr))
5714 gcc_assert (dim_expr->ts.type == BT_INTEGER);
5715 gfc_extract_int (dim_expr, &dim);
5716 dim -= 1; /* zero-base DIM */
5718 gcc_assert (ncopies_expr->ts.type == BT_INTEGER);
5719 gfc_extract_int (ncopies_expr, &ncopies);
5720 ncopies = MAX (ncopies, 0);
5722 /* Do not allow the array size to exceed the limit for an array
5724 if (source->expr_type == EXPR_ARRAY)
5726 if (gfc_array_size (source, &size) == FAILURE)
5727 gfc_internal_error ("Failure getting length of a constant array.");
5730 mpz_init_set_ui (size, 1);
5732 if (mpz_get_si (size)*ncopies > gfc_option.flag_max_array_constructor)
5735 if (source->expr_type == EXPR_CONSTANT)
5737 gcc_assert (dim == 0);
5739 result = gfc_get_array_expr (source->ts.type, source->ts.kind,
5741 if (source->ts.type == BT_DERIVED)
5742 result->ts.u.derived = source->ts.u.derived;
5744 result->shape = gfc_get_shape (result->rank);
5745 mpz_init_set_si (result->shape[0], ncopies);
5747 for (i = 0; i < ncopies; ++i)
5748 gfc_constructor_append_expr (&result->value.constructor,
5749 gfc_copy_expr (source), NULL);
5751 else if (source->expr_type == EXPR_ARRAY)
5753 int offset, rstride[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS];
5754 gfc_constructor *source_ctor;
5756 gcc_assert (source->rank < GFC_MAX_DIMENSIONS);
5757 gcc_assert (dim >= 0 && dim <= source->rank);
5759 result = gfc_get_array_expr (source->ts.type, source->ts.kind,
5761 if (source->ts.type == BT_DERIVED)
5762 result->ts.u.derived = source->ts.u.derived;
5763 result->rank = source->rank + 1;
5764 result->shape = gfc_get_shape (result->rank);
5766 for (i = 0, j = 0; i < result->rank; ++i)
5769 mpz_init_set (result->shape[i], source->shape[j++]);
5771 mpz_init_set_si (result->shape[i], ncopies);
5773 extent[i] = mpz_get_si (result->shape[i]);
5774 rstride[i] = (i == 0) ? 1 : rstride[i-1] * extent[i-1];
5778 for (source_ctor = gfc_constructor_first (source->value.constructor);
5779 source_ctor; source_ctor = gfc_constructor_next (source_ctor))
5781 for (i = 0; i < ncopies; ++i)
5782 gfc_constructor_insert_expr (&result->value.constructor,
5783 gfc_copy_expr (source_ctor->expr),
5784 NULL, offset + i * rstride[dim]);
5786 offset += (dim == 0 ? ncopies : 1);
5790 /* FIXME: Returning here avoids a regression in array_simplify_1.f90.
5791 Replace NULL with gcc_unreachable() after implementing
5792 gfc_simplify_cshift(). */
5795 if (source->ts.type == BT_CHARACTER)
5796 result->ts.u.cl = source->ts.u.cl;
5803 gfc_simplify_sqrt (gfc_expr *e)
5805 gfc_expr *result = NULL;
5807 if (e->expr_type != EXPR_CONSTANT)
5813 if (mpfr_cmp_si (e->value.real, 0) < 0)
5815 gfc_error ("Argument of SQRT at %L has a negative value",
5817 return &gfc_bad_expr;
5819 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
5820 mpfr_sqrt (result->value.real, e->value.real, GFC_RND_MODE);
5824 gfc_set_model (e->value.real);
5826 result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
5827 mpc_sqrt (result->value.complex, e->value.complex, GFC_MPC_RND_MODE);
5831 gfc_internal_error ("invalid argument of SQRT at %L", &e->where);
5834 return range_check (result, "SQRT");
5839 gfc_simplify_sum (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
5841 return simplify_transformation (array, dim, mask, 0, gfc_add);
5846 gfc_simplify_tan (gfc_expr *x)
5850 if (x->expr_type != EXPR_CONSTANT)
5853 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
5858 mpfr_tan (result->value.real, x->value.real, GFC_RND_MODE);
5862 mpc_tan (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
5869 return range_check (result, "TAN");
5874 gfc_simplify_tanh (gfc_expr *x)
5878 if (x->expr_type != EXPR_CONSTANT)
5881 result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
5886 mpfr_tanh (result->value.real, x->value.real, GFC_RND_MODE);
5890 mpc_tanh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
5897 return range_check (result, "TANH");
5902 gfc_simplify_tiny (gfc_expr *e)
5907 i = gfc_validate_kind (BT_REAL, e->ts.kind, false);
5909 result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
5910 mpfr_set (result->value.real, gfc_real_kinds[i].tiny, GFC_RND_MODE);
5917 gfc_simplify_trailz (gfc_expr *e)
5919 unsigned long tz, bs;
5922 if (e->expr_type != EXPR_CONSTANT)
5925 i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
5926 bs = gfc_integer_kinds[i].bit_size;
5927 tz = mpz_scan1 (e->value.integer, 0);
5929 return gfc_get_int_expr (gfc_default_integer_kind,
5930 &e->where, MIN (tz, bs));
5935 gfc_simplify_transfer (gfc_expr *source, gfc_expr *mold, gfc_expr *size)
5938 gfc_expr *mold_element;
5941 size_t result_elt_size;
5944 unsigned char *buffer;
5946 if (!gfc_is_constant_expr (source)
5947 || (gfc_init_expr_flag && !gfc_is_constant_expr (mold))
5948 || !gfc_is_constant_expr (size))
5951 if (source->expr_type == EXPR_FUNCTION)
5954 /* Calculate the size of the source. */
5955 if (source->expr_type == EXPR_ARRAY
5956 && gfc_array_size (source, &tmp) == FAILURE)
5957 gfc_internal_error ("Failure getting length of a constant array.");
5959 source_size = gfc_target_expr_size (source);
5961 /* Create an empty new expression with the appropriate characteristics. */
5962 result = gfc_get_constant_expr (mold->ts.type, mold->ts.kind,
5964 result->ts = mold->ts;
5966 mold_element = mold->expr_type == EXPR_ARRAY
5967 ? gfc_constructor_first (mold->value.constructor)->expr
5970 /* Set result character length, if needed. Note that this needs to be
5971 set even for array expressions, in order to pass this information into
5972 gfc_target_interpret_expr. */
5973 if (result->ts.type == BT_CHARACTER && gfc_is_constant_expr (mold_element))
5974 result->value.character.length = mold_element->value.character.length;
5976 /* Set the number of elements in the result, and determine its size. */
5977 result_elt_size = gfc_target_expr_size (mold_element);
5978 if (result_elt_size == 0)
5980 gfc_free_expr (result);
5984 if (mold->expr_type == EXPR_ARRAY || mold->rank || size)
5988 result->expr_type = EXPR_ARRAY;
5992 result_length = (size_t)mpz_get_ui (size->value.integer);
5995 result_length = source_size / result_elt_size;
5996 if (result_length * result_elt_size < source_size)
6000 result->shape = gfc_get_shape (1);
6001 mpz_init_set_ui (result->shape[0], result_length);
6003 result_size = result_length * result_elt_size;
6008 result_size = result_elt_size;
6011 if (gfc_option.warn_surprising && source_size < result_size)
6012 gfc_warning("Intrinsic TRANSFER at %L has partly undefined result: "
6013 "source size %ld < result size %ld", &source->where,
6014 (long) source_size, (long) result_size);
6016 /* Allocate the buffer to store the binary version of the source. */
6017 buffer_size = MAX (source_size, result_size);
6018 buffer = (unsigned char*)alloca (buffer_size);
6019 memset (buffer, 0, buffer_size);
6021 /* Now write source to the buffer. */
6022 gfc_target_encode_expr (source, buffer, buffer_size);
6024 /* And read the buffer back into the new expression. */
6025 gfc_target_interpret_expr (buffer, buffer_size, result);
6032 gfc_simplify_transpose (gfc_expr *matrix)
6034 int row, matrix_rows, col, matrix_cols;
6037 if (!is_constant_array_expr (matrix))
6040 gcc_assert (matrix->rank == 2);
6042 result = gfc_get_array_expr (matrix->ts.type, matrix->ts.kind,
6045 result->shape = gfc_get_shape (result->rank);
6046 mpz_set (result->shape[0], matrix->shape[1]);
6047 mpz_set (result->shape[1], matrix->shape[0]);
6049 if (matrix->ts.type == BT_CHARACTER)
6050 result->ts.u.cl = matrix->ts.u.cl;
6051 else if (matrix->ts.type == BT_DERIVED)
6052 result->ts.u.derived = matrix->ts.u.derived;
6054 matrix_rows = mpz_get_si (matrix->shape[0]);
6055 matrix_cols = mpz_get_si (matrix->shape[1]);
6056 for (row = 0; row < matrix_rows; ++row)
6057 for (col = 0; col < matrix_cols; ++col)
6059 gfc_expr *e = gfc_constructor_lookup_expr (matrix->value.constructor,
6060 col * matrix_rows + row);
6061 gfc_constructor_insert_expr (&result->value.constructor,
6062 gfc_copy_expr (e), &matrix->where,
6063 row * matrix_cols + col);
6071 gfc_simplify_trim (gfc_expr *e)
6074 int count, i, len, lentrim;
6076 if (e->expr_type != EXPR_CONSTANT)
6079 len = e->value.character.length;
6080 for (count = 0, i = 1; i <= len; ++i)
6082 if (e->value.character.string[len - i] == ' ')
6088 lentrim = len - count;
6090 result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, lentrim);
6091 for (i = 0; i < lentrim; i++)
6092 result->value.character.string[i] = e->value.character.string[i];
6099 gfc_simplify_image_index (gfc_expr *coarray, gfc_expr *sub)
6104 gfc_constructor *sub_cons;
6108 if (!is_constant_array_expr (sub))
6109 goto not_implemented; /* return NULL;*/
6111 /* Follow any component references. */
6112 as = coarray->symtree->n.sym->as;
6113 for (ref = coarray->ref; ref; ref = ref->next)
6114 if (ref->type == REF_COMPONENT)
6117 if (as->type == AS_DEFERRED)
6118 goto not_implemented; /* return NULL;*/
6120 /* "valid sequence of cosubscripts" are required; thus, return 0 unless
6121 the cosubscript addresses the first image. */
6123 sub_cons = gfc_constructor_first (sub->value.constructor);
6126 for (d = 1; d <= as->corank; d++)
6131 if (sub_cons == NULL)
6133 gfc_error ("Too few elements in expression for SUB= argument at %L",
6135 return &gfc_bad_expr;
6138 ca_bound = simplify_bound_dim (coarray, NULL, d + as->rank, 0, as,
6140 if (ca_bound == NULL)
6141 goto not_implemented; /* return NULL */
6143 if (ca_bound == &gfc_bad_expr)
6146 cmp = mpz_cmp (ca_bound->value.integer, sub_cons->expr->value.integer);
6150 gfc_free_expr (ca_bound);
6151 sub_cons = gfc_constructor_next (sub_cons);
6155 first_image = false;
6159 gfc_error ("Out of bounds in IMAGE_INDEX at %L for dimension %d, "
6160 "SUB has %ld and COARRAY lower bound is %ld)",
6162 mpz_get_si (sub_cons->expr->value.integer),
6163 mpz_get_si (ca_bound->value.integer));
6164 gfc_free_expr (ca_bound);
6165 return &gfc_bad_expr;
6168 gfc_free_expr (ca_bound);
6170 /* Check whether upperbound is valid for the multi-images case. */
6173 ca_bound = simplify_bound_dim (coarray, NULL, d + as->rank, 1, as,
6175 if (ca_bound == &gfc_bad_expr)
6178 if (ca_bound && ca_bound->expr_type == EXPR_CONSTANT
6179 && mpz_cmp (ca_bound->value.integer,
6180 sub_cons->expr->value.integer) < 0)
6182 gfc_error ("Out of bounds in IMAGE_INDEX at %L for dimension %d, "
6183 "SUB has %ld and COARRAY upper bound is %ld)",
6185 mpz_get_si (sub_cons->expr->value.integer),
6186 mpz_get_si (ca_bound->value.integer));
6187 gfc_free_expr (ca_bound);
6188 return &gfc_bad_expr;
6192 gfc_free_expr (ca_bound);
6195 sub_cons = gfc_constructor_next (sub_cons);
6198 if (sub_cons != NULL)
6200 gfc_error ("Too many elements in expression for SUB= argument at %L",
6202 return &gfc_bad_expr;
6205 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
6206 &gfc_current_locus);
6208 mpz_set_si (result->value.integer, 1);
6210 mpz_set_si (result->value.integer, 0);
6215 gfc_error ("Not yet implemented: IMAGE_INDEX for coarray with non-constant "
6216 "cobounds at %L", &coarray->where);
6217 return &gfc_bad_expr;
6222 gfc_simplify_this_image (gfc_expr *coarray, gfc_expr *dim)
6228 if (coarray == NULL)
6231 /* FIXME: gfc_current_locus is wrong. */
6232 result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
6233 &gfc_current_locus);
6234 mpz_set_si (result->value.integer, 1);
6238 gcc_assert (coarray->expr_type == EXPR_VARIABLE);
6240 /* Follow any component references. */
6241 as = coarray->symtree->n.sym->as;
6242 for (ref = coarray->ref; ref; ref = ref->next)
6243 if (ref->type == REF_COMPONENT)
6246 if (as->type == AS_DEFERRED)
6247 goto not_implemented; /* return NULL;*/
6251 /* Multi-dimensional bounds. */
6252 gfc_expr *bounds[GFC_MAX_DIMENSIONS];
6255 /* Simplify the bounds for each dimension. */
6256 for (d = 0; d < as->corank; d++)
6258 bounds[d] = simplify_bound_dim (coarray, NULL, d + as->rank + 1, 0,
6260 if (bounds[d] == NULL || bounds[d] == &gfc_bad_expr)
6264 for (j = 0; j < d; j++)
6265 gfc_free_expr (bounds[j]);
6266 if (bounds[d] == NULL)
6267 goto not_implemented;
6272 /* Allocate the result expression. */
6273 e = gfc_get_expr ();
6274 e->where = coarray->where;
6275 e->expr_type = EXPR_ARRAY;
6276 e->ts.type = BT_INTEGER;
6277 e->ts.kind = gfc_default_integer_kind;
6280 e->shape = gfc_get_shape (1);
6281 mpz_init_set_ui (e->shape[0], as->corank);
6283 /* Create the constructor for this array. */
6284 for (d = 0; d < as->corank; d++)
6285 gfc_constructor_append_expr (&e->value.constructor,
6286 bounds[d], &e->where);
6293 /* A DIM argument is specified. */
6294 if (dim->expr_type != EXPR_CONSTANT)
6295 goto not_implemented; /*return NULL;*/
6297 d = mpz_get_si (dim->value.integer);
6299 if (d < 1 || d > as->corank)
6301 gfc_error ("DIM argument at %L is out of bounds", &dim->where);
6302 return &gfc_bad_expr;
6305 /*return simplify_bound_dim (coarray, NULL, d + as->rank, 0, as, NULL, true);*/
6306 e = simplify_bound_dim (coarray, NULL, d + as->rank, 0, as, NULL, true);
6310 goto not_implemented;
6314 gfc_error ("Not yet implemented: THIS_IMAGE for coarray with non-constant "
6315 "cobounds at %L", &coarray->where);
6316 return &gfc_bad_expr;
6321 gfc_simplify_ubound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
6323 return simplify_bound (array, dim, kind, 1);
6327 gfc_simplify_ucobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
6330 /* return simplify_cobound (array, dim, kind, 1);*/
6332 e = simplify_cobound (array, dim, kind, 1);
6336 gfc_error ("Not yet implemented: UCOBOUND for coarray with non-constant "
6337 "cobounds at %L", &array->where);
6338 return &gfc_bad_expr;
6343 gfc_simplify_unpack (gfc_expr *vector, gfc_expr *mask, gfc_expr *field)
6345 gfc_expr *result, *e;
6346 gfc_constructor *vector_ctor, *mask_ctor, *field_ctor;
6348 if (!is_constant_array_expr (vector)
6349 || !is_constant_array_expr (mask)
6350 || (!gfc_is_constant_expr (field)
6351 && !is_constant_array_expr(field)))
6354 result = gfc_get_array_expr (vector->ts.type, vector->ts.kind,
6356 if (vector->ts.type == BT_DERIVED)
6357 result->ts.u.derived = vector->ts.u.derived;
6358 result->rank = mask->rank;
6359 result->shape = gfc_copy_shape (mask->shape, mask->rank);
6361 if (vector->ts.type == BT_CHARACTER)
6362 result->ts.u.cl = vector->ts.u.cl;
6364 vector_ctor = gfc_constructor_first (vector->value.constructor);
6365 mask_ctor = gfc_constructor_first (mask->value.constructor);
6367 = field->expr_type == EXPR_ARRAY
6368 ? gfc_constructor_first (field->value.constructor)
6373 if (mask_ctor->expr->value.logical)
6375 gcc_assert (vector_ctor);
6376 e = gfc_copy_expr (vector_ctor->expr);
6377 vector_ctor = gfc_constructor_next (vector_ctor);
6379 else if (field->expr_type == EXPR_ARRAY)
6380 e = gfc_copy_expr (field_ctor->expr);
6382 e = gfc_copy_expr (field);
6384 gfc_constructor_append_expr (&result->value.constructor, e, NULL);
6386 mask_ctor = gfc_constructor_next (mask_ctor);
6387 field_ctor = gfc_constructor_next (field_ctor);
6395 gfc_simplify_verify (gfc_expr *s, gfc_expr *set, gfc_expr *b, gfc_expr *kind)
6399 size_t index, len, lenset;
6401 int k = get_kind (BT_INTEGER, kind, "VERIFY", gfc_default_integer_kind);
6404 return &gfc_bad_expr;
6406 if (s->expr_type != EXPR_CONSTANT || set->expr_type != EXPR_CONSTANT)
6409 if (b != NULL && b->value.logical != 0)
6414 result = gfc_get_constant_expr (BT_INTEGER, k, &s->where);
6416 len = s->value.character.length;
6417 lenset = set->value.character.length;
6421 mpz_set_ui (result->value.integer, 0);
6429 mpz_set_ui (result->value.integer, 1);
6433 index = wide_strspn (s->value.character.string,
6434 set->value.character.string) + 1;
6443 mpz_set_ui (result->value.integer, len);
6446 for (index = len; index > 0; index --)
6448 for (i = 0; i < lenset; i++)
6450 if (s->value.character.string[index - 1]
6451 == set->value.character.string[i])
6459 mpz_set_ui (result->value.integer, index);
6465 gfc_simplify_xor (gfc_expr *x, gfc_expr *y)
6470 if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
6473 kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
6478 result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
6479 mpz_xor (result->value.integer, x->value.integer, y->value.integer);
6480 return range_check (result, "XOR");
6483 return gfc_get_logical_expr (kind, &x->where,
6484 (x->value.logical && !y->value.logical)
6485 || (!x->value.logical && y->value.logical));
6493 /****************** Constant simplification *****************/
6495 /* Master function to convert one constant to another. While this is
6496 used as a simplification function, it requires the destination type
6497 and kind information which is supplied by a special case in
6501 gfc_convert_constant (gfc_expr *e, bt type, int kind)
6503 gfc_expr *g, *result, *(*f) (gfc_expr *, int);
6518 f = gfc_int2complex;
6538 f = gfc_real2complex;
6549 f = gfc_complex2int;
6552 f = gfc_complex2real;
6555 f = gfc_complex2complex;
6581 f = gfc_hollerith2int;
6585 f = gfc_hollerith2real;
6589 f = gfc_hollerith2complex;
6593 f = gfc_hollerith2character;
6597 f = gfc_hollerith2logical;
6607 gfc_internal_error ("gfc_convert_constant(): Unexpected type");
6612 switch (e->expr_type)
6615 result = f (e, kind);
6617 return &gfc_bad_expr;
6621 if (!gfc_is_constant_expr (e))
6624 result = gfc_get_array_expr (type, kind, &e->where);
6625 result->shape = gfc_copy_shape (e->shape, e->rank);
6626 result->rank = e->rank;
6628 for (c = gfc_constructor_first (e->value.constructor);
6629 c; c = gfc_constructor_next (c))
6632 if (c->iterator == NULL)
6633 tmp = f (c->expr, kind);
6636 g = gfc_convert_constant (c->expr, type, kind);
6637 if (g == &gfc_bad_expr)
6639 gfc_free_expr (result);
6647 gfc_free_expr (result);
6651 gfc_constructor_append_expr (&result->value.constructor,
6665 /* Function for converting character constants. */
6667 gfc_convert_char_constant (gfc_expr *e, bt type ATTRIBUTE_UNUSED, int kind)
6672 if (!gfc_is_constant_expr (e))
6675 if (e->expr_type == EXPR_CONSTANT)
6677 /* Simple case of a scalar. */
6678 result = gfc_get_constant_expr (BT_CHARACTER, kind, &e->where);
6680 return &gfc_bad_expr;
6682 result->value.character.length = e->value.character.length;
6683 result->value.character.string
6684 = gfc_get_wide_string (e->value.character.length + 1);
6685 memcpy (result->value.character.string, e->value.character.string,
6686 (e->value.character.length + 1) * sizeof (gfc_char_t));
6688 /* Check we only have values representable in the destination kind. */
6689 for (i = 0; i < result->value.character.length; i++)
6690 if (!gfc_check_character_range (result->value.character.string[i],
6693 gfc_error ("Character '%s' in string at %L cannot be converted "
6694 "into character kind %d",
6695 gfc_print_wide_char (result->value.character.string[i]),
6697 return &gfc_bad_expr;
6702 else if (e->expr_type == EXPR_ARRAY)
6704 /* For an array constructor, we convert each constructor element. */
6707 result = gfc_get_array_expr (type, kind, &e->where);
6708 result->shape = gfc_copy_shape (e->shape, e->rank);
6709 result->rank = e->rank;
6710 result->ts.u.cl = e->ts.u.cl;
6712 for (c = gfc_constructor_first (e->value.constructor);
6713 c; c = gfc_constructor_next (c))
6715 gfc_expr *tmp = gfc_convert_char_constant (c->expr, type, kind);
6716 if (tmp == &gfc_bad_expr)
6718 gfc_free_expr (result);
6719 return &gfc_bad_expr;
6724 gfc_free_expr (result);
6728 gfc_constructor_append_expr (&result->value.constructor,
6740 gfc_simplify_compiler_options (void)
6745 str = gfc_get_option_string ();
6746 result = gfc_get_character_expr (gfc_default_character_kind,
6747 &gfc_current_locus, str, strlen (str));
6754 gfc_simplify_compiler_version (void)
6759 len = strlen ("GCC version ") + strlen (version_string) + 1;
6760 buffer = (char*) alloca (len);
6761 snprintf (buffer, len, "GCC version %s", version_string);
6762 return gfc_get_character_expr (gfc_default_character_kind,
6763 &gfc_current_locus, buffer, len);