LCOV - code coverage report
Current view: top level - gcc/fortran - simplify.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 92.7 % 4709 4363
Test Date: 2026-11-14 16:39:50 Functions: 99.6 % 263 262
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Simplify intrinsic functions at compile-time.
       2              :    Copyright (C) 2000-2026 Free Software Foundation, Inc.
       3              :    Contributed by Andy Vaught & Katherine Holcomb
       4              : 
       5              : This file is part of GCC.
       6              : 
       7              : GCC is free software; you can redistribute it and/or modify it under
       8              : the terms of the GNU General Public License as published by the Free
       9              : Software Foundation; either version 3, or (at your option) any later
      10              : version.
      11              : 
      12              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15              : for more details.
      16              : 
      17              : You should have received a copy of the GNU General Public License
      18              : along with GCC; see the file COPYING3.  If not see
      19              : <http://www.gnu.org/licenses/>.  */
      20              : 
      21              : #include "config.h"
      22              : #include "system.h"
      23              : #include "coretypes.h"
      24              : #include "tm.h"               /* For BITS_PER_UNIT.  */
      25              : #include "gfortran.h"
      26              : #include "arith.h"
      27              : #include "intrinsic.h"
      28              : #include "match.h"
      29              : #include "target-memory.h"
      30              : #include "constructor.h"
      31              : #include "version.h"  /* For version_string.  */
      32              : 
      33              : /* Prototypes.  */
      34              : 
      35              : static int min_max_choose (gfc_expr *, gfc_expr *, int, bool back_val = false);
      36              : 
      37              : gfc_expr gfc_bad_expr;
      38              : 
      39              : static gfc_expr *simplify_size (gfc_expr *, gfc_expr *, int);
      40              : 
      41              : 
      42              : /* Note that 'simplification' is not just transforming expressions.
      43              :    For functions that are not simplified at compile time, range
      44              :    checking is done if possible.
      45              : 
      46              :    The return convention is that each simplification function returns:
      47              : 
      48              :      A new expression node corresponding to the simplified arguments.
      49              :      The original arguments are destroyed by the caller, and must not
      50              :      be a part of the new expression.
      51              : 
      52              :      NULL pointer indicating that no simplification was possible and
      53              :      the original expression should remain intact.
      54              : 
      55              :      An expression pointer to gfc_bad_expr (a static placeholder)
      56              :      indicating that some error has prevented simplification.  The
      57              :      error is generated within the function and should be propagated
      58              :      upwards
      59              : 
      60              :    By the time a simplification function gets control, it has been
      61              :    decided that the function call is really supposed to be the
      62              :    intrinsic.  No type checking is strictly necessary, since only
      63              :    valid types will be passed on.  On the other hand, a simplification
      64              :    subroutine may have to look at the type of an argument as part of
      65              :    its processing.
      66              : 
      67              :    Array arguments are only passed to these subroutines that implement
      68              :    the simplification of transformational intrinsics.
      69              : 
      70              :    The functions in this file don't have much comment with them, but
      71              :    everything is reasonably straight-forward.  The Standard, chapter 13
      72              :    is the best comment you'll find for this file anyway.  */
      73              : 
      74              : /* Range checks an expression node.  If all goes well, returns the
      75              :    node, otherwise returns &gfc_bad_expr and frees the node.  */
      76              : 
      77              : static gfc_expr *
      78       342631 : range_check (gfc_expr *result, const char *name)
      79              : {
      80       342631 :   if (result == NULL)
      81              :     return &gfc_bad_expr;
      82              : 
      83       342631 :   if (result->expr_type != EXPR_CONSTANT)
      84              :     return result;
      85              : 
      86       342611 :   switch (gfc_range_check (result))
      87              :     {
      88              :       case ARITH_OK:
      89              :         return result;
      90              : 
      91            5 :       case ARITH_OVERFLOW:
      92            5 :         gfc_error ("Result of %s overflows its kind at %L", name,
      93              :                    &result->where);
      94            5 :         break;
      95              : 
      96            0 :       case ARITH_UNDERFLOW:
      97            0 :         gfc_error ("Result of %s underflows its kind at %L", name,
      98              :                    &result->where);
      99            0 :         break;
     100              : 
     101            0 :       case ARITH_NAN:
     102            0 :         gfc_error ("Result of %s is NaN at %L", name, &result->where);
     103            0 :         break;
     104              : 
     105            0 :       default:
     106            0 :         gfc_error ("Result of %s gives range error for its kind at %L", name,
     107              :                    &result->where);
     108            0 :         break;
     109              :     }
     110              : 
     111            5 :   gfc_free_expr (result);
     112            5 :   return &gfc_bad_expr;
     113              : }
     114              : 
     115              : 
     116              : /* A helper function that gets an optional and possibly missing
     117              :    kind parameter.  Returns the kind, -1 if something went wrong.  */
     118              : 
     119              : static int
     120       156748 : get_kind (bt type, gfc_expr *k, const char *name, int default_kind)
     121              : {
     122       156748 :   int kind;
     123              : 
     124       156748 :   if (k == NULL)
     125              :     return default_kind;
     126              : 
     127        34505 :   if (k->expr_type != EXPR_CONSTANT)
     128              :     {
     129            0 :       gfc_error ("KIND parameter of %s at %L must be an initialization "
     130              :                  "expression", name, &k->where);
     131            0 :       return -1;
     132              :     }
     133              : 
     134        34505 :   if (gfc_extract_int (k, &kind)
     135        34505 :       || gfc_validate_kind (type, kind, true) < 0)
     136              :     {
     137            0 :       gfc_error ("Invalid KIND parameter of %s at %L", name, &k->where);
     138            0 :       return -1;
     139              :     }
     140              : 
     141        34505 :   return kind;
     142              : }
     143              : 
     144              : 
     145              : /* Converts an mpz_t signed variable into an unsigned one, assuming
     146              :    two's complement representations and a binary width of bitsize.
     147              :    The conversion is a no-op unless x is negative; otherwise, it can
     148              :    be accomplished by masking out the high bits.  */
     149              : 
     150              : void
     151       105912 : gfc_convert_mpz_to_unsigned (mpz_t x, int bitsize, bool sign)
     152              : {
     153       105912 :   mpz_t mask;
     154              : 
     155       105912 :   if (mpz_sgn (x) < 0)
     156              :     {
     157              :       /* Confirm that no bits above the signed range are unset if we
     158              :          are doing range checking.  */
     159          720 :       if (sign && flag_range_check != 0)
     160          720 :         gcc_assert (mpz_scan0 (x, bitsize-1) == ULONG_MAX);
     161              : 
     162          720 :       mpz_init_set_ui (mask, 1);
     163          720 :       mpz_mul_2exp (mask, mask, bitsize);
     164          720 :       mpz_sub_ui (mask, mask, 1);
     165              : 
     166          720 :       mpz_and (x, x, mask);
     167              : 
     168          720 :       mpz_clear (mask);
     169              :     }
     170              :   else
     171              :     {
     172              :       /* Confirm that no bits above the signed range are set if we
     173              :          are doing range checking.  */
     174       105192 :       if (sign && flag_range_check != 0)
     175         2794 :         gcc_assert (mpz_scan1 (x, bitsize-1) == ULONG_MAX);
     176              :     }
     177       105912 : }
     178              : 
     179              : 
     180              : /* Converts an mpz_t unsigned variable into a signed one, assuming
     181              :    two's complement representations and a binary width of bitsize.
     182              :    If the bitsize-1 bit is set, this is taken as a sign bit and
     183              :    the number is converted to the corresponding negative number.  */
     184              : 
     185              : void
     186         8937 : gfc_convert_mpz_to_signed (mpz_t x, int bitsize)
     187              : {
     188         8937 :   mpz_t mask;
     189              : 
     190              :   /* Confirm that no bits above the unsigned range are set if we are
     191              :      doing range checking.  */
     192         8937 :   if (flag_range_check != 0)
     193         8805 :     gcc_assert (mpz_scan1 (x, bitsize) == ULONG_MAX);
     194              : 
     195         8937 :   if (mpz_tstbit (x, bitsize - 1) == 1)
     196              :     {
     197         1788 :       mpz_init_set_ui (mask, 1);
     198         1788 :       mpz_mul_2exp (mask, mask, bitsize);
     199         1788 :       mpz_sub_ui (mask, mask, 1);
     200              : 
     201              :       /* We negate the number by hand, zeroing the high bits, that is
     202              :          make it the corresponding positive number, and then have it
     203              :          negated by GMP, giving the correct representation of the
     204              :          negative number.  */
     205         1788 :       mpz_com (x, x);
     206         1788 :       mpz_add_ui (x, x, 1);
     207         1788 :       mpz_and (x, x, mask);
     208              : 
     209         1788 :       mpz_neg (x, x);
     210              : 
     211         1788 :       mpz_clear (mask);
     212              :     }
     213         8937 : }
     214              : 
     215              : 
     216              : /* Test that the expression is a constant array, simplifying if
     217              :    we are dealing with a parameter array.  */
     218              : 
     219              : static bool
     220       136842 : is_constant_array_expr (gfc_expr *e)
     221              : {
     222       136842 :   gfc_constructor *c;
     223       136842 :   bool array_OK = true;
     224       136842 :   mpz_t size;
     225              : 
     226       136842 :   if (e == NULL)
     227              :     return true;
     228              : 
     229       123218 :   if (e->expr_type == EXPR_VARIABLE && e->rank > 0
     230        46329 :       && e->symtree->n.sym->attr.flavor == FL_PARAMETER)
     231         3352 :     gfc_simplify_expr (e, 1);
     232              : 
     233       123218 :   if (e->expr_type != EXPR_ARRAY || !gfc_is_constant_expr (e))
     234              :     return false;
     235              : 
     236              :   /* A non-zero-sized constant array shall have a non-empty constructor.  */
     237        29580 :   if (e->rank > 0 && e->shape != NULL && e->value.constructor == NULL)
     238              :     {
     239         1219 :       mpz_init_set_ui (size, 1);
     240         3867 :       for (int j = 0; j < e->rank; j++)
     241         1429 :         mpz_mul (size, size, e->shape[j]);
     242         1219 :       bool not_size0 = (mpz_cmp_si (size, 0) != 0);
     243         1219 :       mpz_clear (size);
     244         1219 :       if (not_size0)
     245              :         return false;
     246              :     }
     247              : 
     248        29577 :   for (c = gfc_constructor_first (e->value.constructor);
     249       512091 :        c; c = gfc_constructor_next (c))
     250       482539 :     if (c->expr->expr_type != EXPR_CONSTANT
     251          972 :           && c->expr->expr_type != EXPR_STRUCTURE)
     252              :       {
     253              :         array_OK = false;
     254              :         break;
     255              :       }
     256              : 
     257              :   /* Check and expand the constructor.  We do this when either
     258              :      gfc_init_expr_flag is set or for not too large array constructors.  */
     259        29577 :   bool expand;
     260        59154 :   expand = (e->rank == 1
     261        28628 :             && e->shape
     262        58194 :             && (mpz_cmp_ui (e->shape[0], flag_max_array_constructor) < 0));
     263              : 
     264        29577 :   if (!array_OK && (gfc_init_expr_flag || expand) && e->rank == 1)
     265              :     {
     266           19 :       bool saved_init_expr_flag = gfc_init_expr_flag;
     267           19 :       array_OK = gfc_reduce_init_expr (e);
     268              :       /* gfc_reduce_init_expr resets the flag.  */
     269           19 :       gfc_init_expr_flag = saved_init_expr_flag;
     270              :     }
     271              :   else
     272              :     return array_OK;
     273              : 
     274              :   /* Recheck to make sure that any EXPR_ARRAYs have gone.  */
     275           19 :   for (c = gfc_constructor_first (e->value.constructor);
     276          146 :        c; c = gfc_constructor_next (c))
     277          131 :     if (c->expr->expr_type != EXPR_CONSTANT
     278            4 :           && c->expr->expr_type != EXPR_STRUCTURE)
     279              :       return false;
     280              : 
     281              :   /* Make sure that the array has a valid shape.  */
     282           15 :   if (e->shape == NULL && e->rank == 1)
     283              :     {
     284            0 :       if (!gfc_array_size(e, &size))
     285              :         return false;
     286            0 :       e->shape = gfc_get_shape (1);
     287            0 :       mpz_init_set (e->shape[0], size);
     288            0 :       mpz_clear (size);
     289              :     }
     290              : 
     291              :   return array_OK;
     292              : }
     293              : 
     294              : bool
     295        11351 : gfc_is_constant_array_expr (gfc_expr *e)
     296              : {
     297        11351 :   return is_constant_array_expr (e);
     298              : }
     299              : 
     300              : 
     301              : /* Test for a size zero array.  */
     302              : bool
     303       176609 : gfc_is_size_zero_array (gfc_expr *array)
     304              : {
     305              : 
     306       176609 :   if (array->rank == 0)
     307              :     return false;
     308              : 
     309       171441 :   if (array->expr_type == EXPR_VARIABLE && array->rank > 0
     310        22464 :       && array->symtree->n.sym->attr.flavor == FL_PARAMETER
     311        10745 :       && array->shape != NULL)
     312              :     {
     313        22090 :       for (int i = 0; i < array->rank; i++)
     314        12506 :         if (mpz_cmp_si (array->shape[i], 0) <= 0)
     315              :           return true;
     316              : 
     317              :       return false;
     318              :     }
     319              : 
     320       160950 :   if (array->expr_type == EXPR_ARRAY)
     321       103397 :     return array->value.constructor == NULL;
     322              : 
     323              :   return false;
     324              : }
     325              : 
     326              : 
     327              : /* Initialize a transformational result expression with a given value.  */
     328              : 
     329              : static void
     330         4068 : init_result_expr (gfc_expr *e, int init, gfc_expr *array)
     331              : {
     332         4068 :   if (e && e->expr_type == EXPR_ARRAY)
     333              :     {
     334          225 :       gfc_constructor *ctor = gfc_constructor_first (e->value.constructor);
     335         1049 :       while (ctor)
     336              :         {
     337          599 :           init_result_expr (ctor->expr, init, array);
     338          599 :           ctor = gfc_constructor_next (ctor);
     339              :         }
     340              :     }
     341         3843 :   else if (e && e->expr_type == EXPR_CONSTANT)
     342              :     {
     343         3843 :       int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
     344         3843 :       HOST_WIDE_INT length;
     345         3843 :       gfc_char_t *string;
     346              : 
     347         3843 :       switch (e->ts.type)
     348              :         {
     349         2256 :           case BT_LOGICAL:
     350         2256 :             e->value.logical = (init ? 1 : 0);
     351         2256 :             break;
     352              : 
     353         1029 :           case BT_INTEGER:
     354         1029 :             if (init == INT_MIN)
     355          144 :               mpz_set (e->value.integer, gfc_integer_kinds[i].min_int);
     356          885 :             else if (init == INT_MAX)
     357          158 :               mpz_set (e->value.integer, gfc_integer_kinds[i].huge);
     358              :             else
     359          727 :               mpz_set_si (e->value.integer, init);
     360              :             break;
     361              : 
     362          186 :           case BT_UNSIGNED:
     363          186 :             if (init == INT_MIN)
     364           48 :               mpz_set_ui (e->value.integer, 0);
     365          138 :             else if (init == INT_MAX)
     366           48 :               mpz_set (e->value.integer, gfc_unsigned_kinds[i].huge);
     367              :             else
     368           90 :               mpz_set_ui (e->value.integer, init);
     369              :             break;
     370              : 
     371          280 :         case BT_REAL:
     372          280 :             if (init == INT_MIN)
     373              :               {
     374           26 :                 mpfr_set (e->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
     375           26 :                 mpfr_neg (e->value.real, e->value.real, GFC_RND_MODE);
     376              :               }
     377          254 :             else if (init == INT_MAX)
     378           27 :               mpfr_set (e->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
     379              :             else
     380          227 :               mpfr_set_si (e->value.real, init, GFC_RND_MODE);
     381              :             break;
     382              : 
     383           48 :           case BT_COMPLEX:
     384           48 :             mpc_set_si (e->value.complex, init, GFC_MPC_RND_MODE);
     385           48 :             break;
     386              : 
     387           44 :           case BT_CHARACTER:
     388           44 :             if (init == INT_MIN)
     389              :               {
     390           22 :                 gfc_expr *len = gfc_simplify_len (array, NULL);
     391           22 :                 gfc_extract_hwi (len, &length);
     392           22 :                 string = gfc_get_wide_string (length + 1);
     393           22 :                 gfc_wide_memset (string, 0, length);
     394              :               }
     395           22 :             else if (init == INT_MAX)
     396              :               {
     397           22 :                 gfc_expr *len = gfc_simplify_len (array, NULL);
     398           22 :                 gfc_extract_hwi (len, &length);
     399           22 :                 string = gfc_get_wide_string (length + 1);
     400           22 :                 gfc_wide_memset (string, 255, length);
     401              :               }
     402              :             else
     403              :               {
     404            0 :                 length = 0;
     405            0 :                 string = gfc_get_wide_string (1);
     406              :               }
     407              : 
     408           44 :             string[length] = '\0';
     409           44 :             e->value.character.length = length;
     410           44 :             e->value.character.string = string;
     411           44 :             break;
     412              : 
     413            0 :           default:
     414            0 :             gcc_unreachable();
     415              :         }
     416         3843 :     }
     417              :   else
     418            0 :     gcc_unreachable();
     419         4068 : }
     420              : 
     421              : 
     422              : /* Helper function for gfc_simplify_dot_product() and gfc_simplify_matmul;
     423              :    if conj_a is true, the matrix_a is complex conjugated.  */
     424              : 
     425              : static gfc_expr *
     426          458 : compute_dot_product (gfc_expr *matrix_a, int stride_a, int offset_a,
     427              :                      gfc_expr *matrix_b, int stride_b, int offset_b,
     428              :                      bool conj_a)
     429              : {
     430          458 :   gfc_expr *result, *a, *b, *c;
     431              : 
     432              :   /* Set result to an UNSIGNED of correct kind for unsigned,
     433              :      INTEGER(1) 0 for other numeric types, and .false. for
     434              :      LOGICAL.  Mixed-mode math in the loop will promote result to the
     435              :      correct type and kind.  */
     436          458 :   if (matrix_a->ts.type == BT_LOGICAL)
     437            0 :     result = gfc_get_logical_expr (gfc_default_logical_kind, NULL, false);
     438          458 :   else if (matrix_a->ts.type == BT_UNSIGNED)
     439              :     {
     440           60 :       int kind = MAX (matrix_a->ts.kind, matrix_b->ts.kind);
     441           60 :       result = gfc_get_unsigned_expr (kind, NULL, 0);
     442              :     }
     443              :   else
     444          398 :     result = gfc_get_int_expr (1, NULL, 0);
     445              : 
     446          458 :   result->where = matrix_a->where;
     447              : 
     448          458 :   a = gfc_constructor_lookup_expr (matrix_a->value.constructor, offset_a);
     449          458 :   b = gfc_constructor_lookup_expr (matrix_b->value.constructor, offset_b);
     450         2050 :   while (a && b)
     451              :     {
     452              :       /* Copying of expressions is required as operands are free'd
     453              :          by the gfc_arith routines.  */
     454         1134 :       switch (result->ts.type)
     455              :         {
     456            0 :           case BT_LOGICAL:
     457            0 :             result = gfc_or (result,
     458              :                              gfc_and (gfc_copy_expr (a),
     459              :                                       gfc_copy_expr (b)));
     460            0 :             break;
     461              : 
     462         1134 :           case BT_INTEGER:
     463         1134 :           case BT_REAL:
     464         1134 :           case BT_COMPLEX:
     465         1134 :           case BT_UNSIGNED:
     466         1134 :             if (conj_a && a->ts.type == BT_COMPLEX)
     467            2 :               c = gfc_simplify_conjg (a);
     468              :             else
     469         1132 :               c = gfc_copy_expr (a);
     470         1134 :             result = gfc_add (result, gfc_multiply (c, gfc_copy_expr (b)));
     471         1134 :             break;
     472              : 
     473            0 :           default:
     474            0 :             gcc_unreachable();
     475              :         }
     476              : 
     477         1134 :       offset_a += stride_a;
     478         1134 :       a = gfc_constructor_lookup_expr (matrix_a->value.constructor, offset_a);
     479              : 
     480         1134 :       offset_b += stride_b;
     481         1134 :       b = gfc_constructor_lookup_expr (matrix_b->value.constructor, offset_b);
     482              :     }
     483              : 
     484          458 :   return result;
     485              : }
     486              : 
     487              : 
     488              : /* Build a result expression for transformational intrinsics,
     489              :    depending on DIM.  */
     490              : 
     491              : static gfc_expr *
     492         3270 : transformational_result (gfc_expr *array, gfc_expr *dim, bt type,
     493              :                          int kind, locus* where)
     494              : {
     495         3270 :   gfc_expr *result;
     496         3270 :   int i, nelem;
     497              : 
     498         3270 :   if (!dim || array->rank == 1)
     499         3045 :     return gfc_get_constant_expr (type, kind, where);
     500              : 
     501          225 :   result = gfc_get_array_expr (type, kind, where);
     502          225 :   result->shape = gfc_copy_shape_excluding (array->shape, array->rank, dim);
     503          225 :   result->rank = array->rank - 1;
     504              : 
     505              :   /* gfc_array_size() would count the number of elements in the constructor,
     506              :      we have not built those yet.  */
     507          225 :   nelem = 1;
     508          450 :   for  (i = 0; i < result->rank; ++i)
     509          230 :     nelem *= mpz_get_ui (result->shape[i]);
     510              : 
     511          824 :   for (i = 0; i < nelem; ++i)
     512              :     {
     513          599 :       gfc_constructor_append_expr (&result->value.constructor,
     514              :                                    gfc_get_constant_expr (type, kind, where),
     515              :                                    NULL);
     516              :     }
     517              : 
     518              :   return result;
     519              : }
     520              : 
     521              : 
     522              : typedef gfc_expr* (*transformational_op)(gfc_expr*, gfc_expr*);
     523              : 
     524              : /* Wrapper function, implements 'op1 += 1'. Only called if MASK
     525              :    of COUNT intrinsic is .TRUE..
     526              : 
     527              :    Interface and implementation mimics arith functions as
     528              :    gfc_add, gfc_multiply, etc.  */
     529              : 
     530              : static gfc_expr *
     531          108 : gfc_count (gfc_expr *op1, gfc_expr *op2)
     532              : {
     533          108 :   gfc_expr *result;
     534              : 
     535          108 :   gcc_assert (op1->ts.type == BT_INTEGER);
     536          108 :   gcc_assert (op2->ts.type == BT_LOGICAL);
     537          108 :   gcc_assert (op2->value.logical);
     538              : 
     539          108 :   result = gfc_copy_expr (op1);
     540          108 :   mpz_add_ui (result->value.integer, result->value.integer, 1);
     541              : 
     542          108 :   gfc_free_expr (op1);
     543          108 :   gfc_free_expr (op2);
     544          108 :   return result;
     545              : }
     546              : 
     547              : 
     548              : /* Transforms an ARRAY with operation OP, according to MASK, to a
     549              :    scalar RESULT. E.g. called if
     550              : 
     551              :      REAL, PARAMETER :: array(n, m) = ...
     552              :      REAL, PARAMETER :: s = SUM(array)
     553              : 
     554              :   where OP == gfc_add().  */
     555              : 
     556              : static gfc_expr *
     557         2629 : simplify_transformation_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *mask,
     558              :                                    transformational_op op)
     559              : {
     560         2629 :   gfc_expr *a, *m;
     561         2629 :   gfc_constructor *array_ctor, *mask_ctor;
     562              : 
     563              :   /* Shortcut for constant .FALSE. MASK.  */
     564         2629 :   if (mask
     565           98 :       && mask->expr_type == EXPR_CONSTANT
     566           24 :       && !mask->value.logical)
     567              :     return result;
     568              : 
     569         2605 :   array_ctor = gfc_constructor_first (array->value.constructor);
     570         2605 :   mask_ctor = NULL;
     571         2605 :   if (mask && mask->expr_type == EXPR_ARRAY)
     572           74 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
     573              : 
     574        71477 :   while (array_ctor)
     575              :     {
     576        68872 :       a = array_ctor->expr;
     577        68872 :       array_ctor = gfc_constructor_next (array_ctor);
     578              : 
     579              :       /* A constant MASK equals .TRUE. here and can be ignored.  */
     580        68872 :       if (mask_ctor)
     581              :         {
     582          430 :           m = mask_ctor->expr;
     583          430 :           mask_ctor = gfc_constructor_next (mask_ctor);
     584          430 :           if (!m->value.logical)
     585          304 :             continue;
     586              :         }
     587              : 
     588        68568 :       result = op (result, gfc_copy_expr (a));
     589        68568 :       if (!result)
     590              :         return result;
     591              :     }
     592              : 
     593              :   return result;
     594              : }
     595              : 
     596              : /* Transforms an ARRAY with operation OP, according to MASK, to an
     597              :    array RESULT. E.g. called if
     598              : 
     599              :      REAL, PARAMETER :: array(n, m) = ...
     600              :      REAL, PARAMETER :: s(n) = PROD(array, DIM=1)
     601              : 
     602              :    where OP == gfc_multiply().
     603              :    The result might be post processed using post_op.  */
     604              : 
     605              : static gfc_expr *
     606          150 : simplify_transformation_to_array (gfc_expr *result, gfc_expr *array, gfc_expr *dim,
     607              :                                   gfc_expr *mask, transformational_op op,
     608              :                                   transformational_op post_op)
     609              : {
     610          150 :   mpz_t size;
     611          150 :   int done, i, n, arraysize, resultsize, dim_index, dim_extent, dim_stride;
     612          150 :   gfc_expr **arrayvec, **resultvec, **base, **src, **dest;
     613          150 :   gfc_constructor *array_ctor, *mask_ctor, *result_ctor;
     614              : 
     615          150 :   int count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
     616              :       sstride[GFC_MAX_DIMENSIONS], dstride[GFC_MAX_DIMENSIONS],
     617              :       tmpstride[GFC_MAX_DIMENSIONS];
     618              : 
     619              :   /* Shortcut for constant .FALSE. MASK.  */
     620          150 :   if (mask
     621           16 :       && mask->expr_type == EXPR_CONSTANT
     622            0 :       && !mask->value.logical)
     623              :     return result;
     624              : 
     625              :   /* Build an indexed table for array element expressions to minimize
     626              :      linked-list traversal. Masked elements are set to NULL.  */
     627          150 :   gfc_array_size (array, &size);
     628          150 :   arraysize = mpz_get_ui (size);
     629          150 :   mpz_clear (size);
     630              : 
     631          150 :   arrayvec = XCNEWVEC (gfc_expr*, arraysize);
     632              : 
     633          150 :   array_ctor = gfc_constructor_first (array->value.constructor);
     634          150 :   mask_ctor = NULL;
     635          150 :   if (mask && mask->expr_type == EXPR_ARRAY)
     636           16 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
     637              : 
     638         1174 :   for (i = 0; i < arraysize; ++i)
     639              :     {
     640         1024 :       arrayvec[i] = array_ctor->expr;
     641         1024 :       array_ctor = gfc_constructor_next (array_ctor);
     642              : 
     643         1024 :       if (mask_ctor)
     644              :         {
     645          156 :           if (!mask_ctor->expr->value.logical)
     646           83 :             arrayvec[i] = NULL;
     647              : 
     648          156 :           mask_ctor = gfc_constructor_next (mask_ctor);
     649              :         }
     650              :     }
     651              : 
     652              :   /* Same for the result expression.  */
     653          150 :   gfc_array_size (result, &size);
     654          150 :   resultsize = mpz_get_ui (size);
     655          150 :   mpz_clear (size);
     656              : 
     657          150 :   resultvec = XCNEWVEC (gfc_expr*, resultsize);
     658          150 :   result_ctor = gfc_constructor_first (result->value.constructor);
     659          696 :   for (i = 0; i < resultsize; ++i)
     660              :     {
     661          396 :       resultvec[i] = result_ctor->expr;
     662          396 :       result_ctor = gfc_constructor_next (result_ctor);
     663              :     }
     664              : 
     665          150 :   gfc_extract_int (dim, &dim_index);
     666          150 :   dim_index -= 1;               /* zero-base index */
     667          150 :   dim_extent = 0;
     668          150 :   dim_stride = 0;
     669              : 
     670          450 :   for (i = 0, n = 0; i < array->rank; ++i)
     671              :     {
     672          300 :       count[i] = 0;
     673          300 :       tmpstride[i] = (i == 0) ? 1 : tmpstride[i-1] * mpz_get_si (array->shape[i-1]);
     674          300 :       if (i == dim_index)
     675              :         {
     676          150 :           dim_extent = mpz_get_si (array->shape[i]);
     677          150 :           dim_stride = tmpstride[i];
     678          150 :           continue;
     679              :         }
     680              : 
     681          150 :       extent[n] = mpz_get_si (array->shape[i]);
     682          150 :       sstride[n] = tmpstride[i];
     683          150 :       dstride[n] = (n == 0) ? 1 : dstride[n-1] * extent[n-1];
     684          150 :       n += 1;
     685              :     }
     686              : 
     687          150 :   done = resultsize <= 0;
     688          150 :   base = arrayvec;
     689          150 :   dest = resultvec;
     690          696 :   while (!done)
     691              :     {
     692         1420 :       for (src = base, n = 0; n < dim_extent; src += dim_stride, ++n)
     693         1024 :         if (*src)
     694          941 :           *dest = op (*dest, gfc_copy_expr (*src));
     695              : 
     696          396 :       if (post_op)
     697            2 :         *dest = post_op (*dest, *dest);
     698              : 
     699          396 :       count[0]++;
     700          396 :       base += sstride[0];
     701          396 :       dest += dstride[0];
     702              : 
     703          396 :       n = 0;
     704          396 :       while (!done && count[n] == extent[n])
     705              :         {
     706          150 :           count[n] = 0;
     707          150 :           base -= sstride[n] * extent[n];
     708          150 :           dest -= dstride[n] * extent[n];
     709              : 
     710          150 :           n++;
     711          150 :           if (n < result->rank)
     712              :             {
     713              :               /* If the nested loop is unrolled GFC_MAX_DIMENSIONS
     714              :                  times, we'd warn for the last iteration, because the
     715              :                  array index will have already been incremented to the
     716              :                  array sizes, and we can't tell that this must make
     717              :                  the test against result->rank false, because ranks
     718              :                  must not exceed GFC_MAX_DIMENSIONS.  */
     719            0 :               GCC_DIAGNOSTIC_PUSH_IGNORED (-Warray-bounds)
     720            0 :               count[n]++;
     721            0 :               base += sstride[n];
     722            0 :               dest += dstride[n];
     723            0 :               GCC_DIAGNOSTIC_POP
     724              :             }
     725              :           else
     726              :             done = true;
     727              :        }
     728              :     }
     729              : 
     730              :   /* Place updated expression in result constructor.  */
     731          150 :   result_ctor = gfc_constructor_first (result->value.constructor);
     732          696 :   for (i = 0; i < resultsize; ++i)
     733              :     {
     734          396 :       result_ctor->expr = resultvec[i];
     735          396 :       result_ctor = gfc_constructor_next (result_ctor);
     736              :     }
     737              : 
     738          150 :   free (arrayvec);
     739          150 :   free (resultvec);
     740          150 :   return result;
     741              : }
     742              : 
     743              : 
     744              : static gfc_expr *
     745        60294 : simplify_transformation (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
     746              :                          int init_val, transformational_op op)
     747              : {
     748        60294 :   gfc_expr *result;
     749        60294 :   bool size_zero;
     750              : 
     751        60294 :   size_zero = gfc_is_size_zero_array (array);
     752              : 
     753       117465 :   if (!(is_constant_array_expr (array) || size_zero)
     754         3123 :       || array->shape == NULL
     755        63410 :       || !gfc_is_constant_expr (dim))
     756              :     return NULL;
     757              : 
     758         3116 :   if (mask
     759          242 :       && !is_constant_array_expr (mask)
     760         3298 :       && mask->expr_type != EXPR_CONSTANT)
     761              :     return NULL;
     762              : 
     763         2958 :   result = transformational_result (array, dim, array->ts.type,
     764              :                                     array->ts.kind, &array->where);
     765         2958 :   init_result_expr (result, init_val, array);
     766              : 
     767         2958 :   if (size_zero)
     768              :     return result;
     769              : 
     770         2711 :   return !dim || array->rank == 1 ?
     771         2568 :     simplify_transformation_to_scalar (result, array, mask, op) :
     772         2711 :     simplify_transformation_to_array (result, array, dim, mask, op, NULL);
     773              : }
     774              : 
     775              : 
     776              : /********************** Simplification functions *****************************/
     777              : 
     778              : gfc_expr *
     779        25959 : gfc_simplify_abs (gfc_expr *e)
     780              : {
     781        25959 :   gfc_expr *result;
     782              : 
     783        25959 :   if (e->expr_type != EXPR_CONSTANT)
     784              :     return NULL;
     785              : 
     786          980 :   switch (e->ts.type)
     787              :     {
     788           36 :       case BT_INTEGER:
     789           36 :         result = gfc_get_constant_expr (BT_INTEGER, e->ts.kind, &e->where);
     790           36 :         mpz_abs (result->value.integer, e->value.integer);
     791           36 :         return range_check (result, "IABS");
     792              : 
     793          782 :       case BT_REAL:
     794          782 :         result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
     795          782 :         mpfr_abs (result->value.real, e->value.real, GFC_RND_MODE);
     796          782 :         return range_check (result, "ABS");
     797              : 
     798          162 :       case BT_COMPLEX:
     799          162 :         gfc_set_model_kind (e->ts.kind);
     800          162 :         result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
     801          162 :         mpc_abs (result->value.real, e->value.complex, GFC_RND_MODE);
     802          162 :         return range_check (result, "CABS");
     803              : 
     804            0 :       default:
     805            0 :         gfc_internal_error ("gfc_simplify_abs(): Bad type");
     806              :     }
     807              : }
     808              : 
     809              : 
     810              : static gfc_expr *
     811        22284 : simplify_achar_char (gfc_expr *e, gfc_expr *k, const char *name, bool ascii)
     812              : {
     813        22284 :   gfc_expr *result;
     814        22284 :   int kind;
     815        22284 :   bool too_large = false;
     816              : 
     817        22284 :   if (e->expr_type != EXPR_CONSTANT)
     818              :     return NULL;
     819              : 
     820        14621 :   kind = get_kind (BT_CHARACTER, k, name, gfc_default_character_kind);
     821        14621 :   if (kind == -1)
     822              :     return &gfc_bad_expr;
     823              : 
     824        14621 :   if (mpz_cmp_si (e->value.integer, 0) < 0)
     825              :     {
     826            8 :       gfc_error ("Argument of %s function at %L is negative", name,
     827              :                  &e->where);
     828            8 :       return &gfc_bad_expr;
     829              :     }
     830              : 
     831        14613 :   if (ascii && warn_surprising && mpz_cmp_si (e->value.integer, 127) > 0)
     832            1 :     gfc_warning (OPT_Wsurprising,
     833              :                  "Argument of %s function at %L outside of range [0,127]",
     834              :                  name, &e->where);
     835              : 
     836        14613 :   if (kind == 1 && mpz_cmp_si (e->value.integer, 255) > 0)
     837              :     too_large = true;
     838        14604 :   else if (kind == 4)
     839              :     {
     840         1486 :       mpz_t t;
     841         1486 :       mpz_init_set_ui (t, 2);
     842         1486 :       mpz_pow_ui (t, t, 32);
     843         1486 :       mpz_sub_ui (t, t, 1);
     844         1486 :       if (mpz_cmp (e->value.integer, t) > 0)
     845            2 :         too_large = true;
     846         1486 :       mpz_clear (t);
     847              :     }
     848              : 
     849         1486 :   if (too_large)
     850              :     {
     851           11 :       gfc_error ("Argument of %s function at %L is too large for the "
     852              :                  "collating sequence of kind %d", name, &e->where, kind);
     853           11 :       return &gfc_bad_expr;
     854              :     }
     855              : 
     856        14602 :   result = gfc_get_character_expr (kind, &e->where, NULL, 1);
     857        14602 :   result->value.character.string[0] = mpz_get_ui (e->value.integer);
     858              : 
     859        14602 :   return result;
     860              : }
     861              : 
     862              : 
     863              : 
     864              : /* We use the processor's collating sequence, because all
     865              :    systems that gfortran currently works on are ASCII.  */
     866              : 
     867              : gfc_expr *
     868        13442 : gfc_simplify_achar (gfc_expr *e, gfc_expr *k)
     869              : {
     870        13442 :   return simplify_achar_char (e, k, "ACHAR", true);
     871              : }
     872              : 
     873              : 
     874              : gfc_expr *
     875          558 : gfc_simplify_acos (gfc_expr *x)
     876              : {
     877          558 :   gfc_expr *result;
     878              : 
     879          558 :   if (x->expr_type != EXPR_CONSTANT)
     880              :     return NULL;
     881              : 
     882           94 :   switch (x->ts.type)
     883              :     {
     884           90 :       case BT_REAL:
     885           90 :         if (mpfr_cmp_si (x->value.real, 1) > 0
     886           90 :             || mpfr_cmp_si (x->value.real, -1) < 0)
     887              :           {
     888            0 :             gfc_error ("Argument of ACOS at %L must be within the closed "
     889              :                        "interval [-1, 1]",
     890              :                        &x->where);
     891            0 :             return &gfc_bad_expr;
     892              :           }
     893           90 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
     894           90 :         mpfr_acos (result->value.real, x->value.real, GFC_RND_MODE);
     895           90 :         break;
     896              : 
     897            4 :       case BT_COMPLEX:
     898            4 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
     899            4 :         mpc_acos (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
     900            4 :         break;
     901              : 
     902            0 :       default:
     903            0 :         gfc_internal_error ("in gfc_simplify_acos(): Bad type");
     904              :     }
     905              : 
     906           94 :   return range_check (result, "ACOS");
     907              : }
     908              : 
     909              : gfc_expr *
     910          266 : gfc_simplify_acosh (gfc_expr *x)
     911              : {
     912          266 :   gfc_expr *result;
     913              : 
     914          266 :   if (x->expr_type != EXPR_CONSTANT)
     915              :     return NULL;
     916              : 
     917           34 :   switch (x->ts.type)
     918              :     {
     919           30 :       case BT_REAL:
     920           30 :         if (mpfr_cmp_si (x->value.real, 1) < 0)
     921              :           {
     922            0 :             gfc_error ("Argument of ACOSH at %L must not be less than 1",
     923              :                        &x->where);
     924            0 :             return &gfc_bad_expr;
     925              :           }
     926              : 
     927           30 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
     928           30 :         mpfr_acosh (result->value.real, x->value.real, GFC_RND_MODE);
     929           30 :         break;
     930              : 
     931            4 :       case BT_COMPLEX:
     932            4 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
     933            4 :         mpc_acosh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
     934            4 :         break;
     935              : 
     936            0 :       default:
     937            0 :         gfc_internal_error ("in gfc_simplify_acosh(): Bad type");
     938              :     }
     939              : 
     940           34 :   return range_check (result, "ACOSH");
     941              : }
     942              : 
     943              : gfc_expr *
     944         1173 : gfc_simplify_adjustl (gfc_expr *e)
     945              : {
     946         1173 :   gfc_expr *result;
     947         1173 :   int count, i, len;
     948         1173 :   gfc_char_t ch;
     949              : 
     950         1173 :   if (e->expr_type != EXPR_CONSTANT)
     951              :     return NULL;
     952              : 
     953           31 :   len = e->value.character.length;
     954              : 
     955           89 :   for (count = 0, i = 0; i < len; ++i)
     956              :     {
     957           89 :       ch = e->value.character.string[i];
     958           89 :       if (ch != ' ')
     959              :         break;
     960           58 :       ++count;
     961              :     }
     962              : 
     963           31 :   result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, len);
     964          476 :   for (i = 0; i < len - count; ++i)
     965          414 :     result->value.character.string[i] = e->value.character.string[count + i];
     966              : 
     967              :   return result;
     968              : }
     969              : 
     970              : 
     971              : gfc_expr *
     972          371 : gfc_simplify_adjustr (gfc_expr *e)
     973              : {
     974          371 :   gfc_expr *result;
     975          371 :   int count, i, len;
     976          371 :   gfc_char_t ch;
     977              : 
     978          371 :   if (e->expr_type != EXPR_CONSTANT)
     979              :     return NULL;
     980              : 
     981           23 :   len = e->value.character.length;
     982              : 
     983          173 :   for (count = 0, i = len - 1; i >= 0; --i)
     984              :     {
     985          173 :       ch = e->value.character.string[i];
     986          173 :       if (ch != ' ')
     987              :         break;
     988          150 :       ++count;
     989              :     }
     990              : 
     991           23 :   result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, len);
     992          196 :   for (i = 0; i < count; ++i)
     993          150 :     result->value.character.string[i] = ' ';
     994              : 
     995          260 :   for (i = count; i < len; ++i)
     996          237 :     result->value.character.string[i] = e->value.character.string[i - count];
     997              : 
     998              :   return result;
     999              : }
    1000              : 
    1001              : 
    1002              : gfc_expr *
    1003         1773 : gfc_simplify_aimag (gfc_expr *e)
    1004              : {
    1005         1773 :   gfc_expr *result;
    1006              : 
    1007         1773 :   if (e->expr_type != EXPR_CONSTANT)
    1008              :     return NULL;
    1009              : 
    1010          164 :   result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
    1011          164 :   mpfr_set (result->value.real, mpc_imagref (e->value.complex), GFC_RND_MODE);
    1012              : 
    1013          164 :   return range_check (result, "AIMAG");
    1014              : }
    1015              : 
    1016              : 
    1017              : gfc_expr *
    1018          594 : gfc_simplify_aint (gfc_expr *e, gfc_expr *k)
    1019              : {
    1020          594 :   gfc_expr *rtrunc, *result;
    1021          594 :   int kind;
    1022              : 
    1023          594 :   kind = get_kind (BT_REAL, k, "AINT", e->ts.kind);
    1024          594 :   if (kind == -1)
    1025              :     return &gfc_bad_expr;
    1026              : 
    1027          594 :   if (e->expr_type != EXPR_CONSTANT)
    1028              :     return NULL;
    1029              : 
    1030           31 :   rtrunc = gfc_copy_expr (e);
    1031           31 :   mpfr_trunc (rtrunc->value.real, e->value.real);
    1032              : 
    1033           31 :   result = gfc_real2real (rtrunc, kind);
    1034              : 
    1035           31 :   gfc_free_expr (rtrunc);
    1036              : 
    1037           31 :   return range_check (result, "AINT");
    1038              : }
    1039              : 
    1040              : 
    1041              : gfc_expr *
    1042         1359 : gfc_simplify_all (gfc_expr *mask, gfc_expr *dim)
    1043              : {
    1044         1359 :   return simplify_transformation (mask, dim, NULL, true, gfc_and);
    1045              : }
    1046              : 
    1047              : 
    1048              : gfc_expr *
    1049           63 : gfc_simplify_dint (gfc_expr *e)
    1050              : {
    1051           63 :   gfc_expr *rtrunc, *result;
    1052              : 
    1053           63 :   if (e->expr_type != EXPR_CONSTANT)
    1054              :     return NULL;
    1055              : 
    1056           16 :   rtrunc = gfc_copy_expr (e);
    1057           16 :   mpfr_trunc (rtrunc->value.real, e->value.real);
    1058              : 
    1059           16 :   result = gfc_real2real (rtrunc, gfc_default_double_kind);
    1060              : 
    1061           16 :   gfc_free_expr (rtrunc);
    1062              : 
    1063           16 :   return range_check (result, "DINT");
    1064              : }
    1065              : 
    1066              : 
    1067              : gfc_expr *
    1068            3 : gfc_simplify_dreal (gfc_expr *e)
    1069              : {
    1070            3 :   gfc_expr *result = NULL;
    1071              : 
    1072            3 :   if (e->expr_type != EXPR_CONSTANT)
    1073              :     return NULL;
    1074              : 
    1075            1 :   result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
    1076            1 :   mpc_real (result->value.real, e->value.complex, GFC_RND_MODE);
    1077              : 
    1078            1 :   return range_check (result, "DREAL");
    1079              : }
    1080              : 
    1081              : 
    1082              : gfc_expr *
    1083          162 : gfc_simplify_anint (gfc_expr *e, gfc_expr *k)
    1084              : {
    1085          162 :   gfc_expr *result;
    1086          162 :   int kind;
    1087              : 
    1088          162 :   kind = get_kind (BT_REAL, k, "ANINT", e->ts.kind);
    1089          162 :   if (kind == -1)
    1090              :     return &gfc_bad_expr;
    1091              : 
    1092          162 :   if (e->expr_type != EXPR_CONSTANT)
    1093              :     return NULL;
    1094              : 
    1095           55 :   result = gfc_get_constant_expr (e->ts.type, kind, &e->where);
    1096           55 :   mpfr_round (result->value.real, e->value.real);
    1097              : 
    1098           55 :   return range_check (result, "ANINT");
    1099              : }
    1100              : 
    1101              : 
    1102              : gfc_expr *
    1103          334 : gfc_simplify_and (gfc_expr *x, gfc_expr *y)
    1104              : {
    1105          334 :   gfc_expr *result;
    1106          334 :   int kind;
    1107              : 
    1108          334 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    1109              :     return NULL;
    1110              : 
    1111            7 :   kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
    1112              : 
    1113            7 :   switch (x->ts.type)
    1114              :     {
    1115            1 :       case BT_INTEGER:
    1116            1 :         result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
    1117            1 :         mpz_and (result->value.integer, x->value.integer, y->value.integer);
    1118            1 :         return range_check (result, "AND");
    1119              : 
    1120            6 :       case BT_LOGICAL:
    1121            6 :         return gfc_get_logical_expr (kind, &x->where,
    1122           12 :                                      x->value.logical && y->value.logical);
    1123              : 
    1124            0 :       default:
    1125            0 :         gcc_unreachable ();
    1126              :     }
    1127              : }
    1128              : 
    1129              : 
    1130              : gfc_expr *
    1131        44975 : gfc_simplify_any (gfc_expr *mask, gfc_expr *dim)
    1132              : {
    1133        44975 :   return simplify_transformation (mask, dim, NULL, false, gfc_or);
    1134              : }
    1135              : 
    1136              : 
    1137              : gfc_expr *
    1138          105 : gfc_simplify_dnint (gfc_expr *e)
    1139              : {
    1140          105 :   gfc_expr *result;
    1141              : 
    1142          105 :   if (e->expr_type != EXPR_CONSTANT)
    1143              :     return NULL;
    1144              : 
    1145           46 :   result = gfc_get_constant_expr (BT_REAL, gfc_default_double_kind, &e->where);
    1146           46 :   mpfr_round (result->value.real, e->value.real);
    1147              : 
    1148           46 :   return range_check (result, "DNINT");
    1149              : }
    1150              : 
    1151              : 
    1152              : gfc_expr *
    1153          546 : gfc_simplify_asin (gfc_expr *x)
    1154              : {
    1155          546 :   gfc_expr *result;
    1156              : 
    1157          546 :   if (x->expr_type != EXPR_CONSTANT)
    1158              :     return NULL;
    1159              : 
    1160           49 :   switch (x->ts.type)
    1161              :     {
    1162           45 :       case BT_REAL:
    1163           45 :         if (mpfr_cmp_si (x->value.real, 1) > 0
    1164           45 :             || mpfr_cmp_si (x->value.real, -1) < 0)
    1165              :           {
    1166            0 :             gfc_error ("Argument of ASIN at %L must be within the closed "
    1167              :                        "interval [-1, 1]",
    1168              :                        &x->where);
    1169            0 :             return &gfc_bad_expr;
    1170              :           }
    1171           45 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1172           45 :         mpfr_asin (result->value.real, x->value.real, GFC_RND_MODE);
    1173           45 :         break;
    1174              : 
    1175            4 :       case BT_COMPLEX:
    1176            4 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1177            4 :         mpc_asin (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    1178            4 :         break;
    1179              : 
    1180            0 :       default:
    1181            0 :         gfc_internal_error ("in gfc_simplify_asin(): Bad type");
    1182              :     }
    1183              : 
    1184           49 :   return range_check (result, "ASIN");
    1185              : }
    1186              : 
    1187              : 
    1188              : #if MPFR_VERSION < MPFR_VERSION_NUM(4,2,0)
    1189              : /* Convert radians to degrees, i.e., x * 180 / pi.  */
    1190              : 
    1191              : static void
    1192              : rad2deg (mpfr_t x)
    1193              : {
    1194              :   mpfr_t tmp;
    1195              : 
    1196              :   mpfr_init (tmp);
    1197              :   mpfr_const_pi (tmp, GFC_RND_MODE);
    1198              :   mpfr_mul_ui (x, x, 180, GFC_RND_MODE);
    1199              :   mpfr_div (x, x, tmp, GFC_RND_MODE);
    1200              :   mpfr_clear (tmp);
    1201              : }
    1202              : #endif
    1203              : 
    1204              : 
    1205              : /* Simplify ACOSD(X) where the returned value has units of degree.  */
    1206              : 
    1207              : gfc_expr *
    1208          211 : gfc_simplify_acosd (gfc_expr *x)
    1209              : {
    1210          211 :   gfc_expr *result;
    1211              : 
    1212          211 :   if (x->expr_type != EXPR_CONSTANT)
    1213              :     return NULL;
    1214              : 
    1215           25 :   if (mpfr_cmp_si (x->value.real, 1) > 0
    1216           25 :       || mpfr_cmp_si (x->value.real, -1) < 0)
    1217              :     {
    1218            1 :       gfc_error (
    1219              :         "Argument of ACOSD at %L must be within the closed interval [-1, 1]",
    1220              :         &x->where);
    1221            1 :       return &gfc_bad_expr;
    1222              :     }
    1223              : 
    1224           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1225              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    1226           24 :   mpfr_acosu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    1227              : #else
    1228              :   mpfr_acos (result->value.real, x->value.real, GFC_RND_MODE);
    1229              :   rad2deg (result->value.real);
    1230              : #endif
    1231              : 
    1232           24 :   return range_check (result, "ACOSD");
    1233              : }
    1234              : 
    1235              : 
    1236              : /* Simplify asind (x) where the returned value has units of degree. */
    1237              : 
    1238              : gfc_expr *
    1239          211 : gfc_simplify_asind (gfc_expr *x)
    1240              : {
    1241          211 :   gfc_expr *result;
    1242              : 
    1243          211 :   if (x->expr_type != EXPR_CONSTANT)
    1244              :     return NULL;
    1245              : 
    1246           25 :   if (mpfr_cmp_si (x->value.real, 1) > 0
    1247           25 :       || mpfr_cmp_si (x->value.real, -1) < 0)
    1248              :     {
    1249            1 :       gfc_error (
    1250              :         "Argument of ASIND at %L must be within the closed interval [-1, 1]",
    1251              :         &x->where);
    1252            1 :       return &gfc_bad_expr;
    1253              :     }
    1254              : 
    1255           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1256              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    1257           24 :   mpfr_asinu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    1258              : #else
    1259              :   mpfr_asin (result->value.real, x->value.real, GFC_RND_MODE);
    1260              :   rad2deg (result->value.real);
    1261              : #endif
    1262              : 
    1263           24 :   return range_check (result, "ASIND");
    1264              : }
    1265              : 
    1266              : 
    1267              : /* Simplify atand (x) where the returned value has units of degree. */
    1268              : 
    1269              : gfc_expr *
    1270          210 : gfc_simplify_atand (gfc_expr *x)
    1271              : {
    1272          210 :   gfc_expr *result;
    1273              : 
    1274          210 :   if (x->expr_type != EXPR_CONSTANT)
    1275              :     return NULL;
    1276              : 
    1277           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1278              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    1279           24 :   mpfr_atanu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    1280              : #else
    1281              :   mpfr_atan (result->value.real, x->value.real, GFC_RND_MODE);
    1282              :   rad2deg (result->value.real);
    1283              : #endif
    1284              : 
    1285           24 :   return range_check (result, "ATAND");
    1286              : }
    1287              : 
    1288              : 
    1289              : gfc_expr *
    1290          269 : gfc_simplify_asinh (gfc_expr *x)
    1291              : {
    1292          269 :   gfc_expr *result;
    1293              : 
    1294          269 :   if (x->expr_type != EXPR_CONSTANT)
    1295              :     return NULL;
    1296              : 
    1297           37 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1298              : 
    1299           37 :   switch (x->ts.type)
    1300              :     {
    1301           33 :       case BT_REAL:
    1302           33 :         mpfr_asinh (result->value.real, x->value.real, GFC_RND_MODE);
    1303           33 :         break;
    1304              : 
    1305            4 :       case BT_COMPLEX:
    1306            4 :         mpc_asinh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    1307            4 :         break;
    1308              : 
    1309            0 :       default:
    1310            0 :         gfc_internal_error ("in gfc_simplify_asinh(): Bad type");
    1311              :     }
    1312              : 
    1313           37 :   return range_check (result, "ASINH");
    1314              : }
    1315              : 
    1316              : 
    1317              : gfc_expr *
    1318          611 : gfc_simplify_atan (gfc_expr *x)
    1319              : {
    1320          611 :   gfc_expr *result;
    1321              : 
    1322          611 :   if (x->expr_type != EXPR_CONSTANT)
    1323              :     return NULL;
    1324              : 
    1325          109 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1326              : 
    1327          109 :   switch (x->ts.type)
    1328              :     {
    1329          105 :       case BT_REAL:
    1330          105 :         mpfr_atan (result->value.real, x->value.real, GFC_RND_MODE);
    1331          105 :         break;
    1332              : 
    1333            4 :       case BT_COMPLEX:
    1334            4 :         mpc_atan (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    1335            4 :         break;
    1336              : 
    1337            0 :       default:
    1338            0 :         gfc_internal_error ("in gfc_simplify_atan(): Bad type");
    1339              :     }
    1340              : 
    1341          109 :   return range_check (result, "ATAN");
    1342              : }
    1343              : 
    1344              : 
    1345              : gfc_expr *
    1346          266 : gfc_simplify_atanh (gfc_expr *x)
    1347              : {
    1348          266 :   gfc_expr *result;
    1349              : 
    1350          266 :   if (x->expr_type != EXPR_CONSTANT)
    1351              :     return NULL;
    1352              : 
    1353           34 :   switch (x->ts.type)
    1354              :     {
    1355           30 :       case BT_REAL:
    1356           30 :         if (mpfr_cmp_si (x->value.real, 1) >= 0
    1357           30 :             || mpfr_cmp_si (x->value.real, -1) <= 0)
    1358              :           {
    1359            0 :             gfc_error ("Argument of ATANH at %L must be inside the range -1 "
    1360              :                        "to 1", &x->where);
    1361            0 :             return &gfc_bad_expr;
    1362              :           }
    1363           30 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1364           30 :         mpfr_atanh (result->value.real, x->value.real, GFC_RND_MODE);
    1365           30 :         break;
    1366              : 
    1367            4 :       case BT_COMPLEX:
    1368            4 :         result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1369            4 :         mpc_atanh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    1370            4 :         break;
    1371              : 
    1372            0 :       default:
    1373            0 :         gfc_internal_error ("in gfc_simplify_atanh(): Bad type");
    1374              :     }
    1375              : 
    1376           34 :   return range_check (result, "ATANH");
    1377              : }
    1378              : 
    1379              : 
    1380              : gfc_expr *
    1381          887 : gfc_simplify_atan2 (gfc_expr *y, gfc_expr *x)
    1382              : {
    1383          887 :   gfc_expr *result;
    1384              : 
    1385          887 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    1386              :     return NULL;
    1387              : 
    1388          324 :   if (mpfr_zero_p (y->value.real) && mpfr_zero_p (x->value.real))
    1389              :     {
    1390            0 :       gfc_error ("If the first argument of ATAN2 at %L is zero, then the "
    1391              :                  "second argument must not be zero", &y->where);
    1392            0 :       return &gfc_bad_expr;
    1393              :     }
    1394              : 
    1395          324 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1396          324 :   mpfr_atan2 (result->value.real, y->value.real, x->value.real, GFC_RND_MODE);
    1397              : 
    1398          324 :   return range_check (result, "ATAN2");
    1399              : }
    1400              : 
    1401              : 
    1402              : gfc_expr *
    1403           82 : gfc_simplify_bessel_j0 (gfc_expr *x)
    1404              : {
    1405           82 :   gfc_expr *result;
    1406              : 
    1407           82 :   if (x->expr_type != EXPR_CONSTANT)
    1408              :     return NULL;
    1409              : 
    1410           14 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1411           14 :   mpfr_j0 (result->value.real, x->value.real, GFC_RND_MODE);
    1412              : 
    1413           14 :   return range_check (result, "BESSEL_J0");
    1414              : }
    1415              : 
    1416              : 
    1417              : gfc_expr *
    1418           80 : gfc_simplify_bessel_j1 (gfc_expr *x)
    1419              : {
    1420           80 :   gfc_expr *result;
    1421              : 
    1422           80 :   if (x->expr_type != EXPR_CONSTANT)
    1423              :     return NULL;
    1424              : 
    1425           12 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1426           12 :   mpfr_j1 (result->value.real, x->value.real, GFC_RND_MODE);
    1427              : 
    1428           12 :   return range_check (result, "BESSEL_J1");
    1429              : }
    1430              : 
    1431              : 
    1432              : gfc_expr *
    1433         1302 : gfc_simplify_bessel_jn (gfc_expr *order, gfc_expr *x)
    1434              : {
    1435         1302 :   gfc_expr *result;
    1436         1302 :   long n;
    1437              : 
    1438         1302 :   if (x->expr_type != EXPR_CONSTANT || order->expr_type != EXPR_CONSTANT)
    1439              :     return NULL;
    1440              : 
    1441         1054 :   n = mpz_get_si (order->value.integer);
    1442         1054 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1443         1054 :   mpfr_jn (result->value.real, n, x->value.real, GFC_RND_MODE);
    1444              : 
    1445         1054 :   return range_check (result, "BESSEL_JN");
    1446              : }
    1447              : 
    1448              : 
    1449              : /* Simplify transformational form of JN and YN.  */
    1450              : 
    1451              : static gfc_expr *
    1452           81 : gfc_simplify_bessel_n2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x,
    1453              :                         bool jn)
    1454              : {
    1455           81 :   gfc_expr *result;
    1456           81 :   gfc_expr *e;
    1457           81 :   long n1, n2;
    1458           81 :   int i;
    1459           81 :   mpfr_t x2rev, last1, last2;
    1460              : 
    1461           81 :   if (x->expr_type != EXPR_CONSTANT || order1->expr_type != EXPR_CONSTANT
    1462           57 :       || order2->expr_type != EXPR_CONSTANT)
    1463              :     return NULL;
    1464              : 
    1465           57 :   n1 = mpz_get_si (order1->value.integer);
    1466           57 :   n2 = mpz_get_si (order2->value.integer);
    1467           57 :   result = gfc_get_array_expr (x->ts.type, x->ts.kind, &x->where);
    1468           57 :   result->rank = 1;
    1469           57 :   result->shape = gfc_get_shape (1);
    1470           57 :   mpz_init_set_ui (result->shape[0], MAX (n2-n1+1, 0));
    1471              : 
    1472           57 :   if (n2 < n1)
    1473              :     return result;
    1474              : 
    1475              :   /* Special case: x == 0; it is J0(0.0) == 1, JN(N > 0, 0.0) == 0; and
    1476              :      YN(N, 0.0) = -Inf.  */
    1477              : 
    1478           57 :   if (mpfr_cmp_ui (x->value.real, 0.0) == 0)
    1479              :     {
    1480           14 :       if (!jn && flag_range_check)
    1481              :         {
    1482            1 :           gfc_error ("Result of BESSEL_YN is -INF at %L", &result->where);
    1483            1 :           gfc_free_expr (result);
    1484            1 :           return &gfc_bad_expr;
    1485              :         }
    1486              : 
    1487           13 :       if (jn && n1 == 0)
    1488              :         {
    1489            7 :           e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1490            7 :           mpfr_set_ui (e->value.real, 1, GFC_RND_MODE);
    1491            7 :           gfc_constructor_append_expr (&result->value.constructor, e,
    1492              :                                        &x->where);
    1493            7 :           n1++;
    1494              :         }
    1495              : 
    1496          149 :       for (i = n1; i <= n2; i++)
    1497              :         {
    1498          136 :           e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1499          136 :           if (jn)
    1500           70 :             mpfr_set_ui (e->value.real, 0, GFC_RND_MODE);
    1501              :           else
    1502           66 :             mpfr_set_inf (e->value.real, -1);
    1503          136 :           gfc_constructor_append_expr (&result->value.constructor, e,
    1504              :                                        &x->where);
    1505              :         }
    1506              : 
    1507              :       return result;
    1508              :     }
    1509              : 
    1510              :   /* Use the faster but more verbose recurrence algorithm. Bessel functions
    1511              :      are stable for downward recursion and Neumann functions are stable
    1512              :      for upward recursion. It is
    1513              :        x2rev = 2.0/x,
    1514              :        J(N-1, x) = x2rev * N * J(N, x) - J(N+1, x),
    1515              :        Y(N+1, x) = x2rev * N * Y(N, x) - Y(N-1, x).
    1516              :      Cf. http://dlmf.nist.gov/10.74#iv and http://dlmf.nist.gov/10.6#E1  */
    1517              : 
    1518           43 :   gfc_set_model_kind (x->ts.kind);
    1519              : 
    1520              :   /* Get first recursion anchor.  */
    1521              : 
    1522           43 :   mpfr_init (last1);
    1523           43 :   if (jn)
    1524           22 :     mpfr_jn (last1, n2, x->value.real, GFC_RND_MODE);
    1525              :   else
    1526           21 :     mpfr_yn (last1, n1, x->value.real, GFC_RND_MODE);
    1527              : 
    1528           43 :   e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1529           43 :   mpfr_set (e->value.real, last1, GFC_RND_MODE);
    1530           64 :   if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
    1531              :     {
    1532            0 :       mpfr_clear (last1);
    1533            0 :       gfc_free_expr (e);
    1534            0 :       gfc_free_expr (result);
    1535            0 :       return &gfc_bad_expr;
    1536              :     }
    1537           43 :   gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
    1538              : 
    1539           43 :   if (n1 == n2)
    1540              :     {
    1541            0 :       mpfr_clear (last1);
    1542            0 :       return result;
    1543              :     }
    1544              : 
    1545              :   /* Get second recursion anchor.  */
    1546              : 
    1547           43 :   mpfr_init (last2);
    1548           43 :   if (jn)
    1549           22 :     mpfr_jn (last2, n2-1, x->value.real, GFC_RND_MODE);
    1550              :   else
    1551           21 :     mpfr_yn (last2, n1+1, x->value.real, GFC_RND_MODE);
    1552              : 
    1553           43 :   e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1554           43 :   mpfr_set (e->value.real, last2, GFC_RND_MODE);
    1555           43 :   if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
    1556              :     {
    1557            0 :       mpfr_clear (last1);
    1558            0 :       mpfr_clear (last2);
    1559            0 :       gfc_free_expr (e);
    1560            0 :       gfc_free_expr (result);
    1561            0 :       return &gfc_bad_expr;
    1562              :     }
    1563           43 :   if (jn)
    1564           22 :     gfc_constructor_insert_expr (&result->value.constructor, e, &x->where, -2);
    1565              :   else
    1566           21 :     gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
    1567              : 
    1568           43 :   if (n1 + 1 == n2)
    1569              :     {
    1570            1 :       mpfr_clear (last1);
    1571            1 :       mpfr_clear (last2);
    1572            1 :       return result;
    1573              :     }
    1574              : 
    1575              :   /* Start actual recursion.  */
    1576              : 
    1577           42 :   mpfr_init (x2rev);
    1578           42 :   mpfr_ui_div (x2rev, 2, x->value.real, GFC_RND_MODE);
    1579              : 
    1580          364 :   for (i = 2; i <= n2-n1; i++)
    1581              :     {
    1582          280 :       e = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1583              : 
    1584              :       /* Special case: For YN, if the previous N gave -INF, set
    1585              :          also N+1 to -INF.  */
    1586          280 :       if (!jn && !flag_range_check && mpfr_inf_p (last2))
    1587              :         {
    1588            0 :           mpfr_set_inf (e->value.real, -1);
    1589            0 :           gfc_constructor_append_expr (&result->value.constructor, e,
    1590              :                                        &x->where);
    1591            0 :           continue;
    1592              :         }
    1593              : 
    1594          280 :       mpfr_mul_si (e->value.real, x2rev, jn ? (n2-i+1) : (n1+i-1),
    1595              :                    GFC_RND_MODE);
    1596          280 :       mpfr_mul (e->value.real, e->value.real, last2, GFC_RND_MODE);
    1597          280 :       mpfr_sub (e->value.real, e->value.real, last1, GFC_RND_MODE);
    1598              : 
    1599          280 :       if (range_check (e, jn ? "BESSEL_JN" : "BESSEL_YN") == &gfc_bad_expr)
    1600              :         {
    1601              :           /* Range_check frees "e" in that case.  */
    1602            0 :           e = NULL;
    1603            0 :           goto error;
    1604              :         }
    1605              : 
    1606          280 :       if (jn)
    1607          140 :         gfc_constructor_insert_expr (&result->value.constructor, e, &x->where,
    1608              :                                      -i-1);
    1609              :       else
    1610          140 :         gfc_constructor_append_expr (&result->value.constructor, e, &x->where);
    1611              : 
    1612          280 :       mpfr_set (last1, last2, GFC_RND_MODE);
    1613          280 :       mpfr_set (last2, e->value.real, GFC_RND_MODE);
    1614              :     }
    1615              : 
    1616           42 :   mpfr_clear (last1);
    1617           42 :   mpfr_clear (last2);
    1618           42 :   mpfr_clear (x2rev);
    1619           42 :   return result;
    1620              : 
    1621            0 : error:
    1622            0 :   mpfr_clear (last1);
    1623            0 :   mpfr_clear (last2);
    1624            0 :   mpfr_clear (x2rev);
    1625            0 :   gfc_free_expr (e);
    1626            0 :   gfc_free_expr (result);
    1627            0 :   return &gfc_bad_expr;
    1628              : }
    1629              : 
    1630              : 
    1631              : gfc_expr *
    1632           41 : gfc_simplify_bessel_jn2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x)
    1633              : {
    1634           41 :   return gfc_simplify_bessel_n2 (order1, order2, x, true);
    1635              : }
    1636              : 
    1637              : 
    1638              : gfc_expr *
    1639           80 : gfc_simplify_bessel_y0 (gfc_expr *x)
    1640              : {
    1641           80 :   gfc_expr *result;
    1642              : 
    1643           80 :   if (x->expr_type != EXPR_CONSTANT)
    1644              :     return NULL;
    1645              : 
    1646           12 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1647           12 :   mpfr_y0 (result->value.real, x->value.real, GFC_RND_MODE);
    1648              : 
    1649           12 :   return range_check (result, "BESSEL_Y0");
    1650              : }
    1651              : 
    1652              : 
    1653              : gfc_expr *
    1654           80 : gfc_simplify_bessel_y1 (gfc_expr *x)
    1655              : {
    1656           80 :   gfc_expr *result;
    1657              : 
    1658           80 :   if (x->expr_type != EXPR_CONSTANT)
    1659              :     return NULL;
    1660              : 
    1661           12 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1662           12 :   mpfr_y1 (result->value.real, x->value.real, GFC_RND_MODE);
    1663              : 
    1664           12 :   return range_check (result, "BESSEL_Y1");
    1665              : }
    1666              : 
    1667              : 
    1668              : gfc_expr *
    1669         1868 : gfc_simplify_bessel_yn (gfc_expr *order, gfc_expr *x)
    1670              : {
    1671         1868 :   gfc_expr *result;
    1672         1868 :   long n;
    1673              : 
    1674         1868 :   if (x->expr_type != EXPR_CONSTANT || order->expr_type != EXPR_CONSTANT)
    1675              :     return NULL;
    1676              : 
    1677         1010 :   n = mpz_get_si (order->value.integer);
    1678         1010 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1679         1010 :   mpfr_yn (result->value.real, n, x->value.real, GFC_RND_MODE);
    1680              : 
    1681         1010 :   return range_check (result, "BESSEL_YN");
    1682              : }
    1683              : 
    1684              : 
    1685              : gfc_expr *
    1686           40 : gfc_simplify_bessel_yn2 (gfc_expr *order1, gfc_expr *order2, gfc_expr *x)
    1687              : {
    1688           40 :   return gfc_simplify_bessel_n2 (order1, order2, x, false);
    1689              : }
    1690              : 
    1691              : 
    1692              : gfc_expr *
    1693         3661 : gfc_simplify_bit_size (gfc_expr *e)
    1694              : {
    1695         3661 :   int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    1696         3661 :   int bit_size;
    1697              : 
    1698         3661 :   if (flag_unsigned && e->ts.type == BT_UNSIGNED)
    1699           24 :     bit_size = gfc_unsigned_kinds[i].bit_size;
    1700              :   else
    1701         3637 :     bit_size = gfc_integer_kinds[i].bit_size;
    1702              : 
    1703         3661 :   return gfc_get_int_expr (e->ts.kind, &e->where, bit_size);
    1704              : }
    1705              : 
    1706              : 
    1707              : gfc_expr *
    1708          342 : gfc_simplify_btest (gfc_expr *e, gfc_expr *bit)
    1709              : {
    1710          342 :   int b;
    1711              : 
    1712          342 :   if (e->expr_type != EXPR_CONSTANT || bit->expr_type != EXPR_CONSTANT)
    1713              :     return NULL;
    1714              : 
    1715           31 :   if (!gfc_check_bitfcn (e, bit))
    1716              :     return &gfc_bad_expr;
    1717              : 
    1718           23 :   if (gfc_extract_int (bit, &b) || b < 0)
    1719            0 :     return gfc_get_logical_expr (gfc_default_logical_kind, &e->where, false);
    1720              : 
    1721           23 :   return gfc_get_logical_expr (gfc_default_logical_kind, &e->where,
    1722           23 :                                mpz_tstbit (e->value.integer, b));
    1723              : }
    1724              : 
    1725              : 
    1726              : static int
    1727         1230 : compare_bitwise (gfc_expr *i, gfc_expr *j)
    1728              : {
    1729         1230 :   mpz_t x, y;
    1730         1230 :   int k, res;
    1731              : 
    1732         1230 :   gcc_assert (i->ts.type == BT_INTEGER);
    1733         1230 :   gcc_assert (j->ts.type == BT_INTEGER);
    1734              : 
    1735         1230 :   mpz_init_set (x, i->value.integer);
    1736         1230 :   k = gfc_validate_kind (i->ts.type, i->ts.kind, false);
    1737         1230 :   gfc_convert_mpz_to_unsigned (x, gfc_integer_kinds[k].bit_size);
    1738              : 
    1739         1230 :   mpz_init_set (y, j->value.integer);
    1740         1230 :   k = gfc_validate_kind (j->ts.type, j->ts.kind, false);
    1741         1230 :   gfc_convert_mpz_to_unsigned (y, gfc_integer_kinds[k].bit_size);
    1742              : 
    1743         1230 :   res = mpz_cmp (x, y);
    1744         1230 :   mpz_clear (x);
    1745         1230 :   mpz_clear (y);
    1746         1230 :   return res;
    1747              : }
    1748              : 
    1749              : 
    1750              : gfc_expr *
    1751          504 : gfc_simplify_bge (gfc_expr *i, gfc_expr *j)
    1752              : {
    1753          504 :   bool result;
    1754              : 
    1755          504 :   if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
    1756              :     return NULL;
    1757              : 
    1758          384 :   if (flag_unsigned && i->ts.type == BT_UNSIGNED)
    1759           54 :     result = mpz_cmp (i->value.integer, j->value.integer) >= 0;
    1760              :   else
    1761          330 :     result = compare_bitwise (i, j) >= 0;
    1762              : 
    1763          384 :   return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
    1764          384 :                                result);
    1765              : }
    1766              : 
    1767              : 
    1768              : gfc_expr *
    1769          474 : gfc_simplify_bgt (gfc_expr *i, gfc_expr *j)
    1770              : {
    1771          474 :   bool result;
    1772              : 
    1773          474 :   if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
    1774              :     return NULL;
    1775              : 
    1776          354 :   if (flag_unsigned && i->ts.type == BT_UNSIGNED)
    1777           54 :     result = mpz_cmp (i->value.integer, j->value.integer) > 0;
    1778              :   else
    1779          300 :     result = compare_bitwise (i, j) > 0;
    1780              : 
    1781          354 :   return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
    1782          354 :                                result);
    1783              : }
    1784              : 
    1785              : 
    1786              : gfc_expr *
    1787          474 : gfc_simplify_ble (gfc_expr *i, gfc_expr *j)
    1788              : {
    1789          474 :   bool result;
    1790              : 
    1791          474 :   if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
    1792              :     return NULL;
    1793              : 
    1794          354 :   if (flag_unsigned && i->ts.type == BT_UNSIGNED)
    1795           54 :     result = mpz_cmp (i->value.integer, j->value.integer) <= 0;
    1796              :   else
    1797          300 :     result = compare_bitwise (i, j) <= 0;
    1798              : 
    1799          354 :   return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
    1800          354 :                                result);
    1801              : }
    1802              : 
    1803              : 
    1804              : gfc_expr *
    1805          474 : gfc_simplify_blt (gfc_expr *i, gfc_expr *j)
    1806              : {
    1807          474 :   bool result;
    1808              : 
    1809          474 :   if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT)
    1810              :     return NULL;
    1811              : 
    1812          354 :   if (flag_unsigned && i->ts.type == BT_UNSIGNED)
    1813           54 :     result = mpz_cmp (i->value.integer, j->value.integer) < 0;
    1814              :   else
    1815          300 :     result = compare_bitwise (i, j) < 0;
    1816              : 
    1817          354 :   return gfc_get_logical_expr (gfc_default_logical_kind, &i->where,
    1818          354 :                                result);
    1819              : }
    1820              : 
    1821              : gfc_expr *
    1822           90 : gfc_simplify_ceiling (gfc_expr *e, gfc_expr *k)
    1823              : {
    1824           90 :   gfc_expr *ceil, *result;
    1825           90 :   int kind;
    1826              : 
    1827           90 :   kind = get_kind (BT_INTEGER, k, "CEILING", gfc_default_integer_kind);
    1828           90 :   if (kind == -1)
    1829              :     return &gfc_bad_expr;
    1830              : 
    1831           90 :   if (e->expr_type != EXPR_CONSTANT)
    1832              :     return NULL;
    1833              : 
    1834           13 :   ceil = gfc_copy_expr (e);
    1835           13 :   mpfr_ceil (ceil->value.real, e->value.real);
    1836              : 
    1837           13 :   result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
    1838           13 :   gfc_mpfr_to_mpz (result->value.integer, ceil->value.real, &e->where);
    1839              : 
    1840           13 :   gfc_free_expr (ceil);
    1841              : 
    1842           13 :   return range_check (result, "CEILING");
    1843              : }
    1844              : 
    1845              : 
    1846              : gfc_expr *
    1847         8842 : gfc_simplify_char (gfc_expr *e, gfc_expr *k)
    1848              : {
    1849         8842 :   return simplify_achar_char (e, k, "CHAR", false);
    1850              : }
    1851              : 
    1852              : 
    1853              : /* Common subroutine for simplifying CMPLX, COMPLEX and DCMPLX.  */
    1854              : 
    1855              : static gfc_expr *
    1856         7305 : simplify_cmplx (const char *name, gfc_expr *x, gfc_expr *y, int kind)
    1857              : {
    1858         7305 :   gfc_expr *result;
    1859              : 
    1860         7305 :   if (x->expr_type != EXPR_CONSTANT
    1861         5655 :       || (y != NULL && y->expr_type != EXPR_CONSTANT))
    1862              :     return NULL;
    1863              : 
    1864         5449 :   result = gfc_get_constant_expr (BT_COMPLEX, kind, &x->where);
    1865              : 
    1866         5449 :   switch (x->ts.type)
    1867              :     {
    1868         3910 :       case BT_INTEGER:
    1869         3910 :       case BT_UNSIGNED:
    1870         3910 :         mpc_set_z (result->value.complex, x->value.integer, GFC_MPC_RND_MODE);
    1871         3910 :         break;
    1872              : 
    1873         1539 :       case BT_REAL:
    1874         1539 :         mpc_set_fr (result->value.complex, x->value.real, GFC_RND_MODE);
    1875         1539 :         break;
    1876              : 
    1877            0 :       case BT_COMPLEX:
    1878            0 :         mpc_set (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    1879            0 :         break;
    1880              : 
    1881            0 :       default:
    1882            0 :         gfc_internal_error ("gfc_simplify_dcmplx(): Bad type (x)");
    1883              :     }
    1884              : 
    1885         5449 :   if (!y)
    1886          224 :     return range_check (result, name);
    1887              : 
    1888         5225 :   switch (y->ts.type)
    1889              :     {
    1890         3798 :       case BT_INTEGER:
    1891         3798 :       case BT_UNSIGNED:
    1892         3798 :         mpfr_set_z (mpc_imagref (result->value.complex),
    1893         3798 :                     y->value.integer, GFC_RND_MODE);
    1894         3798 :         break;
    1895              : 
    1896         1427 :       case BT_REAL:
    1897         1427 :         mpfr_set (mpc_imagref (result->value.complex),
    1898              :                   y->value.real, GFC_RND_MODE);
    1899         1427 :         break;
    1900              : 
    1901            0 :       default:
    1902            0 :         gfc_internal_error ("gfc_simplify_dcmplx(): Bad type (y)");
    1903              :     }
    1904              : 
    1905         5225 :   return range_check (result, name);
    1906              : }
    1907              : 
    1908              : 
    1909              : gfc_expr *
    1910         6951 : gfc_simplify_cmplx (gfc_expr *x, gfc_expr *y, gfc_expr *k)
    1911              : {
    1912         6951 :   int kind;
    1913              : 
    1914         6951 :   kind = get_kind (BT_REAL, k, "CMPLX", gfc_default_complex_kind);
    1915         6951 :   if (kind == -1)
    1916              :     return &gfc_bad_expr;
    1917              : 
    1918         6951 :   return simplify_cmplx ("CMPLX", x, y, kind);
    1919              : }
    1920              : 
    1921              : 
    1922              : gfc_expr *
    1923           55 : gfc_simplify_complex (gfc_expr *x, gfc_expr *y)
    1924              : {
    1925           55 :   int kind;
    1926              : 
    1927           55 :   if (x->ts.type == BT_INTEGER && y->ts.type == BT_INTEGER)
    1928           15 :     kind = gfc_default_complex_kind;
    1929           40 :   else if (x->ts.type == BT_REAL || y->ts.type == BT_INTEGER)
    1930           34 :     kind = x->ts.kind;
    1931            6 :   else if (x->ts.type == BT_INTEGER || y->ts.type == BT_REAL)
    1932            6 :     kind = y->ts.kind;
    1933            0 :   else if (x->ts.type == BT_REAL && y->ts.type == BT_REAL)
    1934              :     kind = (x->ts.kind > y->ts.kind) ? x->ts.kind : y->ts.kind;
    1935              :   else
    1936            0 :     gcc_unreachable ();
    1937              : 
    1938           55 :   return simplify_cmplx ("COMPLEX", x, y, kind);
    1939              : }
    1940              : 
    1941              : 
    1942              : gfc_expr *
    1943          725 : gfc_simplify_conjg (gfc_expr *e)
    1944              : {
    1945          725 :   gfc_expr *result;
    1946              : 
    1947          725 :   if (e->expr_type != EXPR_CONSTANT)
    1948              :     return NULL;
    1949              : 
    1950           47 :   result = gfc_copy_expr (e);
    1951           47 :   mpc_conj (result->value.complex, result->value.complex, GFC_MPC_RND_MODE);
    1952              : 
    1953           47 :   return range_check (result, "CONJG");
    1954              : }
    1955              : 
    1956              : 
    1957              : /* Simplify atan2d (x) where the unit is degree.  */
    1958              : 
    1959              : gfc_expr *
    1960          331 : gfc_simplify_atan2d (gfc_expr *y, gfc_expr *x)
    1961              : {
    1962          331 :   gfc_expr *result;
    1963              : 
    1964          331 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    1965              :     return NULL;
    1966              : 
    1967           49 :   if (mpfr_zero_p (y->value.real) && mpfr_zero_p (x->value.real))
    1968              :     {
    1969            1 :       gfc_error ("If the first argument of ATAN2D at %L is zero, then the "
    1970              :                  "second argument must not be zero", &y->where);
    1971            1 :       return &gfc_bad_expr;
    1972              :     }
    1973              : 
    1974           48 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1975              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    1976           48 :   mpfr_atan2u (result->value.real, y->value.real, x->value.real, 360,
    1977              :                GFC_RND_MODE);
    1978              : #else
    1979              :   mpfr_atan2 (result->value.real, y->value.real, x->value.real, GFC_RND_MODE);
    1980              :   rad2deg (result->value.real);
    1981              : #endif
    1982              : 
    1983           48 :   return range_check (result, "ATAN2D");
    1984              : }
    1985              : 
    1986              : 
    1987              : gfc_expr *
    1988          914 : gfc_simplify_cos (gfc_expr *x)
    1989              : {
    1990          914 :   gfc_expr *result;
    1991              : 
    1992          914 :   if (x->expr_type != EXPR_CONSTANT)
    1993              :     return NULL;
    1994              : 
    1995          166 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    1996              : 
    1997          166 :   switch (x->ts.type)
    1998              :     {
    1999          109 :       case BT_REAL:
    2000          109 :         mpfr_cos (result->value.real, x->value.real, GFC_RND_MODE);
    2001          109 :         break;
    2002              : 
    2003           57 :       case BT_COMPLEX:
    2004           57 :         gfc_set_model_kind (x->ts.kind);
    2005           57 :         mpc_cos (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    2006           57 :         break;
    2007              : 
    2008            0 :       default:
    2009            0 :         gfc_internal_error ("in gfc_simplify_cos(): Bad type");
    2010              :     }
    2011              : 
    2012          166 :   return range_check (result, "COS");
    2013              : }
    2014              : 
    2015              : 
    2016              : #if MPFR_VERSION < MPFR_VERSION_NUM(4,2,0)
    2017              : /* Used by trigd_fe.inc.  */
    2018              : static void
    2019              : deg2rad (mpfr_t x)
    2020              : {
    2021              :   mpfr_t d2r;
    2022              : 
    2023              :   mpfr_init (d2r);
    2024              :   mpfr_const_pi (d2r, GFC_RND_MODE);
    2025              :   mpfr_div_ui (d2r, d2r, 180, GFC_RND_MODE);
    2026              :   mpfr_mul (x, x, d2r, GFC_RND_MODE);
    2027              :   mpfr_clear (d2r);
    2028              : }
    2029              : #endif
    2030              : 
    2031              : 
    2032              : #if MPFR_VERSION < MPFR_VERSION_NUM(4,2,0)
    2033              : /* Simplification routines for SIND, COSD, TAND.  */
    2034              : #include "trigd_fe.inc"
    2035              : #endif
    2036              : 
    2037              : /* Simplify COSD(X) where X has the unit of degree.  */
    2038              : 
    2039              : gfc_expr *
    2040          221 : gfc_simplify_cosd (gfc_expr *x)
    2041              : {
    2042          221 :   gfc_expr *result;
    2043              : 
    2044          221 :   if (x->expr_type != EXPR_CONSTANT)
    2045              :     return NULL;
    2046              : 
    2047           25 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2048              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    2049           25 :   mpfr_cosu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    2050              : #else
    2051              :   mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    2052              :   simplify_cosd (result->value.real);
    2053              : #endif
    2054              : 
    2055           25 :   return range_check (result, "COSD");
    2056              : }
    2057              : 
    2058              : 
    2059              : /* Simplify SIND(X) where X has the unit of degree.  */
    2060              : 
    2061              : gfc_expr *
    2062          221 : gfc_simplify_sind (gfc_expr *x)
    2063              : {
    2064          221 :   gfc_expr *result;
    2065              : 
    2066          221 :   if (x->expr_type != EXPR_CONSTANT)
    2067              :     return NULL;
    2068              : 
    2069           25 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2070              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    2071           25 :   mpfr_sinu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    2072              : #else
    2073              :   mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    2074              :   simplify_sind (result->value.real);
    2075              : #endif
    2076              : 
    2077           25 :   return range_check (result, "SIND");
    2078              : }
    2079              : 
    2080              : 
    2081              : /* Simplify TAND(X) where X has the unit of degree.  */
    2082              : 
    2083              : gfc_expr *
    2084          305 : gfc_simplify_tand (gfc_expr *x)
    2085              : {
    2086          305 :   gfc_expr *result;
    2087              : 
    2088          305 :   if (x->expr_type != EXPR_CONSTANT)
    2089              :     return NULL;
    2090              : 
    2091           25 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2092              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    2093           25 :   mpfr_tanu (result->value.real, x->value.real, 360, GFC_RND_MODE);
    2094              : #else
    2095              :   mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    2096              :   simplify_tand (result->value.real);
    2097              : #endif
    2098              : 
    2099           25 :   return range_check (result, "TAND");
    2100              : }
    2101              : 
    2102              : 
    2103              : /* Simplify COTAND(X) where X has the unit of degree.  */
    2104              : 
    2105              : gfc_expr *
    2106          241 : gfc_simplify_cotand (gfc_expr *x)
    2107              : {
    2108          241 :   gfc_expr *result;
    2109              : 
    2110          241 :   if (x->expr_type != EXPR_CONSTANT)
    2111              :     return NULL;
    2112              : 
    2113              :   /* Implement COTAND = -TAND(x+90).
    2114              :      TAND offers correct exact values for multiples of 30 degrees.
    2115              :      This implementation is also compatible with the behavior of some legacy
    2116              :      compilers.  Keep this consistent with gfc_conv_intrinsic_cotand.  */
    2117           25 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2118           25 :   mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    2119           25 :   mpfr_add_ui (result->value.real, result->value.real, 90, GFC_RND_MODE);
    2120              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4,2,0)
    2121           25 :   mpfr_tanu (result->value.real, result->value.real, 360, GFC_RND_MODE);
    2122              : #else
    2123              :   simplify_tand (result->value.real);
    2124              : #endif
    2125           25 :   mpfr_neg (result->value.real, result->value.real, GFC_RND_MODE);
    2126              : 
    2127           25 :   return range_check (result, "COTAND");
    2128              : }
    2129              : 
    2130              : 
    2131              : gfc_expr *
    2132          317 : gfc_simplify_cosh (gfc_expr *x)
    2133              : {
    2134          317 :   gfc_expr *result;
    2135              : 
    2136          317 :   if (x->expr_type != EXPR_CONSTANT)
    2137              :     return NULL;
    2138              : 
    2139           47 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2140              : 
    2141           47 :   switch (x->ts.type)
    2142              :     {
    2143           43 :       case BT_REAL:
    2144           43 :         mpfr_cosh (result->value.real, x->value.real, GFC_RND_MODE);
    2145           43 :         break;
    2146              : 
    2147            4 :       case BT_COMPLEX:
    2148            4 :         mpc_cosh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    2149            4 :         break;
    2150              : 
    2151            0 :       default:
    2152            0 :         gcc_unreachable ();
    2153              :     }
    2154              : 
    2155           47 :   return range_check (result, "COSH");
    2156              : }
    2157              : 
    2158              : gfc_expr *
    2159           25 : gfc_simplify_acospi (gfc_expr *x)
    2160              : {
    2161           25 :   gfc_expr *result;
    2162              : 
    2163           25 :   if (x->expr_type != EXPR_CONSTANT)
    2164              :     return NULL;
    2165              : 
    2166           25 :   if (mpfr_cmp_si (x->value.real, 1) > 0 || mpfr_cmp_si (x->value.real, -1) < 0)
    2167              :     {
    2168            1 :       gfc_error (
    2169              :         "Argument of ACOSPI at %L must be within the closed interval [-1, 1]",
    2170              :         &x->where);
    2171            1 :       return &gfc_bad_expr;
    2172              :     }
    2173              : 
    2174           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2175              : 
    2176              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2177           24 :   mpfr_acospi (result->value.real, x->value.real, GFC_RND_MODE);
    2178              : #else
    2179              :   mpfr_t pi, tmp;
    2180              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), pi, tmp, NULL);
    2181              :   mpfr_const_pi (pi, GFC_RND_MODE);
    2182              :   mpfr_acos (tmp, x->value.real, GFC_RND_MODE);
    2183              :   mpfr_div (result->value.real, tmp, pi, GFC_RND_MODE);
    2184              :   mpfr_clears (pi, tmp, NULL);
    2185              : #endif
    2186              : 
    2187           24 :   return result;
    2188              : }
    2189              : 
    2190              : gfc_expr *
    2191           25 : gfc_simplify_asinpi (gfc_expr *x)
    2192              : {
    2193           25 :   gfc_expr *result;
    2194              : 
    2195           25 :   if (x->expr_type != EXPR_CONSTANT)
    2196              :     return NULL;
    2197              : 
    2198           25 :   if (mpfr_cmp_si (x->value.real, 1) > 0 || mpfr_cmp_si (x->value.real, -1) < 0)
    2199              :     {
    2200            1 :       gfc_error (
    2201              :         "Argument of ASINPI at %L must be within the closed interval [-1, 1]",
    2202              :         &x->where);
    2203            1 :       return &gfc_bad_expr;
    2204              :     }
    2205              : 
    2206           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2207              : 
    2208              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2209           24 :   mpfr_asinpi (result->value.real, x->value.real, GFC_RND_MODE);
    2210              : #else
    2211              :   mpfr_t pi, tmp;
    2212              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), pi, tmp, NULL);
    2213              :   mpfr_const_pi (pi, GFC_RND_MODE);
    2214              :   mpfr_asin (tmp, x->value.real, GFC_RND_MODE);
    2215              :   mpfr_div (result->value.real, tmp, pi, GFC_RND_MODE);
    2216              :   mpfr_clears (pi, tmp, NULL);
    2217              : #endif
    2218              : 
    2219           24 :   return result;
    2220              : }
    2221              : 
    2222              : gfc_expr *
    2223           24 : gfc_simplify_atanpi (gfc_expr *x)
    2224              : {
    2225           24 :   gfc_expr *result;
    2226              : 
    2227           24 :   if (x->expr_type != EXPR_CONSTANT)
    2228              :     return NULL;
    2229              : 
    2230           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2231              : 
    2232              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2233           24 :   mpfr_atanpi (result->value.real, x->value.real, GFC_RND_MODE);
    2234              : #else
    2235              :   mpfr_t pi, tmp;
    2236              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), pi, tmp, NULL);
    2237              :   mpfr_const_pi (pi, GFC_RND_MODE);
    2238              :   mpfr_atan (tmp, x->value.real, GFC_RND_MODE);
    2239              :   mpfr_div (result->value.real, tmp, pi, GFC_RND_MODE);
    2240              :   mpfr_clears (pi, tmp, NULL);
    2241              : #endif
    2242              : 
    2243           24 :   return range_check (result, "ATANPI");
    2244              : }
    2245              : 
    2246              : gfc_expr *
    2247           25 : gfc_simplify_atan2pi (gfc_expr *y, gfc_expr *x)
    2248              : {
    2249           25 :   gfc_expr *result;
    2250              : 
    2251           25 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    2252              :     return NULL;
    2253              : 
    2254           25 :   if (mpfr_zero_p (y->value.real) && mpfr_zero_p (x->value.real))
    2255              :     {
    2256            1 :       gfc_error ("If the first argument of ATAN2PI at %L is zero, then the "
    2257              :                  "second argument must not be zero",
    2258              :                  &y->where);
    2259            1 :       return &gfc_bad_expr;
    2260              :     }
    2261              : 
    2262           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2263              : 
    2264              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2265           24 :   mpfr_atan2pi (result->value.real, y->value.real, x->value.real, GFC_RND_MODE);
    2266              : #else
    2267              :   mpfr_t pi, tmp;
    2268              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), pi, tmp, NULL);
    2269              :   mpfr_const_pi (pi, GFC_RND_MODE);
    2270              :   mpfr_atan2 (tmp, y->value.real, x->value.real, GFC_RND_MODE);
    2271              :   mpfr_div (result->value.real, tmp, pi, GFC_RND_MODE);
    2272              :   mpfr_clears (pi, tmp, NULL);
    2273              : #endif
    2274              : 
    2275           24 :   return range_check (result, "ATAN2PI");
    2276              : }
    2277              : 
    2278              : gfc_expr *
    2279           24 : gfc_simplify_cospi (gfc_expr *x)
    2280              : {
    2281           24 :   gfc_expr *result;
    2282              : 
    2283           24 :   if (x->expr_type != EXPR_CONSTANT)
    2284              :     return NULL;
    2285              : 
    2286           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2287              : 
    2288              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2289           24 :   mpfr_cospi (result->value.real, x->value.real, GFC_RND_MODE);
    2290              : #else
    2291              :   mpfr_t cs, n, r, two;
    2292              :   int s;
    2293              : 
    2294              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), cs, n, r, two, NULL);
    2295              : 
    2296              :   mpfr_abs (r, x->value.real, GFC_RND_MODE);
    2297              :   mpfr_modf (n, r, r, GFC_RND_MODE);
    2298              : 
    2299              :   if (mpfr_cmp_d (r, 0.5) == 0)
    2300              :     {
    2301              :       mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    2302              :       return result;
    2303              :     }
    2304              : 
    2305              :   mpfr_set_ui (two, 2, GFC_RND_MODE);
    2306              :   mpfr_fmod (cs, n, two, GFC_RND_MODE);
    2307              :   s = mpfr_cmp_ui (cs, 0) == 0 ? 1 : -1;
    2308              : 
    2309              :   mpfr_const_pi (cs, GFC_RND_MODE);
    2310              :   mpfr_mul (cs, cs, r, GFC_RND_MODE);
    2311              :   mpfr_cos (cs, cs, GFC_RND_MODE);
    2312              :   mpfr_mul_si (result->value.real, cs, s, GFC_RND_MODE);
    2313              : 
    2314              :   mpfr_clears (cs, n, r, two, NULL);
    2315              : #endif
    2316              : 
    2317           24 :   return range_check (result, "COSPI");
    2318              : }
    2319              : 
    2320              : gfc_expr *
    2321           24 : gfc_simplify_sinpi (gfc_expr *x)
    2322              : {
    2323           24 :   gfc_expr *result;
    2324              : 
    2325           24 :   if (x->expr_type != EXPR_CONSTANT)
    2326              :     return NULL;
    2327              : 
    2328           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2329              : 
    2330              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2331           24 :   mpfr_sinpi (result->value.real, x->value.real, GFC_RND_MODE);
    2332              : #else
    2333              :   mpfr_t sn, n, r, two;
    2334              :   int s;
    2335              : 
    2336              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), sn, n, r, two, NULL);
    2337              : 
    2338              :   mpfr_abs (r, x->value.real, GFC_RND_MODE);
    2339              :   mpfr_modf (n, r, r, GFC_RND_MODE);
    2340              : 
    2341              :   if (mpfr_cmp_d (r, 0.0) == 0)
    2342              :     {
    2343              :       mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    2344              :       return result;
    2345              :     }
    2346              : 
    2347              :   mpfr_set_ui (two, 2, GFC_RND_MODE);
    2348              :   mpfr_fmod (sn, n, two, GFC_RND_MODE);
    2349              :   s = mpfr_cmp_si (x->value.real, 0) < 0 ? -1 : 1;
    2350              :   s *= mpfr_cmp_ui (sn, 0) == 0 ? 1 : -1;
    2351              : 
    2352              :   mpfr_const_pi (sn, GFC_RND_MODE);
    2353              :   mpfr_mul (sn, sn, r, GFC_RND_MODE);
    2354              :   mpfr_sin (sn, sn, GFC_RND_MODE);
    2355              :   mpfr_mul_si (result->value.real, sn, s, GFC_RND_MODE);
    2356              : 
    2357              :   mpfr_clears (sn, n, r, two, NULL);
    2358              : #endif
    2359              : 
    2360           24 :   return range_check (result, "SINPI");
    2361              : }
    2362              : 
    2363              : gfc_expr *
    2364           24 : gfc_simplify_tanpi (gfc_expr *x)
    2365              : {
    2366           24 :   gfc_expr *result;
    2367              : 
    2368           24 :   if (x->expr_type != EXPR_CONSTANT)
    2369              :     return NULL;
    2370              : 
    2371           24 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    2372              : 
    2373              : #if MPFR_VERSION >= MPFR_VERSION_NUM(4, 2, 0)
    2374           24 :   mpfr_tanpi (result->value.real, x->value.real, GFC_RND_MODE);
    2375              : #else
    2376              :   mpfr_t tn, n, r;
    2377              :   int s;
    2378              : 
    2379              :   mpfr_inits2 (2 * mpfr_get_prec (x->value.real), tn, n, r, NULL);
    2380              : 
    2381              :   mpfr_abs (r, x->value.real, GFC_RND_MODE);
    2382              :   mpfr_modf (n, r, r, GFC_RND_MODE);
    2383              : 
    2384              :   if (mpfr_cmp_d (r, 0.0) == 0)
    2385              :     {
    2386              :       mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    2387              :       return result;
    2388              :     }
    2389              : 
    2390              :   s = mpfr_cmp_si (x->value.real, 0) < 0 ? -1 : 1;
    2391              : 
    2392              :   mpfr_const_pi (tn, GFC_RND_MODE);
    2393              :   mpfr_mul (tn, tn, r, GFC_RND_MODE);
    2394              :   mpfr_tan (tn, tn, GFC_RND_MODE);
    2395              :   mpfr_mul_si (result->value.real, tn, s, GFC_RND_MODE);
    2396              : 
    2397              :   mpfr_clears (tn, n, r, NULL);
    2398              : #endif
    2399              : 
    2400           24 :   return range_check (result, "TANPI");
    2401              : }
    2402              : 
    2403              : gfc_expr *
    2404          459 : gfc_simplify_count (gfc_expr *mask, gfc_expr *dim, gfc_expr *kind)
    2405              : {
    2406          459 :   gfc_expr *result;
    2407          459 :   bool size_zero;
    2408              : 
    2409          459 :   size_zero = gfc_is_size_zero_array (mask);
    2410              : 
    2411          863 :   if (!(is_constant_array_expr (mask) || size_zero)
    2412           55 :       || !gfc_is_constant_expr (dim)
    2413          514 :       || !gfc_is_constant_expr (kind))
    2414              :     return NULL;
    2415              : 
    2416           55 :   result = transformational_result (mask, dim,
    2417              :                                     BT_INTEGER,
    2418              :                                     get_kind (BT_INTEGER, kind, "COUNT",
    2419              :                                               gfc_default_integer_kind),
    2420              :                                     &mask->where);
    2421              : 
    2422           55 :   init_result_expr (result, 0, NULL);
    2423              : 
    2424           55 :   if (size_zero)
    2425              :     return result;
    2426              : 
    2427              :   /* Passing MASK twice, once as data array, once as mask.
    2428              :      Whenever gfc_count is called, '1' is added to the result.  */
    2429           30 :   return !dim || mask->rank == 1 ?
    2430           24 :     simplify_transformation_to_scalar (result, mask, mask, gfc_count) :
    2431           30 :     simplify_transformation_to_array (result, mask, dim, mask, gfc_count, NULL);
    2432              : }
    2433              : 
    2434              : /* Simplification routine for cshift. This works by copying the array
    2435              :    expressions into a one-dimensional array, shuffling the values into another
    2436              :    one-dimensional array and creating the new array expression from this.  The
    2437              :    shuffling part is basically taken from the library routine.  */
    2438              : 
    2439              : gfc_expr *
    2440          965 : gfc_simplify_cshift (gfc_expr *array, gfc_expr *shift, gfc_expr *dim)
    2441              : {
    2442          965 :   gfc_expr *result;
    2443          965 :   int which;
    2444          965 :   gfc_expr **arrayvec, **resultvec;
    2445          965 :   gfc_expr **rptr, **sptr;
    2446          965 :   mpz_t size;
    2447          965 :   size_t arraysize, shiftsize, i;
    2448          965 :   gfc_constructor *array_ctor, *shift_ctor;
    2449          965 :   ssize_t *shiftvec, *hptr;
    2450          965 :   ssize_t shift_val, len;
    2451          965 :   ssize_t count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    2452              :     hs_ex[GFC_MAX_DIMENSIONS + 1],
    2453              :     hstride[GFC_MAX_DIMENSIONS], sstride[GFC_MAX_DIMENSIONS],
    2454              :     a_extent[GFC_MAX_DIMENSIONS], a_stride[GFC_MAX_DIMENSIONS],
    2455              :     h_extent[GFC_MAX_DIMENSIONS],
    2456              :     ss_ex[GFC_MAX_DIMENSIONS + 1];
    2457          965 :   ssize_t rsoffset;
    2458          965 :   int d, n;
    2459          965 :   bool continue_loop;
    2460          965 :   gfc_expr **src, **dest;
    2461              : 
    2462          965 :   if (!is_constant_array_expr (array))
    2463              :     return NULL;
    2464              : 
    2465           80 :   if (shift->rank > 0)
    2466            9 :     gfc_simplify_expr (shift, 1);
    2467              : 
    2468           80 :   if (!gfc_is_constant_expr (shift))
    2469              :     return NULL;
    2470              : 
    2471              :   /* Make dim zero-based.  */
    2472           80 :   if (dim)
    2473              :     {
    2474           25 :       if (!gfc_is_constant_expr (dim))
    2475              :         return NULL;
    2476           13 :       which = mpz_get_si (dim->value.integer) - 1;
    2477              :     }
    2478              :   else
    2479              :     which = 0;
    2480              : 
    2481           68 :   if (array->shape == NULL)
    2482              :     return NULL;
    2483              : 
    2484           68 :   gfc_array_size (array, &size);
    2485           68 :   arraysize = mpz_get_ui (size);
    2486           68 :   mpz_clear (size);
    2487              : 
    2488           68 :   result = gfc_get_array_expr (array->ts.type, array->ts.kind, &array->where);
    2489           68 :   result->shape = gfc_copy_shape (array->shape, array->rank);
    2490           68 :   result->rank = array->rank;
    2491           68 :   result->ts.u.derived = array->ts.u.derived;
    2492              : 
    2493           68 :   if (arraysize == 0)
    2494              :     return result;
    2495              : 
    2496           67 :   arrayvec = XCNEWVEC (gfc_expr *, arraysize);
    2497           67 :   array_ctor = gfc_constructor_first (array->value.constructor);
    2498          985 :   for (i = 0; i < arraysize; i++)
    2499              :     {
    2500          851 :       arrayvec[i] = array_ctor->expr;
    2501          851 :       array_ctor = gfc_constructor_next (array_ctor);
    2502              :     }
    2503              : 
    2504           67 :   resultvec = XCNEWVEC (gfc_expr *, arraysize);
    2505              : 
    2506           67 :   sstride[0] = 0;
    2507           67 :   extent[0] = 1;
    2508           67 :   count[0] = 0;
    2509              : 
    2510          161 :   for (d=0; d < array->rank; d++)
    2511              :     {
    2512           94 :       a_extent[d] = mpz_get_si (array->shape[d]);
    2513           94 :       a_stride[d] = d == 0 ? 1 : a_stride[d-1] * a_extent[d-1];
    2514              :     }
    2515              : 
    2516           67 :   if (shift->rank > 0)
    2517              :     {
    2518            9 :       gfc_array_size (shift, &size);
    2519            9 :       shiftsize = mpz_get_ui (size);
    2520            9 :       mpz_clear (size);
    2521            9 :       shiftvec = XCNEWVEC (ssize_t, shiftsize);
    2522            9 :       shift_ctor = gfc_constructor_first (shift->value.constructor);
    2523           30 :       for (d = 0; d < shift->rank; d++)
    2524              :         {
    2525           12 :           h_extent[d] = mpz_get_si (shift->shape[d]);
    2526           12 :           hstride[d] = d == 0 ? 1 : hstride[d-1] * h_extent[d-1];
    2527              :         }
    2528              :     }
    2529              :   else
    2530              :     shiftvec = NULL;
    2531              : 
    2532              :   /* Shut up compiler */
    2533           67 :   len = 1;
    2534           67 :   rsoffset = 1;
    2535              : 
    2536           67 :   n = 0;
    2537          161 :   for (d=0; d < array->rank; d++)
    2538              :     {
    2539           94 :       if (d == which)
    2540              :         {
    2541           67 :           rsoffset = a_stride[d];
    2542           67 :           len = a_extent[d];
    2543              :         }
    2544              :       else
    2545              :         {
    2546           27 :           count[n] = 0;
    2547           27 :           extent[n] = a_extent[d];
    2548           27 :           sstride[n] = a_stride[d];
    2549           27 :           ss_ex[n] = sstride[n] * extent[n];
    2550           27 :           if (shiftvec)
    2551           12 :             hs_ex[n] = hstride[n] * extent[n];
    2552           27 :           n++;
    2553              :         }
    2554              :     }
    2555           67 :   ss_ex[n] = 0;
    2556           67 :   hs_ex[n] = 0;
    2557              : 
    2558           67 :   if (shiftvec)
    2559              :     {
    2560           74 :       for (i = 0; i < shiftsize; i++)
    2561              :         {
    2562           65 :           ssize_t val;
    2563           65 :           val = mpz_get_si (shift_ctor->expr->value.integer);
    2564           65 :           val = val % len;
    2565           65 :           if (val < 0)
    2566           18 :             val += len;
    2567           65 :           shiftvec[i] = val;
    2568           65 :           shift_ctor = gfc_constructor_next (shift_ctor);
    2569              :         }
    2570              :       shift_val = 0;
    2571              :     }
    2572              :   else
    2573              :     {
    2574           58 :       shift_val = mpz_get_si (shift->value.integer);
    2575           58 :       shift_val = shift_val % len;
    2576           58 :       if (shift_val < 0)
    2577            6 :         shift_val += len;
    2578              :     }
    2579              : 
    2580           67 :   continue_loop = true;
    2581           67 :   d = array->rank;
    2582           67 :   rptr = resultvec;
    2583           67 :   sptr = arrayvec;
    2584           67 :   hptr = shiftvec;
    2585              : 
    2586          359 :   while (continue_loop)
    2587              :     {
    2588          225 :       ssize_t sh;
    2589          225 :       if (shiftvec)
    2590           65 :         sh = *hptr;
    2591              :       else
    2592              :         sh = shift_val;
    2593              : 
    2594          225 :       src = &sptr[sh * rsoffset];
    2595          225 :       dest = rptr;
    2596          807 :       for (n = 0; n < len - sh; n++)
    2597              :         {
    2598          582 :           *dest = *src;
    2599          582 :           dest += rsoffset;
    2600          582 :           src += rsoffset;
    2601              :         }
    2602              :       src = sptr;
    2603          494 :       for ( n = 0; n < sh; n++)
    2604              :         {
    2605          269 :           *dest = *src;
    2606          269 :           dest += rsoffset;
    2607          269 :           src += rsoffset;
    2608              :         }
    2609          225 :       rptr += sstride[0];
    2610          225 :       sptr += sstride[0];
    2611          225 :       if (shiftvec)
    2612           65 :         hptr += hstride[0];
    2613          225 :       count[0]++;
    2614          225 :       n = 0;
    2615          268 :       while (count[n] == extent[n])
    2616              :         {
    2617          110 :           count[n] = 0;
    2618          110 :           rptr -= ss_ex[n];
    2619          110 :           sptr -= ss_ex[n];
    2620          110 :           if (shiftvec)
    2621           23 :             hptr -= hs_ex[n];
    2622          110 :           n++;
    2623          110 :           if (n >= d - 1)
    2624              :             {
    2625              :               continue_loop = false;
    2626              :               break;
    2627              :             }
    2628              :           else
    2629              :             {
    2630           43 :               count[n]++;
    2631           43 :               rptr += sstride[n];
    2632           43 :               sptr += sstride[n];
    2633           43 :               if (shiftvec)
    2634           14 :                 hptr += hstride[n];
    2635              :             }
    2636              :         }
    2637              :     }
    2638              : 
    2639          918 :   for (i = 0; i < arraysize; i++)
    2640              :     {
    2641          851 :       gfc_constructor_append_expr (&result->value.constructor,
    2642          851 :                                    gfc_copy_expr (resultvec[i]),
    2643              :                                    NULL);
    2644              :     }
    2645              :   return result;
    2646              : }
    2647              : 
    2648              : 
    2649              : gfc_expr *
    2650          299 : gfc_simplify_dcmplx (gfc_expr *x, gfc_expr *y)
    2651              : {
    2652          299 :   return simplify_cmplx ("DCMPLX", x, y, gfc_default_double_kind);
    2653              : }
    2654              : 
    2655              : 
    2656              : gfc_expr *
    2657          644 : gfc_simplify_dble (gfc_expr *e)
    2658              : {
    2659          644 :   gfc_expr *result = NULL;
    2660          644 :   int tmp1, tmp2;
    2661              : 
    2662          644 :   if (e->expr_type != EXPR_CONSTANT)
    2663              :     return NULL;
    2664              : 
    2665              :   /* For explicit conversion, turn off -Wconversion and -Wconversion-extra
    2666              :      warnings.  */
    2667          119 :   tmp1 = warn_conversion;
    2668          119 :   tmp2 = warn_conversion_extra;
    2669          119 :   warn_conversion = warn_conversion_extra = 0;
    2670              : 
    2671          119 :   result = gfc_convert_constant (e, BT_REAL, gfc_default_double_kind);
    2672              : 
    2673          119 :   warn_conversion = tmp1;
    2674          119 :   warn_conversion_extra = tmp2;
    2675              : 
    2676          119 :   if (result == &gfc_bad_expr)
    2677              :     return &gfc_bad_expr;
    2678              : 
    2679          119 :   return range_check (result, "DBLE");
    2680              : }
    2681              : 
    2682              : 
    2683              : gfc_expr *
    2684           40 : gfc_simplify_digits (gfc_expr *x)
    2685              : {
    2686           40 :   int i, digits;
    2687              : 
    2688           40 :   i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    2689              : 
    2690           40 :   switch (x->ts.type)
    2691              :     {
    2692            1 :       case BT_INTEGER:
    2693            1 :         digits = gfc_integer_kinds[i].digits;
    2694            1 :         break;
    2695              : 
    2696            6 :       case BT_UNSIGNED:
    2697            6 :         digits = gfc_unsigned_kinds[i].digits;
    2698            6 :         break;
    2699              : 
    2700           33 :       case BT_REAL:
    2701           33 :       case BT_COMPLEX:
    2702           33 :         digits = gfc_real_kinds[i].digits;
    2703           33 :         break;
    2704              : 
    2705            0 :       default:
    2706            0 :         gcc_unreachable ();
    2707              :     }
    2708              : 
    2709           40 :   return gfc_get_int_expr (gfc_default_integer_kind, NULL, digits);
    2710              : }
    2711              : 
    2712              : 
    2713              : gfc_expr *
    2714          324 : gfc_simplify_dim (gfc_expr *x, gfc_expr *y)
    2715              : {
    2716          324 :   gfc_expr *result;
    2717          324 :   int kind;
    2718              : 
    2719          324 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    2720              :     return NULL;
    2721              : 
    2722           78 :   kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
    2723           78 :   result = gfc_get_constant_expr (x->ts.type, kind, &x->where);
    2724              : 
    2725           78 :   switch (x->ts.type)
    2726              :     {
    2727           36 :       case BT_INTEGER:
    2728           36 :         if (mpz_cmp (x->value.integer, y->value.integer) > 0)
    2729           15 :           mpz_sub (result->value.integer, x->value.integer, y->value.integer);
    2730              :         else
    2731           21 :           mpz_set_ui (result->value.integer, 0);
    2732              : 
    2733              :         break;
    2734              : 
    2735           42 :       case BT_REAL:
    2736           42 :         if (mpfr_cmp (x->value.real, y->value.real) > 0)
    2737           30 :           mpfr_sub (result->value.real, x->value.real, y->value.real,
    2738              :                     GFC_RND_MODE);
    2739              :         else
    2740           12 :           mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    2741              : 
    2742              :         break;
    2743              : 
    2744            0 :       default:
    2745            0 :         gfc_internal_error ("gfc_simplify_dim(): Bad type");
    2746              :     }
    2747              : 
    2748           78 :   return range_check (result, "DIM");
    2749              : }
    2750              : 
    2751              : 
    2752              : gfc_expr*
    2753          236 : gfc_simplify_dot_product (gfc_expr *vector_a, gfc_expr *vector_b)
    2754              : {
    2755              :   /* If vector_a is a zero-sized array, the result is 0 for INTEGER,
    2756              :      REAL, and COMPLEX types and .false. for LOGICAL.  */
    2757          236 :   if (vector_a->shape && mpz_get_si (vector_a->shape[0]) == 0)
    2758              :     {
    2759           30 :       if (vector_a->ts.type == BT_LOGICAL)
    2760            6 :         return gfc_get_logical_expr (gfc_default_logical_kind, NULL, false);
    2761              :       else
    2762           24 :         return gfc_get_int_expr (gfc_default_integer_kind, NULL, 0);
    2763              :     }
    2764              : 
    2765          206 :   if (!is_constant_array_expr (vector_a)
    2766          206 :       || !is_constant_array_expr (vector_b))
    2767              :     return NULL;
    2768              : 
    2769           40 :   return compute_dot_product (vector_a, 1, 0, vector_b, 1, 0, true);
    2770              : }
    2771              : 
    2772              : 
    2773              : gfc_expr *
    2774           34 : gfc_simplify_dprod (gfc_expr *x, gfc_expr *y)
    2775              : {
    2776           34 :   gfc_expr *a1, *a2, *result;
    2777              : 
    2778           34 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    2779              :     return NULL;
    2780              : 
    2781            6 :   a1 = gfc_real2real (x, gfc_default_double_kind);
    2782            6 :   a2 = gfc_real2real (y, gfc_default_double_kind);
    2783              : 
    2784            6 :   result = gfc_get_constant_expr (BT_REAL, gfc_default_double_kind, &x->where);
    2785            6 :   mpfr_mul (result->value.real, a1->value.real, a2->value.real, GFC_RND_MODE);
    2786              : 
    2787            6 :   gfc_free_expr (a2);
    2788            6 :   gfc_free_expr (a1);
    2789              : 
    2790            6 :   return range_check (result, "DPROD");
    2791              : }
    2792              : 
    2793              : 
    2794              : static gfc_expr *
    2795         1876 : simplify_dshift (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg,
    2796              :                       bool right)
    2797              : {
    2798         1876 :   gfc_expr *result;
    2799         1876 :   int i, k, size, shift;
    2800         1876 :   bt type = BT_INTEGER;
    2801              : 
    2802         1876 :   if (arg1->expr_type != EXPR_CONSTANT || arg2->expr_type != EXPR_CONSTANT
    2803         1572 :       || shiftarg->expr_type != EXPR_CONSTANT)
    2804              :     return NULL;
    2805              : 
    2806         1488 :   if (flag_unsigned && arg1->ts.type == BT_UNSIGNED)
    2807              :     {
    2808           12 :       k = gfc_validate_kind (BT_UNSIGNED, arg1->ts.kind, false);
    2809           12 :       size = gfc_unsigned_kinds[k].bit_size;
    2810           12 :       type = BT_UNSIGNED;
    2811              :     }
    2812              :   else
    2813              :     {
    2814         1476 :       k = gfc_validate_kind (BT_INTEGER, arg1->ts.kind, false);
    2815         1476 :       size = gfc_integer_kinds[k].bit_size;
    2816              :     }
    2817              : 
    2818         1488 :   gfc_extract_int (shiftarg, &shift);
    2819              : 
    2820              :   /* DSHIFTR(I,J,SHIFT) = DSHIFTL(I,J,SIZE-SHIFT).  */
    2821         1488 :   if (right)
    2822          744 :     shift = size - shift;
    2823              : 
    2824         1488 :   result = gfc_get_constant_expr (type, arg1->ts.kind, &arg1->where);
    2825         1488 :   mpz_set_ui (result->value.integer, 0);
    2826              : 
    2827        39456 :   for (i = 0; i < shift; i++)
    2828        36480 :     if (mpz_tstbit (arg2->value.integer, size - shift + i))
    2829        15006 :       mpz_setbit (result->value.integer, i);
    2830              : 
    2831        37968 :   for (i = 0; i < size - shift; i++)
    2832        36480 :     if (mpz_tstbit (arg1->value.integer, i))
    2833        14424 :       mpz_setbit (result->value.integer, shift + i);
    2834              : 
    2835              :   /* Convert to a signed value if needed.  */
    2836         1488 :   if (type == BT_INTEGER)
    2837         1476 :     gfc_convert_mpz_to_signed (result->value.integer, size);
    2838              :   else
    2839           12 :     gfc_reduce_unsigned (result);
    2840              : 
    2841              :   return result;
    2842              : }
    2843              : 
    2844              : 
    2845              : gfc_expr *
    2846          938 : gfc_simplify_dshiftr (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg)
    2847              : {
    2848          938 :   return simplify_dshift (arg1, arg2, shiftarg, true);
    2849              : }
    2850              : 
    2851              : 
    2852              : gfc_expr *
    2853          938 : gfc_simplify_dshiftl (gfc_expr *arg1, gfc_expr *arg2, gfc_expr *shiftarg)
    2854              : {
    2855          938 :   return simplify_dshift (arg1, arg2, shiftarg, false);
    2856              : }
    2857              : 
    2858              : 
    2859              : gfc_expr *
    2860         1574 : gfc_simplify_eoshift (gfc_expr *array, gfc_expr *shift, gfc_expr *boundary,
    2861              :                    gfc_expr *dim)
    2862              : {
    2863         1574 :   bool temp_boundary;
    2864         1574 :   gfc_expr *bnd;
    2865         1574 :   gfc_expr *result;
    2866         1574 :   int which;
    2867         1574 :   gfc_expr **arrayvec, **resultvec;
    2868         1574 :   gfc_expr **rptr, **sptr;
    2869         1574 :   mpz_t size;
    2870         1574 :   size_t arraysize, i;
    2871         1574 :   gfc_constructor *array_ctor, *shift_ctor, *bnd_ctor;
    2872         1574 :   ssize_t shift_val, len;
    2873         1574 :   ssize_t count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    2874              :     sstride[GFC_MAX_DIMENSIONS], a_extent[GFC_MAX_DIMENSIONS],
    2875              :     a_stride[GFC_MAX_DIMENSIONS], ss_ex[GFC_MAX_DIMENSIONS + 1];
    2876         1574 :   ssize_t rsoffset;
    2877         1574 :   int d, n;
    2878         1574 :   bool continue_loop;
    2879         1574 :   gfc_expr **src, **dest;
    2880         1574 :   size_t s_len;
    2881              : 
    2882         1574 :   if (!is_constant_array_expr (array))
    2883              :     return NULL;
    2884              : 
    2885           60 :   if (shift->rank > 0)
    2886           13 :     gfc_simplify_expr (shift, 1);
    2887              : 
    2888           60 :   if (!gfc_is_constant_expr (shift))
    2889              :     return NULL;
    2890              : 
    2891           60 :   if (boundary)
    2892              :     {
    2893           29 :       if (boundary->rank > 0)
    2894            6 :         gfc_simplify_expr (boundary, 1);
    2895              : 
    2896           29 :       if (!gfc_is_constant_expr (boundary))
    2897              :           return NULL;
    2898              :     }
    2899              : 
    2900           48 :   if (dim)
    2901              :     {
    2902           25 :       if (!gfc_is_constant_expr (dim))
    2903              :         return NULL;
    2904           19 :       which = mpz_get_si (dim->value.integer) - 1;
    2905              :     }
    2906              :   else
    2907              :     which = 0;
    2908              : 
    2909           42 :   s_len = 0;
    2910           42 :   if (boundary == NULL)
    2911              :     {
    2912           29 :       temp_boundary = true;
    2913           29 :       switch (array->ts.type)
    2914              :         {
    2915              : 
    2916           17 :         case BT_INTEGER:
    2917           17 :           bnd = gfc_get_int_expr (array->ts.kind, NULL, 0);
    2918           17 :           break;
    2919              : 
    2920            6 :         case BT_UNSIGNED:
    2921            6 :           bnd = gfc_get_unsigned_expr (array->ts.kind, NULL, 0);
    2922            6 :           break;
    2923              : 
    2924            0 :         case BT_LOGICAL:
    2925            0 :           bnd = gfc_get_logical_expr (array->ts.kind, NULL, 0);
    2926            0 :           break;
    2927              : 
    2928            2 :         case BT_REAL:
    2929            2 :           bnd = gfc_get_constant_expr (array->ts.type, array->ts.kind, &gfc_current_locus);
    2930            2 :           mpfr_set_ui (bnd->value.real, 0, GFC_RND_MODE);
    2931            2 :           break;
    2932              : 
    2933            1 :         case BT_COMPLEX:
    2934            1 :           bnd = gfc_get_constant_expr (array->ts.type, array->ts.kind, &gfc_current_locus);
    2935            1 :           mpc_set_ui (bnd->value.complex, 0, GFC_RND_MODE);
    2936            1 :           break;
    2937              : 
    2938            3 :         case BT_CHARACTER:
    2939            3 :           s_len = mpz_get_ui (array->ts.u.cl->length->value.integer);
    2940            3 :           bnd = gfc_get_character_expr (array->ts.kind, &gfc_current_locus, NULL, s_len);
    2941            3 :           break;
    2942              : 
    2943            0 :         default:
    2944            0 :           gcc_unreachable();
    2945              : 
    2946              :         }
    2947              :     }
    2948              :   else
    2949              :     {
    2950              :       temp_boundary = false;
    2951              :       bnd = boundary;
    2952              :     }
    2953              : 
    2954           42 :   gfc_array_size (array, &size);
    2955           42 :   arraysize = mpz_get_ui (size);
    2956           42 :   mpz_clear (size);
    2957              : 
    2958           42 :   result = gfc_get_array_expr (array->ts.type, array->ts.kind, &array->where);
    2959           42 :   result->shape = gfc_copy_shape (array->shape, array->rank);
    2960           42 :   result->rank = array->rank;
    2961           42 :   result->ts = array->ts;
    2962              : 
    2963           42 :   if (arraysize == 0)
    2964            1 :     goto final;
    2965              : 
    2966           41 :   if (array->shape == NULL)
    2967            1 :     goto final;
    2968              : 
    2969           40 :   arrayvec = XCNEWVEC (gfc_expr *, arraysize);
    2970           40 :   array_ctor = gfc_constructor_first (array->value.constructor);
    2971          536 :   for (i = 0; i < arraysize; i++)
    2972              :     {
    2973          456 :       arrayvec[i] = array_ctor->expr;
    2974          456 :       array_ctor = gfc_constructor_next (array_ctor);
    2975              :     }
    2976              : 
    2977           40 :   resultvec = XCNEWVEC (gfc_expr *, arraysize);
    2978              : 
    2979           40 :   extent[0] = 1;
    2980           40 :   count[0] = 0;
    2981              : 
    2982          110 :   for (d=0; d < array->rank; d++)
    2983              :     {
    2984           70 :       a_extent[d] = mpz_get_si (array->shape[d]);
    2985           70 :       a_stride[d] = d == 0 ? 1 : a_stride[d-1] * a_extent[d-1];
    2986              :     }
    2987              : 
    2988           40 :   if (shift->rank > 0)
    2989              :     {
    2990           13 :       shift_ctor = gfc_constructor_first (shift->value.constructor);
    2991           13 :       shift_val = 0;
    2992              :     }
    2993              :   else
    2994              :     {
    2995           27 :       shift_ctor = NULL;
    2996           27 :       shift_val = mpz_get_si (shift->value.integer);
    2997              :     }
    2998              : 
    2999           40 :   if (bnd->rank > 0)
    3000            4 :     bnd_ctor = gfc_constructor_first (bnd->value.constructor);
    3001              :   else
    3002              :     bnd_ctor = NULL;
    3003              : 
    3004              :   /* Shut up compiler */
    3005           40 :   len = 1;
    3006           40 :   rsoffset = 1;
    3007           40 :   sstride[0] = 0;
    3008              : 
    3009           40 :   n = 0;
    3010          110 :   for (d=0; d < array->rank; d++)
    3011              :     {
    3012           70 :       if (d == which)
    3013              :         {
    3014           40 :           rsoffset = a_stride[d];
    3015           40 :           len = a_extent[d];
    3016              :         }
    3017              :       else
    3018              :         {
    3019           30 :           count[n] = 0;
    3020           30 :           extent[n] = a_extent[d];
    3021           30 :           sstride[n] = a_stride[d];
    3022           30 :           ss_ex[n] = sstride[n] * extent[n];
    3023           30 :           n++;
    3024              :         }
    3025              :     }
    3026           40 :   ss_ex[n] = 0;
    3027              : 
    3028           40 :   continue_loop = true;
    3029           40 :   d = array->rank;
    3030           40 :   rptr = resultvec;
    3031           40 :   sptr = arrayvec;
    3032              : 
    3033          172 :   while (continue_loop)
    3034              :     {
    3035          132 :       ssize_t sh, delta;
    3036              : 
    3037          132 :       if (shift_ctor)
    3038           60 :         sh = mpz_get_si (shift_ctor->expr->value.integer);
    3039              :       else
    3040              :         sh = shift_val;
    3041              : 
    3042          132 :       if (( sh >= 0 ? sh : -sh ) > len)
    3043              :         {
    3044              :           delta = len;
    3045              :           sh = len;
    3046              :         }
    3047              :       else
    3048          118 :         delta = (sh >= 0) ? sh: -sh;
    3049              : 
    3050          132 :       if (sh > 0)
    3051              :         {
    3052           81 :           src = &sptr[delta * rsoffset];
    3053           81 :           dest = rptr;
    3054              :         }
    3055              :       else
    3056              :         {
    3057           51 :           src = sptr;
    3058           51 :           dest = &rptr[delta * rsoffset];
    3059              :         }
    3060              : 
    3061          387 :       for (n = 0; n < len - delta; n++)
    3062              :         {
    3063          255 :           *dest = *src;
    3064          255 :           dest += rsoffset;
    3065          255 :           src += rsoffset;
    3066              :         }
    3067              : 
    3068          132 :       if (sh < 0)
    3069           45 :         dest = rptr;
    3070              : 
    3071          132 :       n = delta;
    3072              : 
    3073          132 :       if (bnd_ctor)
    3074              :         {
    3075           73 :           while (n--)
    3076              :             {
    3077           47 :               *dest = bnd_ctor->expr;
    3078           47 :               dest += rsoffset;
    3079              :             }
    3080              :         }
    3081              :       else
    3082              :         {
    3083          260 :           while (n--)
    3084              :             {
    3085          154 :               *dest = bnd;
    3086          154 :               dest += rsoffset;
    3087              :             }
    3088              :         }
    3089          132 :       rptr += sstride[0];
    3090          132 :       sptr += sstride[0];
    3091          132 :       if (shift_ctor)
    3092           60 :         shift_ctor =  gfc_constructor_next (shift_ctor);
    3093              : 
    3094          132 :       if (bnd_ctor)
    3095           26 :         bnd_ctor = gfc_constructor_next (bnd_ctor);
    3096              : 
    3097          132 :       count[0]++;
    3098          132 :       n = 0;
    3099          155 :       while (count[n] == extent[n])
    3100              :         {
    3101           63 :           count[n] = 0;
    3102           63 :           rptr -= ss_ex[n];
    3103           63 :           sptr -= ss_ex[n];
    3104           63 :           n++;
    3105           63 :           if (n >= d - 1)
    3106              :             {
    3107              :               continue_loop = false;
    3108              :               break;
    3109              :             }
    3110              :           else
    3111              :             {
    3112           23 :               count[n]++;
    3113           23 :               rptr += sstride[n];
    3114           23 :               sptr += sstride[n];
    3115              :             }
    3116              :         }
    3117              :     }
    3118              : 
    3119          496 :   for (i = 0; i < arraysize; i++)
    3120              :     {
    3121          456 :       gfc_constructor_append_expr (&result->value.constructor,
    3122          456 :                                    gfc_copy_expr (resultvec[i]),
    3123              :                                    NULL);
    3124              :     }
    3125              : 
    3126           40 :   free (arrayvec);
    3127           40 :   free (resultvec);
    3128              : 
    3129           42 :  final:
    3130           42 :   if (temp_boundary)
    3131           29 :     gfc_free_expr (bnd);
    3132              : 
    3133              :   return result;
    3134              : }
    3135              : 
    3136              : gfc_expr *
    3137          169 : gfc_simplify_erf (gfc_expr *x)
    3138              : {
    3139          169 :   gfc_expr *result;
    3140              : 
    3141          169 :   if (x->expr_type != EXPR_CONSTANT)
    3142              :     return NULL;
    3143              : 
    3144           35 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3145           35 :   mpfr_erf (result->value.real, x->value.real, GFC_RND_MODE);
    3146              : 
    3147           35 :   return range_check (result, "ERF");
    3148              : }
    3149              : 
    3150              : 
    3151              : gfc_expr *
    3152          242 : gfc_simplify_erfc (gfc_expr *x)
    3153              : {
    3154          242 :   gfc_expr *result;
    3155              : 
    3156          242 :   if (x->expr_type != EXPR_CONSTANT)
    3157              :     return NULL;
    3158              : 
    3159           36 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3160           36 :   mpfr_erfc (result->value.real, x->value.real, GFC_RND_MODE);
    3161              : 
    3162           36 :   return range_check (result, "ERFC");
    3163              : }
    3164              : 
    3165              : 
    3166              : /* Helper functions to simplify ERFC_SCALED(x) = ERFC(x) * EXP(X**2).  */
    3167              : 
    3168              : #define MAX_ITER 200
    3169              : #define ARG_LIMIT 12
    3170              : 
    3171              : /* Calculate ERFC_SCALED directly by its definition:
    3172              : 
    3173              :      ERFC_SCALED(x) = ERFC(x) * EXP(X**2)
    3174              : 
    3175              :    using a large precision for intermediate results.  This is used for all
    3176              :    but large values of the argument.  */
    3177              : static void
    3178           39 : fullprec_erfc_scaled (mpfr_t res, mpfr_t arg)
    3179              : {
    3180           39 :   mpfr_prec_t prec;
    3181           39 :   mpfr_t a, b;
    3182              : 
    3183           39 :   prec = mpfr_get_default_prec ();
    3184           39 :   mpfr_set_default_prec (10 * prec);
    3185              : 
    3186           39 :   mpfr_init (a);
    3187           39 :   mpfr_init (b);
    3188              : 
    3189           39 :   mpfr_set (a, arg, GFC_RND_MODE);
    3190           39 :   mpfr_sqr (b, a, GFC_RND_MODE);
    3191           39 :   mpfr_exp (b, b, GFC_RND_MODE);
    3192           39 :   mpfr_erfc (a, a, GFC_RND_MODE);
    3193           39 :   mpfr_mul (a, a, b, GFC_RND_MODE);
    3194              : 
    3195           39 :   mpfr_set (res, a, GFC_RND_MODE);
    3196           39 :   mpfr_set_default_prec (prec);
    3197              : 
    3198           39 :   mpfr_clear (a);
    3199           39 :   mpfr_clear (b);
    3200           39 : }
    3201              : 
    3202              : /* Calculate ERFC_SCALED using a power series expansion in 1/arg:
    3203              : 
    3204              :     ERFC_SCALED(x) = 1 / (x * sqrt(pi))
    3205              :                      * (1 + Sum_n (-1)**n * (1 * 3 * 5 * ... * (2n-1))
    3206              :                                           / (2 * x**2)**n)
    3207              : 
    3208              :   This is used for large values of the argument.  Intermediate calculations
    3209              :   are performed with twice the precision.  We don't do a fixed number of
    3210              :   iterations of the sum, but stop when it has converged to the required
    3211              :   precision.  */
    3212              : static void
    3213           10 : asympt_erfc_scaled (mpfr_t res, mpfr_t arg)
    3214              : {
    3215           10 :   mpfr_t sum, x, u, v, w, oldsum, sumtrunc;
    3216           10 :   mpz_t num;
    3217           10 :   mpfr_prec_t prec;
    3218           10 :   unsigned i;
    3219              : 
    3220           10 :   prec = mpfr_get_default_prec ();
    3221           10 :   mpfr_set_default_prec (2 * prec);
    3222              : 
    3223           10 :   mpfr_init (sum);
    3224           10 :   mpfr_init (x);
    3225           10 :   mpfr_init (u);
    3226           10 :   mpfr_init (v);
    3227           10 :   mpfr_init (w);
    3228           10 :   mpz_init (num);
    3229              : 
    3230           10 :   mpfr_init (oldsum);
    3231           10 :   mpfr_init (sumtrunc);
    3232           10 :   mpfr_set_prec (oldsum, prec);
    3233           10 :   mpfr_set_prec (sumtrunc, prec);
    3234              : 
    3235           10 :   mpfr_set (x, arg, GFC_RND_MODE);
    3236           10 :   mpfr_set_ui (sum, 1, GFC_RND_MODE);
    3237           10 :   mpz_set_ui (num, 1);
    3238              : 
    3239           10 :   mpfr_set (u, x, GFC_RND_MODE);
    3240           10 :   mpfr_sqr (u, u, GFC_RND_MODE);
    3241           10 :   mpfr_mul_ui (u, u, 2, GFC_RND_MODE);
    3242           10 :   mpfr_pow_si (u, u, -1, GFC_RND_MODE);
    3243              : 
    3244          142 :   for (i = 1; i < MAX_ITER; i++)
    3245              :   {
    3246          132 :     mpfr_set (oldsum, sum, GFC_RND_MODE);
    3247              : 
    3248          132 :     mpz_mul_ui (num, num, 2 * i - 1);
    3249          132 :     mpz_neg (num, num);
    3250              : 
    3251          132 :     mpfr_set (w, u, GFC_RND_MODE);
    3252          132 :     mpfr_pow_ui (w, w, i, GFC_RND_MODE);
    3253              : 
    3254          132 :     mpfr_set_z (v, num, GFC_RND_MODE);
    3255          132 :     mpfr_mul (v, v, w, GFC_RND_MODE);
    3256              : 
    3257          132 :     mpfr_add (sum, sum, v, GFC_RND_MODE);
    3258              : 
    3259          132 :     mpfr_set (sumtrunc, sum, GFC_RND_MODE);
    3260          132 :     if (mpfr_cmp (sumtrunc, oldsum) == 0)
    3261              :       break;
    3262              :   }
    3263              : 
    3264              :   /* We should have converged by now; otherwise, ARG_LIMIT is probably
    3265              :      set too low.  */
    3266           10 :   gcc_assert (i < MAX_ITER);
    3267              : 
    3268              :   /* Divide by x * sqrt(Pi).  */
    3269           10 :   mpfr_const_pi (u, GFC_RND_MODE);
    3270           10 :   mpfr_sqrt (u, u, GFC_RND_MODE);
    3271           10 :   mpfr_mul (u, u, x, GFC_RND_MODE);
    3272           10 :   mpfr_div (sum, sum, u, GFC_RND_MODE);
    3273              : 
    3274           10 :   mpfr_set (res, sum, GFC_RND_MODE);
    3275           10 :   mpfr_set_default_prec (prec);
    3276              : 
    3277           10 :   mpfr_clears (sum, x, u, v, w, oldsum, sumtrunc, NULL);
    3278           10 :   mpz_clear (num);
    3279           10 : }
    3280              : 
    3281              : 
    3282              : gfc_expr *
    3283          143 : gfc_simplify_erfc_scaled (gfc_expr *x)
    3284              : {
    3285          143 :   gfc_expr *result;
    3286              : 
    3287          143 :   if (x->expr_type != EXPR_CONSTANT)
    3288              :     return NULL;
    3289              : 
    3290           49 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3291           49 :   if (mpfr_cmp_d (x->value.real, ARG_LIMIT) >= 0)
    3292           10 :     asympt_erfc_scaled (result->value.real, x->value.real);
    3293              :   else
    3294           39 :     fullprec_erfc_scaled (result->value.real, x->value.real);
    3295              : 
    3296           49 :   return range_check (result, "ERFC_SCALED");
    3297              : }
    3298              : 
    3299              : #undef MAX_ITER
    3300              : #undef ARG_LIMIT
    3301              : 
    3302              : 
    3303              : gfc_expr *
    3304         3653 : gfc_simplify_epsilon (gfc_expr *e)
    3305              : {
    3306         3653 :   gfc_expr *result;
    3307         3653 :   int i;
    3308              : 
    3309         3653 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    3310              : 
    3311         3653 :   result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
    3312         3653 :   mpfr_set (result->value.real, gfc_real_kinds[i].epsilon, GFC_RND_MODE);
    3313              : 
    3314         3653 :   return range_check (result, "EPSILON");
    3315              : }
    3316              : 
    3317              : 
    3318              : gfc_expr *
    3319         1224 : gfc_simplify_exp (gfc_expr *x)
    3320              : {
    3321         1224 :   gfc_expr *result;
    3322              : 
    3323         1224 :   if (x->expr_type != EXPR_CONSTANT)
    3324              :     return NULL;
    3325              : 
    3326          151 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3327              : 
    3328          151 :   switch (x->ts.type)
    3329              :     {
    3330           88 :       case BT_REAL:
    3331           88 :         mpfr_exp (result->value.real, x->value.real, GFC_RND_MODE);
    3332           88 :         break;
    3333              : 
    3334           63 :       case BT_COMPLEX:
    3335           63 :         gfc_set_model_kind (x->ts.kind);
    3336           63 :         mpc_exp (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    3337           63 :         break;
    3338              : 
    3339            0 :       default:
    3340            0 :         gfc_internal_error ("in gfc_simplify_exp(): Bad type");
    3341              :     }
    3342              : 
    3343          151 :   return range_check (result, "EXP");
    3344              : }
    3345              : 
    3346              : 
    3347              : gfc_expr *
    3348         1020 : gfc_simplify_exponent (gfc_expr *x)
    3349              : {
    3350         1020 :   long int val;
    3351         1020 :   gfc_expr *result;
    3352              : 
    3353         1020 :   if (x->expr_type != EXPR_CONSTANT)
    3354              :     return NULL;
    3355              : 
    3356          150 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    3357              :                                   &x->where);
    3358              : 
    3359              :   /* EXPONENT(inf) = EXPONENT(nan) = HUGE(0) */
    3360          150 :   if (mpfr_inf_p (x->value.real) || mpfr_nan_p (x->value.real))
    3361              :     {
    3362           18 :       int i = gfc_validate_kind (BT_INTEGER, gfc_default_integer_kind, false);
    3363           18 :       mpz_set (result->value.integer, gfc_integer_kinds[i].huge);
    3364           18 :       return result;
    3365              :     }
    3366              : 
    3367              :   /* EXPONENT(+/- 0.0) = 0  */
    3368          132 :   if (mpfr_zero_p (x->value.real))
    3369              :     {
    3370           12 :       mpz_set_ui (result->value.integer, 0);
    3371           12 :       return result;
    3372              :     }
    3373              : 
    3374          120 :   gfc_set_model (x->value.real);
    3375              : 
    3376          120 :   val = (long int) mpfr_get_exp (x->value.real);
    3377          120 :   mpz_set_si (result->value.integer, val);
    3378              : 
    3379          120 :   return range_check (result, "EXPONENT");
    3380              : }
    3381              : 
    3382              : 
    3383              : gfc_expr *
    3384          122 : gfc_simplify_failed_or_stopped_images (gfc_expr *team ATTRIBUTE_UNUSED,
    3385              :                                        gfc_expr *kind)
    3386              : {
    3387          122 :   if (flag_coarray == GFC_FCOARRAY_NONE)
    3388              :     {
    3389            0 :       gfc_current_locus = *gfc_current_intrinsic_where;
    3390            0 :       gfc_fatal_error ("Coarrays disabled at %C, use %<-fcoarray=%> to enable");
    3391              :       return &gfc_bad_expr;
    3392              :     }
    3393              : 
    3394          122 :   if (flag_coarray == GFC_FCOARRAY_SINGLE)
    3395              :     {
    3396           22 :       gfc_expr *result;
    3397           22 :       int actual_kind;
    3398           22 :       if (kind)
    3399           10 :         gfc_extract_int (kind, &actual_kind);
    3400              :       else
    3401           12 :         actual_kind = gfc_default_integer_kind;
    3402              : 
    3403           22 :       result = gfc_get_array_expr (BT_INTEGER, actual_kind, &gfc_current_locus);
    3404           22 :       result->rank = 1;
    3405           22 :       return result;
    3406              :     }
    3407              : 
    3408              :   /* For fcoarray = lib no simplification is possible, because it is not known
    3409              :      what images failed or are stopped at compile time.  */
    3410              :   return NULL;
    3411              : }
    3412              : 
    3413              : 
    3414              : gfc_expr *
    3415           95 : gfc_simplify_get_team (gfc_expr *level ATTRIBUTE_UNUSED)
    3416              : {
    3417           95 :   if (flag_coarray == GFC_FCOARRAY_NONE)
    3418              :     {
    3419            0 :       gfc_current_locus = *gfc_current_intrinsic_where;
    3420            0 :       gfc_fatal_error ("Coarrays disabled at %C, use %<-fcoarray=%> to enable");
    3421              :       return &gfc_bad_expr;
    3422              :     }
    3423              : 
    3424           95 :   if (flag_coarray == GFC_FCOARRAY_SINGLE)
    3425              :     {
    3426           17 :       gfc_expr *result;
    3427           17 :       result = gfc_get_null_expr (&gfc_current_locus);
    3428           17 :       result->ts.type = BT_DERIVED;
    3429           17 :       gfc_find_symbol ("team_type", gfc_current_ns, 1, &result->ts.u.derived);
    3430              : 
    3431           17 :       return result;
    3432              :     }
    3433              : 
    3434              :   /* For fcoarray = lib no simplification is possible, because it is not known
    3435              :      what images failed or are stopped at compile time.  */
    3436              :   return NULL;
    3437              : }
    3438              : 
    3439              : 
    3440              : gfc_expr *
    3441          865 : gfc_simplify_float (gfc_expr *a)
    3442              : {
    3443          865 :   gfc_expr *result;
    3444              : 
    3445          865 :   if (a->expr_type != EXPR_CONSTANT)
    3446              :     return NULL;
    3447              : 
    3448          493 :   result = gfc_int2real (a, gfc_default_real_kind);
    3449              : 
    3450          493 :   return range_check (result, "FLOAT");
    3451              : }
    3452              : 
    3453              : 
    3454              : static bool
    3455         2441 : is_last_ref_vtab (gfc_expr *e)
    3456              : {
    3457         2441 :   gfc_ref *ref;
    3458         2441 :   gfc_component *comp = NULL;
    3459              : 
    3460         2441 :   if (e->expr_type != EXPR_VARIABLE)
    3461              :     return false;
    3462              : 
    3463         3537 :   for (ref = e->ref; ref; ref = ref->next)
    3464         1131 :     if (ref->type == REF_COMPONENT)
    3465          483 :       comp = ref->u.c.component;
    3466              : 
    3467         2406 :   if (!e->ref || !comp)
    3468         1969 :     return e->symtree->n.sym->attr.vtab;
    3469              : 
    3470          437 :   if (comp->name[0] == '_' && strcmp (comp->name, "_vptr") == 0)
    3471          147 :     return true;
    3472              : 
    3473              :   return false;
    3474              : }
    3475              : 
    3476              : 
    3477              : gfc_expr *
    3478          541 : gfc_simplify_extends_type_of (gfc_expr *a, gfc_expr *mold)
    3479              : {
    3480              :   /* Avoid simplification of resolved symbols.  */
    3481          541 :   if (is_last_ref_vtab (a) || is_last_ref_vtab (mold))
    3482              :     return NULL;
    3483              : 
    3484          324 :   if (a->ts.type == BT_DERIVED && mold->ts.type == BT_DERIVED)
    3485           27 :     return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    3486           27 :                                  gfc_type_is_extension_of (mold->ts.u.derived,
    3487           54 :                                                            a->ts.u.derived));
    3488              : 
    3489          297 :   if (UNLIMITED_POLY (a) || UNLIMITED_POLY (mold))
    3490              :     return NULL;
    3491              : 
    3492          105 :   if ((a->ts.type == BT_CLASS && !gfc_expr_attr (a).class_ok)
    3493          240 :       || (mold->ts.type == BT_CLASS && !gfc_expr_attr (mold).class_ok))
    3494              :     return NULL;
    3495              : 
    3496              :   /* Return .false. if the dynamic type can never be an extension.  */
    3497          104 :   if ((a->ts.type == BT_CLASS && mold->ts.type == BT_CLASS
    3498           40 :        && !gfc_type_is_extension_of
    3499           40 :                         (CLASS_DATA (mold)->ts.u.derived,
    3500           40 :                          CLASS_DATA (a)->ts.u.derived)
    3501            5 :        && !gfc_type_is_extension_of
    3502            5 :                         (CLASS_DATA (a)->ts.u.derived,
    3503            5 :                          CLASS_DATA (mold)->ts.u.derived))
    3504          127 :       || (a->ts.type == BT_DERIVED && mold->ts.type == BT_CLASS
    3505           27 :           && !gfc_type_is_extension_of
    3506           27 :                         (CLASS_DATA (mold)->ts.u.derived,
    3507           27 :                          a->ts.u.derived))
    3508          253 :       || (a->ts.type == BT_CLASS && mold->ts.type == BT_DERIVED
    3509           64 :           && !gfc_type_is_extension_of
    3510           64 :                         (mold->ts.u.derived,
    3511           64 :                          CLASS_DATA (a)->ts.u.derived)
    3512           19 :           && !gfc_type_is_extension_of
    3513           19 :                         (CLASS_DATA (a)->ts.u.derived,
    3514           19 :                          mold->ts.u.derived)))
    3515           13 :     return gfc_get_logical_expr (gfc_default_logical_kind, &a->where, false);
    3516              : 
    3517              :   /* Return .true. if the dynamic type is guaranteed to be an extension.  */
    3518           96 :   if (a->ts.type == BT_CLASS && mold->ts.type == BT_DERIVED
    3519          178 :       && gfc_type_is_extension_of (mold->ts.u.derived,
    3520           60 :                                    CLASS_DATA (a)->ts.u.derived))
    3521           45 :     return gfc_get_logical_expr (gfc_default_logical_kind, &a->where, true);
    3522              : 
    3523              :   return NULL;
    3524              : }
    3525              : 
    3526              : 
    3527              : gfc_expr *
    3528          788 : gfc_simplify_same_type_as (gfc_expr *a, gfc_expr *b)
    3529              : {
    3530              :   /* Avoid simplification of resolved symbols.  */
    3531          788 :   if (is_last_ref_vtab (a) || is_last_ref_vtab (b))
    3532              :     return NULL;
    3533              : 
    3534              :   /* Return .false. if the dynamic type can never be the
    3535              :      same.  */
    3536          686 :   if (((a->ts.type == BT_CLASS && gfc_expr_attr (a).class_ok)
    3537          103 :        || (b->ts.type == BT_CLASS && gfc_expr_attr (b).class_ok))
    3538          769 :       && !gfc_type_compatible (&a->ts, &b->ts)
    3539          830 :       && !gfc_type_compatible (&b->ts, &a->ts))
    3540            6 :     return gfc_get_logical_expr (gfc_default_logical_kind, &a->where, false);
    3541              : 
    3542          782 :   if (a->ts.type != BT_DERIVED || b->ts.type != BT_DERIVED)
    3543              :      return NULL;
    3544              : 
    3545           18 :   return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    3546           18 :                                gfc_compare_derived_types (a->ts.u.derived,
    3547           36 :                                                           b->ts.u.derived));
    3548              : }
    3549              : 
    3550              : 
    3551              : gfc_expr *
    3552          414 : gfc_simplify_floor (gfc_expr *e, gfc_expr *k)
    3553              : {
    3554          414 :   gfc_expr *result;
    3555          414 :   mpfr_t floor;
    3556          414 :   int kind;
    3557              : 
    3558          414 :   kind = get_kind (BT_INTEGER, k, "FLOOR", gfc_default_integer_kind);
    3559          414 :   if (kind == -1)
    3560            0 :     gfc_internal_error ("gfc_simplify_floor(): Bad kind");
    3561              : 
    3562          414 :   if (e->expr_type != EXPR_CONSTANT)
    3563              :     return NULL;
    3564              : 
    3565           28 :   mpfr_init2 (floor, mpfr_get_prec (e->value.real));
    3566           28 :   mpfr_floor (floor, e->value.real);
    3567              : 
    3568           28 :   result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
    3569           28 :   gfc_mpfr_to_mpz (result->value.integer, floor, &e->where);
    3570              : 
    3571           28 :   mpfr_clear (floor);
    3572              : 
    3573           28 :   return range_check (result, "FLOOR");
    3574              : }
    3575              : 
    3576              : 
    3577              : gfc_expr *
    3578          264 : gfc_simplify_fraction (gfc_expr *x)
    3579              : {
    3580          264 :   gfc_expr *result;
    3581          264 :   mpfr_exp_t e;
    3582              : 
    3583          264 :   if (x->expr_type != EXPR_CONSTANT)
    3584              :     return NULL;
    3585              : 
    3586           84 :   result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
    3587              : 
    3588              :   /* FRACTION(inf) = NaN.  */
    3589           84 :   if (mpfr_inf_p (x->value.real))
    3590              :     {
    3591           12 :       mpfr_set_nan (result->value.real);
    3592           12 :       return result;
    3593              :     }
    3594              : 
    3595              :   /* mpfr_frexp() correctly handles zeros and NaNs.  */
    3596           72 :   mpfr_frexp (&e, result->value.real, x->value.real, GFC_RND_MODE);
    3597              : 
    3598           72 :   return range_check (result, "FRACTION");
    3599              : }
    3600              : 
    3601              : 
    3602              : gfc_expr *
    3603          204 : gfc_simplify_gamma (gfc_expr *x)
    3604              : {
    3605          204 :   gfc_expr *result;
    3606              : 
    3607          204 :   if (x->expr_type != EXPR_CONSTANT)
    3608              :     return NULL;
    3609              : 
    3610           54 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3611           54 :   mpfr_gamma (result->value.real, x->value.real, GFC_RND_MODE);
    3612              : 
    3613           54 :   return range_check (result, "GAMMA");
    3614              : }
    3615              : 
    3616              : 
    3617              : gfc_expr *
    3618         6284 : gfc_simplify_huge (gfc_expr *e)
    3619              : {
    3620         6284 :   gfc_expr *result;
    3621         6284 :   int i;
    3622              : 
    3623         6284 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    3624         6284 :   result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    3625              : 
    3626         6284 :   switch (e->ts.type)
    3627              :     {
    3628         4676 :       case BT_INTEGER:
    3629         4676 :         mpz_set (result->value.integer, gfc_integer_kinds[i].huge);
    3630         4676 :         break;
    3631              : 
    3632          156 :       case BT_UNSIGNED:
    3633          156 :         mpz_set (result->value.integer, gfc_unsigned_kinds[i].huge);
    3634          156 :         break;
    3635              : 
    3636         1452 :     case BT_REAL:
    3637         1452 :         mpfr_set (result->value.real, gfc_real_kinds[i].huge, GFC_RND_MODE);
    3638         1452 :         break;
    3639              : 
    3640            0 :       default:
    3641            0 :         gcc_unreachable ();
    3642              :     }
    3643              : 
    3644         6284 :   return result;
    3645              : }
    3646              : 
    3647              : 
    3648              : gfc_expr *
    3649           36 : gfc_simplify_hypot (gfc_expr *x, gfc_expr *y)
    3650              : {
    3651           36 :   gfc_expr *result;
    3652              : 
    3653           36 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    3654              :     return NULL;
    3655              : 
    3656           12 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3657           12 :   mpfr_hypot (result->value.real, x->value.real, y->value.real, GFC_RND_MODE);
    3658           12 :   return range_check (result, "HYPOT");
    3659              : }
    3660              : 
    3661              : 
    3662              : /* We use the processor's collating sequence, because all
    3663              :    systems that gfortran currently works on are ASCII.  */
    3664              : 
    3665              : gfc_expr *
    3666         9879 : gfc_simplify_iachar (gfc_expr *e, gfc_expr *kind)
    3667              : {
    3668         9879 :   gfc_expr *result;
    3669         9879 :   gfc_char_t index;
    3670         9879 :   int k;
    3671              : 
    3672         9879 :   if (e->expr_type != EXPR_CONSTANT)
    3673              :     return NULL;
    3674              : 
    3675         4965 :   if (e->value.character.length != 1)
    3676              :     {
    3677            0 :       gfc_error ("Argument of IACHAR at %L must be of length one", &e->where);
    3678            0 :       return &gfc_bad_expr;
    3679              :     }
    3680              : 
    3681         4965 :   index = e->value.character.string[0];
    3682              : 
    3683         4965 :   if (warn_surprising && index > 127)
    3684            1 :     gfc_warning (OPT_Wsurprising,
    3685              :                  "Argument of IACHAR function at %L outside of range 0..127",
    3686              :                  &e->where);
    3687              : 
    3688         4965 :   k = get_kind (BT_INTEGER, kind, "IACHAR", gfc_default_integer_kind);
    3689         4965 :   if (k == -1)
    3690              :     return &gfc_bad_expr;
    3691              : 
    3692         4965 :   result = gfc_get_int_expr (k, &e->where, index);
    3693              : 
    3694         4965 :   return range_check (result, "IACHAR");
    3695              : }
    3696              : 
    3697              : 
    3698              : static gfc_expr *
    3699           96 : do_bit_and (gfc_expr *result, gfc_expr *e)
    3700              : {
    3701           96 :   if (flag_unsigned)
    3702              :     {
    3703           72 :       gcc_assert ((e->ts.type == BT_INTEGER || e->ts.type == BT_UNSIGNED)
    3704              :                   && e->expr_type == EXPR_CONSTANT);
    3705           72 :       gcc_assert ((result->ts.type == BT_INTEGER
    3706              :                    || result->ts.type == BT_UNSIGNED)
    3707              :                   && result->expr_type == EXPR_CONSTANT);
    3708              :     }
    3709              :   else
    3710              :     {
    3711           24 :       gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
    3712           24 :       gcc_assert (result->ts.type == BT_INTEGER
    3713              :                   && result->expr_type == EXPR_CONSTANT);
    3714              :     }
    3715              : 
    3716           96 :   mpz_and (result->value.integer, result->value.integer, e->value.integer);
    3717           96 :   return result;
    3718              : }
    3719              : 
    3720              : 
    3721              : gfc_expr *
    3722          217 : gfc_simplify_iall (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
    3723              : {
    3724          217 :   return simplify_transformation (array, dim, mask, -1, do_bit_and);
    3725              : }
    3726              : 
    3727              : 
    3728              : static gfc_expr *
    3729           96 : do_bit_ior (gfc_expr *result, gfc_expr *e)
    3730              : {
    3731           96 :   if (flag_unsigned)
    3732              :     {
    3733           72 :       gcc_assert ((e->ts.type == BT_INTEGER || e->ts.type == BT_UNSIGNED)
    3734              :                   && e->expr_type == EXPR_CONSTANT);
    3735           72 :       gcc_assert ((result->ts.type == BT_INTEGER
    3736              :                    || result->ts.type == BT_UNSIGNED)
    3737              :                   && result->expr_type == EXPR_CONSTANT);
    3738              :     }
    3739              :   else
    3740              :     {
    3741           24 :       gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
    3742           24 :       gcc_assert (result->ts.type == BT_INTEGER
    3743              :                   && result->expr_type == EXPR_CONSTANT);
    3744              :     }
    3745              : 
    3746           96 :   mpz_ior (result->value.integer, result->value.integer, e->value.integer);
    3747           96 :   return result;
    3748              : }
    3749              : 
    3750              : 
    3751              : gfc_expr *
    3752          169 : gfc_simplify_iany (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
    3753              : {
    3754          169 :   return simplify_transformation (array, dim, mask, 0, do_bit_ior);
    3755              : }
    3756              : 
    3757              : 
    3758              : gfc_expr *
    3759         1875 : gfc_simplify_iand (gfc_expr *x, gfc_expr *y)
    3760              : {
    3761         1875 :   gfc_expr *result;
    3762         1875 :   bt type;
    3763              : 
    3764         1875 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    3765              :     return NULL;
    3766              : 
    3767          269 :   type = x->ts.type == BT_UNSIGNED ? BT_UNSIGNED : BT_INTEGER;
    3768          269 :   result = gfc_get_constant_expr (type, x->ts.kind, &x->where);
    3769          269 :   mpz_and (result->value.integer, x->value.integer, y->value.integer);
    3770              : 
    3771          269 :   return range_check (result, "IAND");
    3772              : }
    3773              : 
    3774              : 
    3775              : gfc_expr *
    3776          448 : gfc_simplify_ibclr (gfc_expr *x, gfc_expr *y)
    3777              : {
    3778          448 :   gfc_expr *result;
    3779          448 :   int k, pos;
    3780              : 
    3781          448 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    3782              :     return NULL;
    3783              : 
    3784           66 :   if (!gfc_check_bitfcn (x, y))
    3785              :     return &gfc_bad_expr;
    3786              : 
    3787           58 :   gfc_extract_int (y, &pos);
    3788              : 
    3789           58 :   k = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    3790              : 
    3791           58 :   result = gfc_copy_expr (x);
    3792              :   /* Drop any separate memory representation of x to avoid potential
    3793              :      inconsistencies in result.  */
    3794           58 :   if (result->representation.string)
    3795              :     {
    3796           12 :       free (result->representation.string);
    3797           12 :       result->representation.string = NULL;
    3798              :     }
    3799              : 
    3800           58 :   if (x->ts.type == BT_INTEGER)
    3801              :     {
    3802           52 :       gfc_convert_mpz_to_unsigned (result->value.integer,
    3803              :                                    gfc_integer_kinds[k].bit_size);
    3804              : 
    3805           52 :       mpz_clrbit (result->value.integer, pos);
    3806              : 
    3807           52 :       gfc_convert_mpz_to_signed (result->value.integer,
    3808              :                                  gfc_integer_kinds[k].bit_size);
    3809              :     }
    3810              :   else
    3811            6 :     mpz_clrbit (result->value.integer, pos);
    3812              : 
    3813              :   return result;
    3814              : }
    3815              : 
    3816              : 
    3817              : gfc_expr *
    3818          106 : gfc_simplify_ibits (gfc_expr *x, gfc_expr *y, gfc_expr *z)
    3819              : {
    3820          106 :   gfc_expr *result;
    3821          106 :   int pos, len;
    3822          106 :   int i, k, bitsize;
    3823          106 :   int *bits;
    3824              : 
    3825          106 :   if (x->expr_type != EXPR_CONSTANT
    3826           43 :       || y->expr_type != EXPR_CONSTANT
    3827           33 :       || z->expr_type != EXPR_CONSTANT)
    3828              :     return NULL;
    3829              : 
    3830           28 :   if (!gfc_check_ibits (x, y, z))
    3831              :     return &gfc_bad_expr;
    3832              : 
    3833           16 :   gfc_extract_int (y, &pos);
    3834           16 :   gfc_extract_int (z, &len);
    3835              : 
    3836           16 :   k = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    3837              : 
    3838           16 :   if (x->ts.type == BT_INTEGER)
    3839           10 :     bitsize = gfc_integer_kinds[k].bit_size;
    3840              :   else
    3841            6 :     bitsize = gfc_unsigned_kinds[k].bit_size;
    3842              : 
    3843              : 
    3844           16 :   if (pos + len > bitsize)
    3845              :     {
    3846            0 :       gfc_error ("Sum of second and third arguments of IBITS exceeds "
    3847              :                  "bit size at %L", &y->where);
    3848            0 :       return &gfc_bad_expr;
    3849              :     }
    3850              : 
    3851           16 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    3852              : 
    3853           16 :   if (x->ts.type == BT_INTEGER)
    3854           10 :     gfc_convert_mpz_to_unsigned (result->value.integer,
    3855              :                                  gfc_integer_kinds[k].bit_size);
    3856              : 
    3857           16 :   bits = XCNEWVEC (int, bitsize);
    3858              : 
    3859          576 :   for (i = 0; i < bitsize; i++)
    3860          544 :     bits[i] = 0;
    3861              : 
    3862           60 :   for (i = 0; i < len; i++)
    3863           44 :     bits[i] = mpz_tstbit (x->value.integer, i + pos);
    3864              : 
    3865          560 :   for (i = 0; i < bitsize; i++)
    3866              :     {
    3867          544 :       if (bits[i] == 0)
    3868          544 :         mpz_clrbit (result->value.integer, i);
    3869            0 :       else if (bits[i] == 1)
    3870            0 :         mpz_setbit (result->value.integer, i);
    3871              :       else
    3872            0 :         gfc_internal_error ("IBITS: Bad bit");
    3873              :     }
    3874              : 
    3875           16 :   free (bits);
    3876              : 
    3877           16 :   if (x->ts.type == BT_INTEGER)
    3878           10 :     gfc_convert_mpz_to_signed (result->value.integer,
    3879              :                                gfc_integer_kinds[k].bit_size);
    3880              : 
    3881              :   return result;
    3882              : }
    3883              : 
    3884              : 
    3885              : gfc_expr *
    3886          394 : gfc_simplify_ibset (gfc_expr *x, gfc_expr *y)
    3887              : {
    3888          394 :   gfc_expr *result;
    3889          394 :   int k, pos;
    3890              : 
    3891          394 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    3892              :     return NULL;
    3893              : 
    3894           72 :   if (!gfc_check_bitfcn (x, y))
    3895              :     return &gfc_bad_expr;
    3896              : 
    3897           64 :   gfc_extract_int (y, &pos);
    3898              : 
    3899           64 :   k = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    3900              : 
    3901           64 :   result = gfc_copy_expr (x);
    3902              :   /* Drop any separate memory representation of x to avoid potential
    3903              :      inconsistencies in result.  */
    3904           64 :   if (result->representation.string)
    3905              :     {
    3906           12 :       free (result->representation.string);
    3907           12 :       result->representation.string = NULL;
    3908              :     }
    3909              : 
    3910           64 :   if (x->ts.type == BT_INTEGER)
    3911              :     {
    3912           58 :       gfc_convert_mpz_to_unsigned (result->value.integer,
    3913              :                                    gfc_integer_kinds[k].bit_size);
    3914              : 
    3915           58 :       mpz_setbit (result->value.integer, pos);
    3916              : 
    3917           58 :       gfc_convert_mpz_to_signed (result->value.integer,
    3918              :                                  gfc_integer_kinds[k].bit_size);
    3919              :     }
    3920              :   else
    3921            6 :     mpz_setbit (result->value.integer, pos);
    3922              : 
    3923              :   return result;
    3924              : }
    3925              : 
    3926              : 
    3927              : gfc_expr *
    3928         3673 : gfc_simplify_ichar (gfc_expr *e, gfc_expr *kind)
    3929              : {
    3930         3673 :   gfc_expr *result;
    3931         3673 :   gfc_char_t index;
    3932         3673 :   int k;
    3933              : 
    3934         3673 :   if (e->expr_type != EXPR_CONSTANT)
    3935              :     return NULL;
    3936              : 
    3937         1961 :   if (e->value.character.length != 1)
    3938              :     {
    3939            2 :       gfc_error ("Argument of ICHAR at %L must be of length one", &e->where);
    3940            2 :       return &gfc_bad_expr;
    3941              :     }
    3942              : 
    3943         1959 :   index = e->value.character.string[0];
    3944              : 
    3945         1959 :   k = get_kind (BT_INTEGER, kind, "ICHAR", gfc_default_integer_kind);
    3946         1959 :   if (k == -1)
    3947              :     return &gfc_bad_expr;
    3948              : 
    3949         1959 :   result = gfc_get_int_expr (k, &e->where, index);
    3950              : 
    3951         1959 :   return range_check (result, "ICHAR");
    3952              : }
    3953              : 
    3954              : 
    3955              : gfc_expr *
    3956         1938 : gfc_simplify_ieor (gfc_expr *x, gfc_expr *y)
    3957              : {
    3958         1938 :   gfc_expr *result;
    3959         1938 :   bt type;
    3960              : 
    3961         1938 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    3962              :     return NULL;
    3963              : 
    3964          155 :   type = x->ts.type == BT_UNSIGNED ? BT_UNSIGNED : BT_INTEGER;
    3965          155 :   result = gfc_get_constant_expr (type, x->ts.kind, &x->where);
    3966          155 :   mpz_xor (result->value.integer, x->value.integer, y->value.integer);
    3967              : 
    3968          155 :   return range_check (result, "IEOR");
    3969              : }
    3970              : 
    3971              : 
    3972              : gfc_expr *
    3973         1364 : gfc_simplify_index (gfc_expr *x, gfc_expr *y, gfc_expr *b, gfc_expr *kind)
    3974              : {
    3975         1364 :   gfc_expr *result;
    3976         1364 :   bool back;
    3977         1364 :   HOST_WIDE_INT len, lensub, start, last, i, index = 0;
    3978         1364 :   int k, delta;
    3979              : 
    3980         1364 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT
    3981          338 :       || ( b != NULL && b->expr_type !=  EXPR_CONSTANT))
    3982              :     return NULL;
    3983              : 
    3984          206 :   back = (b != NULL && b->value.logical != 0);
    3985              : 
    3986          280 :   k = get_kind (BT_INTEGER, kind, "INDEX", gfc_default_integer_kind);
    3987          280 :   if (k == -1)
    3988              :     return &gfc_bad_expr;
    3989              : 
    3990          280 :   result = gfc_get_constant_expr (BT_INTEGER, k, &x->where);
    3991              : 
    3992          280 :   len = x->value.character.length;
    3993          280 :   lensub = y->value.character.length;
    3994              : 
    3995          280 :   if (len < lensub)
    3996              :     {
    3997           12 :       mpz_set_si (result->value.integer, 0);
    3998           12 :       return result;
    3999              :     }
    4000              : 
    4001          268 :   if (lensub == 0)
    4002              :     {
    4003           24 :       if (back)
    4004           12 :         index = len + 1;
    4005              :       else
    4006              :         index = 1;
    4007           24 :       goto done;
    4008              :     }
    4009              : 
    4010          244 :   if (!back)
    4011              :     {
    4012          132 :       last = len + 1 - lensub;
    4013          132 :       start = 0;
    4014          132 :       delta = 1;
    4015              :     }
    4016              :   else
    4017              :     {
    4018          112 :       last = -1;
    4019          112 :       start = len - lensub;
    4020          112 :       delta = -1;
    4021              :     }
    4022              : 
    4023         1222 :   for (; start != last; start += delta)
    4024              :     {
    4025         2078 :       for (i = 0; i < lensub; i++)
    4026              :         {
    4027         1864 :           if (x->value.character.string[start + i]
    4028         1864 :               != y->value.character.string[i])
    4029              :             break;
    4030              :         }
    4031         1192 :       if (i == lensub)
    4032              :         {
    4033          214 :           index = start + 1;
    4034          214 :           goto done;
    4035              :         }
    4036              :     }
    4037              : 
    4038           30 : done:
    4039          268 :   mpz_set_si (result->value.integer, index);
    4040          268 :   return range_check (result, "INDEX");
    4041              : }
    4042              : 
    4043              : static gfc_expr *
    4044         7519 : simplify_intconv (gfc_expr *e, int kind, const char *name)
    4045              : {
    4046         7519 :   gfc_expr *result = NULL;
    4047         7519 :   int tmp1, tmp2;
    4048              : 
    4049              :   /* Convert BOZ to integer, and return without range checking.  */
    4050         7519 :   if (e->ts.type == BT_BOZ)
    4051              :     {
    4052         1631 :       if (!gfc_boz2int (e, kind))
    4053              :         return NULL;
    4054         1631 :       result = gfc_copy_expr (e);
    4055         1631 :       return result;
    4056              :     }
    4057              : 
    4058         5888 :   if (e->expr_type != EXPR_CONSTANT)
    4059              :     return NULL;
    4060              : 
    4061              :   /* For explicit conversion, turn off -Wconversion and -Wconversion-extra
    4062              :      warnings.  */
    4063         1362 :   tmp1 = warn_conversion;
    4064         1362 :   tmp2 = warn_conversion_extra;
    4065         1362 :   warn_conversion = warn_conversion_extra = 0;
    4066              : 
    4067         1362 :   result = gfc_convert_constant (e, BT_INTEGER, kind);
    4068              : 
    4069         1362 :   warn_conversion = tmp1;
    4070         1362 :   warn_conversion_extra = tmp2;
    4071              : 
    4072         1362 :   if (result == &gfc_bad_expr)
    4073              :     return &gfc_bad_expr;
    4074              : 
    4075         1362 :   return range_check (result, name);
    4076              : }
    4077              : 
    4078              : 
    4079              : gfc_expr *
    4080         7416 : gfc_simplify_int (gfc_expr *e, gfc_expr *k)
    4081              : {
    4082         7416 :   int kind;
    4083              : 
    4084         7416 :   kind = get_kind (BT_INTEGER, k, "INT", gfc_default_integer_kind);
    4085         7416 :   if (kind == -1)
    4086              :     return &gfc_bad_expr;
    4087              : 
    4088         7416 :   return simplify_intconv (e, kind, "INT");
    4089              : }
    4090              : 
    4091              : gfc_expr *
    4092           58 : gfc_simplify_int2 (gfc_expr *e)
    4093              : {
    4094           58 :   return simplify_intconv (e, 2, "INT2");
    4095              : }
    4096              : 
    4097              : 
    4098              : gfc_expr *
    4099           45 : gfc_simplify_int8 (gfc_expr *e)
    4100              : {
    4101           45 :   return simplify_intconv (e, 8, "INT8");
    4102              : }
    4103              : 
    4104              : 
    4105              : gfc_expr *
    4106            0 : gfc_simplify_long (gfc_expr *e)
    4107              : {
    4108            0 :   return simplify_intconv (e, 4, "LONG");
    4109              : }
    4110              : 
    4111              : 
    4112              : gfc_expr *
    4113         2441 : gfc_simplify_ifix (gfc_expr *e)
    4114              : {
    4115         2441 :   gfc_expr *rtrunc, *result;
    4116              : 
    4117         2441 :   if (e->expr_type != EXPR_CONSTANT)
    4118              :     return NULL;
    4119              : 
    4120          131 :   rtrunc = gfc_copy_expr (e);
    4121          131 :   mpfr_trunc (rtrunc->value.real, e->value.real);
    4122              : 
    4123          131 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    4124              :                                   &e->where);
    4125          131 :   gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real, &e->where);
    4126              : 
    4127          131 :   gfc_free_expr (rtrunc);
    4128              : 
    4129          131 :   return range_check (result, "IFIX");
    4130              : }
    4131              : 
    4132              : 
    4133              : gfc_expr *
    4134          891 : gfc_simplify_idint (gfc_expr *e)
    4135              : {
    4136          891 :   gfc_expr *rtrunc, *result;
    4137              : 
    4138          891 :   if (e->expr_type != EXPR_CONSTANT)
    4139              :     return NULL;
    4140              : 
    4141           50 :   rtrunc = gfc_copy_expr (e);
    4142           50 :   mpfr_trunc (rtrunc->value.real, e->value.real);
    4143              : 
    4144           50 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    4145              :                                   &e->where);
    4146           50 :   gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real, &e->where);
    4147              : 
    4148           50 :   gfc_free_expr (rtrunc);
    4149              : 
    4150           50 :   return range_check (result, "IDINT");
    4151              : }
    4152              : 
    4153              : gfc_expr *
    4154          459 : gfc_simplify_uint (gfc_expr *e, gfc_expr *k)
    4155              : {
    4156          459 :   gfc_expr *result = NULL;
    4157          459 :   int kind;
    4158              : 
    4159              :   /* KIND is always an integer.  */
    4160              : 
    4161          459 :   kind = get_kind (BT_INTEGER, k, "INT", gfc_default_integer_kind);
    4162          459 :   if (kind == -1)
    4163              :     return &gfc_bad_expr;
    4164              : 
    4165              :   /* Convert BOZ to integer, and return without range checking.  */
    4166          459 :   if (e->ts.type == BT_BOZ)
    4167              :     {
    4168            6 :       if (!gfc_boz2uint (e, kind))
    4169              :         return NULL;
    4170            6 :       result = gfc_copy_expr (e);
    4171            6 :       return result;
    4172              :     }
    4173              : 
    4174          453 :   if (e->expr_type != EXPR_CONSTANT)
    4175              :     return NULL;
    4176              : 
    4177          165 :   result = gfc_convert_constant (e, BT_UNSIGNED, kind);
    4178              : 
    4179          165 :   if (result == &gfc_bad_expr)
    4180              :     return &gfc_bad_expr;
    4181              : 
    4182          165 :   return range_check (result, "UINT");
    4183              : }
    4184              : 
    4185              : 
    4186              : gfc_expr *
    4187         4382 : gfc_simplify_ior (gfc_expr *x, gfc_expr *y)
    4188              : {
    4189         4382 :   gfc_expr *result;
    4190         4382 :   bt type;
    4191              : 
    4192         4382 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    4193              :     return NULL;
    4194              : 
    4195         3055 :   type = x->ts.type == BT_UNSIGNED ? BT_UNSIGNED : BT_INTEGER;
    4196         3055 :   result = gfc_get_constant_expr (type, x->ts.kind, &x->where);
    4197         3055 :   mpz_ior (result->value.integer, x->value.integer, y->value.integer);
    4198              : 
    4199         3055 :   return range_check (result, "IOR");
    4200              : }
    4201              : 
    4202              : 
    4203              : static gfc_expr *
    4204           96 : do_bit_xor (gfc_expr *result, gfc_expr *e)
    4205              : {
    4206           96 :   if (flag_unsigned)
    4207              :     {
    4208           72 :       gcc_assert ((e->ts.type == BT_INTEGER || e->ts.type == BT_UNSIGNED)
    4209              :                   && e->expr_type == EXPR_CONSTANT);
    4210           72 :       gcc_assert ((result->ts.type == BT_INTEGER
    4211              :                    || result->ts.type == BT_UNSIGNED)
    4212              :                   && result->expr_type == EXPR_CONSTANT);
    4213              :     }
    4214              :   else
    4215              :     {
    4216           24 :       gcc_assert (e->ts.type == BT_INTEGER && e->expr_type == EXPR_CONSTANT);
    4217           24 :       gcc_assert (result->ts.type == BT_INTEGER
    4218              :                   && result->expr_type == EXPR_CONSTANT);
    4219              :     }
    4220              : 
    4221           96 :   mpz_xor (result->value.integer, result->value.integer, e->value.integer);
    4222           96 :   return result;
    4223              : }
    4224              : 
    4225              : 
    4226              : gfc_expr *
    4227          259 : gfc_simplify_iparity (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
    4228              : {
    4229          259 :   return simplify_transformation (array, dim, mask, 0, do_bit_xor);
    4230              : }
    4231              : 
    4232              : 
    4233              : gfc_expr *
    4234           46 : gfc_simplify_is_iostat_end (gfc_expr *x)
    4235              : {
    4236           46 :   if (x->expr_type != EXPR_CONSTANT)
    4237              :     return NULL;
    4238              : 
    4239           28 :   return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
    4240           28 :                                mpz_cmp_si (x->value.integer,
    4241           28 :                                            LIBERROR_END) == 0);
    4242              : }
    4243              : 
    4244              : 
    4245              : gfc_expr *
    4246           70 : gfc_simplify_is_iostat_eor (gfc_expr *x)
    4247              : {
    4248           70 :   if (x->expr_type != EXPR_CONSTANT)
    4249              :     return NULL;
    4250              : 
    4251           16 :   return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
    4252           16 :                                mpz_cmp_si (x->value.integer,
    4253           16 :                                            LIBERROR_EOR) == 0);
    4254              : }
    4255              : 
    4256              : 
    4257              : gfc_expr *
    4258         1568 : gfc_simplify_isnan (gfc_expr *x)
    4259              : {
    4260         1568 :   if (x->expr_type != EXPR_CONSTANT)
    4261              :     return NULL;
    4262              : 
    4263          194 :   return gfc_get_logical_expr (gfc_default_logical_kind, &x->where,
    4264          194 :                                mpfr_nan_p (x->value.real));
    4265              : }
    4266              : 
    4267              : 
    4268              : /* Performs a shift on its first argument.  Depending on the last
    4269              :    argument, the shift can be arithmetic, i.e. with filling from the
    4270              :    left like in the SHIFTA intrinsic.  */
    4271              : static gfc_expr *
    4272         9828 : simplify_shift (gfc_expr *e, gfc_expr *s, const char *name,
    4273              :                 bool arithmetic, int direction)
    4274              : {
    4275         9828 :   gfc_expr *result;
    4276         9828 :   int ashift, *bits, i, k, bitsize, shift;
    4277              : 
    4278         9828 :   if (e->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
    4279              :     return NULL;
    4280              : 
    4281         7729 :   gfc_extract_int (s, &shift);
    4282              : 
    4283         7729 :   k = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    4284         7729 :   if (e->ts.type == BT_INTEGER)
    4285         7627 :     bitsize = gfc_integer_kinds[k].bit_size;
    4286              :   else
    4287          102 :     bitsize = gfc_unsigned_kinds[k].bit_size;
    4288              : 
    4289         7729 :   result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    4290              : 
    4291         7729 :   if (shift == 0)
    4292              :     {
    4293         1194 :       mpz_set (result->value.integer, e->value.integer);
    4294         1194 :       return result;
    4295              :     }
    4296              : 
    4297         6535 :   if (direction > 0 && shift < 0)
    4298              :     {
    4299              :       /* Left shift, as in SHIFTL.  */
    4300            0 :       gfc_error ("Second argument of %s is negative at %L", name, &e->where);
    4301            0 :       return &gfc_bad_expr;
    4302              :     }
    4303         6535 :   else if (direction < 0)
    4304              :     {
    4305              :       /* Right shift, as in SHIFTR or SHIFTA.  */
    4306         2832 :       if (shift < 0)
    4307              :         {
    4308            0 :           gfc_error ("Second argument of %s is negative at %L",
    4309              :                      name, &e->where);
    4310            0 :           return &gfc_bad_expr;
    4311              :         }
    4312              : 
    4313         2832 :       shift = -shift;
    4314              :     }
    4315              : 
    4316         6535 :   ashift = (shift >= 0 ? shift : -shift);
    4317              : 
    4318         6535 :   if (ashift > bitsize)
    4319              :     {
    4320            0 :       gfc_error ("Magnitude of second argument of %s exceeds bit size "
    4321              :                  "at %L", name, &e->where);
    4322            0 :       return &gfc_bad_expr;
    4323              :     }
    4324              : 
    4325         6535 :   bits = XCNEWVEC (int, bitsize);
    4326              : 
    4327       325358 :   for (i = 0; i < bitsize; i++)
    4328       312288 :     bits[i] = mpz_tstbit (e->value.integer, i);
    4329              : 
    4330         6535 :   if (shift > 0)
    4331              :     {
    4332              :       /* Left shift.  */
    4333        86026 :       for (i = 0; i < shift; i++)
    4334        82467 :         mpz_clrbit (result->value.integer, i);
    4335              : 
    4336        85300 :       for (i = 0; i < bitsize - shift; i++)
    4337              :         {
    4338        81741 :           if (bits[i] == 0)
    4339        53126 :             mpz_clrbit (result->value.integer, i + shift);
    4340              :           else
    4341        28615 :             mpz_setbit (result->value.integer, i + shift);
    4342              :         }
    4343              :     }
    4344              :   else
    4345              :     {
    4346              :       /* Right shift.  */
    4347         2976 :       if (arithmetic && bits[bitsize - 1])
    4348          504 :         for (i = bitsize - 1; i >= bitsize - ashift; i--)
    4349          438 :           mpz_setbit (result->value.integer, i);
    4350              :       else
    4351        75186 :         for (i = bitsize - 1; i >= bitsize - ashift; i--)
    4352        72276 :           mpz_clrbit (result->value.integer, i);
    4353              : 
    4354        78342 :       for (i = bitsize - 1; i >= ashift; i--)
    4355              :         {
    4356        75366 :           if (bits[i] == 0)
    4357        46920 :             mpz_clrbit (result->value.integer, i - ashift);
    4358              :           else
    4359        28446 :             mpz_setbit (result->value.integer, i - ashift);
    4360              :         }
    4361              :     }
    4362              : 
    4363         6535 :   if (result->ts.type == BT_INTEGER)
    4364         6433 :     gfc_convert_mpz_to_signed (result->value.integer, bitsize);
    4365              :   else
    4366          102 :     gfc_reduce_unsigned(result);
    4367              : 
    4368         6535 :   free (bits);
    4369              : 
    4370         6535 :   return result;
    4371              : }
    4372              : 
    4373              : 
    4374              : gfc_expr *
    4375         2103 : gfc_simplify_ishft (gfc_expr *e, gfc_expr *s)
    4376              : {
    4377         2103 :   return simplify_shift (e, s, "ISHFT", false, 0);
    4378              : }
    4379              : 
    4380              : 
    4381              : gfc_expr *
    4382          192 : gfc_simplify_lshift (gfc_expr *e, gfc_expr *s)
    4383              : {
    4384          192 :   return simplify_shift (e, s, "LSHIFT", false, 1);
    4385              : }
    4386              : 
    4387              : 
    4388              : gfc_expr *
    4389           66 : gfc_simplify_rshift (gfc_expr *e, gfc_expr *s)
    4390              : {
    4391           66 :   return simplify_shift (e, s, "RSHIFT", true, -1);
    4392              : }
    4393              : 
    4394              : 
    4395              : gfc_expr *
    4396          438 : gfc_simplify_shifta (gfc_expr *e, gfc_expr *s)
    4397              : {
    4398          438 :   return simplify_shift (e, s, "SHIFTA", true, -1);
    4399              : }
    4400              : 
    4401              : 
    4402              : gfc_expr *
    4403         3753 : gfc_simplify_shiftl (gfc_expr *e, gfc_expr *s)
    4404              : {
    4405         3753 :   return simplify_shift (e, s, "SHIFTL", false, 1);
    4406              : }
    4407              : 
    4408              : 
    4409              : gfc_expr *
    4410         3276 : gfc_simplify_shiftr (gfc_expr *e, gfc_expr *s)
    4411              : {
    4412         3276 :   return simplify_shift (e, s, "SHIFTR", false, -1);
    4413              : }
    4414              : 
    4415              : 
    4416              : gfc_expr *
    4417         1929 : gfc_simplify_ishftc (gfc_expr *e, gfc_expr *s, gfc_expr *sz)
    4418              : {
    4419         1929 :   gfc_expr *result;
    4420         1929 :   int shift, ashift, isize, ssize, delta, k;
    4421         1929 :   int i, *bits;
    4422              : 
    4423         1929 :   if (e->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
    4424              :     return NULL;
    4425              : 
    4426          411 :   gfc_extract_int (s, &shift);
    4427              : 
    4428          411 :   k = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    4429          411 :   isize = gfc_integer_kinds[k].bit_size;
    4430              : 
    4431          411 :   if (sz != NULL)
    4432              :     {
    4433          213 :       if (sz->expr_type != EXPR_CONSTANT)
    4434              :         return NULL;
    4435              : 
    4436          213 :       gfc_extract_int (sz, &ssize);
    4437              : 
    4438          213 :       if (ssize > isize || ssize <= 0)
    4439              :         return &gfc_bad_expr;
    4440              :     }
    4441              :   else
    4442          198 :     ssize = isize;
    4443              : 
    4444          411 :   if (shift >= 0)
    4445              :     ashift = shift;
    4446              :   else
    4447              :     ashift = -shift;
    4448              : 
    4449          411 :   if (ashift > ssize)
    4450              :     {
    4451           11 :       if (sz == NULL)
    4452            4 :         gfc_error ("Magnitude of second argument of ISHFTC exceeds "
    4453              :                    "BIT_SIZE of first argument at %C");
    4454              :       else
    4455            7 :         gfc_error ("Absolute value of SHIFT shall be less than or equal "
    4456              :                    "to SIZE at %C");
    4457              :       return &gfc_bad_expr;
    4458              :     }
    4459              : 
    4460          400 :   result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    4461              : 
    4462          400 :   mpz_set (result->value.integer, e->value.integer);
    4463              : 
    4464          400 :   if (shift == 0)
    4465              :     return result;
    4466              : 
    4467          364 :   if (result->ts.type == BT_INTEGER)
    4468          352 :     gfc_convert_mpz_to_unsigned (result->value.integer, isize);
    4469              : 
    4470          364 :   bits = XCNEWVEC (int, ssize);
    4471              : 
    4472         6877 :   for (i = 0; i < ssize; i++)
    4473         6149 :     bits[i] = mpz_tstbit (e->value.integer, i);
    4474              : 
    4475          364 :   delta = ssize - ashift;
    4476              : 
    4477          364 :   if (shift > 0)
    4478              :     {
    4479         3975 :       for (i = 0; i < delta; i++)
    4480              :         {
    4481         3707 :           if (bits[i] == 0)
    4482         2226 :             mpz_clrbit (result->value.integer, i + shift);
    4483              :           else
    4484         1481 :             mpz_setbit (result->value.integer, i + shift);
    4485              :         }
    4486              : 
    4487         1030 :       for (i = delta; i < ssize; i++)
    4488              :         {
    4489          762 :           if (bits[i] == 0)
    4490          612 :             mpz_clrbit (result->value.integer, i - delta);
    4491              :           else
    4492          150 :             mpz_setbit (result->value.integer, i - delta);
    4493              :         }
    4494              :     }
    4495              :   else
    4496              :     {
    4497          288 :       for (i = 0; i < ashift; i++)
    4498              :         {
    4499          192 :           if (bits[i] == 0)
    4500           90 :             mpz_clrbit (result->value.integer, i + delta);
    4501              :           else
    4502          102 :             mpz_setbit (result->value.integer, i + delta);
    4503              :         }
    4504              : 
    4505         1584 :       for (i = ashift; i < ssize; i++)
    4506              :         {
    4507         1488 :           if (bits[i] == 0)
    4508          624 :             mpz_clrbit (result->value.integer, i + shift);
    4509              :           else
    4510          864 :             mpz_setbit (result->value.integer, i + shift);
    4511              :         }
    4512              :     }
    4513              : 
    4514          364 :   if (result->ts.type == BT_INTEGER)
    4515          352 :     gfc_convert_mpz_to_signed (result->value.integer, isize);
    4516              : 
    4517          364 :   free (bits);
    4518          364 :   return result;
    4519              : }
    4520              : 
    4521              : 
    4522              : gfc_expr *
    4523         5439 : gfc_simplify_kind (gfc_expr *e)
    4524              : {
    4525         5439 :   return gfc_get_int_expr (gfc_default_integer_kind, NULL, e->ts.kind);
    4526              : }
    4527              : 
    4528              : 
    4529              : static gfc_expr *
    4530        13435 : simplify_bound_dim (gfc_expr *array, gfc_expr *kind, int d, int upper,
    4531              :                     gfc_array_spec *as, gfc_ref *ref, bool coarray)
    4532              : {
    4533        13435 :   gfc_expr *l, *u, *result;
    4534        13435 :   int k;
    4535              : 
    4536        22474 :   k = get_kind (BT_INTEGER, kind, upper ? "UBOUND" : "LBOUND",
    4537              :                 gfc_default_integer_kind);
    4538        13435 :   if (k == -1)
    4539              :     return &gfc_bad_expr;
    4540              : 
    4541        13435 :   result = gfc_get_constant_expr (BT_INTEGER, k, &array->where);
    4542              : 
    4543              :   /* For non-variables, LBOUND(expr, DIM=n) = 1 and
    4544              :      UBOUND(expr, DIM=n) = SIZE(expr, DIM=n).  */
    4545        13435 :   if (!coarray && array->expr_type != EXPR_VARIABLE)
    4546              :     {
    4547         1414 :       if (upper)
    4548              :         {
    4549          782 :           gfc_expr* dim = result;
    4550          782 :           mpz_set_si (dim->value.integer, d);
    4551              : 
    4552          782 :           result = simplify_size (array, dim, k);
    4553          782 :           gfc_free_expr (dim);
    4554          782 :           if (!result)
    4555          375 :             goto returnNull;
    4556              :         }
    4557              :       else
    4558          632 :         mpz_set_si (result->value.integer, 1);
    4559              : 
    4560         1039 :       goto done;
    4561              :     }
    4562              : 
    4563              :   /* Otherwise, we have a variable expression.  */
    4564        12021 :   gcc_assert (array->expr_type == EXPR_VARIABLE);
    4565        12021 :   gcc_assert (as);
    4566              : 
    4567        12021 :   if (!gfc_resolve_array_spec (as, 0))
    4568              :     return NULL;
    4569              : 
    4570              :   /* The last dimension of an assumed-size array is special.  */
    4571        12018 :   if ((!coarray && d == as->rank && as->type == AS_ASSUMED_SIZE && !upper)
    4572         1631 :       || (coarray && d == as->rank + as->corank
    4573          598 :           && (!upper || flag_coarray == GFC_FCOARRAY_SINGLE)))
    4574              :     {
    4575          684 :       if (as->lower[d-1] && as->lower[d-1]->expr_type == EXPR_CONSTANT)
    4576              :         {
    4577          457 :           gfc_free_expr (result);
    4578          457 :           return gfc_copy_expr (as->lower[d-1]);
    4579              :         }
    4580              : 
    4581          227 :       goto returnNull;
    4582              :     }
    4583              : 
    4584              :   /* Then, we need to know the extent of the given dimension.  */
    4585        10191 :   if (coarray || (ref->u.ar.type == AR_FULL && !ref->next))
    4586              :     {
    4587        10831 :       gfc_expr *declared_bound;
    4588        10831 :       int empty_bound;
    4589        10831 :       bool constant_lbound, constant_ubound;
    4590              : 
    4591        10831 :       l = as->lower[d-1];
    4592        10831 :       u = as->upper[d-1];
    4593              : 
    4594        10831 :       gcc_assert (l != NULL);
    4595              : 
    4596        10831 :       constant_lbound = l->expr_type == EXPR_CONSTANT;
    4597        10831 :       constant_ubound = u && u->expr_type == EXPR_CONSTANT;
    4598              : 
    4599        10831 :       empty_bound = upper ? 0 : 1;
    4600        10831 :       declared_bound = upper ? u : l;
    4601              : 
    4602        10831 :       if ((!upper && !constant_lbound)
    4603         9959 :           || (upper && !constant_ubound))
    4604         2242 :         goto returnNull;
    4605              : 
    4606         8589 :       if (!coarray)
    4607              :         {
    4608              :           /* For {L,U}BOUND, the value depends on whether the array
    4609              :              is empty.  We can nevertheless simplify if the declared bound
    4610              :              has the same value as that of an empty array, in which case
    4611              :              the result isn't dependent on the array emptiness.  */
    4612         7766 :           if (mpz_cmp_si (declared_bound->value.integer, empty_bound) == 0)
    4613         3590 :             mpz_set_si (result->value.integer, empty_bound);
    4614         4176 :           else if (!constant_lbound || !constant_ubound)
    4615              :             /* Array emptiness can't be determined, we can't simplify.  */
    4616         1815 :             goto returnNull;
    4617         2361 :           else if (mpz_cmp (l->value.integer, u->value.integer) > 0)
    4618           97 :             mpz_set_si (result->value.integer, empty_bound);
    4619              :           else
    4620         2264 :             mpz_set (result->value.integer, declared_bound->value.integer);
    4621              :         }
    4622              :       else
    4623          823 :         mpz_set (result->value.integer, declared_bound->value.integer);
    4624              :     }
    4625              :   else
    4626              :     {
    4627          503 :       if (upper)
    4628              :         {
    4629              :           int d2 = 0, cnt = 0;
    4630          523 :           for (int idx = 0; idx < ref->u.ar.dimen; ++idx)
    4631              :             {
    4632          523 :               if (ref->u.ar.dimen_type[idx] == DIMEN_ELEMENT)
    4633          120 :                 d2++;
    4634          403 :               else if (cnt < d - 1)
    4635          102 :                 cnt++;
    4636              :               else
    4637              :                 break;
    4638              :             }
    4639          301 :           if (!gfc_ref_dimen_size (&ref->u.ar, d2 + d - 1, &result->value.integer, NULL))
    4640           73 :             goto returnNull;
    4641              :         }
    4642              :       else
    4643          202 :         mpz_set_si (result->value.integer, (long int) 1);
    4644              :     }
    4645              : 
    4646         8243 : done:
    4647         8243 :   return range_check (result, upper ? "UBOUND" : "LBOUND");
    4648              : 
    4649         4732 : returnNull:
    4650         4732 :   gfc_free_expr (result);
    4651         4732 :   return NULL;
    4652              : }
    4653              : 
    4654              : 
    4655              : static gfc_expr *
    4656        35093 : simplify_bound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind, int upper)
    4657              : {
    4658        35093 :   gfc_ref *ref;
    4659        35093 :   gfc_array_spec *as;
    4660        35093 :   ar_type type = AR_UNKNOWN;
    4661        35093 :   int d;
    4662              : 
    4663        35093 :   if (array->ts.type == BT_CLASS)
    4664              :     return NULL;
    4665              : 
    4666        33647 :   if (array->expr_type != EXPR_VARIABLE)
    4667              :     {
    4668         1242 :       as = NULL;
    4669         1242 :       ref = NULL;
    4670         1242 :       goto done;
    4671              :     }
    4672              : 
    4673              :   /* Do not attempt to resolve if error has already been issued.  */
    4674        32405 :   if (array->symtree->n.sym->error)
    4675              :     return NULL;
    4676              : 
    4677              :   /* Follow any component references.  */
    4678        32404 :   as = array->symtree->n.sym->as;
    4679        33743 :   for (ref = array->ref; ref; ref = ref->next)
    4680              :     {
    4681        33743 :       switch (ref->type)
    4682              :         {
    4683        32538 :         case REF_ARRAY:
    4684        32538 :           type = ref->u.ar.type;
    4685        32538 :           switch (ref->u.ar.type)
    4686              :             {
    4687          134 :             case AR_ELEMENT:
    4688          134 :               as = NULL;
    4689          134 :               continue;
    4690              : 
    4691        31541 :             case AR_FULL:
    4692              :               /* We're done because 'as' has already been set in the
    4693              :                  previous iteration.  */
    4694        31541 :               goto done;
    4695              : 
    4696              :             case AR_UNKNOWN:
    4697              :               return NULL;
    4698              : 
    4699          863 :             case AR_SECTION:
    4700          863 :               as = ref->u.ar.as;
    4701          863 :               goto done;
    4702              :             }
    4703              : 
    4704            0 :           gcc_unreachable ();
    4705              : 
    4706         1205 :         case REF_COMPONENT:
    4707         1205 :           as = ref->u.c.component->as;
    4708         1205 :           continue;
    4709              : 
    4710            0 :         case REF_SUBSTRING:
    4711            0 :         case REF_INQUIRY:
    4712            0 :           continue;
    4713              :         }
    4714              :     }
    4715              : 
    4716            0 :   gcc_unreachable ();
    4717              : 
    4718        33646 :  done:
    4719              : 
    4720        33646 :   if (as && (as->type == AS_DEFERRED || as->type == AS_ASSUMED_RANK
    4721        11443 :              || (as->type == AS_ASSUMED_SHAPE && upper)))
    4722              :     return NULL;
    4723              : 
    4724              :   /* 'array' shall not be an unallocated allocatable variable or a pointer that
    4725              :      is not associated.  */
    4726        10485 :   if (array->expr_type == EXPR_VARIABLE
    4727        10485 :       && (gfc_expr_attr (array).allocatable || gfc_expr_attr (array).pointer))
    4728              :     return NULL;
    4729              : 
    4730        10479 :   gcc_assert (!as
    4731              :               || (as->type != AS_DEFERRED
    4732              :                   && array->expr_type == EXPR_VARIABLE
    4733              :                   && !gfc_expr_attr (array).allocatable
    4734              :                   && !gfc_expr_attr (array).pointer));
    4735              : 
    4736        10479 :   if (dim == NULL)
    4737              :     {
    4738              :       /* Multi-dimensional bounds.  */
    4739         1579 :       gfc_expr *bounds[GFC_MAX_DIMENSIONS];
    4740         1579 :       gfc_expr *e;
    4741         1579 :       int k;
    4742              : 
    4743              :       /* UBOUND(ARRAY) is not valid for an assumed-size array.  */
    4744         1579 :       if (upper && type == AR_FULL && as && as->type == AS_ASSUMED_SIZE)
    4745              :         {
    4746              :           /* An error message will be emitted in
    4747              :              check_assumed_size_reference (resolve.cc).  */
    4748              :           return &gfc_bad_expr;
    4749              :         }
    4750              : 
    4751              :       /* Simplify the bounds for each dimension.  */
    4752         4146 :       for (d = 0; d < array->rank; d++)
    4753              :         {
    4754         2902 :           bounds[d] = simplify_bound_dim (array, kind, d + 1, upper, as, ref,
    4755              :                                           false);
    4756         2902 :           if (bounds[d] == NULL || bounds[d] == &gfc_bad_expr)
    4757              :             {
    4758              :               int j;
    4759              : 
    4760          340 :               for (j = 0; j < d; j++)
    4761            6 :                 gfc_free_expr (bounds[j]);
    4762              : 
    4763          334 :               if (gfc_seen_div0)
    4764              :                 return &gfc_bad_expr;
    4765              :               else
    4766          333 :                 return bounds[d];
    4767              :             }
    4768              :         }
    4769              : 
    4770              :       /* Allocate the result expression.  */
    4771         1942 :       k = get_kind (BT_INTEGER, kind, upper ? "UBOUND" : "LBOUND",
    4772              :                     gfc_default_integer_kind);
    4773         1244 :       if (k == -1)
    4774              :         return &gfc_bad_expr;
    4775              : 
    4776         1244 :       e = gfc_get_array_expr (BT_INTEGER, k, &array->where);
    4777              : 
    4778              :       /* The result is a rank 1 array; its size is the rank of the first
    4779              :          argument to {L,U}BOUND.  */
    4780         1244 :       e->rank = 1;
    4781         1244 :       e->shape = gfc_get_shape (1);
    4782         1244 :       mpz_init_set_ui (e->shape[0], array->rank);
    4783              : 
    4784              :       /* Create the constructor for this array.  */
    4785         5050 :       for (d = 0; d < array->rank; d++)
    4786         2562 :         gfc_constructor_append_expr (&e->value.constructor,
    4787              :                                      bounds[d], &e->where);
    4788              : 
    4789              :       return e;
    4790              :     }
    4791              :   else
    4792              :     {
    4793              :       /* A DIM argument is specified.  */
    4794         8900 :       if (dim->expr_type != EXPR_CONSTANT)
    4795              :         return NULL;
    4796              : 
    4797         8900 :       d = mpz_get_si (dim->value.integer);
    4798              : 
    4799         8900 :       if ((d < 1 || d > array->rank)
    4800         8900 :           || (d == array->rank && as && as->type == AS_ASSUMED_SIZE && upper))
    4801              :         {
    4802            0 :           gfc_error ("DIM argument at %L is out of bounds", &dim->where);
    4803            0 :           return &gfc_bad_expr;
    4804              :         }
    4805              : 
    4806         8483 :       if (as && as->type == AS_ASSUMED_RANK)
    4807              :         return NULL;
    4808              : 
    4809         8900 :       return simplify_bound_dim (array, kind, d, upper, as, ref, false);
    4810              :     }
    4811              : }
    4812              : 
    4813              : 
    4814              : static gfc_expr *
    4815         1866 : simplify_cobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind, int upper)
    4816              : {
    4817         1866 :   gfc_ref *ref;
    4818         1866 :   gfc_array_spec *as;
    4819         1866 :   gfc_symbol *sym;
    4820         1866 :   int d;
    4821              : 
    4822         1866 :   if (array->expr_type != EXPR_VARIABLE)
    4823              :     return NULL;
    4824              : 
    4825              :   /* Do not attempt to resolve if an error has already been issued.  */
    4826         1866 :   if (array->symtree->n.sym->error)
    4827              :     return NULL;
    4828              : 
    4829              :   /* Follow any component references, starting from the base symbol's array
    4830              :      spec; ARRAY itself may be a subobject of the coarray.  */
    4831         1866 :   sym = array->symtree->n.sym;
    4832         1866 :   as = (sym->ts.type == BT_CLASS && sym->attr.class_ok && CLASS_DATA (sym))
    4833         1866 :        ? CLASS_DATA (sym)->as
    4834              :        : sym->as;
    4835         2210 :   for (ref = array->ref; ref; ref = ref->next)
    4836              :     {
    4837         2206 :       switch (ref->type)
    4838              :         {
    4839         1862 :         case REF_ARRAY:
    4840         1862 :           switch (ref->u.ar.type)
    4841              :             {
    4842          583 :             case AR_ELEMENT:
    4843          583 :               if (ref->u.ar.as->corank > 0)
    4844              :                 {
    4845          583 :                   as = ref->u.ar.as;
    4846          583 :                   goto done;
    4847              :                 }
    4848            0 :               as = NULL;
    4849            0 :               continue;
    4850              : 
    4851         1279 :             case AR_FULL:
    4852              :               /* We're done because 'as' has already been set in the
    4853              :                  previous iteration.  */
    4854         1279 :               goto done;
    4855              : 
    4856              :             case AR_UNKNOWN:
    4857              :               return NULL;
    4858              : 
    4859            0 :             case AR_SECTION:
    4860            0 :               as = ref->u.ar.as;
    4861            0 :               goto done;
    4862              :             }
    4863              : 
    4864            0 :           gcc_unreachable ();
    4865              : 
    4866          344 :         case REF_COMPONENT:
    4867          344 :           as = ref->u.c.component->as;
    4868          344 :           continue;
    4869              : 
    4870            0 :         case REF_SUBSTRING:
    4871            0 :         case REF_INQUIRY:
    4872            0 :           continue;
    4873              :         }
    4874              :     }
    4875              : 
    4876            4 :  done:
    4877              : 
    4878         1866 :   if (!as || as->cotype == AS_DEFERRED || as->cotype == AS_ASSUMED_SHAPE)
    4879              :     return NULL;
    4880              : 
    4881          927 :   if (dim == NULL)
    4882              :     {
    4883              :       /* Multi-dimensional cobounds.  */
    4884              :       gfc_expr *bounds[GFC_MAX_DIMENSIONS];
    4885              :       gfc_expr *e;
    4886              :       int k;
    4887              : 
    4888              :       /* Simplify the cobounds for each dimension.  */
    4889         1044 :       for (d = 0; d < as->corank; d++)
    4890              :         {
    4891          902 :           bounds[d] = simplify_bound_dim (array, kind, d + 1 + as->rank,
    4892              :                                           upper, as, ref, true);
    4893          902 :           if (bounds[d] == NULL || bounds[d] == &gfc_bad_expr)
    4894              :             {
    4895              :               int j;
    4896              : 
    4897          436 :               for (j = 0; j < d; j++)
    4898          240 :                 gfc_free_expr (bounds[j]);
    4899              :               return bounds[d];
    4900              :             }
    4901              :         }
    4902              : 
    4903              :       /* Allocate the result expression.  */
    4904          142 :       e = gfc_get_expr ();
    4905          142 :       e->where = array->where;
    4906          142 :       e->expr_type = EXPR_ARRAY;
    4907          142 :       e->ts.type = BT_INTEGER;
    4908          259 :       k = get_kind (BT_INTEGER, kind, upper ? "UCOBOUND" : "LCOBOUND",
    4909              :                     gfc_default_integer_kind);
    4910          142 :       if (k == -1)
    4911              :         {
    4912            0 :           gfc_free_expr (e);
    4913            0 :           return &gfc_bad_expr;
    4914              :         }
    4915          142 :       e->ts.kind = k;
    4916              : 
    4917              :       /* The result is a rank 1 array; its size is the rank of the first
    4918              :          argument to {L,U}COBOUND.  */
    4919          142 :       e->rank = 1;
    4920          142 :       e->shape = gfc_get_shape (1);
    4921          142 :       mpz_init_set_ui (e->shape[0], as->corank);
    4922              : 
    4923              :       /* Create the constructor for this array.  */
    4924          750 :       for (d = 0; d < as->corank; d++)
    4925          466 :         gfc_constructor_append_expr (&e->value.constructor,
    4926              :                                      bounds[d], &e->where);
    4927              :       return e;
    4928              :     }
    4929              :   else
    4930              :     {
    4931              :       /* A DIM argument is specified.  */
    4932          589 :       if (dim->expr_type != EXPR_CONSTANT)
    4933              :         return NULL;
    4934              : 
    4935          449 :       d = mpz_get_si (dim->value.integer);
    4936              : 
    4937          449 :       if (d < 1 || d > as->corank)
    4938              :         {
    4939            0 :           gfc_error ("DIM argument at %L is out of bounds", &dim->where);
    4940            0 :           return &gfc_bad_expr;
    4941              :         }
    4942              : 
    4943          449 :       return simplify_bound_dim (array, kind, d+as->rank, upper, as, ref, true);
    4944              :     }
    4945              : }
    4946              : 
    4947              : 
    4948              : gfc_expr *
    4949        19809 : gfc_simplify_lbound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
    4950              : {
    4951        19809 :   return simplify_bound (array, dim, kind, 0);
    4952              : }
    4953              : 
    4954              : 
    4955              : gfc_expr *
    4956          696 : gfc_simplify_lcobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
    4957              : {
    4958          696 :   return simplify_cobound (array, dim, kind, 0);
    4959              : }
    4960              : 
    4961              : gfc_expr *
    4962         1608 : gfc_simplify_leadz (gfc_expr *e)
    4963              : {
    4964         1608 :   unsigned long lz, bs;
    4965         1608 :   int i;
    4966              : 
    4967         1608 :   if (e->expr_type != EXPR_CONSTANT)
    4968              :     return NULL;
    4969              : 
    4970          312 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    4971          312 :   bs = gfc_integer_kinds[i].bit_size;
    4972          312 :   if (mpz_cmp_si (e->value.integer, 0) == 0)
    4973              :     lz = bs;
    4974          276 :   else if (mpz_cmp_si (e->value.integer, 0) < 0)
    4975              :     lz = 0;
    4976              :   else
    4977          186 :     lz = bs - mpz_sizeinbase (e->value.integer, 2);
    4978              : 
    4979          312 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, lz);
    4980              : }
    4981              : 
    4982              : 
    4983              : /* Check for constant length of a substring.  */
    4984              : 
    4985              : static bool
    4986        18217 : substring_has_constant_len (gfc_expr *e)
    4987              : {
    4988        18217 :   gfc_ref *ref;
    4989        18217 :   HOST_WIDE_INT istart, iend, length;
    4990        18217 :   bool equal_length = false;
    4991              : 
    4992        18217 :   if (e->ts.type != BT_CHARACTER)
    4993              :     return false;
    4994              : 
    4995        26008 :   for (ref = e->ref; ref; ref = ref->next)
    4996         8221 :     if (ref->type != REF_COMPONENT && ref->type != REF_ARRAY)
    4997              :       break;
    4998              : 
    4999        18217 :   if (!ref
    5000          430 :       || ref->type != REF_SUBSTRING
    5001          430 :       || !ref->u.ss.start
    5002          430 :       || ref->u.ss.start->expr_type != EXPR_CONSTANT
    5003          208 :       || !ref->u.ss.end
    5004          208 :       || ref->u.ss.end->expr_type != EXPR_CONSTANT)
    5005              :     return false;
    5006              : 
    5007              :   /* Basic checks on substring starting and ending indices.  */
    5008          207 :   if (!gfc_resolve_substring (ref, &equal_length))
    5009              :     return false;
    5010              : 
    5011          207 :   istart = gfc_mpz_get_hwi (ref->u.ss.start->value.integer);
    5012          207 :   iend = gfc_mpz_get_hwi (ref->u.ss.end->value.integer);
    5013              : 
    5014          207 :   if (istart <= iend)
    5015          199 :     length = iend - istart + 1;
    5016              :   else
    5017              :     length = 0;
    5018              : 
    5019              :   /* Fix substring length.  */
    5020          207 :   e->value.character.length = length;
    5021              : 
    5022          207 :   return true;
    5023              : }
    5024              : 
    5025              : 
    5026              : gfc_expr *
    5027        18760 : gfc_simplify_len (gfc_expr *e, gfc_expr *kind)
    5028              : {
    5029        18760 :   gfc_expr *result;
    5030        18760 :   int k = get_kind (BT_INTEGER, kind, "LEN", gfc_default_integer_kind);
    5031              : 
    5032        18760 :   if (k == -1)
    5033              :     return &gfc_bad_expr;
    5034              : 
    5035              :   /* Catch parameterized strings of nested PDTs and let the expansion occur
    5036              :      downstream in trans-array.cc(structure_alloc_comps).  */
    5037        18760 :   if (e->expr_type == EXPR_VARIABLE && IS_PDT (e->symtree->n.sym)
    5038          217 :       && !e->param_list && e->ref)
    5039              :     {
    5040              :       gfc_ref *r = e->ref;
    5041          482 :       for (; r; r = r->next)
    5042          301 :         if (r->type == REF_COMPONENT
    5043          217 :             && (IS_PDT (r->u.c.component) || IS_CLASS_PDT (r->u.c.component)))
    5044              :           return NULL;
    5045              :     }
    5046              : 
    5047        18724 :   if (e->expr_type == EXPR_CONSTANT
    5048        18724 :       || substring_has_constant_len (e))
    5049              :     {
    5050          714 :       result = gfc_get_constant_expr (BT_INTEGER, k, &e->where);
    5051          714 :       mpz_set_si (result->value.integer, e->value.character.length);
    5052          714 :       return range_check (result, "LEN");
    5053              :     }
    5054        18010 :   else if (e->ts.u.cl != NULL && e->ts.u.cl->length != NULL
    5055         6071 :            && e->ts.u.cl->length->expr_type == EXPR_CONSTANT
    5056         3226 :            && e->ts.u.cl->length->ts.type == BT_INTEGER)
    5057              :     {
    5058         3226 :       result = gfc_get_constant_expr (BT_INTEGER, k, &e->where);
    5059         3226 :       mpz_set (result->value.integer, e->ts.u.cl->length->value.integer);
    5060         3226 :       return range_check (result, "LEN");
    5061              :     }
    5062        14784 :   else if (e->expr_type == EXPR_VARIABLE && e->ts.type == BT_CHARACTER
    5063        12778 :            && e->symtree->n.sym)
    5064              :     {
    5065        12778 :       if (e->symtree->n.sym->ts.type != BT_DERIVED
    5066        12274 :           && e->symtree->n.sym->assoc && e->symtree->n.sym->assoc->target
    5067         1193 :           && e->symtree->n.sym->assoc->target->ts.type == BT_DERIVED
    5068          373 :           && e->symtree->n.sym->assoc->target->symtree->n.sym
    5069          373 :           && UNLIMITED_POLY (e->symtree->n.sym->assoc->target->symtree->n.sym))
    5070              :         /* The expression in assoc->target points to a ref to the _data
    5071              :            component of the unlimited polymorphic entity.  To get the _len
    5072              :            component the last _data ref needs to be stripped and a ref to the
    5073              :            _len component added.  */
    5074          373 :         return gfc_get_len_component (e->symtree->n.sym->assoc->target, k);
    5075        12405 :       else if (gfc_expr_attr (e).pdt_string
    5076        12405 :                && e->ts.u.cl->length->expr_type == EXPR_VARIABLE)
    5077              :         {
    5078          108 :           const char *name = e->ts.u.cl->length->symtree->name;
    5079          108 :           if (gfc_init_expr_flag)
    5080              :             {
    5081           12 :               gfc_expr* tmp;
    5082           12 :               tmp = gfc_pdt_find_component_copy_initializer (e->symtree->n.sym,
    5083              :                                                              name);
    5084           12 :               if (tmp)
    5085              :                 return tmp;
    5086              :             }
    5087              :           else
    5088              :             {
    5089           96 :               gfc_expr *len_expr = gfc_copy_expr (e);
    5090           96 :               gfc_free_ref_list (len_expr->ref);
    5091           96 :               len_expr->ref = NULL;
    5092           96 :               gfc_find_component (len_expr->symtree->n.sym->ts.u.derived,
    5093              :                                   name, false, true, &len_expr->ref);
    5094           96 :               len_expr->ts = len_expr->ref->u.c.component->ts;
    5095           96 :               return len_expr;
    5096              :             }
    5097              :         }
    5098        12297 :       else if (gfc_expr_attr (e).pdt_string)
    5099              :         {
    5100           12 :           gfc_actual_arglist *parms;
    5101           12 :           gfc_expr *len_expr;
    5102              : 
    5103           12 :           len_expr = gfc_copy_expr (e->ts.u.cl->length);
    5104           12 :           parms = e->param_list ? e->param_list :
    5105           12 :                                   e->symtree->n.sym->param_list;
    5106           12 :           if (parms)
    5107           12 :             gfc_insert_parameter_exprs (len_expr, parms);
    5108              : 
    5109           12 :           if (e->ts.u.cl->length->expr_type != EXPR_VARIABLE
    5110           12 :               && gfc_simplify_expr (len_expr, 0)
    5111           24 :               && gfc_is_constant_expr (len_expr))
    5112              :             return len_expr;
    5113              : 
    5114            0 :           gfc_free_expr (len_expr);
    5115              :         }
    5116              :     }
    5117         2006 :   else if (e->expr_type == EXPR_ARRAY && e->ts.type == BT_CHARACTER
    5118          127 :            && e->ts.u.cl
    5119          127 :            && e->ts.u.cl->length_from_typespec
    5120          126 :            && e->ts.u.cl->length
    5121          126 :            && e->ts.u.cl->length->ts.type == BT_INTEGER)
    5122              :     {
    5123          126 :       gfc_typespec ts;
    5124          126 :       gfc_clear_ts (&ts);
    5125          126 :       ts.type = BT_INTEGER;
    5126          126 :       ts.kind = k;
    5127          126 :       result = gfc_copy_expr (e->ts.u.cl->length);
    5128          126 :       gfc_convert_type_warn (result, &ts, 2, 0);
    5129          126 :       return result;
    5130              :     }
    5131              : 
    5132              :   return NULL;
    5133              : }
    5134              : 
    5135              : 
    5136              : gfc_expr *
    5137         4364 : gfc_simplify_len_trim (gfc_expr *e, gfc_expr *kind)
    5138              : {
    5139         4364 :   gfc_expr *result;
    5140         4364 :   size_t count, len, i;
    5141         4364 :   int k = get_kind (BT_INTEGER, kind, "LEN_TRIM", gfc_default_integer_kind);
    5142              : 
    5143         4364 :   if (k == -1)
    5144              :     return &gfc_bad_expr;
    5145              : 
    5146              :   /* If the expression is either an array element or section, an array
    5147              :      parameter must be built so that the reference can be applied. Constant
    5148              :      references should have already been simplified away. All other cases
    5149              :      can proceed to translation, where kind conversion will occur silently.  */
    5150         4364 :   if (e->expr_type == EXPR_VARIABLE
    5151         3517 :       && e->ts.type == BT_CHARACTER
    5152         3517 :       && e->symtree->n.sym->attr.flavor == FL_PARAMETER
    5153          129 :       && e->ref && e->ref->type == REF_ARRAY
    5154          129 :       && e->ref->u.ar.type != AR_FULL
    5155           82 :       && e->symtree->n.sym->value)
    5156              :     {
    5157           82 :       char name[2*GFC_MAX_SYMBOL_LEN + 12];
    5158           82 :       gfc_namespace *ns = e->symtree->n.sym->ns;
    5159           82 :       gfc_symtree *st;
    5160           82 :       gfc_expr *expr;
    5161           82 :       gfc_expr *p;
    5162           82 :       gfc_constructor *c;
    5163           82 :       int cnt = 0;
    5164              : 
    5165           82 :       sprintf (name, "_len_trim_%s_%s", e->symtree->n.sym->name,
    5166           82 :                ns->proc_name->name);
    5167           82 :       st = gfc_find_symtree (ns->sym_root, name);
    5168           82 :       if (st)
    5169           44 :         goto already_built;
    5170              : 
    5171              :       /* Recursively call this fcn to simplify the constructor elements.  */
    5172           38 :       expr = gfc_copy_expr (e->symtree->n.sym->value);
    5173           38 :       expr->ts.type = BT_INTEGER;
    5174           38 :       expr->ts.kind = k;
    5175           38 :       expr->ts.u.cl = NULL;
    5176           38 :       c = gfc_constructor_first (expr->value.constructor);
    5177          237 :       for (; c; c = gfc_constructor_next (c))
    5178              :         {
    5179          161 :           if (c->iterator)
    5180            0 :             continue;
    5181              : 
    5182          161 :           if (c->expr && c->expr->ts.type == BT_CHARACTER)
    5183              :             {
    5184          161 :               p = gfc_simplify_len_trim (c->expr, kind);
    5185          161 :               if (p == NULL)
    5186            0 :                 goto clean_up;
    5187          161 :               gfc_replace_expr (c->expr, p);
    5188          161 :               cnt++;
    5189              :             }
    5190              :         }
    5191              : 
    5192           38 :       if (cnt)
    5193              :         {
    5194              :           /* Build a new parameter to take the result.  */
    5195           38 :           st = gfc_new_symtree (&ns->sym_root, name);
    5196           38 :           st->n.sym = gfc_new_symbol (st->name, ns);
    5197           38 :           st->n.sym->value = expr;
    5198           38 :           st->n.sym->ts = expr->ts;
    5199           38 :           st->n.sym->attr.dimension = 1;
    5200           38 :           st->n.sym->attr.save = SAVE_IMPLICIT;
    5201           38 :           st->n.sym->attr.flavor = FL_PARAMETER;
    5202           38 :           st->n.sym->as = gfc_copy_array_spec (e->symtree->n.sym->as);
    5203           38 :           gfc_set_sym_referenced (st->n.sym);
    5204           38 :           st->n.sym->refs++;
    5205           38 :           gfc_commit_symbol (st->n.sym);
    5206              : 
    5207           82 : already_built:
    5208              :           /* Build a return expression.  */
    5209           82 :           expr = gfc_copy_expr (e);
    5210           82 :           expr->ts = st->n.sym->ts;
    5211           82 :           expr->symtree = st;
    5212           82 :           gfc_expression_rank (expr);
    5213           82 :           return expr;
    5214              :         }
    5215              : 
    5216            0 : clean_up:
    5217            0 :       gfc_free_expr (expr);
    5218            0 :       return NULL;
    5219              :     }
    5220              : 
    5221         4282 :   if (e->expr_type != EXPR_CONSTANT)
    5222              :     return NULL;
    5223              : 
    5224          388 :   len = e->value.character.length;
    5225         1215 :   for (count = 0, i = 1; i <= len; i++)
    5226         1203 :     if (e->value.character.string[len - i] == ' ')
    5227          827 :       count++;
    5228              :     else
    5229              :       break;
    5230              : 
    5231          388 :   result = gfc_get_int_expr (k, &e->where, len - count);
    5232          388 :   return range_check (result, "LEN_TRIM");
    5233              : }
    5234              : 
    5235              : gfc_expr *
    5236           50 : gfc_simplify_lgamma (gfc_expr *x)
    5237              : {
    5238           50 :   gfc_expr *result;
    5239           50 :   int sg;
    5240              : 
    5241           50 :   if (x->expr_type != EXPR_CONSTANT)
    5242              :     return NULL;
    5243              : 
    5244           42 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    5245           42 :   mpfr_lgamma (result->value.real, &sg, x->value.real, GFC_RND_MODE);
    5246              : 
    5247           42 :   return range_check (result, "LGAMMA");
    5248              : }
    5249              : 
    5250              : 
    5251              : gfc_expr *
    5252           55 : gfc_simplify_lge (gfc_expr *a, gfc_expr *b)
    5253              : {
    5254           55 :   if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
    5255              :     return NULL;
    5256              : 
    5257            1 :   return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    5258            2 :                                gfc_compare_string (a, b) >= 0);
    5259              : }
    5260              : 
    5261              : 
    5262              : gfc_expr *
    5263           81 : gfc_simplify_lgt (gfc_expr *a, gfc_expr *b)
    5264              : {
    5265           81 :   if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
    5266              :     return NULL;
    5267              : 
    5268            1 :   return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    5269            2 :                                gfc_compare_string (a, b) > 0);
    5270              : }
    5271              : 
    5272              : 
    5273              : gfc_expr *
    5274           64 : gfc_simplify_lle (gfc_expr *a, gfc_expr *b)
    5275              : {
    5276           64 :   if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
    5277              :     return NULL;
    5278              : 
    5279            1 :   return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    5280            2 :                                gfc_compare_string (a, b) <= 0);
    5281              : }
    5282              : 
    5283              : 
    5284              : gfc_expr *
    5285           72 : gfc_simplify_llt (gfc_expr *a, gfc_expr *b)
    5286              : {
    5287           72 :   if (a->expr_type != EXPR_CONSTANT || b->expr_type != EXPR_CONSTANT)
    5288              :     return NULL;
    5289              : 
    5290            1 :   return gfc_get_logical_expr (gfc_default_logical_kind, &a->where,
    5291            2 :                                gfc_compare_string (a, b) < 0);
    5292              : }
    5293              : 
    5294              : 
    5295              : gfc_expr *
    5296          494 : gfc_simplify_log (gfc_expr *x)
    5297              : {
    5298          494 :   gfc_expr *result;
    5299              : 
    5300          494 :   if (x->expr_type != EXPR_CONSTANT)
    5301              :     return NULL;
    5302              : 
    5303          229 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    5304              : 
    5305          229 :   switch (x->ts.type)
    5306              :     {
    5307          106 :     case BT_REAL:
    5308          106 :       if (mpfr_sgn (x->value.real) <= 0)
    5309              :         {
    5310            0 :           gfc_error ("Argument of LOG at %L cannot be less than or equal "
    5311              :                      "to zero", &x->where);
    5312            0 :           gfc_free_expr (result);
    5313            0 :           return &gfc_bad_expr;
    5314              :         }
    5315              : 
    5316          106 :       mpfr_log (result->value.real, x->value.real, GFC_RND_MODE);
    5317          106 :       break;
    5318              : 
    5319          123 :     case BT_COMPLEX:
    5320          123 :       if (mpfr_zero_p (mpc_realref (x->value.complex))
    5321            0 :           && mpfr_zero_p (mpc_imagref (x->value.complex)))
    5322              :         {
    5323            0 :           gfc_error ("Complex argument of LOG at %L cannot be zero",
    5324              :                      &x->where);
    5325            0 :           gfc_free_expr (result);
    5326            0 :           return &gfc_bad_expr;
    5327              :         }
    5328              : 
    5329          123 :       gfc_set_model_kind (x->ts.kind);
    5330          123 :       mpc_log (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    5331          123 :       break;
    5332              : 
    5333            0 :     default:
    5334            0 :       gfc_internal_error ("gfc_simplify_log: bad type");
    5335              :     }
    5336              : 
    5337          229 :   return range_check (result, "LOG");
    5338              : }
    5339              : 
    5340              : 
    5341              : gfc_expr *
    5342          328 : gfc_simplify_log10 (gfc_expr *x)
    5343              : {
    5344          328 :   gfc_expr *result;
    5345              : 
    5346          328 :   if (x->expr_type != EXPR_CONSTANT)
    5347              :     return NULL;
    5348              : 
    5349           82 :   if (mpfr_sgn (x->value.real) <= 0)
    5350              :     {
    5351            0 :       gfc_error ("Argument of LOG10 at %L cannot be less than or equal "
    5352              :                  "to zero", &x->where);
    5353            0 :       return &gfc_bad_expr;
    5354              :     }
    5355              : 
    5356           82 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    5357           82 :   mpfr_log10 (result->value.real, x->value.real, GFC_RND_MODE);
    5358              : 
    5359           82 :   return range_check (result, "LOG10");
    5360              : }
    5361              : 
    5362              : 
    5363              : gfc_expr *
    5364           52 : gfc_simplify_logical (gfc_expr *e, gfc_expr *k)
    5365              : {
    5366           52 :   int kind;
    5367              : 
    5368           52 :   kind = get_kind (BT_LOGICAL, k, "LOGICAL", gfc_default_logical_kind);
    5369           52 :   if (kind < 0)
    5370              :     return &gfc_bad_expr;
    5371              : 
    5372           52 :   if (e->expr_type != EXPR_CONSTANT)
    5373              :     return NULL;
    5374              : 
    5375            4 :   return gfc_get_logical_expr (kind, &e->where, e->value.logical);
    5376              : }
    5377              : 
    5378              : 
    5379              : gfc_expr*
    5380         1166 : gfc_simplify_matmul (gfc_expr *matrix_a, gfc_expr *matrix_b)
    5381              : {
    5382         1166 :   gfc_expr *result;
    5383         1166 :   int row, result_rows, col, result_columns;
    5384         1166 :   int stride_a, offset_a, stride_b, offset_b;
    5385              : 
    5386         1166 :   if (!is_constant_array_expr (matrix_a)
    5387         1166 :       || !is_constant_array_expr (matrix_b))
    5388              :     return NULL;
    5389              : 
    5390              :   /* MATMUL should do mixed-mode arithmetic.  Set the result type.  */
    5391           63 :   if (matrix_a->ts.type != matrix_b->ts.type)
    5392              :     {
    5393           12 :       gfc_expr e;
    5394           12 :       e.expr_type = EXPR_OP;
    5395           12 :       gfc_clear_ts (&e.ts);
    5396           12 :       e.value.op.op = INTRINSIC_NONE;
    5397           12 :       e.value.op.op1 = matrix_a;
    5398           12 :       e.value.op.op2 = matrix_b;
    5399           12 :       gfc_type_convert_binary (&e, 1);
    5400           12 :       result = gfc_get_array_expr (e.ts.type, e.ts.kind, &matrix_a->where);
    5401              :     }
    5402              :   else
    5403              :     {
    5404           51 :       result = gfc_get_array_expr (matrix_a->ts.type, matrix_a->ts.kind,
    5405              :                                    &matrix_a->where);
    5406              :     }
    5407              : 
    5408           63 :   if (matrix_a->rank == 1 && matrix_b->rank == 2)
    5409              :     {
    5410            7 :       result_rows = 1;
    5411            7 :       result_columns = mpz_get_si (matrix_b->shape[1]);
    5412            7 :       stride_a = 1;
    5413            7 :       stride_b = mpz_get_si (matrix_b->shape[0]);
    5414              : 
    5415            7 :       result->rank = 1;
    5416            7 :       result->shape = gfc_get_shape (result->rank);
    5417            7 :       mpz_init_set_si (result->shape[0], result_columns);
    5418              :     }
    5419           56 :   else if (matrix_a->rank == 2 && matrix_b->rank == 1)
    5420              :     {
    5421            6 :       result_rows = mpz_get_si (matrix_a->shape[0]);
    5422            6 :       result_columns = 1;
    5423            6 :       stride_a = mpz_get_si (matrix_a->shape[0]);
    5424            6 :       stride_b = 1;
    5425              : 
    5426            6 :       result->rank = 1;
    5427            6 :       result->shape = gfc_get_shape (result->rank);
    5428            6 :       mpz_init_set_si (result->shape[0], result_rows);
    5429              :     }
    5430           50 :   else if (matrix_a->rank == 2 && matrix_b->rank == 2)
    5431              :     {
    5432           50 :       result_rows = mpz_get_si (matrix_a->shape[0]);
    5433           50 :       result_columns = mpz_get_si (matrix_b->shape[1]);
    5434           50 :       stride_a = mpz_get_si (matrix_a->shape[0]);
    5435           50 :       stride_b = mpz_get_si (matrix_b->shape[0]);
    5436              : 
    5437           50 :       result->rank = 2;
    5438           50 :       result->shape = gfc_get_shape (result->rank);
    5439           50 :       mpz_init_set_si (result->shape[0], result_rows);
    5440           50 :       mpz_init_set_si (result->shape[1], result_columns);
    5441              :     }
    5442              :   else
    5443            0 :     gcc_unreachable();
    5444              : 
    5445           63 :   offset_b = 0;
    5446          223 :   for (col = 0; col < result_columns; ++col)
    5447              :     {
    5448              :       offset_a = 0;
    5449              : 
    5450          578 :       for (row = 0; row < result_rows; ++row)
    5451              :         {
    5452          418 :           gfc_expr *e = compute_dot_product (matrix_a, stride_a, offset_a,
    5453              :                                              matrix_b, 1, offset_b, false);
    5454          418 :           gfc_constructor_append_expr (&result->value.constructor,
    5455              :                                        e, NULL);
    5456              : 
    5457          418 :           offset_a += 1;
    5458              :         }
    5459              : 
    5460          160 :       offset_b += stride_b;
    5461              :     }
    5462              : 
    5463              :   return result;
    5464              : }
    5465              : 
    5466              : 
    5467              : gfc_expr *
    5468          285 : gfc_simplify_maskr (gfc_expr *i, gfc_expr *kind_arg)
    5469              : {
    5470          285 :   gfc_expr *result;
    5471          285 :   int kind, arg, k;
    5472              : 
    5473          285 :   if (i->expr_type != EXPR_CONSTANT)
    5474              :     return NULL;
    5475              : 
    5476          213 :   kind = get_kind (BT_INTEGER, kind_arg, "MASKR", gfc_default_integer_kind);
    5477          213 :   if (kind == -1)
    5478              :     return &gfc_bad_expr;
    5479          213 :   k = gfc_validate_kind (BT_INTEGER, kind, false);
    5480              : 
    5481          213 :   bool fail = gfc_extract_int (i, &arg);
    5482          213 :   gcc_assert (!fail);
    5483              : 
    5484          213 :   if (!gfc_check_mask (i, kind_arg))
    5485              :     return &gfc_bad_expr;
    5486              : 
    5487          211 :   result = gfc_get_constant_expr (BT_INTEGER, kind, &i->where);
    5488              : 
    5489              :   /* MASKR(n) = 2^n - 1 */
    5490          211 :   mpz_set_ui (result->value.integer, 1);
    5491          211 :   mpz_mul_2exp (result->value.integer, result->value.integer, arg);
    5492          211 :   mpz_sub_ui (result->value.integer, result->value.integer, 1);
    5493              : 
    5494          211 :   gfc_convert_mpz_to_signed (result->value.integer, gfc_integer_kinds[k].bit_size);
    5495              : 
    5496          211 :   return result;
    5497              : }
    5498              : 
    5499              : 
    5500              : gfc_expr *
    5501          297 : gfc_simplify_maskl (gfc_expr *i, gfc_expr *kind_arg)
    5502              : {
    5503          297 :   gfc_expr *result;
    5504          297 :   int kind, arg, k;
    5505          297 :   mpz_t z;
    5506              : 
    5507          297 :   if (i->expr_type != EXPR_CONSTANT)
    5508              :     return NULL;
    5509              : 
    5510          217 :   kind = get_kind (BT_INTEGER, kind_arg, "MASKL", gfc_default_integer_kind);
    5511          217 :   if (kind == -1)
    5512              :     return &gfc_bad_expr;
    5513          217 :   k = gfc_validate_kind (BT_INTEGER, kind, false);
    5514              : 
    5515          217 :   bool fail = gfc_extract_int (i, &arg);
    5516          217 :   gcc_assert (!fail);
    5517              : 
    5518          217 :   if (!gfc_check_mask (i, kind_arg))
    5519              :     return &gfc_bad_expr;
    5520              : 
    5521          213 :   result = gfc_get_constant_expr (BT_INTEGER, kind, &i->where);
    5522              : 
    5523              :   /* MASKL(n) = 2^bit_size - 2^(bit_size - n) */
    5524          213 :   mpz_init_set_ui (z, 1);
    5525          213 :   mpz_mul_2exp (z, z, gfc_integer_kinds[k].bit_size);
    5526          213 :   mpz_set_ui (result->value.integer, 1);
    5527          213 :   mpz_mul_2exp (result->value.integer, result->value.integer,
    5528          213 :                 gfc_integer_kinds[k].bit_size - arg);
    5529          213 :   mpz_sub (result->value.integer, z, result->value.integer);
    5530          213 :   mpz_clear (z);
    5531              : 
    5532          213 :   gfc_convert_mpz_to_signed (result->value.integer, gfc_integer_kinds[k].bit_size);
    5533              : 
    5534          213 :   return result;
    5535              : }
    5536              : 
    5537              : /* Similar to gfc_simplify_maskr, but code paths are different enough to make
    5538              :    this into a separate function.  */
    5539              : 
    5540              : gfc_expr *
    5541           24 : gfc_simplify_umaskr (gfc_expr *i, gfc_expr *kind_arg)
    5542              : {
    5543           24 :   gfc_expr *result;
    5544           24 :   int kind, arg, k;
    5545              : 
    5546           24 :   if (i->expr_type != EXPR_CONSTANT)
    5547              :     return NULL;
    5548              : 
    5549           24 :   kind = get_kind (BT_UNSIGNED, kind_arg, "UMASKR", gfc_default_unsigned_kind);
    5550           24 :   if (kind == -1)
    5551              :     return &gfc_bad_expr;
    5552           24 :   k = gfc_validate_kind (BT_UNSIGNED, kind, false);
    5553              : 
    5554           24 :   bool fail = gfc_extract_int (i, &arg);
    5555           24 :   gcc_assert (!fail);
    5556              : 
    5557           24 :   if (!gfc_check_mask (i, kind_arg))
    5558              :     return &gfc_bad_expr;
    5559              : 
    5560           24 :   result = gfc_get_constant_expr (BT_UNSIGNED, kind, &i->where);
    5561              : 
    5562              :   /* MASKR(n) = 2^n - 1 */
    5563           24 :   mpz_set_ui (result->value.integer, 1);
    5564           24 :   mpz_mul_2exp (result->value.integer, result->value.integer, arg);
    5565           24 :   mpz_sub_ui (result->value.integer, result->value.integer, 1);
    5566              : 
    5567           24 :   gfc_convert_mpz_to_unsigned (result->value.integer,
    5568              :                                gfc_unsigned_kinds[k].bit_size,
    5569              :                                false);
    5570              : 
    5571           24 :   return result;
    5572              : }
    5573              : 
    5574              : /* Likewise, similar to gfc_simplify_maskl.  */
    5575              : 
    5576              : gfc_expr *
    5577           24 : gfc_simplify_umaskl (gfc_expr *i, gfc_expr *kind_arg)
    5578              : {
    5579           24 :   gfc_expr *result;
    5580           24 :   int kind, arg, k;
    5581           24 :   mpz_t z;
    5582              : 
    5583           24 :   if (i->expr_type != EXPR_CONSTANT)
    5584              :     return NULL;
    5585              : 
    5586           24 :   kind = get_kind (BT_UNSIGNED, kind_arg, "UMASKL", gfc_default_integer_kind);
    5587           24 :   if (kind == -1)
    5588              :     return &gfc_bad_expr;
    5589           24 :   k = gfc_validate_kind (BT_UNSIGNED, kind, false);
    5590              : 
    5591           24 :   bool fail = gfc_extract_int (i, &arg);
    5592           24 :   gcc_assert (!fail);
    5593              : 
    5594           24 :   if (!gfc_check_mask (i, kind_arg))
    5595              :     return &gfc_bad_expr;
    5596              : 
    5597           24 :   result = gfc_get_constant_expr (BT_UNSIGNED, kind, &i->where);
    5598              : 
    5599              :   /* MASKL(n) = 2^bit_size - 2^(bit_size - n) */
    5600           24 :   mpz_init_set_ui (z, 1);
    5601           24 :   mpz_mul_2exp (z, z, gfc_unsigned_kinds[k].bit_size);
    5602           24 :   mpz_set_ui (result->value.integer, 1);
    5603           24 :   mpz_mul_2exp (result->value.integer, result->value.integer,
    5604           24 :                 gfc_integer_kinds[k].bit_size - arg);
    5605           24 :   mpz_sub (result->value.integer, z, result->value.integer);
    5606           24 :   mpz_clear (z);
    5607              : 
    5608           24 :   gfc_convert_mpz_to_unsigned (result->value.integer,
    5609              :                                gfc_unsigned_kinds[k].bit_size,
    5610              :                                false);
    5611              : 
    5612           24 :   return result;
    5613              : }
    5614              : 
    5615              : 
    5616              : gfc_expr *
    5617         4086 : gfc_simplify_merge (gfc_expr *tsource, gfc_expr *fsource, gfc_expr *mask)
    5618              : {
    5619         4086 :   gfc_expr * result;
    5620         4086 :   gfc_constructor *tsource_ctor, *fsource_ctor, *mask_ctor;
    5621              : 
    5622         4086 :   if (mask->expr_type == EXPR_CONSTANT)
    5623              :     {
    5624              :       /* The standard requires evaluation of all function arguments.
    5625              :          Simplify only when the other dropped argument (FSOURCE or TSOURCE)
    5626              :          is a constant expression.  */
    5627          702 :       if (mask->value.logical)
    5628              :         {
    5629          485 :           if (!gfc_is_constant_expr (fsource))
    5630              :             return NULL;
    5631          171 :           result = gfc_copy_expr (tsource);
    5632              :         }
    5633              :       else
    5634              :         {
    5635          217 :           if (!gfc_is_constant_expr (tsource))
    5636              :             return NULL;
    5637           67 :           result = gfc_copy_expr (fsource);
    5638              :         }
    5639              : 
    5640              :       /* Parenthesis is needed to get lower bounds of 1.  */
    5641          238 :       result = gfc_get_parentheses (result);
    5642          238 :       gfc_simplify_expr (result, 1);
    5643          238 :       return result;
    5644              :     }
    5645              : 
    5646          773 :   if (!mask->rank || !is_constant_array_expr (mask)
    5647         3431 :       || !is_constant_array_expr (tsource) || !is_constant_array_expr (fsource))
    5648              :     return NULL;
    5649              : 
    5650           19 :   result = gfc_get_array_expr (tsource->ts.type, tsource->ts.kind,
    5651              :                                &tsource->where);
    5652           19 :   if (tsource->ts.type == BT_DERIVED)
    5653            1 :     result->ts.u.derived = tsource->ts.u.derived;
    5654           18 :   else if (tsource->ts.type == BT_CHARACTER)
    5655            6 :     result->ts.u.cl = tsource->ts.u.cl;
    5656              : 
    5657           19 :   tsource_ctor = gfc_constructor_first (tsource->value.constructor);
    5658           19 :   fsource_ctor = gfc_constructor_first (fsource->value.constructor);
    5659           19 :   mask_ctor = gfc_constructor_first (mask->value.constructor);
    5660              : 
    5661           87 :   while (mask_ctor)
    5662              :     {
    5663           49 :       if (mask_ctor->expr->value.logical)
    5664           31 :         gfc_constructor_append_expr (&result->value.constructor,
    5665              :                                      gfc_copy_expr (tsource_ctor->expr),
    5666              :                                      NULL);
    5667              :       else
    5668           18 :         gfc_constructor_append_expr (&result->value.constructor,
    5669              :                                      gfc_copy_expr (fsource_ctor->expr),
    5670              :                                      NULL);
    5671           49 :       tsource_ctor = gfc_constructor_next (tsource_ctor);
    5672           49 :       fsource_ctor = gfc_constructor_next (fsource_ctor);
    5673           49 :       mask_ctor = gfc_constructor_next (mask_ctor);
    5674              :     }
    5675              : 
    5676           19 :   result->shape = gfc_get_shape (1);
    5677           19 :   gfc_array_size (result, &result->shape[0]);
    5678              : 
    5679           19 :   return result;
    5680              : }
    5681              : 
    5682              : 
    5683              : gfc_expr *
    5684          390 : gfc_simplify_merge_bits (gfc_expr *i, gfc_expr *j, gfc_expr *mask_expr)
    5685              : {
    5686          390 :   mpz_t arg1, arg2, mask;
    5687          390 :   gfc_expr *result;
    5688              : 
    5689          390 :   if (i->expr_type != EXPR_CONSTANT || j->expr_type != EXPR_CONSTANT
    5690          294 :       || mask_expr->expr_type != EXPR_CONSTANT)
    5691              :     return NULL;
    5692              : 
    5693          294 :   result = gfc_get_constant_expr (i->ts.type, i->ts.kind, &i->where);
    5694              : 
    5695              :   /* Convert all argument to unsigned.  */
    5696          294 :   mpz_init_set (arg1, i->value.integer);
    5697          294 :   mpz_init_set (arg2, j->value.integer);
    5698          294 :   mpz_init_set (mask, mask_expr->value.integer);
    5699              : 
    5700              :   /* MERGE_BITS(I,J,MASK) = IOR (IAND (I, MASK), IAND (J, NOT (MASK))).  */
    5701          294 :   mpz_and (arg1, arg1, mask);
    5702          294 :   mpz_com (mask, mask);
    5703          294 :   mpz_and (arg2, arg2, mask);
    5704          294 :   mpz_ior (result->value.integer, arg1, arg2);
    5705              : 
    5706          294 :   mpz_clear (arg1);
    5707          294 :   mpz_clear (arg2);
    5708          294 :   mpz_clear (mask);
    5709              : 
    5710          294 :   return result;
    5711              : }
    5712              : 
    5713              : 
    5714              : /* Selects between current value and extremum for simplify_min_max
    5715              :    and simplify_minval_maxval.  */
    5716              : static int
    5717         3196 : min_max_choose (gfc_expr *arg, gfc_expr *extremum, int sign, bool back_val)
    5718              : {
    5719         3196 :   int ret;
    5720              : 
    5721         3196 :   switch (arg->ts.type)
    5722              :     {
    5723         2101 :       case BT_INTEGER:
    5724         2101 :       case BT_UNSIGNED:
    5725         2101 :         if (extremum->ts.kind < arg->ts.kind)
    5726            1 :           extremum->ts.kind = arg->ts.kind;
    5727         2101 :         ret = mpz_cmp (arg->value.integer,
    5728         2101 :                        extremum->value.integer) * sign;
    5729         2101 :         if (ret > 0)
    5730         1278 :           mpz_set (extremum->value.integer, arg->value.integer);
    5731              :         break;
    5732              : 
    5733          598 :       case BT_REAL:
    5734          598 :         if (extremum->ts.kind < arg->ts.kind)
    5735           25 :           extremum->ts.kind = arg->ts.kind;
    5736          598 :         if (mpfr_nan_p (extremum->value.real))
    5737              :           {
    5738          192 :             ret = 1;
    5739          192 :             mpfr_set (extremum->value.real, arg->value.real, GFC_RND_MODE);
    5740              :           }
    5741          406 :         else if (mpfr_nan_p (arg->value.real))
    5742              :           ret = -1;
    5743              :         else
    5744              :           {
    5745          286 :             ret = mpfr_cmp (arg->value.real, extremum->value.real) * sign;
    5746          286 :             if (ret > 0)
    5747          140 :               mpfr_set (extremum->value.real, arg->value.real, GFC_RND_MODE);
    5748              :           }
    5749              :         break;
    5750              : 
    5751          497 :       case BT_CHARACTER:
    5752              : #define LENGTH(x) ((x)->value.character.length)
    5753              : #define STRING(x) ((x)->value.character.string)
    5754          497 :         if (LENGTH (extremum) < LENGTH(arg))
    5755              :           {
    5756           12 :             gfc_char_t *tmp = STRING(extremum);
    5757              : 
    5758           12 :             STRING(extremum) = gfc_get_wide_string (LENGTH(arg) + 1);
    5759           12 :             memcpy (STRING(extremum), tmp,
    5760           12 :                       LENGTH(extremum) * sizeof (gfc_char_t));
    5761           12 :             gfc_wide_memset (&STRING(extremum)[LENGTH(extremum)], ' ',
    5762           12 :                                LENGTH(arg) - LENGTH(extremum));
    5763           12 :             STRING(extremum)[LENGTH(arg)] = '\0';  /* For debugger  */
    5764           12 :             LENGTH(extremum) = LENGTH(arg);
    5765           12 :             free (tmp);
    5766              :           }
    5767          497 :         ret = gfc_compare_string (arg, extremum) * sign;
    5768          497 :         if (ret > 0)
    5769              :           {
    5770          187 :             free (STRING(extremum));
    5771          187 :             STRING(extremum) = gfc_get_wide_string (LENGTH(extremum) + 1);
    5772          187 :             memcpy (STRING(extremum), STRING(arg),
    5773          187 :                       LENGTH(arg) * sizeof (gfc_char_t));
    5774          187 :             gfc_wide_memset (&STRING(extremum)[LENGTH(arg)], ' ',
    5775          187 :                                LENGTH(extremum) - LENGTH(arg));
    5776          187 :             STRING(extremum)[LENGTH(extremum)] = '\0';  /* For debugger  */
    5777              :           }
    5778              : #undef LENGTH
    5779              : #undef STRING
    5780              :         break;
    5781              : 
    5782            0 :       default:
    5783            0 :         gfc_internal_error ("simplify_min_max(): Bad type in arglist");
    5784              :     }
    5785         3196 :   if (back_val && ret == 0)
    5786           59 :     ret = 1;
    5787              : 
    5788         3196 :   return ret;
    5789              : }
    5790              : 
    5791              : 
    5792              : /* This function is special since MAX() can take any number of
    5793              :    arguments.  The simplified expression is a rewritten version of the
    5794              :    argument list containing at most one constant element.  Other
    5795              :    constant elements are deleted.  Because the argument list has
    5796              :    already been checked, this function always succeeds.  sign is 1 for
    5797              :    MAX(), -1 for MIN().  */
    5798              : 
    5799              : static gfc_expr *
    5800         6190 : simplify_min_max (gfc_expr *expr, int sign)
    5801              : {
    5802         6190 :   int tmp1, tmp2;
    5803         6190 :   gfc_actual_arglist *arg, *last, *extremum;
    5804         6190 :   gfc_expr *tmp, *ret;
    5805         6190 :   const char *fname;
    5806              : 
    5807         6190 :   last = NULL;
    5808         6190 :   extremum = NULL;
    5809              : 
    5810         6190 :   arg = expr->value.function.actual;
    5811              : 
    5812        19846 :   for (; arg; last = arg, arg = arg->next)
    5813              :     {
    5814        13656 :       if (arg->expr->expr_type != EXPR_CONSTANT)
    5815         8099 :         continue;
    5816              : 
    5817         5557 :       if (extremum == NULL)
    5818              :         {
    5819         3492 :           extremum = arg;
    5820         3492 :           continue;
    5821              :         }
    5822              : 
    5823         2065 :       min_max_choose (arg->expr, extremum->expr, sign);
    5824              : 
    5825              :       /* Delete the extra constant argument.  */
    5826         2065 :       last->next = arg->next;
    5827              : 
    5828         2065 :       arg->next = NULL;
    5829         2065 :       gfc_free_actual_arglist (arg);
    5830         2065 :       arg = last;
    5831              :     }
    5832              : 
    5833              :   /* If there is one value left, replace the function call with the
    5834              :      expression.  */
    5835         6190 :   if (expr->value.function.actual->next != NULL)
    5836              :     return NULL;
    5837              : 
    5838              :   /* Handle special cases of specific functions (min|max)1 and
    5839              :      a(min|max)0.  */
    5840              : 
    5841         1684 :   tmp = expr->value.function.actual->expr;
    5842         1684 :   fname = expr->value.function.isym->name;
    5843              : 
    5844         1684 :   if ((tmp->ts.type != BT_INTEGER || tmp->ts.kind != gfc_integer_4_kind)
    5845          582 :       && (strcmp (fname, "min1") == 0 || strcmp (fname, "max1") == 0))
    5846              :     {
    5847              :       /* Explicit conversion, turn off -Wconversion and -Wconversion-extra
    5848              :          warnings.  */
    5849           15 :       tmp1 = warn_conversion;
    5850           15 :       tmp2 = warn_conversion_extra;
    5851           15 :       warn_conversion = warn_conversion_extra = 0;
    5852              : 
    5853           15 :       ret = gfc_convert_constant (tmp, BT_INTEGER, gfc_integer_4_kind);
    5854              : 
    5855           15 :       warn_conversion = tmp1;
    5856           15 :       warn_conversion_extra = tmp2;
    5857              :     }
    5858         1669 :   else if ((tmp->ts.type != BT_REAL || tmp->ts.kind != gfc_real_4_kind)
    5859         1452 :            && (strcmp (fname, "amin0") == 0 || strcmp (fname, "amax0") == 0))
    5860              :     {
    5861           15 :       ret = gfc_convert_constant (tmp, BT_REAL, gfc_real_4_kind);
    5862              :     }
    5863              :   else
    5864         1654 :     ret = gfc_copy_expr (tmp);
    5865              : 
    5866              :   return ret;
    5867              : 
    5868              : }
    5869              : 
    5870              : 
    5871              : gfc_expr *
    5872         2055 : gfc_simplify_min (gfc_expr *e)
    5873              : {
    5874         2055 :   return simplify_min_max (e, -1);
    5875              : }
    5876              : 
    5877              : 
    5878              : gfc_expr *
    5879         4135 : gfc_simplify_max (gfc_expr *e)
    5880              : {
    5881         4135 :   return simplify_min_max (e, 1);
    5882              : }
    5883              : 
    5884              : /* Helper function for gfc_simplify_minval.  */
    5885              : 
    5886              : static gfc_expr *
    5887          295 : gfc_min (gfc_expr *op1, gfc_expr *op2)
    5888              : {
    5889          295 :   min_max_choose (op1, op2, -1);
    5890          295 :   gfc_free_expr (op1);
    5891          295 :   return op2;
    5892              : }
    5893              : 
    5894              : /* Simplify minval for constant arrays.  */
    5895              : 
    5896              : gfc_expr *
    5897         3981 : gfc_simplify_minval (gfc_expr *array, gfc_expr* dim, gfc_expr *mask)
    5898              : {
    5899         3981 :   return simplify_transformation (array, dim, mask, INT_MAX, gfc_min);
    5900              : }
    5901              : 
    5902              : /* Helper function for gfc_simplify_maxval.  */
    5903              : 
    5904              : static gfc_expr *
    5905          271 : gfc_max (gfc_expr *op1, gfc_expr *op2)
    5906              : {
    5907          271 :   min_max_choose (op1, op2, 1);
    5908          271 :   gfc_free_expr (op1);
    5909          271 :   return op2;
    5910              : }
    5911              : 
    5912              : 
    5913              : /* Simplify maxval for constant arrays.  */
    5914              : 
    5915              : gfc_expr *
    5916         3013 : gfc_simplify_maxval (gfc_expr *array, gfc_expr* dim, gfc_expr *mask)
    5917              : {
    5918         3013 :   return simplify_transformation (array, dim, mask, INT_MIN, gfc_max);
    5919              : }
    5920              : 
    5921              : 
    5922              : /* Transform minloc or maxloc of an array, according to MASK,
    5923              :    to the scalar result.  This code is mostly identical to
    5924              :    simplify_transformation_to_scalar.  */
    5925              : 
    5926              : static gfc_expr *
    5927           82 : simplify_minmaxloc_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *mask,
    5928              :                               gfc_expr *extremum, int sign, bool back_val)
    5929              : {
    5930           82 :   gfc_expr *a, *m;
    5931           82 :   gfc_constructor *array_ctor, *mask_ctor;
    5932           82 :   mpz_t count;
    5933              : 
    5934           82 :   mpz_set_si (result->value.integer, 0);
    5935              : 
    5936              : 
    5937              :   /* Shortcut for constant .FALSE. MASK.  */
    5938           82 :   if (mask
    5939           42 :       && mask->expr_type == EXPR_CONSTANT
    5940           36 :       && !mask->value.logical)
    5941              :     return result;
    5942              : 
    5943           46 :   array_ctor = gfc_constructor_first (array->value.constructor);
    5944           46 :   if (mask && mask->expr_type == EXPR_ARRAY)
    5945            6 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    5946              :   else
    5947              :     mask_ctor = NULL;
    5948              : 
    5949           46 :   mpz_init_set_si (count, 0);
    5950          216 :   while (array_ctor)
    5951              :     {
    5952          124 :       mpz_add_ui (count, count, 1);
    5953          124 :       a = array_ctor->expr;
    5954          124 :       array_ctor = gfc_constructor_next (array_ctor);
    5955              :       /* A constant MASK equals .TRUE. here and can be ignored.  */
    5956          124 :       if (mask_ctor)
    5957              :         {
    5958           28 :           m = mask_ctor->expr;
    5959           28 :           mask_ctor = gfc_constructor_next (mask_ctor);
    5960           28 :           if (!m->value.logical)
    5961           12 :             continue;
    5962              :         }
    5963          112 :       if (min_max_choose (a, extremum, sign, back_val) > 0)
    5964           60 :         mpz_set (result->value.integer, count);
    5965              :     }
    5966           46 :   mpz_clear (count);
    5967           46 :   gfc_free_expr (extremum);
    5968           46 :   return result;
    5969              : }
    5970              : 
    5971              : /* Simplify minloc / maxloc in the absence of a dim argument.  */
    5972              : 
    5973              : static gfc_expr *
    5974           69 : simplify_minmaxloc_nodim (gfc_expr *result, gfc_expr *extremum,
    5975              :                           gfc_expr *array, gfc_expr *mask, int sign,
    5976              :                           bool back_val)
    5977              : {
    5978           69 :   ssize_t res[GFC_MAX_DIMENSIONS];
    5979           69 :   int i, n;
    5980           69 :   gfc_constructor *result_ctor, *array_ctor, *mask_ctor;
    5981           69 :   ssize_t count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    5982              :     sstride[GFC_MAX_DIMENSIONS];
    5983           69 :   gfc_expr *a, *m;
    5984           69 :   bool continue_loop;
    5985           69 :   bool ma;
    5986              : 
    5987          154 :   for (i = 0; i<array->rank; i++)
    5988           85 :     res[i] = -1;
    5989              : 
    5990              :   /* Shortcut for constant .FALSE. MASK.  */
    5991           69 :   if (mask
    5992           56 :       && mask->expr_type == EXPR_CONSTANT
    5993           40 :       && !mask->value.logical)
    5994           38 :     goto finish;
    5995              : 
    5996           31 :   if (array->shape == NULL)
    5997            1 :     goto finish;
    5998              : 
    5999           66 :   for (i = 0; i < array->rank; i++)
    6000              :     {
    6001           44 :       count[i] = 0;
    6002           44 :       sstride[i] = (i == 0) ? 1 : sstride[i-1] * mpz_get_si (array->shape[i-1]);
    6003           44 :       extent[i] = mpz_get_si (array->shape[i]);
    6004           44 :       if (extent[i] <= 0)
    6005            8 :         goto finish;
    6006              :     }
    6007              : 
    6008           22 :   continue_loop = true;
    6009           22 :   array_ctor = gfc_constructor_first (array->value.constructor);
    6010           22 :   if (mask && mask->rank > 0)
    6011           12 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    6012              :   else
    6013           22 :     mask_ctor = NULL;
    6014              : 
    6015              :   /* Loop over the array elements (and mask), keeping track of
    6016              :      the indices to return.  */
    6017           66 :   while (continue_loop)
    6018              :     {
    6019          120 :       do
    6020              :         {
    6021          120 :           a = array_ctor->expr;
    6022          120 :           if (mask_ctor)
    6023              :             {
    6024           46 :               m = mask_ctor->expr;
    6025           46 :               ma = m->value.logical;
    6026           46 :               mask_ctor = gfc_constructor_next (mask_ctor);
    6027              :             }
    6028              :           else
    6029              :             ma = true;
    6030              : 
    6031          120 :           if (ma && min_max_choose (a, extremum, sign, back_val) > 0)
    6032              :             {
    6033          130 :               for (i = 0; i<array->rank; i++)
    6034           86 :                 res[i] = count[i];
    6035              :             }
    6036          120 :           array_ctor = gfc_constructor_next (array_ctor);
    6037          120 :           count[0] ++;
    6038          120 :         } while (count[0] != extent[0]);
    6039              :       n = 0;
    6040           58 :       do
    6041              :         {
    6042              :           /* When we get to the end of a dimension, reset it and increment
    6043              :              the next dimension.  */
    6044           58 :           count[n] = 0;
    6045           58 :           n++;
    6046           58 :           if (n >= array->rank)
    6047              :             {
    6048              :               continue_loop = false;
    6049              :               break;
    6050              :             }
    6051              :           else
    6052           36 :             count[n] ++;
    6053           36 :         } while (count[n] == extent[n]);
    6054              :     }
    6055              : 
    6056           22 :  finish:
    6057           69 :   gfc_free_expr (extremum);
    6058           69 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6059          223 :   for (i = 0; i<array->rank; i++)
    6060              :     {
    6061           85 :       gfc_expr *r_expr;
    6062           85 :       r_expr = result_ctor->expr;
    6063           85 :       mpz_set_si (r_expr->value.integer, res[i] + 1);
    6064           85 :       result_ctor = gfc_constructor_next (result_ctor);
    6065              :     }
    6066           69 :   return result;
    6067              : }
    6068              : 
    6069              : /* Helper function for gfc_simplify_minmaxloc - build an array
    6070              :    expression with n elements.  */
    6071              : 
    6072              : static gfc_expr *
    6073          116 : new_array (bt type, int kind, int n, locus *where)
    6074              : {
    6075          116 :   gfc_expr *result;
    6076          116 :   int i;
    6077              : 
    6078          116 :   result = gfc_get_array_expr (type, kind, where);
    6079          116 :   result->rank = 1;
    6080          116 :   result->shape = gfc_get_shape(1);
    6081          116 :   mpz_init_set_si (result->shape[0], n);
    6082          401 :   for (i = 0; i < n; i++)
    6083              :     {
    6084          169 :       gfc_constructor_append_expr (&result->value.constructor,
    6085              :                                    gfc_get_constant_expr (type, kind, where),
    6086              :                                    NULL);
    6087              :     }
    6088              : 
    6089          116 :   return result;
    6090              : }
    6091              : 
    6092              : /* Simplify minloc and maxloc. This code is mostly identical to
    6093              :    simplify_transformation_to_array.  */
    6094              : 
    6095              : static gfc_expr *
    6096           48 : simplify_minmaxloc_to_array (gfc_expr *result, gfc_expr *array,
    6097              :                              gfc_expr *dim, gfc_expr *mask,
    6098              :                              gfc_expr *extremum, int sign, bool back_val)
    6099              : {
    6100           48 :   mpz_t size;
    6101           48 :   int done, i, n, arraysize, resultsize, dim_index, dim_extent, dim_stride;
    6102           48 :   gfc_expr **arrayvec, **resultvec, **base, **src, **dest;
    6103           48 :   gfc_constructor *array_ctor, *mask_ctor, *result_ctor;
    6104              : 
    6105           48 :   int count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    6106              :       sstride[GFC_MAX_DIMENSIONS], dstride[GFC_MAX_DIMENSIONS],
    6107              :       tmpstride[GFC_MAX_DIMENSIONS];
    6108              : 
    6109              :   /* Shortcut for constant .FALSE. MASK.  */
    6110           48 :   if (mask
    6111           10 :       && mask->expr_type == EXPR_CONSTANT
    6112            0 :       && !mask->value.logical)
    6113              :     return result;
    6114              : 
    6115              :   /* Build an indexed table for array element expressions to minimize
    6116              :      linked-list traversal. Masked elements are set to NULL.  */
    6117           48 :   gfc_array_size (array, &size);
    6118           48 :   arraysize = mpz_get_ui (size);
    6119           48 :   mpz_clear (size);
    6120              : 
    6121           48 :   arrayvec = XCNEWVEC (gfc_expr*, arraysize);
    6122              : 
    6123           48 :   array_ctor = gfc_constructor_first (array->value.constructor);
    6124           48 :   mask_ctor = NULL;
    6125           48 :   if (mask && mask->expr_type == EXPR_ARRAY)
    6126           10 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    6127              : 
    6128          474 :   for (i = 0; i < arraysize; ++i)
    6129              :     {
    6130          426 :       arrayvec[i] = array_ctor->expr;
    6131          426 :       array_ctor = gfc_constructor_next (array_ctor);
    6132              : 
    6133          426 :       if (mask_ctor)
    6134              :         {
    6135          106 :           if (!mask_ctor->expr->value.logical)
    6136           65 :             arrayvec[i] = NULL;
    6137              : 
    6138          106 :           mask_ctor = gfc_constructor_next (mask_ctor);
    6139              :         }
    6140              :     }
    6141              : 
    6142              :   /* Same for the result expression.  */
    6143           48 :   gfc_array_size (result, &size);
    6144           48 :   resultsize = mpz_get_ui (size);
    6145           48 :   mpz_clear (size);
    6146              : 
    6147           48 :   resultvec = XCNEWVEC (gfc_expr*, resultsize);
    6148           48 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6149          234 :   for (i = 0; i < resultsize; ++i)
    6150              :     {
    6151          138 :       resultvec[i] = result_ctor->expr;
    6152          138 :       result_ctor = gfc_constructor_next (result_ctor);
    6153              :     }
    6154              : 
    6155           48 :   gfc_extract_int (dim, &dim_index);
    6156           48 :   dim_index -= 1;               /* zero-base index */
    6157           48 :   dim_extent = 0;
    6158           48 :   dim_stride = 0;
    6159              : 
    6160          144 :   for (i = 0, n = 0; i < array->rank; ++i)
    6161              :     {
    6162           96 :       count[i] = 0;
    6163           96 :       tmpstride[i] = (i == 0) ? 1 : tmpstride[i-1] * mpz_get_si (array->shape[i-1]);
    6164           96 :       if (i == dim_index)
    6165              :         {
    6166           48 :           dim_extent = mpz_get_si (array->shape[i]);
    6167           48 :           dim_stride = tmpstride[i];
    6168           48 :           continue;
    6169              :         }
    6170              : 
    6171           48 :       extent[n] = mpz_get_si (array->shape[i]);
    6172           48 :       sstride[n] = tmpstride[i];
    6173           48 :       dstride[n] = (n == 0) ? 1 : dstride[n-1] * extent[n-1];
    6174           48 :       n += 1;
    6175              :     }
    6176              : 
    6177           48 :   done = resultsize <= 0;
    6178           48 :   base = arrayvec;
    6179           48 :   dest = resultvec;
    6180          234 :   while (!done)
    6181              :     {
    6182          138 :       gfc_expr *ex;
    6183          138 :       ex = gfc_copy_expr (extremum);
    6184          702 :       for (src = base, n = 0; n < dim_extent; src += dim_stride, ++n)
    6185              :         {
    6186          426 :           if (*src && min_max_choose (*src, ex, sign, back_val) > 0)
    6187          215 :             mpz_set_si ((*dest)->value.integer, n + 1);
    6188              :         }
    6189              : 
    6190          138 :       count[0]++;
    6191          138 :       base += sstride[0];
    6192          138 :       dest += dstride[0];
    6193          138 :       gfc_free_expr (ex);
    6194              : 
    6195          138 :       n = 0;
    6196          276 :       while (!done && count[n] == extent[n])
    6197              :         {
    6198           46 :           count[n] = 0;
    6199           46 :           base -= sstride[n] * extent[n];
    6200           46 :           dest -= dstride[n] * extent[n];
    6201              : 
    6202           46 :           n++;
    6203           46 :           if (n < result->rank)
    6204              :             {
    6205              :               /* If the nested loop is unrolled GFC_MAX_DIMENSIONS
    6206              :                  times, we'd warn for the last iteration, because the
    6207              :                  array index will have already been incremented to the
    6208              :                  array sizes, and we can't tell that this must make
    6209              :                  the test against result->rank false, because ranks
    6210              :                  must not exceed GFC_MAX_DIMENSIONS.  */
    6211            0 :               GCC_DIAGNOSTIC_PUSH_IGNORED (-Warray-bounds)
    6212            0 :               count[n]++;
    6213            0 :               base += sstride[n];
    6214            0 :               dest += dstride[n];
    6215            0 :               GCC_DIAGNOSTIC_POP
    6216              :             }
    6217              :           else
    6218              :             done = true;
    6219              :        }
    6220              :     }
    6221              : 
    6222              :   /* Place updated expression in result constructor.  */
    6223           48 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6224          234 :   for (i = 0; i < resultsize; ++i)
    6225              :     {
    6226          138 :       result_ctor->expr = resultvec[i];
    6227          138 :       result_ctor = gfc_constructor_next (result_ctor);
    6228              :     }
    6229              : 
    6230           48 :   free (arrayvec);
    6231           48 :   free (resultvec);
    6232           48 :   free (extremum);
    6233           48 :   return result;
    6234              : }
    6235              : 
    6236              : /* Simplify minloc and maxloc for constant arrays.  */
    6237              : 
    6238              : static gfc_expr *
    6239        20953 : gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
    6240              :                         gfc_expr *kind, gfc_expr *back, int sign)
    6241              : {
    6242        20953 :   gfc_expr *result;
    6243        20953 :   gfc_expr *extremum;
    6244        20953 :   int ikind;
    6245        20953 :   int init_val;
    6246        20953 :   bool back_val = false;
    6247              : 
    6248        20953 :   if (!is_constant_array_expr (array)
    6249        20953 :       || !gfc_is_constant_expr (dim))
    6250              :     return NULL;
    6251              : 
    6252          307 :   if (mask
    6253          216 :       && !is_constant_array_expr (mask)
    6254          491 :       && mask->expr_type != EXPR_CONSTANT)
    6255              :     return NULL;
    6256              : 
    6257          199 :   if (kind)
    6258              :     {
    6259            0 :       if (gfc_extract_int (kind, &ikind, -1))
    6260              :         return NULL;
    6261              :     }
    6262              :   else
    6263          199 :     ikind = gfc_default_integer_kind;
    6264              : 
    6265          199 :   if (back)
    6266              :     {
    6267          199 :       if (back->expr_type != EXPR_CONSTANT)
    6268              :         return NULL;
    6269              : 
    6270          199 :       back_val = back->value.logical;
    6271              :     }
    6272              : 
    6273          199 :   if (sign < 0)
    6274              :     init_val = INT_MAX;
    6275          101 :   else if (sign > 0)
    6276              :     init_val = INT_MIN;
    6277              :   else
    6278            0 :     gcc_unreachable();
    6279              : 
    6280          199 :   extremum = gfc_get_constant_expr (array->ts.type, array->ts.kind, &array->where);
    6281          199 :   init_result_expr (extremum, init_val, array);
    6282              : 
    6283          199 :   if (dim)
    6284              :     {
    6285          130 :       result = transformational_result (array, dim, BT_INTEGER,
    6286              :                                         ikind, &array->where);
    6287          130 :       init_result_expr (result, 0, array);
    6288              : 
    6289          130 :       if (array->rank == 1)
    6290           82 :         return simplify_minmaxloc_to_scalar (result, array, mask, extremum,
    6291           82 :                                              sign, back_val);
    6292              :       else
    6293           48 :         return simplify_minmaxloc_to_array (result, array, dim, mask, extremum,
    6294           48 :                                             sign, back_val);
    6295              :     }
    6296              :   else
    6297              :     {
    6298           69 :       result = new_array (BT_INTEGER, ikind, array->rank, &array->where);
    6299           69 :       return simplify_minmaxloc_nodim (result, extremum, array, mask,
    6300           69 :                                        sign, back_val);
    6301              :     }
    6302              : }
    6303              : 
    6304              : gfc_expr *
    6305        11258 : gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
    6306              :                      gfc_expr *back)
    6307              : {
    6308        11258 :   return gfc_simplify_minmaxloc (array, dim, mask, kind, back, -1);
    6309              : }
    6310              : 
    6311              : gfc_expr *
    6312         9695 : gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
    6313              :                      gfc_expr *back)
    6314              : {
    6315         9695 :   return gfc_simplify_minmaxloc (array, dim, mask, kind, back, 1);
    6316              : }
    6317              : 
    6318              : /* Simplify findloc to scalar.  Similar to
    6319              :    simplify_minmaxloc_to_scalar.  */
    6320              : 
    6321              : static gfc_expr *
    6322           50 : simplify_findloc_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *value,
    6323              :                             gfc_expr *mask, int back_val)
    6324              : {
    6325           50 :   gfc_expr *a, *m;
    6326           50 :   gfc_constructor *array_ctor, *mask_ctor;
    6327           50 :   mpz_t count;
    6328              : 
    6329           50 :   mpz_set_si (result->value.integer, 0);
    6330              : 
    6331              :   /* Shortcut for constant .FALSE. MASK.  */
    6332           50 :   if (mask
    6333           14 :       && mask->expr_type == EXPR_CONSTANT
    6334            0 :       && !mask->value.logical)
    6335              :     return result;
    6336              : 
    6337           50 :   array_ctor = gfc_constructor_first (array->value.constructor);
    6338           50 :   if (mask && mask->expr_type == EXPR_ARRAY)
    6339           14 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    6340              :   else
    6341              :     mask_ctor = NULL;
    6342              : 
    6343           50 :   mpz_init_set_si (count, 0);
    6344          227 :   while (array_ctor)
    6345              :     {
    6346          156 :       mpz_add_ui (count, count, 1);
    6347          156 :       a = array_ctor->expr;
    6348          156 :       array_ctor = gfc_constructor_next (array_ctor);
    6349              :       /* A constant MASK equals .TRUE. here and can be ignored.  */
    6350          156 :       if (mask_ctor)
    6351              :         {
    6352           56 :           m = mask_ctor->expr;
    6353           56 :           mask_ctor = gfc_constructor_next (mask_ctor);
    6354           56 :           if (!m->value.logical)
    6355           14 :             continue;
    6356              :         }
    6357          142 :       if (gfc_compare_expr (a, value, INTRINSIC_EQ) == 0)
    6358              :         {
    6359              :           /* We have a match.  If BACK is true, continue so we find
    6360              :              the last one.  */
    6361           50 :           mpz_set (result->value.integer, count);
    6362           50 :           if (!back_val)
    6363              :             break;
    6364              :         }
    6365              :     }
    6366           50 :   mpz_clear (count);
    6367           50 :   return result;
    6368              : }
    6369              : 
    6370              : /* Simplify findloc in the absence of a dim argument.  Similar to
    6371              :    simplify_minmaxloc_nodim.  */
    6372              : 
    6373              : static gfc_expr *
    6374           47 : simplify_findloc_nodim (gfc_expr *result, gfc_expr *value, gfc_expr *array,
    6375              :                         gfc_expr *mask, bool back_val)
    6376              : {
    6377           47 :   ssize_t res[GFC_MAX_DIMENSIONS];
    6378           47 :   int i, n;
    6379           47 :   gfc_constructor *result_ctor, *array_ctor, *mask_ctor;
    6380           47 :   ssize_t count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    6381              :     sstride[GFC_MAX_DIMENSIONS];
    6382           47 :   gfc_expr *a, *m;
    6383           47 :   bool continue_loop;
    6384           47 :   bool ma;
    6385              : 
    6386          131 :   for (i = 0; i < array->rank; i++)
    6387           84 :     res[i] = -1;
    6388              : 
    6389              :   /* Shortcut for constant .FALSE. MASK.  */
    6390           47 :   if (mask
    6391            7 :       && mask->expr_type == EXPR_CONSTANT
    6392            0 :       && !mask->value.logical)
    6393            0 :     goto finish;
    6394              : 
    6395          125 :   for (i = 0; i < array->rank; i++)
    6396              :     {
    6397           84 :       count[i] = 0;
    6398           84 :       sstride[i] = (i == 0) ? 1 : sstride[i-1] * mpz_get_si (array->shape[i-1]);
    6399           84 :       extent[i] = mpz_get_si (array->shape[i]);
    6400           84 :       if (extent[i] <= 0)
    6401            6 :         goto finish;
    6402              :     }
    6403              : 
    6404           41 :   continue_loop = true;
    6405           41 :   array_ctor = gfc_constructor_first (array->value.constructor);
    6406           41 :   if (mask && mask->rank > 0)
    6407            7 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    6408              :   else
    6409           41 :     mask_ctor = NULL;
    6410              : 
    6411              :   /* Loop over the array elements (and mask), keeping track of
    6412              :      the indices to return.  */
    6413           93 :   while (continue_loop)
    6414              :     {
    6415          138 :       do
    6416              :         {
    6417          138 :           a = array_ctor->expr;
    6418          138 :           if (mask_ctor)
    6419              :             {
    6420           28 :               m = mask_ctor->expr;
    6421           28 :               ma = m->value.logical;
    6422           28 :               mask_ctor = gfc_constructor_next (mask_ctor);
    6423              :             }
    6424              :           else
    6425              :             ma = true;
    6426              : 
    6427          138 :           if (ma && gfc_compare_expr (a, value, INTRINSIC_EQ) == 0)
    6428              :             {
    6429           73 :               for (i = 0; i < array->rank; i++)
    6430           48 :                 res[i] = count[i];
    6431           25 :               if (!back_val)
    6432           17 :                 goto finish;
    6433              :             }
    6434          121 :           array_ctor = gfc_constructor_next (array_ctor);
    6435          121 :           count[0] ++;
    6436          121 :         } while (count[0] != extent[0]);
    6437              :       n = 0;
    6438           73 :       do
    6439              :         {
    6440              :           /* When we get to the end of a dimension, reset it and increment
    6441              :              the next dimension.  */
    6442           73 :           count[n] = 0;
    6443           73 :           n++;
    6444           73 :           if (n >= array->rank)
    6445              :             {
    6446              :               continue_loop = false;
    6447              :               break;
    6448              :             }
    6449              :           else
    6450           49 :             count[n] ++;
    6451           49 :         } while (count[n] == extent[n]);
    6452              :     }
    6453              : 
    6454           24 : finish:
    6455           47 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6456          178 :   for (i = 0; i < array->rank; i++)
    6457              :     {
    6458           84 :       gfc_expr *r_expr;
    6459           84 :       r_expr = result_ctor->expr;
    6460           84 :       mpz_set_si (r_expr->value.integer, res[i] + 1);
    6461           84 :       result_ctor = gfc_constructor_next (result_ctor);
    6462              :     }
    6463           47 :   return result;
    6464              : }
    6465              : 
    6466              : 
    6467              : /* Simplify findloc to an array.  Similar to
    6468              :    simplify_minmaxloc_to_array.  */
    6469              : 
    6470              : static gfc_expr *
    6471           14 : simplify_findloc_to_array (gfc_expr *result, gfc_expr *array, gfc_expr *value,
    6472              :                            gfc_expr *dim, gfc_expr *mask, bool back_val)
    6473              : {
    6474           14 :   mpz_t size;
    6475           14 :   int done, i, n, arraysize, resultsize, dim_index, dim_extent, dim_stride;
    6476           14 :   gfc_expr **arrayvec, **resultvec, **base, **src, **dest;
    6477           14 :   gfc_constructor *array_ctor, *mask_ctor, *result_ctor;
    6478              : 
    6479           14 :   int count[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS],
    6480              :       sstride[GFC_MAX_DIMENSIONS], dstride[GFC_MAX_DIMENSIONS],
    6481              :       tmpstride[GFC_MAX_DIMENSIONS];
    6482              : 
    6483              :   /* Shortcut for constant .FALSE. MASK.  */
    6484           14 :   if (mask
    6485            0 :       && mask->expr_type == EXPR_CONSTANT
    6486            0 :       && !mask->value.logical)
    6487              :     return result;
    6488              : 
    6489              :   /* Build an indexed table for array element expressions to minimize
    6490              :      linked-list traversal. Masked elements are set to NULL.  */
    6491           14 :   gfc_array_size (array, &size);
    6492           14 :   arraysize = mpz_get_ui (size);
    6493           14 :   mpz_clear (size);
    6494              : 
    6495           14 :   arrayvec = XCNEWVEC (gfc_expr*, arraysize);
    6496              : 
    6497           14 :   array_ctor = gfc_constructor_first (array->value.constructor);
    6498           14 :   mask_ctor = NULL;
    6499           14 :   if (mask && mask->expr_type == EXPR_ARRAY)
    6500            0 :     mask_ctor = gfc_constructor_first (mask->value.constructor);
    6501              : 
    6502           98 :   for (i = 0; i < arraysize; ++i)
    6503              :     {
    6504           84 :       arrayvec[i] = array_ctor->expr;
    6505           84 :       array_ctor = gfc_constructor_next (array_ctor);
    6506              : 
    6507           84 :       if (mask_ctor)
    6508              :         {
    6509            0 :           if (!mask_ctor->expr->value.logical)
    6510            0 :             arrayvec[i] = NULL;
    6511              : 
    6512            0 :           mask_ctor = gfc_constructor_next (mask_ctor);
    6513              :         }
    6514              :     }
    6515              : 
    6516              :   /* Same for the result expression.  */
    6517           14 :   gfc_array_size (result, &size);
    6518           14 :   resultsize = mpz_get_ui (size);
    6519           14 :   mpz_clear (size);
    6520              : 
    6521           14 :   resultvec = XCNEWVEC (gfc_expr*, resultsize);
    6522           14 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6523           63 :   for (i = 0; i < resultsize; ++i)
    6524              :     {
    6525           35 :       resultvec[i] = result_ctor->expr;
    6526           35 :       result_ctor = gfc_constructor_next (result_ctor);
    6527              :     }
    6528              : 
    6529           14 :   gfc_extract_int (dim, &dim_index);
    6530              : 
    6531           14 :   dim_index -= 1;       /* Zero-base index.  */
    6532           14 :   dim_extent = 0;
    6533           14 :   dim_stride = 0;
    6534              : 
    6535           42 :   for (i = 0, n = 0; i < array->rank; ++i)
    6536              :     {
    6537           28 :       count[i] = 0;
    6538           28 :       tmpstride[i] = (i == 0) ? 1 : tmpstride[i-1] * mpz_get_si (array->shape[i-1]);
    6539           28 :       if (i == dim_index)
    6540              :         {
    6541           14 :           dim_extent = mpz_get_si (array->shape[i]);
    6542           14 :           dim_stride = tmpstride[i];
    6543           14 :           continue;
    6544              :         }
    6545              : 
    6546           14 :       extent[n] = mpz_get_si (array->shape[i]);
    6547           14 :       sstride[n] = tmpstride[i];
    6548           14 :       dstride[n] = (n == 0) ? 1 : dstride[n-1] * extent[n-1];
    6549           14 :       n += 1;
    6550              :     }
    6551              : 
    6552           14 :   done = resultsize <= 0;
    6553           14 :   base = arrayvec;
    6554           14 :   dest = resultvec;
    6555           63 :   while (!done)
    6556              :     {
    6557           63 :       for (src = base, n = 0; n < dim_extent; src += dim_stride, ++n)
    6558              :         {
    6559           56 :           if (*src && gfc_compare_expr (*src, value, INTRINSIC_EQ) == 0)
    6560              :             {
    6561           28 :               mpz_set_si ((*dest)->value.integer, n + 1);
    6562           28 :               if (!back_val)
    6563              :                 break;
    6564              :             }
    6565              :         }
    6566              : 
    6567           35 :       count[0]++;
    6568           35 :       base += sstride[0];
    6569           35 :       dest += dstride[0];
    6570              : 
    6571           35 :       n = 0;
    6572           35 :       while (!done && count[n] == extent[n])
    6573              :         {
    6574           14 :           count[n] = 0;
    6575           14 :           base -= sstride[n] * extent[n];
    6576           14 :           dest -= dstride[n] * extent[n];
    6577              : 
    6578           14 :           n++;
    6579           14 :           if (n < result->rank)
    6580              :             {
    6581              :               /* If the nested loop is unrolled GFC_MAX_DIMENSIONS
    6582              :                  times, we'd warn for the last iteration, because the
    6583              :                  array index will have already been incremented to the
    6584              :                  array sizes, and we can't tell that this must make
    6585              :                  the test against result->rank false, because ranks
    6586              :                  must not exceed GFC_MAX_DIMENSIONS.  */
    6587            0 :               GCC_DIAGNOSTIC_PUSH_IGNORED (-Warray-bounds)
    6588            0 :               count[n]++;
    6589            0 :               base += sstride[n];
    6590            0 :               dest += dstride[n];
    6591            0 :               GCC_DIAGNOSTIC_POP
    6592              :             }
    6593              :           else
    6594              :             done = true;
    6595              :        }
    6596              :     }
    6597              : 
    6598              :   /* Place updated expression in result constructor.  */
    6599           14 :   result_ctor = gfc_constructor_first (result->value.constructor);
    6600           63 :   for (i = 0; i < resultsize; ++i)
    6601              :     {
    6602           35 :       result_ctor->expr = resultvec[i];
    6603           35 :       result_ctor = gfc_constructor_next (result_ctor);
    6604              :     }
    6605              : 
    6606           14 :   free (arrayvec);
    6607           14 :   free (resultvec);
    6608           14 :   return result;
    6609              : }
    6610              : 
    6611              : /* Simplify findloc.  */
    6612              : 
    6613              : gfc_expr *
    6614         1386 : gfc_simplify_findloc (gfc_expr *array, gfc_expr *value, gfc_expr *dim,
    6615              :                       gfc_expr *mask, gfc_expr *kind, gfc_expr *back)
    6616              : {
    6617         1386 :   gfc_expr *result;
    6618         1386 :   int ikind;
    6619         1386 :   bool back_val = false;
    6620              : 
    6621         1386 :   if (!is_constant_array_expr (array)
    6622          114 :       || array->shape == NULL
    6623         1499 :       || !gfc_is_constant_expr (dim))
    6624              :     return NULL;
    6625              : 
    6626          113 :   if (! gfc_is_constant_expr (value))
    6627              :     return 0;
    6628              : 
    6629          113 :   if (mask
    6630           21 :       && !is_constant_array_expr (mask)
    6631          113 :       && mask->expr_type != EXPR_CONSTANT)
    6632              :     return NULL;
    6633              : 
    6634          113 :   if (kind)
    6635              :     {
    6636            0 :       if (gfc_extract_int (kind, &ikind, -1))
    6637              :         return NULL;
    6638              :     }
    6639              :   else
    6640          113 :     ikind = gfc_default_integer_kind;
    6641              : 
    6642          113 :   if (back)
    6643              :     {
    6644          113 :       if (back->expr_type != EXPR_CONSTANT)
    6645              :         return NULL;
    6646              : 
    6647          111 :       back_val = back->value.logical;
    6648              :     }
    6649              : 
    6650          111 :   if (dim)
    6651              :     {
    6652           64 :       result = transformational_result (array, dim, BT_INTEGER,
    6653              :                                         ikind, &array->where);
    6654           64 :       init_result_expr (result, 0, array);
    6655              : 
    6656           64 :       if (array->rank == 1)
    6657           50 :         return simplify_findloc_to_scalar (result, array, value, mask,
    6658           50 :                                            back_val);
    6659              :       else
    6660           14 :         return simplify_findloc_to_array (result, array, value, dim, mask,
    6661           14 :                                           back_val);
    6662              :     }
    6663              :   else
    6664              :     {
    6665           47 :       result = new_array (BT_INTEGER, ikind, array->rank, &array->where);
    6666           47 :       return simplify_findloc_nodim (result, value, array, mask, back_val);
    6667              :     }
    6668              :   return NULL;
    6669              : }
    6670              : 
    6671              : gfc_expr *
    6672            1 : gfc_simplify_maxexponent (gfc_expr *x)
    6673              : {
    6674            1 :   int i = gfc_validate_kind (BT_REAL, x->ts.kind, false);
    6675            1 :   return gfc_get_int_expr (gfc_default_integer_kind, &x->where,
    6676            1 :                            gfc_real_kinds[i].max_exponent);
    6677              : }
    6678              : 
    6679              : 
    6680              : gfc_expr *
    6681           25 : gfc_simplify_minexponent (gfc_expr *x)
    6682              : {
    6683           25 :   int i = gfc_validate_kind (BT_REAL, x->ts.kind, false);
    6684           25 :   return gfc_get_int_expr (gfc_default_integer_kind, &x->where,
    6685           25 :                            gfc_real_kinds[i].min_exponent);
    6686              : }
    6687              : 
    6688              : 
    6689              : gfc_expr *
    6690       267398 : gfc_simplify_mod (gfc_expr *a, gfc_expr *p)
    6691              : {
    6692       267398 :   gfc_expr *result;
    6693       267398 :   int kind;
    6694              : 
    6695              :   /* First check p.  */
    6696       267398 :   if (p->expr_type != EXPR_CONSTANT)
    6697              :     return NULL;
    6698              : 
    6699              :   /* p shall not be 0.  */
    6700       266515 :   switch (p->ts.type)
    6701              :     {
    6702       266407 :       case BT_INTEGER:
    6703       266407 :       case BT_UNSIGNED:
    6704       266407 :         if (mpz_cmp_ui (p->value.integer, 0) == 0)
    6705              :           {
    6706            4 :             gfc_error ("Argument %qs of MOD at %L shall not be zero",
    6707              :                         "P", &p->where);
    6708            4 :             return &gfc_bad_expr;
    6709              :           }
    6710              :         break;
    6711          108 :       case BT_REAL:
    6712          108 :         if (mpfr_cmp_ui (p->value.real, 0) == 0)
    6713              :           {
    6714            0 :             gfc_error ("Argument %qs of MOD at %L shall not be zero",
    6715              :                         "P", &p->where);
    6716            0 :             return &gfc_bad_expr;
    6717              :           }
    6718              :         break;
    6719            0 :       default:
    6720            0 :         gfc_internal_error ("gfc_simplify_mod(): Bad arguments");
    6721              :     }
    6722              : 
    6723       266511 :   if (a->expr_type != EXPR_CONSTANT)
    6724              :     return NULL;
    6725              : 
    6726       262828 :   kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind;
    6727       262828 :   result = gfc_get_constant_expr (a->ts.type, kind, &a->where);
    6728              : 
    6729       262828 :   if (a->ts.type == BT_INTEGER || a->ts.type == BT_UNSIGNED)
    6730       262720 :     mpz_tdiv_r (result->value.integer, a->value.integer, p->value.integer);
    6731              :   else
    6732              :     {
    6733          108 :       gfc_set_model_kind (kind);
    6734          108 :       mpfr_fmod (result->value.real, a->value.real, p->value.real,
    6735              :                  GFC_RND_MODE);
    6736              :     }
    6737              : 
    6738       262828 :   return range_check (result, "MOD");
    6739              : }
    6740              : 
    6741              : 
    6742              : gfc_expr *
    6743         1941 : gfc_simplify_modulo (gfc_expr *a, gfc_expr *p)
    6744              : {
    6745         1941 :   gfc_expr *result;
    6746         1941 :   int kind;
    6747              : 
    6748              :   /* First check p.  */
    6749         1941 :   if (p->expr_type != EXPR_CONSTANT)
    6750              :     return NULL;
    6751              : 
    6752              :   /* p shall not be 0.  */
    6753         1744 :   switch (p->ts.type)
    6754              :     {
    6755         1708 :       case BT_INTEGER:
    6756         1708 :       case BT_UNSIGNED:
    6757         1708 :         if (mpz_cmp_ui (p->value.integer, 0) == 0)
    6758              :           {
    6759            4 :             gfc_error ("Argument %qs of MODULO at %L shall not be zero",
    6760              :                         "P", &p->where);
    6761            4 :             return &gfc_bad_expr;
    6762              :           }
    6763              :         break;
    6764           36 :       case BT_REAL:
    6765           36 :         if (mpfr_cmp_ui (p->value.real, 0) == 0)
    6766              :           {
    6767            0 :             gfc_error ("Argument %qs of MODULO at %L shall not be zero",
    6768              :                         "P", &p->where);
    6769            0 :             return &gfc_bad_expr;
    6770              :           }
    6771              :         break;
    6772            0 :       default:
    6773            0 :         gfc_internal_error ("gfc_simplify_modulo(): Bad arguments");
    6774              :     }
    6775              : 
    6776         1740 :   if (a->expr_type != EXPR_CONSTANT)
    6777              :     return NULL;
    6778              : 
    6779          253 :   kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind;
    6780          253 :   result = gfc_get_constant_expr (a->ts.type, kind, &a->where);
    6781              : 
    6782          253 :   if (a->ts.type == BT_INTEGER || a->ts.type == BT_UNSIGNED)
    6783          217 :     mpz_fdiv_r (result->value.integer, a->value.integer, p->value.integer);
    6784              :   else
    6785              :     {
    6786           36 :       gfc_set_model_kind (kind);
    6787           36 :       mpfr_fmod (result->value.real, a->value.real, p->value.real,
    6788              :                  GFC_RND_MODE);
    6789           36 :       if (mpfr_cmp_ui (result->value.real, 0) != 0)
    6790              :         {
    6791           12 :           if (mpfr_signbit (a->value.real) != mpfr_signbit (p->value.real))
    6792            6 :             mpfr_add (result->value.real, result->value.real, p->value.real,
    6793              :                       GFC_RND_MODE);
    6794              :             }
    6795              :           else
    6796           24 :         mpfr_copysign (result->value.real, result->value.real,
    6797              :                        p->value.real, GFC_RND_MODE);
    6798              :     }
    6799              : 
    6800          253 :   return range_check (result, "MODULO");
    6801              : }
    6802              : 
    6803              : 
    6804              : gfc_expr *
    6805         6325 : gfc_simplify_nearest (gfc_expr *x, gfc_expr *s)
    6806              : {
    6807         6325 :   gfc_expr *result;
    6808         6325 :   mpfr_exp_t emin, emax;
    6809         6325 :   int kind;
    6810              : 
    6811         6325 :   if (x->expr_type != EXPR_CONSTANT || s->expr_type != EXPR_CONSTANT)
    6812              :     return NULL;
    6813              : 
    6814          891 :   result = gfc_copy_expr (x);
    6815              : 
    6816              :   /* Save current values of emin and emax.  */
    6817          891 :   emin = mpfr_get_emin ();
    6818          891 :   emax = mpfr_get_emax ();
    6819              : 
    6820              :   /* Set emin and emax for the current model number.  */
    6821          891 :   kind = gfc_validate_kind (BT_REAL, x->ts.kind, 0);
    6822          891 :   mpfr_set_emin ((mpfr_exp_t) gfc_real_kinds[kind].min_exponent -
    6823          891 :                 mpfr_get_prec(result->value.real) + 1);
    6824          891 :   mpfr_set_emax ((mpfr_exp_t) gfc_real_kinds[kind].max_exponent);
    6825          891 :   mpfr_check_range (result->value.real, 0, MPFR_RNDU);
    6826              : 
    6827          891 :   if (mpfr_sgn (s->value.real) > 0)
    6828              :     {
    6829          414 :       mpfr_nextabove (result->value.real);
    6830          414 :       mpfr_subnormalize (result->value.real, 0, MPFR_RNDU);
    6831              :     }
    6832              :   else
    6833              :     {
    6834          477 :       mpfr_nextbelow (result->value.real);
    6835          477 :       mpfr_subnormalize (result->value.real, 0, MPFR_RNDD);
    6836              :     }
    6837              : 
    6838          891 :   mpfr_set_emin (emin);
    6839          891 :   mpfr_set_emax (emax);
    6840              : 
    6841              :   /* Only NaN can occur. Do not use range check as it gives an
    6842              :      error for denormal numbers.  */
    6843          891 :   if (mpfr_nan_p (result->value.real) && flag_range_check)
    6844              :     {
    6845            0 :       gfc_error ("Result of NEAREST is NaN at %L", &result->where);
    6846            0 :       gfc_free_expr (result);
    6847            0 :       return &gfc_bad_expr;
    6848              :     }
    6849              : 
    6850              :   return result;
    6851              : }
    6852              : 
    6853              : 
    6854              : static gfc_expr *
    6855          518 : simplify_nint (const char *name, gfc_expr *e, gfc_expr *k)
    6856              : {
    6857          518 :   gfc_expr *itrunc, *result;
    6858          518 :   int kind;
    6859              : 
    6860          518 :   kind = get_kind (BT_INTEGER, k, name, gfc_default_integer_kind);
    6861          518 :   if (kind == -1)
    6862              :     return &gfc_bad_expr;
    6863              : 
    6864          518 :   if (e->expr_type != EXPR_CONSTANT)
    6865              :     return NULL;
    6866              : 
    6867          156 :   itrunc = gfc_copy_expr (e);
    6868          156 :   mpfr_round (itrunc->value.real, e->value.real);
    6869              : 
    6870          156 :   result = gfc_get_constant_expr (BT_INTEGER, kind, &e->where);
    6871          156 :   gfc_mpfr_to_mpz (result->value.integer, itrunc->value.real, &e->where);
    6872              : 
    6873          156 :   gfc_free_expr (itrunc);
    6874              : 
    6875          156 :   return range_check (result, name);
    6876              : }
    6877              : 
    6878              : 
    6879              : gfc_expr *
    6880          331 : gfc_simplify_new_line (gfc_expr *e)
    6881              : {
    6882          331 :   gfc_expr *result;
    6883              : 
    6884          331 :   result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, 1);
    6885          331 :   result->value.character.string[0] = '\n';
    6886              : 
    6887          331 :   return result;
    6888              : }
    6889              : 
    6890              : 
    6891              : gfc_expr *
    6892          406 : gfc_simplify_nint (gfc_expr *e, gfc_expr *k)
    6893              : {
    6894          406 :   return simplify_nint ("NINT", e, k);
    6895              : }
    6896              : 
    6897              : 
    6898              : gfc_expr *
    6899          112 : gfc_simplify_idnint (gfc_expr *e)
    6900              : {
    6901          112 :   return simplify_nint ("IDNINT", e, NULL);
    6902              : }
    6903              : 
    6904              : static int norm2_scale;
    6905              : 
    6906              : static gfc_expr *
    6907          124 : norm2_add_squared (gfc_expr *result, gfc_expr *e)
    6908              : {
    6909          124 :   mpfr_t tmp;
    6910              : 
    6911          124 :   gcc_assert (e->ts.type == BT_REAL && e->expr_type == EXPR_CONSTANT);
    6912          124 :   gcc_assert (result->ts.type == BT_REAL
    6913              :               && result->expr_type == EXPR_CONSTANT);
    6914              : 
    6915          124 :   gfc_set_model_kind (result->ts.kind);
    6916          124 :   int index = gfc_validate_kind (BT_REAL, result->ts.kind, false);
    6917          124 :   mpfr_exp_t exp;
    6918          124 :   if (mpfr_regular_p (result->value.real))
    6919              :     {
    6920           61 :       exp = mpfr_get_exp (result->value.real);
    6921              :       /* If result is getting close to overflowing, scale down.  */
    6922           61 :       if (exp >= gfc_real_kinds[index].max_exponent - 4
    6923            0 :           && norm2_scale <= gfc_real_kinds[index].max_exponent - 2)
    6924              :         {
    6925            0 :           norm2_scale += 2;
    6926            0 :           mpfr_div_ui (result->value.real, result->value.real, 16,
    6927              :                        GFC_RND_MODE);
    6928              :         }
    6929              :     }
    6930              : 
    6931          124 :   mpfr_init (tmp);
    6932          124 :   if (mpfr_regular_p (e->value.real))
    6933              :     {
    6934           88 :       exp = mpfr_get_exp (e->value.real);
    6935              :       /* If e**2 would overflow or close to overflowing, scale down.  */
    6936           88 :       if (exp - norm2_scale >= gfc_real_kinds[index].max_exponent / 2 - 2)
    6937              :         {
    6938           12 :           int new_scale = gfc_real_kinds[index].max_exponent / 2 + 4;
    6939           12 :           mpfr_set_ui (tmp, 1, GFC_RND_MODE);
    6940           12 :           mpfr_set_exp (tmp, new_scale - norm2_scale);
    6941           12 :           mpfr_div (result->value.real, result->value.real, tmp, GFC_RND_MODE);
    6942           12 :           mpfr_div (result->value.real, result->value.real, tmp, GFC_RND_MODE);
    6943           12 :           norm2_scale = new_scale;
    6944              :         }
    6945              :     }
    6946          124 :   if (norm2_scale)
    6947              :     {
    6948           12 :       mpfr_set_ui (tmp, 1, GFC_RND_MODE);
    6949           12 :       mpfr_set_exp (tmp, norm2_scale);
    6950           12 :       mpfr_div (tmp, e->value.real, tmp, GFC_RND_MODE);
    6951              :     }
    6952              :   else
    6953          112 :     mpfr_set (tmp, e->value.real, GFC_RND_MODE);
    6954          124 :   mpfr_pow_ui (tmp, tmp, 2, GFC_RND_MODE);
    6955          124 :   mpfr_add (result->value.real, result->value.real, tmp,
    6956              :             GFC_RND_MODE);
    6957          124 :   mpfr_clear (tmp);
    6958              : 
    6959          124 :   return result;
    6960              : }
    6961              : 
    6962              : 
    6963              : static gfc_expr *
    6964            2 : norm2_do_sqrt (gfc_expr *result, gfc_expr *e)
    6965              : {
    6966            2 :   gcc_assert (e->ts.type == BT_REAL && e->expr_type == EXPR_CONSTANT);
    6967            2 :   gcc_assert (result->ts.type == BT_REAL
    6968              :               && result->expr_type == EXPR_CONSTANT);
    6969              : 
    6970            2 :   if (result != e)
    6971            0 :     mpfr_set (result->value.real, e->value.real, GFC_RND_MODE);
    6972            2 :   mpfr_sqrt (result->value.real, result->value.real, GFC_RND_MODE);
    6973            2 :   if (norm2_scale && mpfr_regular_p (result->value.real))
    6974              :     {
    6975            0 :       mpfr_t tmp;
    6976            0 :       mpfr_init (tmp);
    6977            0 :       mpfr_set_ui (tmp, 1, GFC_RND_MODE);
    6978            0 :       mpfr_set_exp (tmp, norm2_scale);
    6979            0 :       mpfr_mul (result->value.real, result->value.real, tmp, GFC_RND_MODE);
    6980            0 :       mpfr_clear (tmp);
    6981              :     }
    6982            2 :   norm2_scale = 0;
    6983              : 
    6984            2 :   return result;
    6985              : }
    6986              : 
    6987              : 
    6988              : gfc_expr *
    6989          449 : gfc_simplify_norm2 (gfc_expr *e, gfc_expr *dim)
    6990              : {
    6991          449 :   gfc_expr *result;
    6992          449 :   bool size_zero;
    6993              : 
    6994          449 :   size_zero = gfc_is_size_zero_array (e);
    6995              : 
    6996          835 :   if (!(is_constant_array_expr (e) || size_zero)
    6997          449 :       || (dim != NULL && !gfc_is_constant_expr (dim)))
    6998              :     return NULL;
    6999              : 
    7000           63 :   result = transformational_result (e, dim, e->ts.type, e->ts.kind, &e->where);
    7001           63 :   init_result_expr (result, 0, NULL);
    7002              : 
    7003           63 :   if (size_zero)
    7004              :     return result;
    7005              : 
    7006           38 :   norm2_scale = 0;
    7007           38 :   if (!dim || e->rank == 1)
    7008              :     {
    7009           37 :       result = simplify_transformation_to_scalar (result, e, NULL,
    7010              :                                                   norm2_add_squared);
    7011           37 :       mpfr_sqrt (result->value.real, result->value.real, GFC_RND_MODE);
    7012           37 :       if (norm2_scale && mpfr_regular_p (result->value.real))
    7013              :         {
    7014           12 :           mpfr_t tmp;
    7015           12 :           mpfr_init (tmp);
    7016           12 :           mpfr_set_ui (tmp, 1, GFC_RND_MODE);
    7017           12 :           mpfr_set_exp (tmp, norm2_scale);
    7018           12 :           mpfr_mul (result->value.real, result->value.real, tmp, GFC_RND_MODE);
    7019           12 :           mpfr_clear (tmp);
    7020              :         }
    7021           37 :       norm2_scale = 0;
    7022           37 :     }
    7023              :   else
    7024            1 :     result = simplify_transformation_to_array (result, e, dim, NULL,
    7025              :                                                norm2_add_squared,
    7026              :                                                norm2_do_sqrt);
    7027              : 
    7028              :   return result;
    7029              : }
    7030              : 
    7031              : 
    7032              : gfc_expr *
    7033          602 : gfc_simplify_not (gfc_expr *e)
    7034              : {
    7035          602 :   gfc_expr *result;
    7036              : 
    7037          602 :   if (e->expr_type != EXPR_CONSTANT)
    7038              :     return NULL;
    7039              : 
    7040          211 :   result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    7041          211 :   mpz_com (result->value.integer, e->value.integer);
    7042              : 
    7043          211 :   return range_check (result, "NOT");
    7044              : }
    7045              : 
    7046              : 
    7047              : gfc_expr *
    7048         2007 : gfc_simplify_null (gfc_expr *mold)
    7049              : {
    7050         2007 :   gfc_expr *result;
    7051              : 
    7052         2007 :   if (mold)
    7053              :     {
    7054          565 :       result = gfc_copy_expr (mold);
    7055          565 :       result->expr_type = EXPR_NULL;
    7056              :     }
    7057              :   else
    7058         1442 :     result = gfc_get_null_expr (NULL);
    7059              : 
    7060         2007 :   return result;
    7061              : }
    7062              : 
    7063              : 
    7064              : gfc_expr *
    7065         2387 : gfc_simplify_num_images (gfc_expr *team ATTRIBUTE_UNUSED,
    7066              :                          gfc_expr *team_number ATTRIBUTE_UNUSED)
    7067              : {
    7068         2387 :   gfc_expr *result;
    7069              : 
    7070         2387 :   if (flag_coarray == GFC_FCOARRAY_NONE)
    7071              :     {
    7072            0 :       gfc_fatal_error ("Coarrays disabled at %C, use %<-fcoarray=%> to enable");
    7073              :       return &gfc_bad_expr;
    7074              :     }
    7075              : 
    7076         2387 :   if (flag_coarray != GFC_FCOARRAY_SINGLE)
    7077              :     return NULL;
    7078              : 
    7079              :   /* FIXME: gfc_current_locus is wrong.  */
    7080          473 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    7081              :                                   &gfc_current_locus);
    7082          473 :     mpz_set_si (result->value.integer, 1);
    7083              : 
    7084          473 :   return result;
    7085              : }
    7086              : 
    7087              : 
    7088              : gfc_expr *
    7089           20 : gfc_simplify_or (gfc_expr *x, gfc_expr *y)
    7090              : {
    7091           20 :   gfc_expr *result;
    7092           20 :   int kind;
    7093              : 
    7094           20 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    7095              :     return NULL;
    7096              : 
    7097            6 :   kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
    7098              : 
    7099            6 :   switch (x->ts.type)
    7100              :     {
    7101            0 :       case BT_INTEGER:
    7102            0 :         result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
    7103            0 :         mpz_ior (result->value.integer, x->value.integer, y->value.integer);
    7104            0 :         return range_check (result, "OR");
    7105              : 
    7106            6 :       case BT_LOGICAL:
    7107            6 :         return gfc_get_logical_expr (kind, &x->where,
    7108           12 :                                      x->value.logical || y->value.logical);
    7109            0 :       default:
    7110            0 :         gcc_unreachable();
    7111              :     }
    7112              : }
    7113              : 
    7114              : 
    7115              : gfc_expr *
    7116         1602 : gfc_simplify_out_of_range (gfc_expr *x, gfc_expr *mold, gfc_expr *round)
    7117              : {
    7118         1602 :   gfc_expr *result;
    7119         1602 :   mpfr_t a;
    7120         1602 :   mpz_t b;
    7121         1602 :   int i, k;
    7122         1602 :   bool res = false;
    7123         1602 :   bool rnd = false;
    7124              : 
    7125         1602 :   i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    7126         1602 :   k = gfc_validate_kind (mold->ts.type, mold->ts.kind, false);
    7127              : 
    7128         1602 :   mpfr_init (a);
    7129              : 
    7130         1602 :   switch (x->ts.type)
    7131              :     {
    7132         1242 :     case BT_REAL:
    7133         1242 :       if (mold->ts.type == BT_REAL)
    7134              :         {
    7135           90 :           if (mpfr_cmp (gfc_real_kinds[i].huge,
    7136              :                         gfc_real_kinds[k].huge) <= 0)
    7137              :             {
    7138              :               /* Range of MOLD is always sufficient.  */
    7139           42 :               res = false;
    7140           42 :               goto done;
    7141              :             }
    7142           48 :           else if (x->expr_type == EXPR_CONSTANT)
    7143              :             {
    7144            0 :               mpfr_neg (a, gfc_real_kinds[k].huge, GFC_RND_MODE);
    7145            0 :               res = (mpfr_cmp (x->value.real, a) < 0
    7146            0 :                      || mpfr_cmp (x->value.real, gfc_real_kinds[k].huge) > 0);
    7147            0 :               goto done;
    7148              :             }
    7149              :         }
    7150         1152 :       else if (mold->ts.type == BT_INTEGER)
    7151              :         {
    7152          582 :           if (x->expr_type == EXPR_CONSTANT)
    7153              :             {
    7154           48 :               res = mpfr_inf_p (x->value.real) || mpfr_nan_p (x->value.real);
    7155           48 :               if (res)
    7156            0 :                 goto done;
    7157              : 
    7158           48 :               if (round && round->expr_type != EXPR_CONSTANT)
    7159              :                 break;
    7160              : 
    7161           24 :               if (round && round->expr_type == EXPR_CONSTANT)
    7162           24 :                 rnd = round->value.logical;
    7163              : 
    7164           48 :               if (rnd)
    7165           24 :                 mpfr_round (a, x->value.real);
    7166              :               else
    7167           24 :                 mpfr_trunc (a, x->value.real);
    7168              : 
    7169           48 :               mpz_init (b);
    7170           48 :               mpfr_get_z (b, a, GFC_RND_MODE);
    7171           96 :               res = (mpz_cmp (b, gfc_integer_kinds[k].min_int) < 0
    7172           48 :                      || mpz_cmp (b, gfc_integer_kinds[k].huge) > 0);
    7173           48 :               mpz_clear (b);
    7174           48 :               goto done;
    7175              :             }
    7176              :         }
    7177          570 :       else if (mold->ts.type == BT_UNSIGNED)
    7178              :         {
    7179          570 :           if (x->expr_type == EXPR_CONSTANT)
    7180              :             {
    7181           48 :               res = mpfr_inf_p (x->value.real) || mpfr_nan_p (x->value.real);
    7182           48 :               if (res)
    7183            0 :                 goto done;
    7184              : 
    7185           48 :               if (round && round->expr_type != EXPR_CONSTANT)
    7186              :                 break;
    7187              : 
    7188           24 :               if (round && round->expr_type == EXPR_CONSTANT)
    7189           24 :                 rnd = round->value.logical;
    7190              : 
    7191           24 :               if (rnd)
    7192           24 :                 mpfr_round (a, x->value.real);
    7193              :               else
    7194           24 :                 mpfr_trunc (a, x->value.real);
    7195              : 
    7196           48 :               mpz_init (b);
    7197           48 :               mpfr_get_z (b, a, GFC_RND_MODE);
    7198           96 :               res = (mpz_cmp (b, gfc_unsigned_kinds[k].huge) > 0
    7199           48 :                      || mpz_cmp_si (b, 0) < 0);
    7200           48 :               mpz_clear (b);
    7201           48 :               goto done;
    7202              :             }
    7203              :         }
    7204              :       break;
    7205              : 
    7206          168 :     case BT_INTEGER:
    7207          168 :       gcc_assert (round == NULL);
    7208          168 :       if (mold->ts.type == BT_INTEGER)
    7209              :         {
    7210           54 :           if (mpz_cmp (gfc_integer_kinds[i].huge,
    7211           54 :                        gfc_integer_kinds[k].huge) <= 0)
    7212              :             {
    7213              :               /* Range of MOLD is always sufficient.  */
    7214           18 :               res = false;
    7215           18 :               goto done;
    7216              :             }
    7217           36 :           else if (x->expr_type == EXPR_CONSTANT)
    7218              :             {
    7219            0 :               res = (mpz_cmp (x->value.integer,
    7220            0 :                               gfc_integer_kinds[k].min_int) < 0
    7221            0 :                      || mpz_cmp (x->value.integer,
    7222              :                                  gfc_integer_kinds[k].huge) > 0);
    7223            0 :               goto done;
    7224              :             }
    7225              :         }
    7226          114 :       else if (mold->ts.type == BT_UNSIGNED)
    7227              :         {
    7228           90 :           if (x->expr_type == EXPR_CONSTANT)
    7229              :             {
    7230            0 :               res = (mpz_cmp_si (x->value.integer, 0) < 0
    7231            0 :                      || mpz_cmp (x->value.integer,
    7232            0 :                                  gfc_unsigned_kinds[k].huge) > 0);
    7233            0 :               goto done;
    7234              :             }
    7235              :         }
    7236           24 :       else if (mold->ts.type == BT_REAL)
    7237              :         {
    7238           24 :           mpfr_set_z (a, gfc_integer_kinds[i].min_int, GFC_RND_MODE);
    7239           24 :           mpfr_neg (a, a, GFC_RND_MODE);
    7240           24 :           res = mpfr_cmp (a, gfc_real_kinds[k].huge) > 0;
    7241              :           /* When false, range of MOLD is always sufficient.  */
    7242           24 :           if (!res)
    7243           24 :             goto done;
    7244              : 
    7245            0 :           if (x->expr_type == EXPR_CONSTANT)
    7246              :             {
    7247            0 :               mpfr_set_z (a, x->value.integer, GFC_RND_MODE);
    7248            0 :               mpfr_abs (a, a, GFC_RND_MODE);
    7249            0 :               res = mpfr_cmp (a, gfc_real_kinds[k].huge) > 0;
    7250            0 :               goto done;
    7251              :             }
    7252              :         }
    7253              :       break;
    7254              : 
    7255          192 :     case BT_UNSIGNED:
    7256          192 :       gcc_assert (round == NULL);
    7257          192 :       if (mold->ts.type == BT_UNSIGNED)
    7258              :         {
    7259           54 :           if (mpz_cmp (gfc_unsigned_kinds[i].huge,
    7260           54 :                        gfc_unsigned_kinds[k].huge) <= 0)
    7261              :             {
    7262              :               /* Range of MOLD is always sufficient.  */
    7263           18 :               res = false;
    7264           18 :               goto done;
    7265              :             }
    7266           36 :           else if (x->expr_type == EXPR_CONSTANT)
    7267              :             {
    7268            0 :               res = mpz_cmp (x->value.integer,
    7269              :                              gfc_unsigned_kinds[k].huge) > 0;
    7270            0 :               goto done;
    7271              :             }
    7272              :         }
    7273          138 :       else if (mold->ts.type == BT_INTEGER)
    7274              :         {
    7275           60 :           if (mpz_cmp (gfc_unsigned_kinds[i].huge,
    7276           60 :                        gfc_integer_kinds[k].huge) <= 0)
    7277              :             {
    7278              :               /* Range of MOLD is always sufficient.  */
    7279            6 :               res = false;
    7280            6 :               goto done;
    7281              :             }
    7282           54 :           else if (x->expr_type == EXPR_CONSTANT)
    7283              :             {
    7284            0 :               res = mpz_cmp (x->value.integer,
    7285              :                              gfc_integer_kinds[k].huge) > 0;
    7286            0 :               goto done;
    7287              :             }
    7288              :         }
    7289           78 :       else if (mold->ts.type == BT_REAL)
    7290              :         {
    7291           78 :           mpfr_set_z (a, gfc_unsigned_kinds[i].huge, GFC_RND_MODE);
    7292           78 :           res = mpfr_cmp (a, gfc_real_kinds[k].huge) > 0;
    7293              :           /* When false, range of MOLD is always sufficient.  */
    7294           78 :           if (!res)
    7295           36 :             goto done;
    7296              : 
    7297           42 :           if (x->expr_type == EXPR_CONSTANT)
    7298              :             {
    7299           12 :               mpfr_set_z (a, x->value.integer, GFC_RND_MODE);
    7300           12 :               res = mpfr_cmp (a, gfc_real_kinds[k].huge) > 0;
    7301           12 :               goto done;
    7302              :             }
    7303              :         }
    7304              :       break;
    7305              : 
    7306            0 :     default:
    7307            0 :       gcc_unreachable ();
    7308              :     }
    7309              : 
    7310         1350 :   mpfr_clear (a);
    7311              : 
    7312         1350 :   return NULL;
    7313              : 
    7314          252 : done:
    7315          252 :   result = gfc_get_logical_expr (gfc_default_logical_kind, &x->where, res);
    7316              : 
    7317          252 :   mpfr_clear (a);
    7318              : 
    7319          252 :   return result;
    7320              : }
    7321              : 
    7322              : 
    7323              : gfc_expr *
    7324         1012 : gfc_simplify_pack (gfc_expr *array, gfc_expr *mask, gfc_expr *vector)
    7325              : {
    7326         1012 :   gfc_expr *result;
    7327         1012 :   gfc_constructor *array_ctor, *mask_ctor, *vector_ctor;
    7328              : 
    7329         1012 :   if (!is_constant_array_expr (array)
    7330           58 :       || !is_constant_array_expr (vector)
    7331         1070 :       || (!gfc_is_constant_expr (mask)
    7332            2 :           && !is_constant_array_expr (mask)))
    7333              :     return NULL;
    7334              : 
    7335           57 :   result = gfc_get_array_expr (array->ts.type, array->ts.kind, &array->where);
    7336           57 :   if (array->ts.type == BT_DERIVED)
    7337            5 :     result->ts.u.derived = array->ts.u.derived;
    7338              : 
    7339           57 :   array_ctor = gfc_constructor_first (array->value.constructor);
    7340           57 :   vector_ctor = vector
    7341           57 :                   ? gfc_constructor_first (vector->value.constructor)
    7342              :                   : NULL;
    7343              : 
    7344           57 :   if (mask->expr_type == EXPR_CONSTANT
    7345            0 :       && mask->value.logical)
    7346              :     {
    7347              :       /* Copy all elements of ARRAY to RESULT.  */
    7348            0 :       while (array_ctor)
    7349              :         {
    7350            0 :           gfc_constructor_append_expr (&result->value.constructor,
    7351              :                                        gfc_copy_expr (array_ctor->expr),
    7352              :                                        NULL);
    7353              : 
    7354            0 :           array_ctor = gfc_constructor_next (array_ctor);
    7355            0 :           vector_ctor = gfc_constructor_next (vector_ctor);
    7356              :         }
    7357              :     }
    7358           57 :   else if (mask->expr_type == EXPR_ARRAY)
    7359              :     {
    7360              :       /* Copy only those elements of ARRAY to RESULT whose
    7361              :          MASK equals .TRUE..  */
    7362           57 :       mask_ctor = gfc_constructor_first (mask->value.constructor);
    7363          303 :       while (mask_ctor && array_ctor)
    7364              :         {
    7365          189 :           if (mask_ctor->expr->value.logical)
    7366              :             {
    7367          130 :               gfc_constructor_append_expr (&result->value.constructor,
    7368              :                                            gfc_copy_expr (array_ctor->expr),
    7369              :                                            NULL);
    7370          130 :               vector_ctor = gfc_constructor_next (vector_ctor);
    7371              :             }
    7372              : 
    7373          189 :           array_ctor = gfc_constructor_next (array_ctor);
    7374          189 :           mask_ctor = gfc_constructor_next (mask_ctor);
    7375              :         }
    7376              :     }
    7377              : 
    7378              :   /* Append any left-over elements from VECTOR to RESULT.  */
    7379           85 :   while (vector_ctor)
    7380              :     {
    7381           28 :       gfc_constructor_append_expr (&result->value.constructor,
    7382              :                                    gfc_copy_expr (vector_ctor->expr),
    7383              :                                    NULL);
    7384           28 :       vector_ctor = gfc_constructor_next (vector_ctor);
    7385              :     }
    7386              : 
    7387           57 :   result->shape = gfc_get_shape (1);
    7388           57 :   gfc_array_size (result, &result->shape[0]);
    7389              : 
    7390           57 :   if (array->ts.type == BT_CHARACTER)
    7391           51 :     result->ts.u.cl = array->ts.u.cl;
    7392              : 
    7393              :   return result;
    7394              : }
    7395              : 
    7396              : 
    7397              : static gfc_expr *
    7398          124 : do_xor (gfc_expr *result, gfc_expr *e)
    7399              : {
    7400          124 :   gcc_assert (e->ts.type == BT_LOGICAL && e->expr_type == EXPR_CONSTANT);
    7401          124 :   gcc_assert (result->ts.type == BT_LOGICAL
    7402              :               && result->expr_type == EXPR_CONSTANT);
    7403              : 
    7404          124 :   result->value.logical = result->value.logical != e->value.logical;
    7405          124 :   return result;
    7406              : }
    7407              : 
    7408              : 
    7409              : gfc_expr *
    7410         1185 : gfc_simplify_is_contiguous (gfc_expr *array)
    7411              : {
    7412         1185 :   if (gfc_is_simply_contiguous (array, false, true))
    7413           45 :     return gfc_get_logical_expr (gfc_default_logical_kind, &array->where, 1);
    7414              : 
    7415         1140 :   if (gfc_is_not_contiguous (array))
    7416           54 :     return gfc_get_logical_expr (gfc_default_logical_kind, &array->where, 0);
    7417              : 
    7418              :   return NULL;
    7419              : }
    7420              : 
    7421              : 
    7422              : gfc_expr *
    7423          147 : gfc_simplify_parity (gfc_expr *e, gfc_expr *dim)
    7424              : {
    7425          147 :   return simplify_transformation (e, dim, NULL, 0, do_xor);
    7426              : }
    7427              : 
    7428              : 
    7429              : gfc_expr *
    7430         1658 : gfc_simplify_popcnt (gfc_expr *e)
    7431              : {
    7432         1658 :   int res, k;
    7433         1658 :   mpz_t x;
    7434              : 
    7435         1658 :   if (e->expr_type != EXPR_CONSTANT)
    7436              :     return NULL;
    7437              : 
    7438          750 :   k = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    7439              : 
    7440          750 :   if (flag_unsigned && e->ts.type == BT_UNSIGNED)
    7441          216 :     res = mpz_popcount (e->value.integer);
    7442              :   else
    7443              :     {
    7444              :       /* Convert argument to unsigned, then count the '1' bits.  */
    7445          642 :       mpz_init_set (x, e->value.integer);
    7446          642 :       gfc_convert_mpz_to_unsigned (x, gfc_integer_kinds[k].bit_size);
    7447          642 :       res = mpz_popcount (x);
    7448          642 :       mpz_clear (x);
    7449              :     }
    7450              : 
    7451          750 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, res);
    7452              : }
    7453              : 
    7454              : 
    7455              : gfc_expr *
    7456          902 : gfc_simplify_poppar (gfc_expr *e)
    7457              : {
    7458          902 :   gfc_expr *popcnt;
    7459          902 :   int i;
    7460              : 
    7461          902 :   if (e->expr_type != EXPR_CONSTANT)
    7462              :     return NULL;
    7463              : 
    7464          354 :   popcnt = gfc_simplify_popcnt (e);
    7465          354 :   gcc_assert (popcnt);
    7466              : 
    7467          354 :   bool fail = gfc_extract_int (popcnt, &i);
    7468          354 :   gcc_assert (!fail);
    7469              : 
    7470          354 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i % 2);
    7471              : }
    7472              : 
    7473              : 
    7474              : gfc_expr *
    7475          459 : gfc_simplify_precision (gfc_expr *e)
    7476              : {
    7477          459 :   int i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    7478          459 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where,
    7479          459 :                            gfc_real_kinds[i].precision);
    7480              : }
    7481              : 
    7482              : 
    7483              : gfc_expr *
    7484          849 : gfc_simplify_product (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
    7485              : {
    7486          849 :   return simplify_transformation (array, dim, mask, 1, gfc_multiply);
    7487              : }
    7488              : 
    7489              : 
    7490              : gfc_expr *
    7491           61 : gfc_simplify_radix (gfc_expr *e)
    7492              : {
    7493           61 :   int i;
    7494           61 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    7495              : 
    7496           61 :   switch (e->ts.type)
    7497              :     {
    7498            0 :       case BT_INTEGER:
    7499            0 :         i = gfc_integer_kinds[i].radix;
    7500            0 :         break;
    7501              : 
    7502           61 :       case BT_REAL:
    7503           61 :         i = gfc_real_kinds[i].radix;
    7504           61 :         break;
    7505              : 
    7506            0 :       default:
    7507            0 :         gcc_unreachable ();
    7508              :     }
    7509              : 
    7510           61 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i);
    7511              : }
    7512              : 
    7513              : 
    7514              : gfc_expr *
    7515          180 : gfc_simplify_range (gfc_expr *e)
    7516              : {
    7517          180 :   int i;
    7518          180 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    7519              : 
    7520          180 :   switch (e->ts.type)
    7521              :     {
    7522           85 :       case BT_INTEGER:
    7523           85 :         i = gfc_integer_kinds[i].range;
    7524           85 :         break;
    7525              : 
    7526           24 :       case BT_UNSIGNED:
    7527           24 :         i = gfc_unsigned_kinds[i].range;
    7528           24 :         break;
    7529              : 
    7530           71 :       case BT_REAL:
    7531           71 :       case BT_COMPLEX:
    7532           71 :         i = gfc_real_kinds[i].range;
    7533           71 :         break;
    7534              : 
    7535            0 :       default:
    7536            0 :         gcc_unreachable ();
    7537              :     }
    7538              : 
    7539          180 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, i);
    7540              : }
    7541              : 
    7542              : 
    7543              : gfc_expr *
    7544         9932 : gfc_simplify_rank (gfc_expr *e)
    7545              : {
    7546              :   /* Assumed rank.  */
    7547         9932 :   if (e->rank == -1)
    7548              :     return NULL;
    7549              : 
    7550          618 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, e->rank);
    7551              : }
    7552              : 
    7553              : 
    7554              : gfc_expr *
    7555        31871 : gfc_simplify_real (gfc_expr *e, gfc_expr *k)
    7556              : {
    7557        31871 :   gfc_expr *result = NULL;
    7558        31871 :   int kind, tmp1, tmp2;
    7559              : 
    7560              :   /* Convert BOZ to real, and return without range checking.  */
    7561        31871 :   if (e->ts.type == BT_BOZ)
    7562              :     {
    7563              :       /* Determine kind for conversion of the BOZ.  */
    7564           85 :       if (k)
    7565           63 :         gfc_extract_int (k, &kind);
    7566              :       else
    7567           22 :         kind = gfc_default_real_kind;
    7568              : 
    7569           85 :       if (!gfc_boz2real (e, kind))
    7570              :         return NULL;
    7571           85 :       result = gfc_copy_expr (e);
    7572           85 :       return result;
    7573              :     }
    7574              : 
    7575        31786 :   if (e->ts.type == BT_COMPLEX)
    7576         2036 :     kind = get_kind (BT_REAL, k, "REAL", e->ts.kind);
    7577              :   else
    7578        29750 :     kind = get_kind (BT_REAL, k, "REAL", gfc_default_real_kind);
    7579              : 
    7580        31786 :   if (kind == -1)
    7581              :     return &gfc_bad_expr;
    7582              : 
    7583        31786 :   if (e->expr_type != EXPR_CONSTANT)
    7584              :     return NULL;
    7585              : 
    7586              :   /* For explicit conversion, turn off -Wconversion and -Wconversion-extra
    7587              :      warnings.  */
    7588        25483 :   tmp1 = warn_conversion;
    7589        25483 :   tmp2 = warn_conversion_extra;
    7590        25483 :   warn_conversion = warn_conversion_extra = 0;
    7591              : 
    7592        25483 :   result = gfc_convert_constant (e, BT_REAL, kind);
    7593              : 
    7594        25483 :   warn_conversion = tmp1;
    7595        25483 :   warn_conversion_extra = tmp2;
    7596              : 
    7597        25483 :   if (result == &gfc_bad_expr)
    7598              :     return &gfc_bad_expr;
    7599              : 
    7600        25482 :   return range_check (result, "REAL");
    7601              : }
    7602              : 
    7603              : 
    7604              : gfc_expr *
    7605            7 : gfc_simplify_realpart (gfc_expr *e)
    7606              : {
    7607            7 :   gfc_expr *result;
    7608              : 
    7609            7 :   if (e->expr_type != EXPR_CONSTANT)
    7610              :     return NULL;
    7611              : 
    7612            1 :   result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
    7613            1 :   mpc_real (result->value.real, e->value.complex, GFC_RND_MODE);
    7614              : 
    7615            1 :   return range_check (result, "REALPART");
    7616              : }
    7617              : 
    7618              : gfc_expr *
    7619         2695 : gfc_simplify_repeat (gfc_expr *e, gfc_expr *n)
    7620              : {
    7621         2695 :   gfc_expr *result;
    7622         2695 :   gfc_charlen_t len;
    7623         2695 :   mpz_t ncopies;
    7624         2695 :   bool have_length = false;
    7625              : 
    7626              :   /* If NCOPIES isn't a constant, there's nothing we can do.  */
    7627         2695 :   if (n->expr_type != EXPR_CONSTANT)
    7628              :     return NULL;
    7629              : 
    7630              :   /* If NCOPIES is negative, it's an error.  */
    7631         2113 :   if (mpz_sgn (n->value.integer) < 0)
    7632              :     {
    7633            6 :       gfc_error ("Argument NCOPIES of REPEAT intrinsic is negative at %L",
    7634              :                  &n->where);
    7635            6 :       return &gfc_bad_expr;
    7636              :     }
    7637              : 
    7638              :   /* If we don't know the character length, we can do no more.  */
    7639         2107 :   if (e->ts.u.cl && e->ts.u.cl->length
    7640          426 :         && e->ts.u.cl->length->expr_type == EXPR_CONSTANT)
    7641              :     {
    7642          426 :       len = gfc_mpz_get_hwi (e->ts.u.cl->length->value.integer);
    7643          426 :       have_length = true;
    7644              :     }
    7645         1681 :   else if (e->expr_type == EXPR_CONSTANT
    7646         1681 :              && (e->ts.u.cl == NULL || e->ts.u.cl->length == NULL))
    7647              :     {
    7648         1681 :       len = e->value.character.length;
    7649              :     }
    7650              :   else
    7651              :     return NULL;
    7652              : 
    7653              :   /* If the source length is 0, any value of NCOPIES is valid
    7654              :      and everything behaves as if NCOPIES == 0.  */
    7655         2107 :   mpz_init (ncopies);
    7656         2107 :   if (len == 0)
    7657           63 :     mpz_set_ui (ncopies, 0);
    7658              :   else
    7659         2044 :     mpz_set (ncopies, n->value.integer);
    7660              : 
    7661              :   /* Check that NCOPIES isn't too large.  */
    7662         2107 :   if (len)
    7663              :     {
    7664         2044 :       mpz_t max, mlen;
    7665         2044 :       int i;
    7666              : 
    7667              :       /* Compute the maximum value allowed for NCOPIES: huge(cl) / len.  */
    7668         2044 :       mpz_init (max);
    7669         2044 :       i = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false);
    7670              : 
    7671         2044 :       if (have_length)
    7672              :         {
    7673          369 :           mpz_tdiv_q (max, gfc_integer_kinds[i].huge,
    7674          369 :                       e->ts.u.cl->length->value.integer);
    7675              :         }
    7676              :       else
    7677              :         {
    7678         1675 :           mpz_init (mlen);
    7679         1675 :           gfc_mpz_set_hwi (mlen, len);
    7680         1675 :           mpz_tdiv_q (max, gfc_integer_kinds[i].huge, mlen);
    7681         1675 :           mpz_clear (mlen);
    7682              :         }
    7683              : 
    7684              :       /* The check itself.  */
    7685         2044 :       if (mpz_cmp (ncopies, max) > 0)
    7686              :         {
    7687            4 :           mpz_clear (max);
    7688            4 :           mpz_clear (ncopies);
    7689            4 :           gfc_error ("Argument NCOPIES of REPEAT intrinsic is too large at %L",
    7690              :                      &n->where);
    7691            4 :           return &gfc_bad_expr;
    7692              :         }
    7693              : 
    7694         2040 :       mpz_clear (max);
    7695              :     }
    7696         2103 :   mpz_clear (ncopies);
    7697              : 
    7698              :   /* For further simplification, we need the character string to be
    7699              :      constant.  */
    7700         2103 :   if (e->expr_type != EXPR_CONSTANT)
    7701              :     return NULL;
    7702              : 
    7703         1742 :   HOST_WIDE_INT ncop;
    7704         1742 :   if (len ||
    7705           42 :       (e->ts.u.cl->length &&
    7706           18 :        mpz_sgn (e->ts.u.cl->length->value.integer) != 0))
    7707              :     {
    7708         1718 :       bool fail = gfc_extract_hwi (n, &ncop);
    7709         1718 :       gcc_assert (!fail);
    7710              :     }
    7711              :   else
    7712           24 :     ncop = 0;
    7713              : 
    7714         1742 :   if (ncop == 0)
    7715           54 :     return gfc_get_character_expr (e->ts.kind, &e->where, NULL, 0);
    7716              : 
    7717         1688 :   len = e->value.character.length;
    7718         1688 :   gfc_charlen_t nlen = ncop * len;
    7719              : 
    7720              :   /* Here's a semi-arbitrary limit. If the string is longer than 1 GB
    7721              :      (2**28 elements * 4 bytes (wide chars) per element) defer to
    7722              :      runtime instead of consuming (unbounded) memory and CPU at
    7723              :      compile time.  */
    7724         1688 :   if (nlen > 268435456)
    7725              :     {
    7726            1 :       gfc_warning_now (0, "Evaluation of string longer than 2**28 at %L"
    7727              :                        " deferred to runtime, expect bugs", &e->where);
    7728            1 :       return NULL;
    7729              :     }
    7730              : 
    7731         1687 :   result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, nlen);
    7732        62085 :   for (size_t i = 0; i < (size_t) ncop; i++)
    7733       117752 :     for (size_t j = 0; j < (size_t) len; j++)
    7734        59041 :       result->value.character.string[j+i*len]= e->value.character.string[j];
    7735              : 
    7736         1687 :   result->value.character.string[nlen] = '\0';       /* For debugger */
    7737         1687 :   return result;
    7738              : }
    7739              : 
    7740              : 
    7741              : /* This one is a bear, but mainly has to do with shuffling elements.  */
    7742              : 
    7743              : gfc_expr *
    7744        10029 : gfc_simplify_reshape (gfc_expr *source, gfc_expr *shape_exp,
    7745              :                       gfc_expr *pad, gfc_expr *order_exp)
    7746              : {
    7747        10029 :   int order[GFC_MAX_DIMENSIONS], shape[GFC_MAX_DIMENSIONS];
    7748        10029 :   int i, rank, npad, x[GFC_MAX_DIMENSIONS];
    7749        10029 :   mpz_t index, size;
    7750        10029 :   unsigned long j;
    7751        10029 :   size_t nsource;
    7752        10029 :   gfc_expr *e, *result;
    7753        10029 :   bool zerosize = false;
    7754              : 
    7755              :   /* Check that argument expression types are OK.  */
    7756        10029 :   if (!is_constant_array_expr (source)
    7757         8155 :       || !is_constant_array_expr (shape_exp)
    7758         6835 :       || !is_constant_array_expr (pad)
    7759        16864 :       || !is_constant_array_expr (order_exp))
    7760              :     return NULL;
    7761              : 
    7762         6823 :   if (source->shape == NULL)
    7763              :     return NULL;
    7764              : 
    7765              :   /* Proceed with simplification, unpacking the array.  */
    7766              : 
    7767         6820 :   mpz_init (index);
    7768         6820 :   rank = 0;
    7769              : 
    7770       115940 :   for (i = 0; i < GFC_MAX_DIMENSIONS; i++)
    7771       102300 :     x[i] = 0;
    7772              : 
    7773        38412 :   for (;;)
    7774              :     {
    7775        22616 :       e = gfc_constructor_lookup_expr (shape_exp->value.constructor, rank);
    7776        22616 :       if (e == NULL)
    7777              :         break;
    7778              : 
    7779        15796 :       gfc_extract_int (e, &shape[rank]);
    7780              : 
    7781        15796 :       gcc_assert (rank >= 0 && rank < GFC_MAX_DIMENSIONS);
    7782        15796 :       if (shape[rank] < 0)
    7783              :         {
    7784            0 :           gfc_error ("The SHAPE array for the RESHAPE intrinsic at %L has a "
    7785              :                      "negative value %d for dimension %d",
    7786              :                      &shape_exp->where, shape[rank], rank+1);
    7787            0 :           mpz_clear (index);
    7788            0 :           return &gfc_bad_expr;
    7789              :         }
    7790              : 
    7791        15796 :       rank++;
    7792              :     }
    7793              : 
    7794         6820 :   gcc_assert (rank > 0);
    7795              : 
    7796              :   /* Now unpack the order array if present.  */
    7797         6820 :   if (order_exp == NULL)
    7798              :     {
    7799        22547 :       for (i = 0; i < rank; i++)
    7800        15750 :         order[i] = i;
    7801              :     }
    7802              :   else
    7803              :     {
    7804           23 :       mpz_t size;
    7805           23 :       int order_size, shape_size;
    7806              : 
    7807           23 :       if (order_exp->rank != shape_exp->rank)
    7808              :         {
    7809            1 :           gfc_error ("Shapes of ORDER at %L and SHAPE at %L are different",
    7810              :                      &order_exp->where, &shape_exp->where);
    7811            1 :           mpz_clear (index);
    7812            4 :           return &gfc_bad_expr;
    7813              :         }
    7814              : 
    7815           22 :       gfc_array_size (shape_exp, &size);
    7816           22 :       shape_size = mpz_get_ui (size);
    7817           22 :       mpz_clear (size);
    7818           22 :       gfc_array_size (order_exp, &size);
    7819           22 :       order_size = mpz_get_ui (size);
    7820           22 :       mpz_clear (size);
    7821           22 :       if (order_size != shape_size)
    7822              :         {
    7823            1 :           gfc_error ("Sizes of ORDER at %L and SHAPE at %L are different",
    7824              :                      &order_exp->where, &shape_exp->where);
    7825            1 :           mpz_clear (index);
    7826            1 :           return &gfc_bad_expr;
    7827              :         }
    7828              : 
    7829           61 :       for (i = 0; i < rank; i++)
    7830              :         {
    7831           42 :           e = gfc_constructor_lookup_expr (order_exp->value.constructor, i);
    7832           42 :           gcc_assert (e);
    7833              : 
    7834           42 :           gfc_extract_int (e, &order[i]);
    7835              : 
    7836           42 :           if (order[i] < 1 || order[i] > rank)
    7837              :             {
    7838            1 :               gfc_error ("Element with a value of %d in ORDER at %L must be "
    7839              :                          "in the range [1, ..., %d] for the RESHAPE intrinsic "
    7840              :                          "near %L", order[i], &order_exp->where, rank,
    7841              :                          &shape_exp->where);
    7842            1 :               mpz_clear (index);
    7843            1 :               return &gfc_bad_expr;
    7844              :             }
    7845              : 
    7846           41 :           order[i]--;
    7847           41 :           if (x[order[i]] != 0)
    7848              :             {
    7849            1 :               gfc_error ("ORDER at %L is not a permutation of the size of "
    7850              :                          "SHAPE at %L", &order_exp->where, &shape_exp->where);
    7851            1 :               mpz_clear (index);
    7852            1 :               return &gfc_bad_expr;
    7853              :             }
    7854           40 :           x[order[i]] = 1;
    7855              :         }
    7856              :     }
    7857              : 
    7858              :   /* Count the elements in the source and padding arrays.  */
    7859              : 
    7860         6816 :   npad = 0;
    7861         6816 :   if (pad != NULL)
    7862              :     {
    7863           56 :       gfc_array_size (pad, &size);
    7864           56 :       npad = mpz_get_ui (size);
    7865           56 :       mpz_clear (size);
    7866              :     }
    7867              : 
    7868         6816 :   gfc_array_size (source, &size);
    7869         6816 :   nsource = mpz_get_ui (size);
    7870         6816 :   mpz_clear (size);
    7871              : 
    7872              :   /* If it weren't for that pesky permutation we could just loop
    7873              :      through the source and round out any shortage with pad elements.
    7874              :      But no, someone just had to have the compiler do something the
    7875              :      user should be doing.  */
    7876              : 
    7877        29420 :   for (i = 0; i < rank; i++)
    7878        15788 :     x[i] = 0;
    7879              : 
    7880         6816 :   result = gfc_get_array_expr (source->ts.type, source->ts.kind,
    7881              :                                &source->where);
    7882         6816 :   if (source->ts.type == BT_DERIVED)
    7883          117 :     result->ts.u.derived = source->ts.u.derived;
    7884         6816 :   if (source->ts.type == BT_CHARACTER && result->ts.u.cl == NULL)
    7885          278 :     result->ts = source->ts;
    7886         6816 :   result->rank = rank;
    7887         6816 :   result->shape = gfc_get_shape (rank);
    7888        22604 :   for (i = 0; i < rank; i++)
    7889              :     {
    7890        15788 :       mpz_init_set_ui (result->shape[i], shape[i]);
    7891        15788 :       if (shape[i] == 0)
    7892          723 :         zerosize = true;
    7893              :     }
    7894              : 
    7895         6816 :   if (zerosize)
    7896          699 :     goto sizezero;
    7897              : 
    7898       115737 :   while (nsource > 0 || npad > 0)
    7899              :     {
    7900              :       /* Figure out which element to extract.  */
    7901       115737 :       mpz_set_ui (index, 0);
    7902              : 
    7903       407527 :       for (i = rank - 1; i >= 0; i--)
    7904              :         {
    7905       291790 :           mpz_add_ui (index, index, x[order[i]]);
    7906       291790 :           if (i != 0)
    7907       176053 :             mpz_mul_ui (index, index, shape[order[i - 1]]);
    7908              :         }
    7909              : 
    7910       115737 :       if (mpz_cmp_ui (index, INT_MAX) > 0)
    7911            0 :         gfc_internal_error ("Reshaped array too large at %C");
    7912              : 
    7913       115737 :       j = mpz_get_ui (index);
    7914              : 
    7915       115737 :       if (j < nsource)
    7916       115546 :         e = gfc_constructor_lookup_expr (source->value.constructor, j);
    7917              :       else
    7918              :         {
    7919          191 :           if (npad <= 0)
    7920              :             {
    7921           19 :               mpz_clear (index);
    7922           19 :               if (pad == NULL)
    7923           19 :                 gfc_error ("Without padding, there are not enough elements "
    7924              :                            "in the intrinsic RESHAPE source at %L to match "
    7925              :                            "the shape", &source->where);
    7926           19 :               gfc_free_expr (result);
    7927           19 :               return NULL;
    7928              :             }
    7929          172 :           j = j - nsource;
    7930          172 :           j = j % npad;
    7931          172 :           e = gfc_constructor_lookup_expr (pad->value.constructor, j);
    7932              :         }
    7933       115718 :       gcc_assert (e);
    7934              : 
    7935       115718 :       gfc_constructor_append_expr (&result->value.constructor,
    7936              :                                    gfc_copy_expr (e), &e->where);
    7937              : 
    7938              :       /* Calculate the next element.  */
    7939       115718 :       i = 0;
    7940              : 
    7941       153217 : inc:
    7942       153217 :       if (++x[i] < shape[i])
    7943       109620 :         continue;
    7944        43597 :       x[i++] = 0;
    7945        43597 :       if (i < rank)
    7946        37499 :         goto inc;
    7947              : 
    7948              :       break;
    7949              :     }
    7950              : 
    7951            0 : sizezero:
    7952              : 
    7953         6797 :   mpz_clear (index);
    7954              : 
    7955         6797 :   return result;
    7956              : }
    7957              : 
    7958              : 
    7959              : gfc_expr *
    7960          192 : gfc_simplify_rrspacing (gfc_expr *x)
    7961              : {
    7962          192 :   gfc_expr *result;
    7963          192 :   int i;
    7964          192 :   long int e, p;
    7965              : 
    7966          192 :   if (x->expr_type != EXPR_CONSTANT)
    7967              :     return NULL;
    7968              : 
    7969           60 :   i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    7970              : 
    7971           60 :   result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
    7972              : 
    7973              :   /* RRSPACING(+/- 0.0) = 0.0  */
    7974           60 :   if (mpfr_zero_p (x->value.real))
    7975              :     {
    7976           12 :       mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    7977           12 :       return result;
    7978              :     }
    7979              : 
    7980              :   /* RRSPACING(inf) = NaN  */
    7981           48 :   if (mpfr_inf_p (x->value.real))
    7982              :     {
    7983           12 :       mpfr_set_nan (result->value.real);
    7984           12 :       return result;
    7985              :     }
    7986              : 
    7987              :   /* RRSPACING(NaN) = same NaN  */
    7988           36 :   if (mpfr_nan_p (x->value.real))
    7989              :     {
    7990            6 :       mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    7991            6 :       return result;
    7992              :     }
    7993              : 
    7994              :   /* | x * 2**(-e) | * 2**p.  */
    7995           30 :   mpfr_abs (result->value.real, x->value.real, GFC_RND_MODE);
    7996           30 :   e = - (long int) mpfr_get_exp (x->value.real);
    7997           30 :   mpfr_mul_2si (result->value.real, result->value.real, e, GFC_RND_MODE);
    7998              : 
    7999           30 :   p = (long int) gfc_real_kinds[i].digits;
    8000           30 :   mpfr_mul_2si (result->value.real, result->value.real, p, GFC_RND_MODE);
    8001              : 
    8002           30 :   return range_check (result, "RRSPACING");
    8003              : }
    8004              : 
    8005              : 
    8006              : gfc_expr *
    8007          168 : gfc_simplify_scale (gfc_expr *x, gfc_expr *i)
    8008              : {
    8009          168 :   int k, neg_flag, power, exp_range;
    8010          168 :   mpfr_t scale, radix;
    8011          168 :   gfc_expr *result;
    8012              : 
    8013          168 :   if (x->expr_type != EXPR_CONSTANT || i->expr_type != EXPR_CONSTANT)
    8014              :     return NULL;
    8015              : 
    8016           12 :   result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
    8017              : 
    8018           12 :   if (mpfr_zero_p (x->value.real))
    8019              :     {
    8020            0 :       mpfr_set_ui (result->value.real, 0, GFC_RND_MODE);
    8021            0 :       return result;
    8022              :     }
    8023              : 
    8024           12 :   k = gfc_validate_kind (BT_REAL, x->ts.kind, false);
    8025              : 
    8026           12 :   exp_range = gfc_real_kinds[k].max_exponent - gfc_real_kinds[k].min_exponent;
    8027              : 
    8028              :   /* This check filters out values of i that would overflow an int.  */
    8029           12 :   if (mpz_cmp_si (i->value.integer, exp_range + 2) > 0
    8030           12 :       || mpz_cmp_si (i->value.integer, -exp_range - 2) < 0)
    8031              :     {
    8032            0 :       gfc_error ("Result of SCALE overflows its kind at %L", &result->where);
    8033            0 :       gfc_free_expr (result);
    8034            0 :       return &gfc_bad_expr;
    8035              :     }
    8036              : 
    8037              :   /* Compute scale = radix ** power.  */
    8038           12 :   power = mpz_get_si (i->value.integer);
    8039              : 
    8040           12 :   if (power >= 0)
    8041              :     neg_flag = 0;
    8042              :   else
    8043              :     {
    8044            0 :       neg_flag = 1;
    8045            0 :       power = -power;
    8046              :     }
    8047              : 
    8048           12 :   gfc_set_model_kind (x->ts.kind);
    8049           12 :   mpfr_init (scale);
    8050           12 :   mpfr_init (radix);
    8051           12 :   mpfr_set_ui (radix, gfc_real_kinds[k].radix, GFC_RND_MODE);
    8052           12 :   mpfr_pow_ui (scale, radix, power, GFC_RND_MODE);
    8053              : 
    8054           12 :   if (neg_flag)
    8055            0 :     mpfr_div (result->value.real, x->value.real, scale, GFC_RND_MODE);
    8056              :   else
    8057           12 :     mpfr_mul (result->value.real, x->value.real, scale, GFC_RND_MODE);
    8058              : 
    8059           12 :   mpfr_clears (scale, radix, NULL);
    8060              : 
    8061           12 :   return range_check (result, "SCALE");
    8062              : }
    8063              : 
    8064              : 
    8065              : /* Variants of strspn and strcspn that operate on wide characters.  */
    8066              : 
    8067              : static size_t
    8068           60 : wide_strspn (const gfc_char_t *s1, const gfc_char_t *s2)
    8069              : {
    8070           60 :   size_t i = 0;
    8071           60 :   const gfc_char_t *c;
    8072              : 
    8073          144 :   while (s1[i])
    8074              :     {
    8075          354 :       for (c = s2; *c; c++)
    8076              :         {
    8077          294 :           if (s1[i] == *c)
    8078              :             break;
    8079              :         }
    8080          144 :       if (*c == '\0')
    8081              :         break;
    8082           84 :       i++;
    8083              :     }
    8084              : 
    8085           60 :   return i;
    8086              : }
    8087              : 
    8088              : static size_t
    8089           60 : wide_strcspn (const gfc_char_t *s1, const gfc_char_t *s2)
    8090              : {
    8091           60 :   size_t i = 0;
    8092           60 :   const gfc_char_t *c;
    8093              : 
    8094          396 :   while (s1[i])
    8095              :     {
    8096         1392 :       for (c = s2; *c; c++)
    8097              :         {
    8098         1056 :           if (s1[i] == *c)
    8099              :             break;
    8100              :         }
    8101          384 :       if (*c)
    8102              :         break;
    8103          336 :       i++;
    8104              :     }
    8105              : 
    8106           60 :   return i;
    8107              : }
    8108              : 
    8109              : 
    8110              : gfc_expr *
    8111          958 : gfc_simplify_scan (gfc_expr *e, gfc_expr *c, gfc_expr *b, gfc_expr *kind)
    8112              : {
    8113          958 :   gfc_expr *result;
    8114          958 :   int back;
    8115          958 :   size_t i;
    8116          958 :   size_t indx, len, lenc;
    8117          958 :   int k = get_kind (BT_INTEGER, kind, "SCAN", gfc_default_integer_kind);
    8118              : 
    8119          958 :   if (k == -1)
    8120              :     return &gfc_bad_expr;
    8121              : 
    8122          958 :   if (e->expr_type != EXPR_CONSTANT || c->expr_type != EXPR_CONSTANT
    8123          182 :       || ( b != NULL && b->expr_type !=  EXPR_CONSTANT))
    8124              :     return NULL;
    8125              : 
    8126          144 :   if (b != NULL && b->value.logical != 0)
    8127              :     back = 1;
    8128              :   else
    8129           72 :     back = 0;
    8130              : 
    8131          144 :   len = e->value.character.length;
    8132          144 :   lenc = c->value.character.length;
    8133              : 
    8134          144 :   if (len == 0 || lenc == 0)
    8135              :     {
    8136              :       indx = 0;
    8137              :     }
    8138              :   else
    8139              :     {
    8140          120 :       if (back == 0)
    8141              :         {
    8142           60 :           indx = wide_strcspn (e->value.character.string,
    8143           60 :                                c->value.character.string) + 1;
    8144           60 :           if (indx > len)
    8145           48 :             indx = 0;
    8146              :         }
    8147              :       else
    8148          408 :         for (indx = len; indx > 0; indx--)
    8149              :           {
    8150         1488 :             for (i = 0; i < lenc; i++)
    8151              :               {
    8152         1140 :                 if (c->value.character.string[i]
    8153         1140 :                     == e->value.character.string[indx - 1])
    8154              :                   break;
    8155              :               }
    8156          396 :             if (i < lenc)
    8157              :               break;
    8158              :           }
    8159              :     }
    8160              : 
    8161          144 :   result = gfc_get_int_expr (k, &e->where, indx);
    8162          144 :   return range_check (result, "SCAN");
    8163              : }
    8164              : 
    8165              : 
    8166              : gfc_expr *
    8167          289 : gfc_simplify_selected_char_kind (gfc_expr *e)
    8168              : {
    8169          289 :   int kind;
    8170              : 
    8171          289 :   if (e->expr_type != EXPR_CONSTANT)
    8172              :     return NULL;
    8173              : 
    8174          204 :   if (gfc_compare_with_Cstring (e, "ascii", false) == 0
    8175          204 :       || gfc_compare_with_Cstring (e, "default", false) == 0)
    8176              :     kind = 1;
    8177          108 :   else if (gfc_compare_with_Cstring (e, "iso_10646", false) == 0)
    8178              :     kind = 4;
    8179              :   else
    8180           39 :     kind = -1;
    8181              : 
    8182          204 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
    8183              : }
    8184              : 
    8185              : 
    8186              : gfc_expr *
    8187          256 : gfc_simplify_selected_int_kind (gfc_expr *e)
    8188              : {
    8189          256 :   int i, kind, range;
    8190              : 
    8191          256 :   if (e->expr_type != EXPR_CONSTANT || gfc_extract_int (e, &range))
    8192              :     return NULL;
    8193              : 
    8194              :   kind = INT_MAX;
    8195              : 
    8196         1242 :   for (i = 0; gfc_integer_kinds[i].kind != 0; i++)
    8197         1035 :     if (gfc_integer_kinds[i].range >= range
    8198          539 :         && gfc_integer_kinds[i].kind < kind)
    8199         1035 :       kind = gfc_integer_kinds[i].kind;
    8200              : 
    8201          207 :   if (kind == INT_MAX)
    8202            0 :     kind = -1;
    8203              : 
    8204          207 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
    8205              : }
    8206              : 
    8207              : /* Same as above, but with unsigneds.  */
    8208              : 
    8209              : gfc_expr *
    8210           25 : gfc_simplify_selected_unsigned_kind (gfc_expr *e)
    8211              : {
    8212           25 :   int i, kind, range;
    8213              : 
    8214           25 :   if (e->expr_type != EXPR_CONSTANT || gfc_extract_int (e, &range))
    8215              :     return NULL;
    8216              : 
    8217              :   kind = INT_MAX;
    8218              : 
    8219          150 :   for (i = 0; gfc_unsigned_kinds[i].kind != 0; i++)
    8220          125 :     if (gfc_unsigned_kinds[i].range >= range
    8221           86 :         && gfc_unsigned_kinds[i].kind < kind)
    8222          125 :       kind = gfc_unsigned_kinds[i].kind;
    8223              : 
    8224           25 :   if (kind == INT_MAX)
    8225            0 :     kind = -1;
    8226              : 
    8227           25 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
    8228              : }
    8229              : 
    8230              : 
    8231              : gfc_expr *
    8232           78 : gfc_simplify_selected_logical_kind (gfc_expr *e)
    8233              : {
    8234           78 :   int i, kind, bits;
    8235              : 
    8236           78 :   if (e->expr_type != EXPR_CONSTANT || gfc_extract_int (e, &bits))
    8237              :     return NULL;
    8238              : 
    8239              :   kind = INT_MAX;
    8240              : 
    8241          396 :   for (i = 0; gfc_logical_kinds[i].kind != 0; i++)
    8242          330 :     if (gfc_logical_kinds[i].bit_size >= bits
    8243          180 :         && gfc_logical_kinds[i].kind < kind)
    8244          330 :       kind = gfc_logical_kinds[i].kind;
    8245              : 
    8246           66 :   if (kind == INT_MAX)
    8247            6 :     kind = -1;
    8248              : 
    8249           66 :   return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind);
    8250              : }
    8251              : 
    8252              : 
    8253              : gfc_expr *
    8254          987 : gfc_simplify_selected_real_kind (gfc_expr *p, gfc_expr *q, gfc_expr *rdx)
    8255              : {
    8256          987 :   int range, precision, radix, i, kind, found_precision, found_range,
    8257              :       found_radix;
    8258          987 :   locus *loc = &gfc_current_locus;
    8259              : 
    8260          987 :   if (p == NULL)
    8261           60 :     precision = 0;
    8262              :   else
    8263              :     {
    8264          927 :       if (p->expr_type != EXPR_CONSTANT
    8265          927 :           || gfc_extract_int (p, &precision))
    8266              :         return NULL;
    8267          881 :       loc = &p->where;
    8268              :     }
    8269              : 
    8270          941 :   if (q == NULL)
    8271          677 :     range = 0;
    8272              :   else
    8273              :     {
    8274          264 :       if (q->expr_type != EXPR_CONSTANT
    8275          264 :           || gfc_extract_int (q, &range))
    8276              :         return NULL;
    8277              : 
    8278              :       if (!loc)
    8279              :         loc = &q->where;
    8280              :     }
    8281              : 
    8282          887 :   if (rdx == NULL)
    8283          827 :     radix = 0;
    8284              :   else
    8285              :     {
    8286           60 :       if (rdx->expr_type != EXPR_CONSTANT
    8287           60 :           || gfc_extract_int (rdx, &radix))
    8288              :         return NULL;
    8289              : 
    8290              :       if (!loc)
    8291              :         loc = &rdx->where;
    8292              :     }
    8293              : 
    8294          863 :   kind = INT_MAX;
    8295          863 :   found_precision = 0;
    8296          863 :   found_range = 0;
    8297          863 :   found_radix = 0;
    8298              : 
    8299         4315 :   for (i = 0; gfc_real_kinds[i].kind != 0; i++)
    8300              :     {
    8301         3452 :       if (gfc_real_kinds[i].precision >= precision)
    8302         2336 :         found_precision = 1;
    8303              : 
    8304         3452 :       if (gfc_real_kinds[i].range >= range)
    8305         3332 :         found_range = 1;
    8306              : 
    8307         3452 :       if (radix == 0 || gfc_real_kinds[i].radix == radix)
    8308         3428 :         found_radix = 1;
    8309              : 
    8310         3452 :       if (gfc_real_kinds[i].precision >= precision
    8311         2336 :           && gfc_real_kinds[i].range >= range
    8312         2336 :           && (radix == 0 || gfc_real_kinds[i].radix == radix)
    8313         2312 :           && gfc_real_kinds[i].kind < kind)
    8314         3452 :         kind = gfc_real_kinds[i].kind;
    8315              :     }
    8316              : 
    8317          863 :   if (kind == INT_MAX)
    8318              :     {
    8319           12 :       if (found_radix && found_range && !found_precision)
    8320              :         kind = -1;
    8321            6 :       else if (found_radix && found_precision && !found_range)
    8322              :         kind = -2;
    8323            6 :       else if (found_radix && !found_precision && !found_range)
    8324              :         kind = -3;
    8325            6 :       else if (found_radix)
    8326              :         kind = -4;
    8327              :       else
    8328            6 :         kind = -5;
    8329              :     }
    8330              : 
    8331          863 :   return gfc_get_int_expr (gfc_default_integer_kind, loc, kind);
    8332              : }
    8333              : 
    8334              : 
    8335              : gfc_expr *
    8336          770 : gfc_simplify_set_exponent (gfc_expr *x, gfc_expr *i)
    8337              : {
    8338          770 :   gfc_expr *result;
    8339          770 :   mpfr_t exp, absv, log2, pow2, frac;
    8340          770 :   long exp2;
    8341              : 
    8342          770 :   if (x->expr_type != EXPR_CONSTANT || i->expr_type != EXPR_CONSTANT)
    8343              :     return NULL;
    8344              : 
    8345          150 :   result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
    8346              : 
    8347              :   /* SET_EXPONENT (+/-0.0, I) = +/- 0.0
    8348              :      SET_EXPONENT (NaN) = same NaN  */
    8349          150 :   if (mpfr_zero_p (x->value.real) || mpfr_nan_p (x->value.real))
    8350              :     {
    8351           18 :       mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    8352           18 :       return result;
    8353              :     }
    8354              : 
    8355              :   /* SET_EXPONENT (inf) = NaN  */
    8356          132 :   if (mpfr_inf_p (x->value.real))
    8357              :     {
    8358           12 :       mpfr_set_nan (result->value.real);
    8359           12 :       return result;
    8360              :     }
    8361              : 
    8362          120 :   gfc_set_model_kind (x->ts.kind);
    8363          120 :   mpfr_init (absv);
    8364          120 :   mpfr_init (log2);
    8365          120 :   mpfr_init (exp);
    8366          120 :   mpfr_init (pow2);
    8367          120 :   mpfr_init (frac);
    8368              : 
    8369          120 :   mpfr_abs (absv, x->value.real, GFC_RND_MODE);
    8370          120 :   mpfr_log2 (log2, absv, GFC_RND_MODE);
    8371              : 
    8372          120 :   mpfr_floor (log2, log2);
    8373          120 :   mpfr_add_ui (exp, log2, 1, GFC_RND_MODE);
    8374              : 
    8375              :   /* Old exponent value, and fraction.  */
    8376          120 :   mpfr_ui_pow (pow2, 2, exp, GFC_RND_MODE);
    8377              : 
    8378          120 :   mpfr_div (frac, x->value.real, pow2, GFC_RND_MODE);
    8379              : 
    8380              :   /* New exponent.  */
    8381          120 :   exp2 = mpz_get_si (i->value.integer);
    8382          120 :   mpfr_mul_2si (result->value.real, frac, exp2, GFC_RND_MODE);
    8383              : 
    8384          120 :   mpfr_clears (absv, log2, exp, pow2, frac, NULL);
    8385              : 
    8386          120 :   return range_check (result, "SET_EXPONENT");
    8387              : }
    8388              : 
    8389              : 
    8390              : gfc_expr *
    8391        12390 : gfc_simplify_shape (gfc_expr *source, gfc_expr *kind)
    8392              : {
    8393        12390 :   mpz_t shape[GFC_MAX_DIMENSIONS];
    8394        12390 :   gfc_expr *result, *e, *f;
    8395        12390 :   gfc_array_ref *ar;
    8396        12390 :   int n;
    8397        12390 :   bool t;
    8398        12390 :   int k = get_kind (BT_INTEGER, kind, "SHAPE", gfc_default_integer_kind);
    8399              : 
    8400        12390 :   if (source->rank == -1)
    8401              :     return NULL;
    8402              : 
    8403        11478 :   result = gfc_get_array_expr (BT_INTEGER, k, &source->where);
    8404        11478 :   result->shape = gfc_get_shape (1);
    8405        11478 :   mpz_init (result->shape[0]);
    8406              : 
    8407        11478 :   if (source->rank == 0)
    8408              :     return result;
    8409              : 
    8410        11427 :   if (source->expr_type == EXPR_VARIABLE)
    8411              :     {
    8412        11179 :       ar = gfc_find_array_ref (source);
    8413        11179 :       t = gfc_array_ref_shape (ar, shape);
    8414              :     }
    8415          248 :   else if (source->shape)
    8416              :     {
    8417           73 :       t = true;
    8418           73 :       for (n = 0; n < source->rank; n++)
    8419              :         {
    8420           48 :           mpz_init (shape[n]);
    8421           48 :           mpz_set (shape[n], source->shape[n]);
    8422              :         }
    8423              :     }
    8424              :   else
    8425              :     t = false;
    8426              : 
    8427        18191 :   for (n = 0; n < source->rank; n++)
    8428              :     {
    8429        15760 :       e = gfc_get_constant_expr (BT_INTEGER, k, &source->where);
    8430              : 
    8431        15760 :       if (t)
    8432         6750 :         mpz_set (e->value.integer, shape[n]);
    8433              :       else
    8434              :         {
    8435         9010 :           mpz_set_ui (e->value.integer, n + 1);
    8436              : 
    8437         9010 :           f = simplify_size (source, e, k);
    8438         9010 :           gfc_free_expr (e);
    8439         9010 :           if (f == NULL)
    8440              :             {
    8441         8995 :               gfc_free_expr (result);
    8442         8995 :               return NULL;
    8443              :             }
    8444              :           else
    8445              :             e = f;
    8446              :         }
    8447              : 
    8448         6765 :       if (e == &gfc_bad_expr || range_check (e, "SHAPE") == &gfc_bad_expr)
    8449              :         {
    8450            1 :           gfc_free_expr (result);
    8451            1 :           if (t)
    8452            1 :             gfc_clear_shape (shape, source->rank);
    8453              :           return &gfc_bad_expr;
    8454              :         }
    8455              : 
    8456         6764 :       gfc_constructor_append_expr (&result->value.constructor, e, NULL);
    8457              :     }
    8458              : 
    8459         2431 :   if (t)
    8460         2431 :     gfc_clear_shape (shape, source->rank);
    8461              : 
    8462         2431 :   mpz_set_si (result->shape[0], source->rank);
    8463              : 
    8464         2431 :   return result;
    8465              : }
    8466              : 
    8467              : 
    8468              : static gfc_expr *
    8469        43419 : simplify_size (gfc_expr *array, gfc_expr *dim, int k)
    8470              : {
    8471        43419 :   mpz_t size;
    8472        43419 :   gfc_expr *return_value;
    8473        43419 :   int d;
    8474        43419 :   gfc_ref *ref;
    8475              : 
    8476              :   /* For unary operations, the size of the result is given by the size
    8477              :      of the operand.  For binary ones, it's the size of the first operand
    8478              :      unless it is scalar, then it is the size of the second.  */
    8479        43419 :   if (array->expr_type == EXPR_OP && !array->value.op.uop)
    8480              :     {
    8481           44 :       gfc_expr* replacement;
    8482           44 :       gfc_expr* simplified;
    8483              : 
    8484           44 :       switch (array->value.op.op)
    8485              :         {
    8486              :           /* Unary operations.  */
    8487            7 :           case INTRINSIC_NOT:
    8488            7 :           case INTRINSIC_UPLUS:
    8489            7 :           case INTRINSIC_UMINUS:
    8490            7 :           case INTRINSIC_PARENTHESES:
    8491            7 :             replacement = array->value.op.op1;
    8492            7 :             break;
    8493              : 
    8494              :           /* Binary operations.  If any one of the operands is scalar, take
    8495              :              the other one's size.  If both of them are arrays, it does not
    8496              :              matter -- try to find one with known shape, if possible.  */
    8497           37 :           default:
    8498           37 :             if (array->value.op.op1->rank == 0)
    8499           25 :               replacement = array->value.op.op2;
    8500           12 :             else if (array->value.op.op2->rank == 0)
    8501              :               replacement = array->value.op.op1;
    8502              :             else
    8503              :               {
    8504            0 :                 simplified = simplify_size (array->value.op.op1, dim, k);
    8505            0 :                 if (simplified)
    8506              :                   return simplified;
    8507              : 
    8508            0 :                 replacement = array->value.op.op2;
    8509              :               }
    8510              :             break;
    8511              :         }
    8512              : 
    8513              :       /* Try to reduce it directly if possible.  */
    8514           44 :       simplified = simplify_size (replacement, dim, k);
    8515              : 
    8516              :       /* Otherwise, we build a new SIZE call.  This is hopefully at least
    8517              :          simpler than the original one.  */
    8518           44 :       if (!simplified)
    8519              :         {
    8520           20 :           gfc_expr *kind = gfc_get_int_expr (gfc_default_integer_kind, NULL, k);
    8521           20 :           simplified = gfc_build_intrinsic_call (gfc_current_ns,
    8522              :                                                  GFC_ISYM_SIZE, "size",
    8523              :                                                  array->where, 3,
    8524              :                                                  gfc_copy_expr (replacement),
    8525              :                                                  gfc_copy_expr (dim),
    8526              :                                                  kind);
    8527              :         }
    8528              :       return simplified;
    8529              :     }
    8530              : 
    8531        88300 :   for (ref = array->ref; ref; ref = ref->next)
    8532        41413 :     if (ref->type == REF_ARRAY && ref->u.ar.as
    8533        86342 :         && !gfc_resolve_array_spec (ref->u.ar.as, 0))
    8534              :       return NULL;
    8535              : 
    8536        43371 :   if (dim == NULL)
    8537              :     {
    8538        16883 :       if (!gfc_array_size (array, &size))
    8539              :         return NULL;
    8540              :     }
    8541              :   else
    8542              :     {
    8543        26488 :       if (dim->expr_type != EXPR_CONSTANT)
    8544              :         return NULL;
    8545              : 
    8546        26154 :       if (array->rank == -1)
    8547              :         return NULL;
    8548              : 
    8549        25440 :       d = mpz_get_si (dim->value.integer) - 1;
    8550        25440 :       if (d < 0 || d > array->rank - 1)
    8551              :         {
    8552            6 :           gfc_error ("DIM argument (%d) to intrinsic SIZE at %L out of range "
    8553              :                      "(1:%d)", d+1, &array->where, array->rank);
    8554            6 :           return &gfc_bad_expr;
    8555              :         }
    8556              : 
    8557        25434 :       if (!gfc_array_dimen_size (array, d, &size))
    8558              :         return NULL;
    8559              :     }
    8560              : 
    8561         5026 :   return_value = gfc_get_constant_expr (BT_INTEGER, k, &array->where);
    8562         5026 :   mpz_set (return_value->value.integer, size);
    8563         5026 :   mpz_clear (size);
    8564              : 
    8565         5026 :   return return_value;
    8566              : }
    8567              : 
    8568              : 
    8569              : gfc_expr *
    8570        33583 : gfc_simplify_size (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
    8571              : {
    8572        33583 :   gfc_expr *result;
    8573        33583 :   int k = get_kind (BT_INTEGER, kind, "SIZE", gfc_default_integer_kind);
    8574              : 
    8575        33583 :   if (k == -1)
    8576              :     return &gfc_bad_expr;
    8577              : 
    8578        33583 :   result = simplify_size (array, dim, k);
    8579        33583 :   if (result == NULL || result == &gfc_bad_expr)
    8580              :     return result;
    8581              : 
    8582         4624 :   return range_check (result, "SIZE");
    8583              : }
    8584              : 
    8585              : 
    8586              : /* SIZEOF and C_SIZEOF return the size in bytes of an array element
    8587              :    multiplied by the array size.  */
    8588              : 
    8589              : gfc_expr *
    8590         3447 : gfc_simplify_sizeof (gfc_expr *x)
    8591              : {
    8592         3447 :   gfc_expr *result = NULL;
    8593         3447 :   mpz_t array_size;
    8594         3447 :   size_t res_size;
    8595              : 
    8596         3447 :   if (x->ts.type == BT_CLASS || x->ts.deferred)
    8597              :     return NULL;
    8598              : 
    8599         2352 :   if (x->ts.type == BT_CHARACTER
    8600          249 :       && (!x->ts.u.cl || !x->ts.u.cl->length
    8601           75 :           || x->ts.u.cl->length->expr_type != EXPR_CONSTANT))
    8602              :     return NULL;
    8603              : 
    8604         2160 :   if (x->rank && x->expr_type != EXPR_ARRAY)
    8605              :     {
    8606         1394 :       if (!gfc_array_size (x, &array_size))
    8607              :         return NULL;
    8608              : 
    8609          174 :       mpz_clear (array_size);
    8610              :     }
    8611              : 
    8612          940 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_index_integer_kind,
    8613              :                                   &x->where);
    8614          940 :   gfc_target_expr_size (x, &res_size);
    8615          940 :   mpz_set_si (result->value.integer, res_size);
    8616              : 
    8617          940 :   return result;
    8618              : }
    8619              : 
    8620              : 
    8621              : /* STORAGE_SIZE returns the size in bits of a single array element.  */
    8622              : 
    8623              : gfc_expr *
    8624         1416 : gfc_simplify_storage_size (gfc_expr *x,
    8625              :                            gfc_expr *kind)
    8626              : {
    8627         1416 :   gfc_expr *result = NULL;
    8628         1416 :   int k;
    8629         1416 :   size_t siz;
    8630              : 
    8631         1416 :   if (x->ts.type == BT_CLASS || x->ts.deferred)
    8632              :     return NULL;
    8633              : 
    8634          863 :   if (x->ts.type == BT_CHARACTER && x->expr_type != EXPR_CONSTANT
    8635          297 :       && (!x->ts.u.cl || !x->ts.u.cl->length
    8636           96 :           || x->ts.u.cl->length->expr_type != EXPR_CONSTANT))
    8637              :     return NULL;
    8638              : 
    8639          662 :   k = get_kind (BT_INTEGER, kind, "STORAGE_SIZE", gfc_default_integer_kind);
    8640          662 :   if (k == -1)
    8641              :     return &gfc_bad_expr;
    8642              : 
    8643          662 :   result = gfc_get_constant_expr (BT_INTEGER, k, &x->where);
    8644              : 
    8645          662 :   gfc_element_size (x, &siz);
    8646          662 :   mpz_set_si (result->value.integer, siz);
    8647          662 :   mpz_mul_ui (result->value.integer, result->value.integer, BITS_PER_UNIT);
    8648              : 
    8649          662 :   return range_check (result, "STORAGE_SIZE");
    8650              : }
    8651              : 
    8652              : 
    8653              : gfc_expr *
    8654         1365 : gfc_simplify_sign (gfc_expr *x, gfc_expr *y)
    8655              : {
    8656         1365 :   gfc_expr *result;
    8657              : 
    8658         1365 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    8659              :     return NULL;
    8660              : 
    8661           95 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    8662              : 
    8663           95 :   switch (x->ts.type)
    8664              :     {
    8665           22 :       case BT_INTEGER:
    8666           22 :         mpz_abs (result->value.integer, x->value.integer);
    8667           22 :         if (mpz_sgn (y->value.integer) < 0)
    8668            0 :           mpz_neg (result->value.integer, result->value.integer);
    8669              :         break;
    8670              : 
    8671           73 :       case BT_REAL:
    8672           73 :         if (flag_sign_zero)
    8673           61 :           mpfr_copysign (result->value.real, x->value.real, y->value.real,
    8674              :                         GFC_RND_MODE);
    8675              :         else
    8676           24 :           mpfr_setsign (result->value.real, x->value.real,
    8677              :                         mpfr_sgn (y->value.real) < 0 ? 1 : 0, GFC_RND_MODE);
    8678              :         break;
    8679              : 
    8680            0 :       default:
    8681            0 :         gfc_internal_error ("Bad type in gfc_simplify_sign");
    8682              :     }
    8683              : 
    8684              :   return result;
    8685              : }
    8686              : 
    8687              : 
    8688              : gfc_expr *
    8689          849 : gfc_simplify_sin (gfc_expr *x)
    8690              : {
    8691          849 :   gfc_expr *result;
    8692              : 
    8693          849 :   if (x->expr_type != EXPR_CONSTANT)
    8694              :     return NULL;
    8695              : 
    8696          163 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    8697              : 
    8698          163 :   switch (x->ts.type)
    8699              :     {
    8700          106 :       case BT_REAL:
    8701          106 :         mpfr_sin (result->value.real, x->value.real, GFC_RND_MODE);
    8702          106 :         break;
    8703              : 
    8704           57 :       case BT_COMPLEX:
    8705           57 :         gfc_set_model (x->value.real);
    8706           57 :         mpc_sin (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    8707           57 :         break;
    8708              : 
    8709            0 :       default:
    8710            0 :         gfc_internal_error ("in gfc_simplify_sin(): Bad type");
    8711              :     }
    8712              : 
    8713          163 :   return range_check (result, "SIN");
    8714              : }
    8715              : 
    8716              : 
    8717              : gfc_expr *
    8718          316 : gfc_simplify_sinh (gfc_expr *x)
    8719              : {
    8720          316 :   gfc_expr *result;
    8721              : 
    8722          316 :   if (x->expr_type != EXPR_CONSTANT)
    8723              :     return NULL;
    8724              : 
    8725           46 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    8726              : 
    8727           46 :   switch (x->ts.type)
    8728              :     {
    8729           42 :       case BT_REAL:
    8730           42 :         mpfr_sinh (result->value.real, x->value.real, GFC_RND_MODE);
    8731           42 :         break;
    8732              : 
    8733            4 :       case BT_COMPLEX:
    8734            4 :         mpc_sinh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    8735            4 :         break;
    8736              : 
    8737            0 :       default:
    8738            0 :         gcc_unreachable ();
    8739              :     }
    8740              : 
    8741           46 :   return range_check (result, "SINH");
    8742              : }
    8743              : 
    8744              : 
    8745              : /* The argument is always a double precision real that is converted to
    8746              :    single precision.  TODO: Rounding!  */
    8747              : 
    8748              : gfc_expr *
    8749            3 : gfc_simplify_sngl (gfc_expr *a)
    8750              : {
    8751            3 :   gfc_expr *result;
    8752            3 :   int tmp1, tmp2;
    8753              : 
    8754            3 :   if (a->expr_type != EXPR_CONSTANT)
    8755              :     return NULL;
    8756              : 
    8757              :   /* For explicit conversion, turn off -Wconversion and -Wconversion-extra
    8758              :      warnings.  */
    8759            3 :   tmp1 = warn_conversion;
    8760            3 :   tmp2 = warn_conversion_extra;
    8761            3 :   warn_conversion = warn_conversion_extra = 0;
    8762              : 
    8763            3 :   result = gfc_real2real (a, gfc_default_real_kind);
    8764              : 
    8765            3 :   warn_conversion = tmp1;
    8766            3 :   warn_conversion_extra = tmp2;
    8767              : 
    8768            3 :   return range_check (result, "SNGL");
    8769              : }
    8770              : 
    8771              : 
    8772              : gfc_expr *
    8773          309 : gfc_simplify_spacing (gfc_expr *x)
    8774              : {
    8775          309 :   gfc_expr *result;
    8776          309 :   int i;
    8777          309 :   long int en, ep;
    8778              : 
    8779          309 :   if (x->expr_type != EXPR_CONSTANT)
    8780              :     return NULL;
    8781              : 
    8782           96 :   i = gfc_validate_kind (x->ts.type, x->ts.kind, false);
    8783           96 :   result = gfc_get_constant_expr (BT_REAL, x->ts.kind, &x->where);
    8784              : 
    8785              :   /* SPACING(+/- 0.0) = SPACING(TINY(0.0)) = TINY(0.0)  */
    8786           96 :   if (mpfr_zero_p (x->value.real))
    8787              :     {
    8788           12 :       mpfr_set (result->value.real, gfc_real_kinds[i].tiny, GFC_RND_MODE);
    8789           12 :       return result;
    8790              :     }
    8791              : 
    8792              :   /* SPACING(inf) = NaN  */
    8793           84 :   if (mpfr_inf_p (x->value.real))
    8794              :     {
    8795           12 :       mpfr_set_nan (result->value.real);
    8796           12 :       return result;
    8797              :     }
    8798              : 
    8799              :   /* SPACING(NaN) = same NaN  */
    8800           72 :   if (mpfr_nan_p (x->value.real))
    8801              :     {
    8802            6 :       mpfr_set (result->value.real, x->value.real, GFC_RND_MODE);
    8803            6 :       return result;
    8804              :     }
    8805              : 
    8806              :   /* In the Fortran 95 standard, the result is b**(e - p) where b, e, and p
    8807              :      are the radix, exponent of x, and precision.  This excludes the
    8808              :      possibility of subnormal numbers.  Fortran 2003 states the result is
    8809              :      b**max(e - p, emin - 1).  */
    8810              : 
    8811           66 :   ep = (long int) mpfr_get_exp (x->value.real) - gfc_real_kinds[i].digits;
    8812           66 :   en = (long int) gfc_real_kinds[i].min_exponent - 1;
    8813           66 :   en = en > ep ? en : ep;
    8814              : 
    8815           66 :   mpfr_set_ui (result->value.real, 1, GFC_RND_MODE);
    8816           66 :   mpfr_mul_2si (result->value.real, result->value.real, en, GFC_RND_MODE);
    8817              : 
    8818           66 :   return range_check (result, "SPACING");
    8819              : }
    8820              : 
    8821              : 
    8822              : gfc_expr *
    8823          950 : gfc_simplify_spread (gfc_expr *source, gfc_expr *dim_expr, gfc_expr *ncopies_expr)
    8824              : {
    8825          950 :   gfc_expr *result = NULL;
    8826          950 :   int nelem, i, j, dim, ncopies;
    8827          950 :   mpz_t size;
    8828              : 
    8829          950 :   if ((!gfc_is_constant_expr (source)
    8830          837 :        && !is_constant_array_expr (source))
    8831          132 :       || !gfc_is_constant_expr (dim_expr)
    8832         1082 :       || !gfc_is_constant_expr (ncopies_expr))
    8833              :     return NULL;
    8834              : 
    8835          132 :   gcc_assert (dim_expr->ts.type == BT_INTEGER);
    8836          132 :   gfc_extract_int (dim_expr, &dim);
    8837          132 :   dim -= 1;   /* zero-base DIM */
    8838              : 
    8839          132 :   gcc_assert (ncopies_expr->ts.type == BT_INTEGER);
    8840          132 :   gfc_extract_int (ncopies_expr, &ncopies);
    8841          132 :   ncopies = MAX (ncopies, 0);
    8842              : 
    8843              :   /* Do not allow the array size to exceed the limit for an array
    8844              :      constructor.  */
    8845          132 :   if (source->expr_type == EXPR_ARRAY)
    8846              :     {
    8847           37 :       if (!gfc_array_size (source, &size))
    8848            0 :         gfc_internal_error ("Failure getting length of a constant array.");
    8849              :     }
    8850              :   else
    8851           95 :     mpz_init_set_ui (size, 1);
    8852              : 
    8853          132 :   nelem = mpz_get_si (size) * ncopies;
    8854          132 :   if (nelem > flag_max_array_constructor)
    8855              :     {
    8856            3 :       if (gfc_init_expr_flag)
    8857              :         {
    8858            2 :           gfc_error ("The number of elements (%d) in the array constructor "
    8859              :                      "at %L requires an increase of the allowed %d upper "
    8860              :                      "limit.  See %<-fmax-array-constructor%> option.",
    8861              :                      nelem, &source->where, flag_max_array_constructor);
    8862            2 :           return &gfc_bad_expr;
    8863              :         }
    8864              :       else
    8865              :         return NULL;
    8866              :     }
    8867              : 
    8868          129 :   if (source->expr_type == EXPR_CONSTANT
    8869           40 :       || source->expr_type == EXPR_STRUCTURE)
    8870              :     {
    8871           95 :       gcc_assert (dim == 0);
    8872              : 
    8873           95 :       result = gfc_get_array_expr (source->ts.type, source->ts.kind,
    8874              :                                    &source->where);
    8875           95 :       if (source->ts.type == BT_DERIVED)
    8876            6 :         result->ts.u.derived = source->ts.u.derived;
    8877           95 :       result->rank = 1;
    8878           95 :       result->shape = gfc_get_shape (result->rank);
    8879           95 :       mpz_init_set_si (result->shape[0], ncopies);
    8880              : 
    8881          919 :       for (i = 0; i < ncopies; ++i)
    8882          729 :         gfc_constructor_append_expr (&result->value.constructor,
    8883              :                                      gfc_copy_expr (source), NULL);
    8884              :     }
    8885           34 :   else if (source->expr_type == EXPR_ARRAY)
    8886              :     {
    8887           34 :       int offset, rstride[GFC_MAX_DIMENSIONS], extent[GFC_MAX_DIMENSIONS];
    8888           34 :       gfc_constructor *source_ctor;
    8889              : 
    8890           34 :       gcc_assert (source->rank < GFC_MAX_DIMENSIONS);
    8891           34 :       gcc_assert (dim >= 0 && dim <= source->rank);
    8892              : 
    8893           34 :       result = gfc_get_array_expr (source->ts.type, source->ts.kind,
    8894              :                                    &source->where);
    8895           34 :       if (source->ts.type == BT_DERIVED)
    8896            1 :         result->ts.u.derived = source->ts.u.derived;
    8897           34 :       result->rank = source->rank + 1;
    8898           34 :       result->shape = gfc_get_shape (result->rank);
    8899              : 
    8900          120 :       for (i = 0, j = 0; i < result->rank; ++i)
    8901              :         {
    8902           86 :           if (i != dim)
    8903           52 :             mpz_init_set (result->shape[i], source->shape[j++]);
    8904              :           else
    8905           34 :             mpz_init_set_si (result->shape[i], ncopies);
    8906              : 
    8907           86 :           extent[i] = mpz_get_si (result->shape[i]);
    8908           86 :           rstride[i] = (i == 0) ? 1 : rstride[i-1] * extent[i-1];
    8909              :         }
    8910              : 
    8911           34 :       offset = 0;
    8912           34 :       for (source_ctor = gfc_constructor_first (source->value.constructor);
    8913          242 :            source_ctor; source_ctor = gfc_constructor_next (source_ctor))
    8914              :         {
    8915          732 :           for (i = 0; i < ncopies; ++i)
    8916          524 :             gfc_constructor_insert_expr (&result->value.constructor,
    8917              :                                          gfc_copy_expr (source_ctor->expr),
    8918          524 :                                          NULL, offset + i * rstride[dim]);
    8919              : 
    8920          390 :           offset += (dim == 0 ? ncopies : 1);
    8921              :         }
    8922              :     }
    8923              :   else
    8924              :     {
    8925            0 :       gfc_error ("Simplification of SPREAD at %C not yet implemented");
    8926            0 :       return &gfc_bad_expr;
    8927              :     }
    8928              : 
    8929          129 :   if (source->ts.type == BT_CHARACTER)
    8930           20 :     result->ts.u.cl = source->ts.u.cl;
    8931              : 
    8932              :   return result;
    8933              : }
    8934              : 
    8935              : 
    8936              : gfc_expr *
    8937         1359 : gfc_simplify_sqrt (gfc_expr *e)
    8938              : {
    8939         1359 :   gfc_expr *result = NULL;
    8940              : 
    8941         1359 :   if (e->expr_type != EXPR_CONSTANT)
    8942              :     return NULL;
    8943              : 
    8944          221 :   switch (e->ts.type)
    8945              :     {
    8946          164 :       case BT_REAL:
    8947          164 :         if (mpfr_cmp_si (e->value.real, 0) < 0)
    8948              :           {
    8949            0 :             gfc_error ("Argument of SQRT at %L has a negative value",
    8950              :                        &e->where);
    8951            0 :             return &gfc_bad_expr;
    8952              :           }
    8953          164 :         result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    8954          164 :         mpfr_sqrt (result->value.real, e->value.real, GFC_RND_MODE);
    8955          164 :         break;
    8956              : 
    8957           57 :       case BT_COMPLEX:
    8958           57 :         gfc_set_model (e->value.real);
    8959              : 
    8960           57 :         result = gfc_get_constant_expr (e->ts.type, e->ts.kind, &e->where);
    8961           57 :         mpc_sqrt (result->value.complex, e->value.complex, GFC_MPC_RND_MODE);
    8962           57 :         break;
    8963              : 
    8964            0 :       default:
    8965            0 :         gfc_internal_error ("invalid argument of SQRT at %L", &e->where);
    8966              :     }
    8967              : 
    8968          221 :   return range_check (result, "SQRT");
    8969              : }
    8970              : 
    8971              : 
    8972              : gfc_expr *
    8973         5325 : gfc_simplify_sum (gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
    8974              : {
    8975         5325 :   return simplify_transformation (array, dim, mask, 0, gfc_add);
    8976              : }
    8977              : 
    8978              : 
    8979              : /* Simplify COTAN(X) where X has the unit of radian.  */
    8980              : 
    8981              : gfc_expr *
    8982          230 : gfc_simplify_cotan (gfc_expr *x)
    8983              : {
    8984          230 :   gfc_expr *result;
    8985          230 :   mpc_t swp, *val;
    8986              : 
    8987          230 :   if (x->expr_type != EXPR_CONSTANT)
    8988              :     return NULL;
    8989              : 
    8990           26 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    8991              : 
    8992           26 :   switch (x->ts.type)
    8993              :     {
    8994           25 :     case BT_REAL:
    8995           25 :       mpfr_cot (result->value.real, x->value.real, GFC_RND_MODE);
    8996           25 :       break;
    8997              : 
    8998            1 :     case BT_COMPLEX:
    8999              :       /* There is no builtin mpc_cot, so compute cot = cos / sin.  */
    9000            1 :       val = &result->value.complex;
    9001            1 :       mpc_init2 (swp, mpfr_get_default_prec ());
    9002            1 :       mpc_sin_cos (*val, swp, x->value.complex, GFC_MPC_RND_MODE,
    9003              :                    GFC_MPC_RND_MODE);
    9004            1 :       mpc_div (*val, swp, *val, GFC_MPC_RND_MODE);
    9005            1 :       mpc_clear (swp);
    9006            1 :       break;
    9007              : 
    9008            0 :     default:
    9009            0 :       gcc_unreachable ();
    9010              :     }
    9011              : 
    9012           26 :   return range_check (result, "COTAN");
    9013              : }
    9014              : 
    9015              : 
    9016              : gfc_expr *
    9017          586 : gfc_simplify_tan (gfc_expr *x)
    9018              : {
    9019          586 :   gfc_expr *result;
    9020              : 
    9021          586 :   if (x->expr_type != EXPR_CONSTANT)
    9022              :     return NULL;
    9023              : 
    9024           46 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    9025              : 
    9026           46 :   switch (x->ts.type)
    9027              :     {
    9028           42 :       case BT_REAL:
    9029           42 :         mpfr_tan (result->value.real, x->value.real, GFC_RND_MODE);
    9030           42 :         break;
    9031              : 
    9032            4 :       case BT_COMPLEX:
    9033            4 :         mpc_tan (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    9034            4 :         break;
    9035              : 
    9036            0 :       default:
    9037            0 :         gcc_unreachable ();
    9038              :     }
    9039              : 
    9040           46 :   return range_check (result, "TAN");
    9041              : }
    9042              : 
    9043              : 
    9044              : gfc_expr *
    9045          316 : gfc_simplify_tanh (gfc_expr *x)
    9046              : {
    9047          316 :   gfc_expr *result;
    9048              : 
    9049          316 :   if (x->expr_type != EXPR_CONSTANT)
    9050              :     return NULL;
    9051              : 
    9052           46 :   result = gfc_get_constant_expr (x->ts.type, x->ts.kind, &x->where);
    9053              : 
    9054           46 :   switch (x->ts.type)
    9055              :     {
    9056           42 :       case BT_REAL:
    9057           42 :         mpfr_tanh (result->value.real, x->value.real, GFC_RND_MODE);
    9058           42 :         break;
    9059              : 
    9060            4 :       case BT_COMPLEX:
    9061            4 :         mpc_tanh (result->value.complex, x->value.complex, GFC_MPC_RND_MODE);
    9062            4 :         break;
    9063              : 
    9064            0 :       default:
    9065            0 :         gcc_unreachable ();
    9066              :     }
    9067              : 
    9068           46 :   return range_check (result, "TANH");
    9069              : }
    9070              : 
    9071              : 
    9072              : gfc_expr *
    9073          852 : gfc_simplify_tiny (gfc_expr *e)
    9074              : {
    9075          852 :   gfc_expr *result;
    9076          852 :   int i;
    9077              : 
    9078          852 :   i = gfc_validate_kind (BT_REAL, e->ts.kind, false);
    9079              : 
    9080          852 :   result = gfc_get_constant_expr (BT_REAL, e->ts.kind, &e->where);
    9081          852 :   mpfr_set (result->value.real, gfc_real_kinds[i].tiny, GFC_RND_MODE);
    9082              : 
    9083          852 :   return result;
    9084              : }
    9085              : 
    9086              : 
    9087              : gfc_expr *
    9088         1644 : gfc_simplify_trailz (gfc_expr *e)
    9089              : {
    9090         1644 :   unsigned long tz, bs;
    9091         1644 :   int i;
    9092              : 
    9093         1644 :   if (e->expr_type != EXPR_CONSTANT)
    9094              :     return NULL;
    9095              : 
    9096          312 :   i = gfc_validate_kind (e->ts.type, e->ts.kind, false);
    9097          312 :   bs = gfc_integer_kinds[i].bit_size;
    9098          312 :   tz = mpz_scan1 (e->value.integer, 0);
    9099              : 
    9100          312 :   return gfc_get_int_expr (gfc_default_integer_kind,
    9101          312 :                            &e->where, MIN (tz, bs));
    9102              : }
    9103              : 
    9104              : 
    9105              : gfc_expr *
    9106         3140 : gfc_simplify_transfer (gfc_expr *source, gfc_expr *mold, gfc_expr *size)
    9107              : {
    9108         3140 :   gfc_expr *result;
    9109         3140 :   gfc_expr *mold_element;
    9110         3140 :   size_t source_size;
    9111         3140 :   size_t result_size;
    9112         3140 :   size_t buffer_size;
    9113         3140 :   unsigned char *buffer;
    9114         3140 :   size_t result_length;
    9115              : 
    9116         3140 :   if (!gfc_is_constant_expr (source) || !gfc_is_constant_expr (size))
    9117              :     return NULL;
    9118              : 
    9119         1009 :   if (!gfc_resolve_expr (mold))
    9120              :     return NULL;
    9121         1009 :   if (gfc_init_expr_flag && !gfc_is_constant_expr (mold))
    9122              :     return NULL;
    9123              : 
    9124          963 :   if (!gfc_calculate_transfer_sizes (source, mold, size, &source_size,
    9125              :                                      &result_size, &result_length))
    9126              :     return NULL;
    9127              : 
    9128              :   /* Calculate the size of the source.  */
    9129          941 :   if (source->expr_type == EXPR_ARRAY)
    9130              :     {
    9131          239 :       mpz_t tmp;
    9132              : 
    9133          239 :       if (!gfc_array_size (source, &tmp))
    9134            0 :         gfc_internal_error ("Failure getting length of a constant array.");
    9135          239 :       mpz_clear (tmp);
    9136              :     }
    9137              : 
    9138              :   /* Set the number of elements in the result, and determine its size.  */
    9139              : 
    9140          941 :   if (mold->expr_type == EXPR_ARRAY || mold->rank || size)
    9141              :     {
    9142          304 :       result = gfc_get_array_expr (mold->ts.type, mold->ts.kind,
    9143              :                                    &source->where);
    9144          304 :       result->rank = 1;
    9145          304 :       result->shape = gfc_get_shape (1);
    9146          304 :       mpz_init_set_ui (result->shape[0], result_length);
    9147              :     }
    9148              :   else
    9149              :     {
    9150              :       /* Create an empty expression with the appropriate characteristics.  */
    9151          637 :       result = gfc_get_constant_expr (mold->ts.type, mold->ts.kind,
    9152              :                                       &source->where);
    9153          637 :       result->rank = 0;
    9154              :     }
    9155              : 
    9156          941 :   result->ts = mold->ts;
    9157              : 
    9158          342 :   mold_element = (mold->expr_type == EXPR_ARRAY && mold->value.constructor)
    9159         1103 :                  ? gfc_constructor_first (mold->value.constructor)->expr
    9160              :                  : mold;
    9161              : 
    9162              :   /* Set result character length, if needed.  Note that this needs to be
    9163              :      set even for array expressions, in order to pass this information into
    9164              :      gfc_target_interpret_expr.  */
    9165          941 :   if (result->ts.type == BT_CHARACTER && gfc_is_constant_expr (mold_element))
    9166              :     {
    9167          385 :       result->value.character.length = mold_element->value.character.length;
    9168              : 
    9169              :       /* Let the typespec of the result inherit the string length.
    9170              :          This is crucial if a resulting array has size zero.  */
    9171          385 :       if (mold_element->ts.u.cl->length)
    9172          260 :         result->ts.u.cl->length = gfc_copy_expr (mold_element->ts.u.cl->length);
    9173              :       else
    9174          125 :         result->ts.u.cl->length =
    9175          125 :           gfc_get_int_expr (gfc_charlen_int_kind, NULL,
    9176              :                             mold_element->value.character.length);
    9177              :     }
    9178              : 
    9179              :   /* Allocate the buffer to store the binary version of the source.  */
    9180          941 :   buffer_size = MAX (source_size, result_size);
    9181          941 :   buffer = (unsigned char*)alloca (buffer_size);
    9182          941 :   memset (buffer, 0, buffer_size);
    9183              : 
    9184              :   /* Now write source to the buffer.  */
    9185          941 :   gfc_target_encode_expr (source, buffer, buffer_size);
    9186              : 
    9187              :   /* And read the buffer back into the new expression.  */
    9188          941 :   gfc_target_interpret_expr (buffer, buffer_size, result, false);
    9189              : 
    9190          941 :   return result;
    9191              : }
    9192              : 
    9193              : 
    9194              : gfc_expr *
    9195         1709 : gfc_simplify_transpose (gfc_expr *matrix)
    9196              : {
    9197         1709 :   int row, matrix_rows, col, matrix_cols;
    9198         1709 :   gfc_expr *result;
    9199              : 
    9200         1709 :   if (!is_constant_array_expr (matrix))
    9201              :     return NULL;
    9202              : 
    9203           51 :   gcc_assert (matrix->rank == 2);
    9204              : 
    9205           51 :   if (matrix->shape == NULL)
    9206              :     return NULL;
    9207              : 
    9208           51 :   result = gfc_get_array_expr (matrix->ts.type, matrix->ts.kind,
    9209              :                                &matrix->where);
    9210           51 :   result->rank = 2;
    9211           51 :   result->shape = gfc_get_shape (result->rank);
    9212           51 :   mpz_init_set (result->shape[0], matrix->shape[1]);
    9213           51 :   mpz_init_set (result->shape[1], matrix->shape[0]);
    9214              : 
    9215           51 :   if (matrix->ts.type == BT_CHARACTER)
    9216           18 :     result->ts.u.cl = matrix->ts.u.cl;
    9217           33 :   else if (matrix->ts.type == BT_DERIVED)
    9218            7 :     result->ts.u.derived = matrix->ts.u.derived;
    9219              : 
    9220           51 :   matrix_rows = mpz_get_si (matrix->shape[0]);
    9221           51 :   matrix_cols = mpz_get_si (matrix->shape[1]);
    9222          225 :   for (row = 0; row < matrix_rows; ++row)
    9223          584 :     for (col = 0; col < matrix_cols; ++col)
    9224              :       {
    9225          820 :         gfc_expr *e = gfc_constructor_lookup_expr (matrix->value.constructor,
    9226          410 :                                                    col * matrix_rows + row);
    9227          410 :         gfc_constructor_insert_expr (&result->value.constructor,
    9228              :                                      gfc_copy_expr (e), &matrix->where,
    9229          410 :                                      row * matrix_cols + col);
    9230              :       }
    9231              : 
    9232              :   return result;
    9233              : }
    9234              : 
    9235              : 
    9236              : gfc_expr *
    9237         4775 : gfc_simplify_trim (gfc_expr *e)
    9238              : {
    9239         4775 :   gfc_expr *result;
    9240         4775 :   int count, i, len, lentrim;
    9241              : 
    9242         4775 :   if (e->expr_type != EXPR_CONSTANT)
    9243              :     return NULL;
    9244              : 
    9245           44 :   len = e->value.character.length;
    9246          196 :   for (count = 0, i = 1; i <= len; ++i)
    9247              :     {
    9248          196 :       if (e->value.character.string[len - i] == ' ')
    9249          152 :         count++;
    9250              :       else
    9251              :         break;
    9252              :     }
    9253              : 
    9254           44 :   lentrim = len - count;
    9255              : 
    9256           44 :   result = gfc_get_character_expr (e->ts.kind, &e->where, NULL, lentrim);
    9257          769 :   for (i = 0; i < lentrim; i++)
    9258          681 :     result->value.character.string[i] = e->value.character.string[i];
    9259              : 
    9260              :   return result;
    9261              : }
    9262              : 
    9263              : 
    9264              : gfc_expr *
    9265          407 : gfc_simplify_image_index (gfc_expr *coarray, gfc_expr *sub,
    9266              :                           gfc_expr *team ATTRIBUTE_UNUSED,
    9267              :                           gfc_expr *team_number ATTRIBUTE_UNUSED)
    9268              : {
    9269          407 :   gfc_expr *result;
    9270          407 :   gfc_ref *ref;
    9271          407 :   gfc_array_spec *as;
    9272          407 :   gfc_constructor *sub_cons;
    9273          407 :   bool first_image;
    9274          407 :   int d;
    9275              : 
    9276          407 :   if (!is_constant_array_expr (sub))
    9277              :     return NULL;
    9278              : 
    9279              :   /* Follow any component references.  */
    9280          291 :   as = coarray->symtree->n.sym->as;
    9281          596 :   for (ref = coarray->ref; ref; ref = ref->next)
    9282          305 :     if (ref->type == REF_COMPONENT)
    9283            8 :       as = ref->u.ar.as;
    9284              : 
    9285          291 :   if (!as || as->type == AS_DEFERRED)
    9286              :     return NULL;
    9287              : 
    9288              :   /* "valid sequence of cosubscripts" are required; thus, return 0 unless
    9289              :      the cosubscript addresses the first image.  */
    9290              : 
    9291          166 :   sub_cons = gfc_constructor_first (sub->value.constructor);
    9292          166 :   first_image = true;
    9293              : 
    9294          531 :   for (d = 1; d <= as->corank; d++)
    9295              :     {
    9296          255 :       gfc_expr *ca_bound;
    9297          255 :       int cmp;
    9298              : 
    9299          255 :       gcc_assert (sub_cons != NULL);
    9300              : 
    9301          255 :       ca_bound = simplify_bound_dim (coarray, NULL, d + as->rank, 0, as,
    9302              :                                      NULL, true);
    9303          255 :       if (ca_bound == NULL)
    9304              :         return NULL;
    9305              : 
    9306          201 :       if (ca_bound == &gfc_bad_expr)
    9307              :         return ca_bound;
    9308              : 
    9309          201 :       cmp = mpz_cmp (ca_bound->value.integer, sub_cons->expr->value.integer);
    9310              : 
    9311          201 :       if (cmp == 0)
    9312              :         {
    9313          139 :           gfc_free_expr (ca_bound);
    9314          139 :           sub_cons = gfc_constructor_next (sub_cons);
    9315          139 :           continue;
    9316              :         }
    9317              : 
    9318           62 :       first_image = false;
    9319              : 
    9320           62 :       if (cmp > 0)
    9321              :         {
    9322            1 :           gfc_error ("Out of bounds in IMAGE_INDEX at %L for dimension %d, "
    9323              :                      "SUB has %ld and COARRAY lower bound is %ld)",
    9324              :                      &coarray->where, d,
    9325              :                      mpz_get_si (sub_cons->expr->value.integer),
    9326              :                      mpz_get_si (ca_bound->value.integer));
    9327            1 :           gfc_free_expr (ca_bound);
    9328            1 :           return &gfc_bad_expr;
    9329              :         }
    9330              : 
    9331           61 :       gfc_free_expr (ca_bound);
    9332              : 
    9333              :       /* Check whether upperbound is valid for the multi-images case.  */
    9334           61 :       if (d < as->corank)
    9335              :         {
    9336           27 :           ca_bound = simplify_bound_dim (coarray, NULL, d + as->rank, 1, as,
    9337              :                                          NULL, true);
    9338           27 :           if (ca_bound == &gfc_bad_expr)
    9339              :             return ca_bound;
    9340              : 
    9341           27 :           if (ca_bound && ca_bound->expr_type == EXPR_CONSTANT
    9342           27 :               && mpz_cmp (ca_bound->value.integer,
    9343           27 :                           sub_cons->expr->value.integer) < 0)
    9344              :           {
    9345            1 :             gfc_error ("Out of bounds in IMAGE_INDEX at %L for dimension %d, "
    9346              :                        "SUB has %ld and COARRAY upper bound is %ld)",
    9347              :                        &coarray->where, d,
    9348              :                        mpz_get_si (sub_cons->expr->value.integer),
    9349              :                        mpz_get_si (ca_bound->value.integer));
    9350            1 :             gfc_free_expr (ca_bound);
    9351            1 :             return &gfc_bad_expr;
    9352              :           }
    9353              : 
    9354              :           if (ca_bound)
    9355           26 :             gfc_free_expr (ca_bound);
    9356              :         }
    9357              : 
    9358           60 :       sub_cons = gfc_constructor_next (sub_cons);
    9359              :     }
    9360              : 
    9361          110 :   gcc_assert (sub_cons == NULL);
    9362              : 
    9363          110 :   if (flag_coarray != GFC_FCOARRAY_SINGLE && !first_image)
    9364              :     return NULL;
    9365              : 
    9366           88 :   result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    9367              :                                   &gfc_current_locus);
    9368           88 :   if (first_image)
    9369           55 :     mpz_set_si (result->value.integer, 1);
    9370              :   else
    9371           33 :     mpz_set_si (result->value.integer, 0);
    9372              : 
    9373              :   return result;
    9374              : }
    9375              : 
    9376              : gfc_expr *
    9377          154 : gfc_simplify_image_status (gfc_expr *image, gfc_expr *team ATTRIBUTE_UNUSED)
    9378              : {
    9379          154 :   if (flag_coarray == GFC_FCOARRAY_NONE)
    9380              :     {
    9381            0 :       gfc_current_locus = *gfc_current_intrinsic_where;
    9382            0 :       gfc_fatal_error ("Coarrays disabled at %C, use %<-fcoarray=%> to enable");
    9383              :       return &gfc_bad_expr;
    9384              :     }
    9385              : 
    9386              :   /* Simplification is possible for fcoarray = single only.  For all other modes
    9387              :      the result depends on runtime conditions.  */
    9388          154 :   if (flag_coarray != GFC_FCOARRAY_SINGLE)
    9389              :     return NULL;
    9390              : 
    9391           23 :   if (gfc_is_constant_expr (image))
    9392              :     {
    9393           12 :       gfc_expr *result;
    9394           12 :       result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    9395              :                                       &image->where);
    9396           12 :       if (mpz_get_si (image->value.integer) == 1)
    9397            4 :         mpz_set_si (result->value.integer, 0);
    9398              :       else
    9399            8 :         mpz_set_si (result->value.integer, GFC_STAT_STOPPED_IMAGE);
    9400              :       return result;
    9401              :     }
    9402              :   else
    9403              :     return NULL;
    9404              : }
    9405              : 
    9406              : 
    9407              : gfc_expr *
    9408         3877 : gfc_simplify_this_image (gfc_expr *coarray, gfc_expr *dim,
    9409              :                          gfc_expr *team ATTRIBUTE_UNUSED)
    9410              : {
    9411         3877 :   if (flag_coarray != GFC_FCOARRAY_SINGLE)
    9412              :     return NULL;
    9413              : 
    9414              :   /* If no coarray argument has been passed.  */
    9415         1145 :   if (coarray == NULL)
    9416              :     {
    9417          631 :       gfc_expr *result;
    9418              :       /* FIXME: gfc_current_locus is wrong.  */
    9419          631 :       result = gfc_get_constant_expr (BT_INTEGER, gfc_default_integer_kind,
    9420              :                                       &gfc_current_locus);
    9421          631 :       mpz_set_si (result->value.integer, 1);
    9422          631 :       return result;
    9423              :     }
    9424              : 
    9425              :   /* For -fcoarray=single, this_image(A) is the same as lcobound(A).  */
    9426          514 :   return simplify_cobound (coarray, dim, NULL, 0);
    9427              : }
    9428              : 
    9429              : 
    9430              : gfc_expr *
    9431        15284 : gfc_simplify_ubound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
    9432              : {
    9433        15284 :   return simplify_bound (array, dim, kind, 1);
    9434              : }
    9435              : 
    9436              : gfc_expr *
    9437          656 : gfc_simplify_ucobound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind)
    9438              : {
    9439          656 :   return simplify_cobound (array, dim, kind, 1);
    9440              : }
    9441              : 
    9442              : 
    9443              : gfc_expr *
    9444          480 : gfc_simplify_unpack (gfc_expr *vector, gfc_expr *mask, gfc_expr *field)
    9445              : {
    9446          480 :   gfc_expr *result, *e;
    9447          480 :   gfc_constructor *vector_ctor, *mask_ctor, *field_ctor;
    9448              : 
    9449          480 :   if (!is_constant_array_expr (vector)
    9450          242 :       || !is_constant_array_expr (mask)
    9451          503 :       || (!gfc_is_constant_expr (field)
    9452           12 :           && !is_constant_array_expr (field)))
    9453              :     return NULL;
    9454              : 
    9455           23 :   result = gfc_get_array_expr (vector->ts.type, vector->ts.kind,
    9456              :                                &vector->where);
    9457           23 :   if (vector->ts.type == BT_DERIVED)
    9458            4 :     result->ts.u.derived = vector->ts.u.derived;
    9459           23 :   result->rank = mask->rank;
    9460           23 :   result->shape = gfc_copy_shape (mask->shape, mask->rank);
    9461              : 
    9462           23 :   if (vector->ts.type == BT_CHARACTER)
    9463            0 :     result->ts.u.cl = vector->ts.u.cl;
    9464              : 
    9465           23 :   vector_ctor = gfc_constructor_first (vector->value.constructor);
    9466           23 :   mask_ctor = gfc_constructor_first (mask->value.constructor);
    9467           23 :   field_ctor
    9468           23 :     = field->expr_type == EXPR_ARRAY
    9469           23 :                             ? gfc_constructor_first (field->value.constructor)
    9470              :                             : NULL;
    9471              : 
    9472          168 :   while (mask_ctor)
    9473              :     {
    9474          151 :       if (mask_ctor->expr->value.logical)
    9475              :         {
    9476           55 :           if (vector_ctor)
    9477              :             {
    9478           52 :               e = gfc_copy_expr (vector_ctor->expr);
    9479           52 :               vector_ctor = gfc_constructor_next (vector_ctor);
    9480              :             }
    9481              :           else
    9482              :             {
    9483            3 :               gfc_free_expr (result);
    9484            3 :               return NULL;
    9485              :             }
    9486              :         }
    9487           96 :       else if (field->expr_type == EXPR_ARRAY)
    9488              :         {
    9489           52 :           if (field_ctor)
    9490           49 :             e = gfc_copy_expr (field_ctor->expr);
    9491              :           else
    9492              :             {
    9493              :               /* Not enough elements in array FIELD.  */
    9494            3 :               gfc_free_expr (result);
    9495            3 :               return &gfc_bad_expr;
    9496              :             }
    9497              :         }
    9498              :       else
    9499           44 :         e = gfc_copy_expr (field);
    9500              : 
    9501          145 :       gfc_constructor_append_expr (&result->value.constructor, e, NULL);
    9502              : 
    9503          145 :       mask_ctor = gfc_constructor_next (mask_ctor);
    9504          145 :       field_ctor = gfc_constructor_next (field_ctor);
    9505              :     }
    9506              : 
    9507              :   return result;
    9508              : }
    9509              : 
    9510              : 
    9511              : gfc_expr *
    9512          410 : gfc_simplify_verify (gfc_expr *s, gfc_expr *set, gfc_expr *b, gfc_expr *kind)
    9513              : {
    9514          410 :   gfc_expr *result;
    9515          410 :   int back;
    9516          410 :   size_t index, len, lenset;
    9517          410 :   size_t i;
    9518          410 :   int k = get_kind (BT_INTEGER, kind, "VERIFY", gfc_default_integer_kind);
    9519              : 
    9520          410 :   if (k == -1)
    9521              :     return &gfc_bad_expr;
    9522              : 
    9523          410 :   if (s->expr_type != EXPR_CONSTANT || set->expr_type != EXPR_CONSTANT
    9524          158 :       || ( b != NULL && b->expr_type !=  EXPR_CONSTANT))
    9525              :     return NULL;
    9526              : 
    9527          150 :   if (b != NULL && b->value.logical != 0)
    9528              :     back = 1;
    9529              :   else
    9530           78 :     back = 0;
    9531              : 
    9532          156 :   result = gfc_get_constant_expr (BT_INTEGER, k, &s->where);
    9533              : 
    9534          156 :   len = s->value.character.length;
    9535          156 :   lenset = set->value.character.length;
    9536              : 
    9537          156 :   if (len == 0)
    9538              :     {
    9539            0 :       mpz_set_ui (result->value.integer, 0);
    9540            0 :       return result;
    9541              :     }
    9542              : 
    9543          156 :   if (back == 0)
    9544              :     {
    9545           78 :       if (lenset == 0)
    9546              :         {
    9547           18 :           mpz_set_ui (result->value.integer, 1);
    9548           18 :           return result;
    9549              :         }
    9550              : 
    9551           60 :       index = wide_strspn (s->value.character.string,
    9552           60 :                            set->value.character.string) + 1;
    9553           60 :       if (index > len)
    9554            0 :         index = 0;
    9555              : 
    9556              :     }
    9557              :   else
    9558              :     {
    9559           78 :       if (lenset == 0)
    9560              :         {
    9561           18 :           mpz_set_ui (result->value.integer, len);
    9562           18 :           return result;
    9563              :         }
    9564           96 :       for (index = len; index > 0; index --)
    9565              :         {
    9566          300 :           for (i = 0; i < lenset; i++)
    9567              :             {
    9568          240 :               if (s->value.character.string[index - 1]
    9569          240 :                   == set->value.character.string[i])
    9570              :                 break;
    9571              :             }
    9572           96 :           if (i == lenset)
    9573              :             break;
    9574              :         }
    9575              :     }
    9576              : 
    9577          120 :   mpz_set_ui (result->value.integer, index);
    9578          120 :   return result;
    9579              : }
    9580              : 
    9581              : 
    9582              : gfc_expr *
    9583           26 : gfc_simplify_xor (gfc_expr *x, gfc_expr *y)
    9584              : {
    9585           26 :   gfc_expr *result;
    9586           26 :   int kind;
    9587              : 
    9588           26 :   if (x->expr_type != EXPR_CONSTANT || y->expr_type != EXPR_CONSTANT)
    9589              :     return NULL;
    9590              : 
    9591            6 :   kind = x->ts.kind > y->ts.kind ? x->ts.kind : y->ts.kind;
    9592              : 
    9593            6 :   switch (x->ts.type)
    9594              :     {
    9595            0 :       case BT_INTEGER:
    9596            0 :         result = gfc_get_constant_expr (BT_INTEGER, kind, &x->where);
    9597            0 :         mpz_xor (result->value.integer, x->value.integer, y->value.integer);
    9598            0 :         return range_check (result, "XOR");
    9599              : 
    9600            6 :       case BT_LOGICAL:
    9601            6 :         return gfc_get_logical_expr (kind, &x->where,
    9602            6 :                                      (x->value.logical && !y->value.logical)
    9603            6 :                                      || (!x->value.logical && y->value.logical));
    9604              : 
    9605            0 :       default:
    9606            0 :         gcc_unreachable ();
    9607              :     }
    9608              : }
    9609              : 
    9610              : 
    9611              : /****************** Constant simplification *****************/
    9612              : 
    9613              : /* Master function to convert one constant to another.  While this is
    9614              :    used as a simplification function, it requires the destination type
    9615              :    and kind information which is supplied by a special case in
    9616              :    do_simplify().  */
    9617              : 
    9618              : gfc_expr *
    9619       178150 : gfc_convert_constant (gfc_expr *e, bt type, int kind)
    9620              : {
    9621       178150 :   gfc_expr *result, *(*f) (gfc_expr *, int);
    9622       178150 :   gfc_constructor *c, *t;
    9623              : 
    9624       178150 :   switch (e->ts.type)
    9625              :     {
    9626       156718 :     case BT_INTEGER:
    9627       156718 :       switch (type)
    9628              :         {
    9629              :         case BT_INTEGER:
    9630              :           f = gfc_int2int;
    9631              :           break;
    9632          152 :         case BT_UNSIGNED:
    9633          152 :           f = gfc_int2uint;
    9634          152 :           break;
    9635        64587 :         case BT_REAL:
    9636        64587 :           f = gfc_int2real;
    9637        64587 :           break;
    9638         1454 :         case BT_COMPLEX:
    9639         1454 :           f = gfc_int2complex;
    9640         1454 :           break;
    9641            0 :         case BT_LOGICAL:
    9642            0 :           f = gfc_int2log;
    9643            0 :           break;
    9644            0 :         default:
    9645            0 :           goto oops;
    9646              :         }
    9647              :       break;
    9648              : 
    9649          596 :     case BT_UNSIGNED:
    9650          596 :       switch (type)
    9651              :         {
    9652              :         case BT_INTEGER:
    9653              :           f = gfc_uint2int;
    9654              :           break;
    9655          223 :         case BT_UNSIGNED:
    9656          223 :           f = gfc_uint2uint;
    9657          223 :           break;
    9658           48 :         case BT_REAL:
    9659           48 :           f = gfc_uint2real;
    9660           48 :           break;
    9661            0 :         case BT_COMPLEX:
    9662            0 :           f = gfc_uint2complex;
    9663            0 :           break;
    9664            0 :         case BT_LOGICAL:
    9665            0 :           f = gfc_uint2log;
    9666            0 :           break;
    9667            0 :         default:
    9668            0 :           goto oops;
    9669              :         }
    9670              :       break;
    9671              : 
    9672        13808 :     case BT_REAL:
    9673        13808 :       switch (type)
    9674              :         {
    9675              :         case BT_INTEGER:
    9676              :           f = gfc_real2int;
    9677              :           break;
    9678            6 :         case BT_UNSIGNED:
    9679            6 :           f = gfc_real2uint;
    9680            6 :           break;
    9681        10581 :         case BT_REAL:
    9682        10581 :           f = gfc_real2real;
    9683        10581 :           break;
    9684         2017 :         case BT_COMPLEX:
    9685         2017 :           f = gfc_real2complex;
    9686         2017 :           break;
    9687            0 :         default:
    9688            0 :           goto oops;
    9689              :         }
    9690              :       break;
    9691              : 
    9692         2915 :     case BT_COMPLEX:
    9693         2915 :       switch (type)
    9694              :         {
    9695              :         case BT_INTEGER:
    9696              :           f = gfc_complex2int;
    9697              :           break;
    9698            6 :         case BT_UNSIGNED:
    9699            6 :           f = gfc_complex2uint;
    9700            6 :           break;
    9701          205 :         case BT_REAL:
    9702          205 :           f = gfc_complex2real;
    9703          205 :           break;
    9704         2648 :         case BT_COMPLEX:
    9705         2648 :           f = gfc_complex2complex;
    9706         2648 :           break;
    9707              : 
    9708            0 :         default:
    9709            0 :           goto oops;
    9710              :         }
    9711              :       break;
    9712              : 
    9713         2023 :     case BT_LOGICAL:
    9714         2023 :       switch (type)
    9715              :         {
    9716              :         case BT_INTEGER:
    9717              :           f = gfc_log2int;
    9718              :           break;
    9719            0 :         case BT_UNSIGNED:
    9720            0 :           f = gfc_log2uint;
    9721            0 :           break;
    9722         1793 :         case BT_LOGICAL:
    9723         1793 :           f = gfc_log2log;
    9724         1793 :           break;
    9725            0 :         default:
    9726            0 :           goto oops;
    9727              :         }
    9728              :       break;
    9729              : 
    9730         1330 :     case BT_HOLLERITH:
    9731         1330 :       switch (type)
    9732              :         {
    9733              :         case BT_INTEGER:
    9734              :           f = gfc_hollerith2int;
    9735              :           break;
    9736              : 
    9737              :           /* Hollerith is for legacy code, we do not currently support
    9738              :              converting this to UNSIGNED.  */
    9739            0 :         case BT_UNSIGNED:
    9740            0 :           goto oops;
    9741              : 
    9742          327 :         case BT_REAL:
    9743          327 :           f = gfc_hollerith2real;
    9744          327 :           break;
    9745              : 
    9746          288 :         case BT_COMPLEX:
    9747          288 :           f = gfc_hollerith2complex;
    9748          288 :           break;
    9749              : 
    9750          146 :         case BT_CHARACTER:
    9751          146 :           f = gfc_hollerith2character;
    9752          146 :           break;
    9753              : 
    9754          195 :         case BT_LOGICAL:
    9755          195 :           f = gfc_hollerith2logical;
    9756          195 :           break;
    9757              : 
    9758            0 :         default:
    9759            0 :           goto oops;
    9760              :         }
    9761              :       break;
    9762              : 
    9763          747 :     case BT_CHARACTER:
    9764          747 :       switch (type)
    9765              :         {
    9766              :         case BT_INTEGER:
    9767              :           f = gfc_character2int;
    9768              :           break;
    9769              : 
    9770            0 :         case BT_UNSIGNED:
    9771            0 :           goto oops;
    9772              : 
    9773          187 :         case BT_REAL:
    9774          187 :           f = gfc_character2real;
    9775          187 :           break;
    9776              : 
    9777          187 :         case BT_COMPLEX:
    9778          187 :           f = gfc_character2complex;
    9779          187 :           break;
    9780              : 
    9781            0 :         case BT_CHARACTER:
    9782            0 :           f = gfc_character2character;
    9783            0 :           break;
    9784              : 
    9785          186 :         case BT_LOGICAL:
    9786          186 :           f = gfc_character2logical;
    9787          186 :           break;
    9788              : 
    9789            0 :         default:
    9790            0 :           goto oops;
    9791              :         }
    9792              :       break;
    9793              : 
    9794              :     default:
    9795       178150 :     oops:
    9796              :       return &gfc_bad_expr;
    9797              :     }
    9798              : 
    9799       178137 :   result = NULL;
    9800              : 
    9801       178137 :   switch (e->expr_type)
    9802              :     {
    9803       131134 :     case EXPR_CONSTANT:
    9804       131134 :       result = f (e, kind);
    9805       131134 :       if (result == NULL)
    9806            6 :         return &gfc_bad_expr;
    9807              :       break;
    9808              : 
    9809         5070 :     case EXPR_ARRAY:
    9810         5070 :       if (!gfc_is_constant_expr (e))
    9811              :         break;
    9812              : 
    9813         4896 :       result = gfc_get_array_expr (type, kind, &e->where);
    9814         4896 :       result->shape = gfc_copy_shape (e->shape, e->rank);
    9815         4896 :       result->rank = e->rank;
    9816              : 
    9817         4896 :       for (c = gfc_constructor_first (e->value.constructor);
    9818        60578 :            c; c = gfc_constructor_next (c))
    9819              :         {
    9820        55719 :           gfc_expr *tmp;
    9821        55719 :           if (c->iterator == NULL)
    9822              :             {
    9823        55696 :               if (c->expr->expr_type == EXPR_ARRAY)
    9824           69 :                 tmp = gfc_convert_constant (c->expr, type, kind);
    9825        55627 :               else if (c->expr->expr_type == EXPR_OP)
    9826              :                 {
    9827           29 :                   if (!gfc_simplify_expr (c->expr, 1))
    9828              :                     return &gfc_bad_expr;
    9829           29 :                   tmp = f (c->expr, kind);
    9830              :                 }
    9831              :               else
    9832        55598 :                 tmp = f (c->expr, kind);
    9833              :             }
    9834              :           else
    9835           23 :             tmp = gfc_convert_constant (c->expr, type, kind);
    9836              : 
    9837        55719 :           if (tmp == NULL || tmp == &gfc_bad_expr)
    9838              :             {
    9839           37 :               gfc_free_expr (result);
    9840           37 :               return NULL;
    9841              :             }
    9842              : 
    9843        55682 :           t = gfc_constructor_append_expr (&result->value.constructor,
    9844              :                                            tmp, &c->where);
    9845        55682 :           if (c->iterator)
    9846            4 :             t->iterator = gfc_copy_iterator (c->iterator);
    9847              :         }
    9848              : 
    9849              :       break;
    9850              : 
    9851              :     default:
    9852              :       break;
    9853              :     }
    9854              : 
    9855              :   return result;
    9856              : }
    9857              : 
    9858              : 
    9859              : /* Function for converting character constants.  */
    9860              : gfc_expr *
    9861          256 : gfc_convert_char_constant (gfc_expr *e, bt type ATTRIBUTE_UNUSED, int kind)
    9862              : {
    9863          256 :   gfc_expr *result;
    9864          256 :   int i;
    9865              : 
    9866          256 :   if (!gfc_is_constant_expr (e))
    9867              :     return NULL;
    9868              : 
    9869          256 :   if (e->expr_type == EXPR_CONSTANT)
    9870              :     {
    9871              :       /* Simple case of a scalar.  */
    9872          237 :       result = gfc_get_constant_expr (BT_CHARACTER, kind, &e->where);
    9873          237 :       if (result == NULL)
    9874              :         return &gfc_bad_expr;
    9875              : 
    9876          237 :       result->value.character.length = e->value.character.length;
    9877          237 :       result->value.character.string
    9878          237 :         = gfc_get_wide_string (e->value.character.length + 1);
    9879          237 :       memcpy (result->value.character.string, e->value.character.string,
    9880          237 :               (e->value.character.length + 1) * sizeof (gfc_char_t));
    9881              : 
    9882              :       /* Check we only have values representable in the destination kind.  */
    9883         1285 :       for (i = 0; i < result->value.character.length; i++)
    9884         1052 :         if (!gfc_check_character_range (result->value.character.string[i],
    9885              :                                         kind))
    9886              :           {
    9887            4 :             gfc_error ("Character %qs in string at %L cannot be converted "
    9888              :                        "into character kind %d",
    9889            4 :                        gfc_print_wide_char (result->value.character.string[i]),
    9890              :                        &e->where, kind);
    9891            4 :             gfc_free_expr (result);
    9892            4 :             return &gfc_bad_expr;
    9893              :           }
    9894              : 
    9895              :       return result;
    9896              :     }
    9897           19 :   else if (e->expr_type == EXPR_ARRAY)
    9898              :     {
    9899              :       /* For an array constructor, we convert each constructor element.  */
    9900           19 :       gfc_constructor *c;
    9901              : 
    9902           19 :       result = gfc_get_array_expr (type, kind, &e->where);
    9903           19 :       result->shape = gfc_copy_shape (e->shape, e->rank);
    9904           19 :       result->rank = e->rank;
    9905           19 :       result->ts.u.cl = e->ts.u.cl;
    9906              : 
    9907           19 :       for (c = gfc_constructor_first (e->value.constructor);
    9908           76 :            c; c = gfc_constructor_next (c))
    9909              :         {
    9910           57 :           gfc_expr *tmp = gfc_convert_char_constant (c->expr, type, kind);
    9911           57 :           if (tmp == &gfc_bad_expr)
    9912              :             {
    9913            0 :               gfc_free_expr (result);
    9914            0 :               return &gfc_bad_expr;
    9915              :             }
    9916              : 
    9917           57 :           if (tmp == NULL)
    9918              :             {
    9919            0 :               gfc_free_expr (result);
    9920            0 :               return NULL;
    9921              :             }
    9922              : 
    9923           57 :           gfc_constructor_append_expr (&result->value.constructor,
    9924              :                                        tmp, &c->where);
    9925              :         }
    9926              : 
    9927              :       return result;
    9928              :     }
    9929              :   else
    9930              :     return NULL;
    9931              : }
    9932              : 
    9933              : 
    9934              : gfc_expr *
    9935            8 : gfc_simplify_compiler_options (void)
    9936              : {
    9937            8 :   char *str;
    9938            8 :   gfc_expr *result;
    9939              : 
    9940            8 :   str = gfc_get_option_string ();
    9941           16 :   result = gfc_get_character_expr (gfc_default_character_kind,
    9942            8 :                                    &gfc_current_locus, str, strlen (str));
    9943            8 :   free (str);
    9944            8 :   return result;
    9945              : }
    9946              : 
    9947              : 
    9948              : gfc_expr *
    9949           10 : gfc_simplify_compiler_version (void)
    9950              : {
    9951           10 :   char *buffer;
    9952           10 :   size_t len;
    9953              : 
    9954           10 :   len = strlen ("GCC version ") + strlen (version_string);
    9955           10 :   buffer = XALLOCAVEC (char, len + 1);
    9956           10 :   snprintf (buffer, len + 1, "GCC version %s", version_string);
    9957           10 :   return gfc_get_character_expr (gfc_default_character_kind,
    9958           10 :                                 &gfc_current_locus, buffer, len);
    9959              : }
    9960              : 
    9961              : /* Simplification routines for intrinsics of IEEE modules.  */
    9962              : 
    9963              : gfc_expr *
    9964          243 : simplify_ieee_selected_real_kind (gfc_expr *expr)
    9965              : {
    9966          243 :   gfc_actual_arglist *arg;
    9967          243 :   gfc_expr *p = NULL, *q = NULL, *rdx = NULL;
    9968              : 
    9969          243 :   arg = expr->value.function.actual;
    9970          243 :   p = arg->expr;
    9971          243 :   if (arg->next)
    9972              :     {
    9973          241 :       q = arg->next->expr;
    9974          241 :       if (arg->next->next)
    9975          241 :         rdx = arg->next->next->expr;
    9976              :     }
    9977              : 
    9978              :   /* Currently, if IEEE is supported and this module is built, it means
    9979              :      all our floating-point types conform to IEEE. Hence, we simply handle
    9980              :      IEEE_SELECTED_REAL_KIND like SELECTED_REAL_KIND.  */
    9981          243 :   return gfc_simplify_selected_real_kind (p, q, rdx);
    9982              : }
    9983              : 
    9984              : gfc_expr *
    9985          102 : simplify_ieee_support (gfc_expr *expr)
    9986              : {
    9987              :   /* We consider that if the IEEE modules are loaded, we have full support
    9988              :      for flags, halting and rounding, which are the three functions
    9989              :      (IEEE_SUPPORT_{FLAG,HALTING,ROUNDING}) allowed in constant
    9990              :      expressions. One day, we will need libgfortran to detect support and
    9991              :      communicate it back to us, allowing for partial support.  */
    9992              : 
    9993          102 :   return gfc_get_logical_expr (gfc_default_logical_kind, &expr->where,
    9994          102 :                                true);
    9995              : }
    9996              : 
    9997              : bool
    9998          993 : matches_ieee_function_name (gfc_symbol *sym, const char *name)
    9999              : {
   10000          993 :   int n = strlen(name);
   10001              : 
   10002          993 :   if (!strncmp(sym->name, name, n))
   10003              :     return true;
   10004              : 
   10005              :   /* If a generic was used and renamed, we need more work to find out.
   10006              :      Compare the specific name.  */
   10007          654 :   if (sym->generic && !strncmp(sym->generic->sym->name, name, n))
   10008            6 :     return true;
   10009              : 
   10010              :   return false;
   10011              : }
   10012              : 
   10013              : gfc_expr *
   10014          453 : gfc_simplify_ieee_functions (gfc_expr *expr)
   10015              : {
   10016          453 :   gfc_symbol* sym = expr->symtree->n.sym;
   10017              : 
   10018          453 :   if (matches_ieee_function_name(sym, "ieee_selected_real_kind"))
   10019          243 :     return simplify_ieee_selected_real_kind (expr);
   10020          210 :   else if (matches_ieee_function_name(sym, "ieee_support_flag")
   10021          174 :            || matches_ieee_function_name(sym, "ieee_support_halting")
   10022          366 :            || matches_ieee_function_name(sym, "ieee_support_rounding"))
   10023          102 :     return simplify_ieee_support (expr);
   10024              :   else
   10025              :     return NULL;
   10026              : }
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.