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 : }
|