1 /* Code translation -- generate GCC trees from gfc_code.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
3 Free Software Foundation, Inc.
4 Contributed by Paul Brook
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
26 #include "gimple.h" /* For create_tmp_var_raw. */
27 #include "tree-iterator.h"
28 #include "diagnostic-core.h" /* For internal_error. */
33 #include "trans-stmt.h"
34 #include "trans-array.h"
35 #include "trans-types.h"
36 #include "trans-const.h"
38 /* Naming convention for backend interface code:
40 gfc_trans_* translate gfc_code into STMT trees.
42 gfc_conv_* expression conversion
44 gfc_get_* get a backend tree representation of a decl or type */
46 static gfc_file *gfc_current_backend_file;
48 const char gfc_msg_fault[] = N_("Array reference out of bounds");
49 const char gfc_msg_wrong_return[] = N_("Incorrect function return value");
52 /* Advance along TREE_CHAIN n times. */
55 gfc_advance_chain (tree t, int n)
59 gcc_assert (t != NULL_TREE);
66 /* Strip off a legitimate source ending from the input
67 string NAME of length LEN. */
70 remove_suffix (char *name, int len)
74 for (i = 2; i < 8 && len > i; i++)
76 if (name[len - i] == '.')
85 /* Creates a variable declaration with a given TYPE. */
88 gfc_create_var_np (tree type, const char *prefix)
92 t = create_tmp_var_raw (type, prefix);
94 /* No warnings for anonymous variables. */
96 TREE_NO_WARNING (t) = 1;
102 /* Like above, but also adds it to the current scope. */
105 gfc_create_var (tree type, const char *prefix)
109 tmp = gfc_create_var_np (type, prefix);
117 /* If the expression is not constant, evaluate it now. We assign the
118 result of the expression to an artificially created variable VAR, and
119 return a pointer to the VAR_DECL node for this variable. */
122 gfc_evaluate_now_loc (location_t loc, tree expr, stmtblock_t * pblock)
126 if (CONSTANT_CLASS_P (expr))
129 var = gfc_create_var (TREE_TYPE (expr), NULL);
130 gfc_add_modify_loc (loc, pblock, var, expr);
137 gfc_evaluate_now (tree expr, stmtblock_t * pblock)
139 return gfc_evaluate_now_loc (input_location, expr, pblock);
143 /* Build a MODIFY_EXPR node and add it to a given statement block PBLOCK.
144 A MODIFY_EXPR is an assignment:
148 gfc_add_modify_loc (location_t loc, stmtblock_t * pblock, tree lhs, tree rhs)
152 #ifdef ENABLE_CHECKING
154 t1 = TREE_TYPE (rhs);
155 t2 = TREE_TYPE (lhs);
156 /* Make sure that the types of the rhs and the lhs are the same
157 for scalar assignments. We should probably have something
158 similar for aggregates, but right now removing that check just
159 breaks everything. */
161 || AGGREGATE_TYPE_P (TREE_TYPE (lhs)));
164 tmp = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, lhs,
166 gfc_add_expr_to_block (pblock, tmp);
171 gfc_add_modify (stmtblock_t * pblock, tree lhs, tree rhs)
173 gfc_add_modify_loc (input_location, pblock, lhs, rhs);
177 /* Create a new scope/binding level and initialize a block. Care must be
178 taken when translating expressions as any temporaries will be placed in
179 the innermost scope. */
182 gfc_start_block (stmtblock_t * block)
184 /* Start a new binding level. */
186 block->has_scope = 1;
188 /* The block is empty. */
189 block->head = NULL_TREE;
193 /* Initialize a block without creating a new scope. */
196 gfc_init_block (stmtblock_t * block)
198 block->head = NULL_TREE;
199 block->has_scope = 0;
203 /* Sometimes we create a scope but it turns out that we don't actually
204 need it. This function merges the scope of BLOCK with its parent.
205 Only variable decls will be merged, you still need to add the code. */
208 gfc_merge_block_scope (stmtblock_t * block)
213 gcc_assert (block->has_scope);
214 block->has_scope = 0;
216 /* Remember the decls in this scope. */
220 /* Add them to the parent scope. */
221 while (decl != NULL_TREE)
223 next = DECL_CHAIN (decl);
224 DECL_CHAIN (decl) = NULL_TREE;
232 /* Finish a scope containing a block of statements. */
235 gfc_finish_block (stmtblock_t * stmtblock)
241 expr = stmtblock->head;
243 expr = build_empty_stmt (input_location);
245 stmtblock->head = NULL_TREE;
247 if (stmtblock->has_scope)
253 block = poplevel (1, 0, 0);
254 expr = build3_v (BIND_EXPR, decl, expr, block);
264 /* Build an ADDR_EXPR and cast the result to TYPE. If TYPE is NULL, the
265 natural type is used. */
268 gfc_build_addr_expr (tree type, tree t)
270 tree base_type = TREE_TYPE (t);
273 if (type && POINTER_TYPE_P (type)
274 && TREE_CODE (base_type) == ARRAY_TYPE
275 && TYPE_MAIN_VARIANT (TREE_TYPE (type))
276 == TYPE_MAIN_VARIANT (TREE_TYPE (base_type)))
278 tree min_val = size_zero_node;
279 tree type_domain = TYPE_DOMAIN (base_type);
280 if (type_domain && TYPE_MIN_VALUE (type_domain))
281 min_val = TYPE_MIN_VALUE (type_domain);
282 t = fold (build4_loc (input_location, ARRAY_REF, TREE_TYPE (type),
283 t, min_val, NULL_TREE, NULL_TREE));
287 natural_type = build_pointer_type (base_type);
289 if (TREE_CODE (t) == INDIRECT_REF)
293 t = TREE_OPERAND (t, 0);
294 natural_type = TREE_TYPE (t);
298 tree base = get_base_address (t);
299 if (base && DECL_P (base))
300 TREE_ADDRESSABLE (base) = 1;
301 t = fold_build1_loc (input_location, ADDR_EXPR, natural_type, t);
304 if (type && natural_type != type)
305 t = convert (type, t);
311 /* Build an ARRAY_REF with its natural type. */
314 gfc_build_array_ref (tree base, tree offset, tree decl)
316 tree type = TREE_TYPE (base);
320 if (GFC_ARRAY_TYPE_P (type) && GFC_TYPE_ARRAY_RANK (type) == 0)
322 gcc_assert (GFC_TYPE_ARRAY_CORANK (type) > 0);
324 return fold_convert (TYPE_MAIN_VARIANT (type), base);
327 /* Scalar coarray, there is nothing to do. */
328 if (TREE_CODE (type) != ARRAY_TYPE)
330 gcc_assert (decl == NULL_TREE);
331 gcc_assert (integer_zerop (offset));
335 type = TREE_TYPE (type);
338 TREE_ADDRESSABLE (base) = 1;
340 /* Strip NON_LVALUE_EXPR nodes. */
341 STRIP_TYPE_NOPS (offset);
343 /* If the array reference is to a pointer, whose target contains a
344 subreference, use the span that is stored with the backend decl
345 and reference the element with pointer arithmetic. */
346 if (decl && (TREE_CODE (decl) == FIELD_DECL
347 || TREE_CODE (decl) == VAR_DECL
348 || TREE_CODE (decl) == PARM_DECL)
349 && ((GFC_DECL_SUBREF_ARRAY_P (decl)
350 && !integer_zerop (GFC_DECL_SPAN(decl)))
351 || GFC_DECL_CLASS (decl)))
353 if (GFC_DECL_CLASS (decl))
355 /* Allow for dummy arguments and other good things. */
356 if (POINTER_TYPE_P (TREE_TYPE (decl)))
357 decl = build_fold_indirect_ref_loc (input_location, decl);
359 /* Check if '_data' is an array descriptor. If it is not,
360 the array must be one of the components of the class object,
361 so return a normal array reference. */
362 if (!GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (gfc_class_data_get (decl))))
363 return build4_loc (input_location, ARRAY_REF, type, base,
364 offset, NULL_TREE, NULL_TREE);
366 span = gfc_vtable_size_get (decl);
368 else if (GFC_DECL_SUBREF_ARRAY_P (decl))
369 span = GFC_DECL_SPAN(decl);
373 offset = fold_build2_loc (input_location, MULT_EXPR,
374 gfc_array_index_type,
376 tmp = gfc_build_addr_expr (pvoid_type_node, base);
377 tmp = fold_build_pointer_plus_loc (input_location, tmp, offset);
378 tmp = fold_convert (build_pointer_type (type), tmp);
379 if (!TYPE_STRING_FLAG (type))
380 tmp = build_fold_indirect_ref_loc (input_location, tmp);
384 /* Otherwise use a straightforward array reference. */
385 return build4_loc (input_location, ARRAY_REF, type, base, offset,
386 NULL_TREE, NULL_TREE);
390 /* Generate a call to print a runtime error possibly including multiple
391 arguments and a locus. */
394 trans_runtime_error_vararg (bool error, locus* where, const char* msgid,
407 /* Compute the number of extra arguments from the format string. */
408 for (p = msgid, nargs = 0; *p; p++)
416 /* The code to generate the error. */
417 gfc_start_block (&block);
421 line = LOCATION_LINE (where->lb->location);
422 asprintf (&message, "At line %d of file %s", line,
423 where->lb->file->filename);
426 asprintf (&message, "In file '%s', around line %d",
427 gfc_source_file, input_line + 1);
429 arg = gfc_build_addr_expr (pchar_type_node,
430 gfc_build_localized_cstring_const (message));
433 asprintf (&message, "%s", _(msgid));
434 arg2 = gfc_build_addr_expr (pchar_type_node,
435 gfc_build_localized_cstring_const (message));
438 /* Build the argument array. */
439 argarray = XALLOCAVEC (tree, nargs + 2);
442 for (i = 0; i < nargs; i++)
443 argarray[2 + i] = va_arg (ap, tree);
445 /* Build the function call to runtime_(warning,error)_at; because of the
446 variable number of arguments, we can't use build_call_expr_loc dinput_location,
449 fntype = TREE_TYPE (gfor_fndecl_runtime_error_at);
451 fntype = TREE_TYPE (gfor_fndecl_runtime_warning_at);
453 loc = where ? where->lb->location : input_location;
454 tmp = fold_builtin_call_array (loc, TREE_TYPE (fntype),
455 fold_build1_loc (loc, ADDR_EXPR,
456 build_pointer_type (fntype),
458 ? gfor_fndecl_runtime_error_at
459 : gfor_fndecl_runtime_warning_at),
460 nargs + 2, argarray);
461 gfc_add_expr_to_block (&block, tmp);
463 return gfc_finish_block (&block);
468 gfc_trans_runtime_error (bool error, locus* where, const char* msgid, ...)
473 va_start (ap, msgid);
474 result = trans_runtime_error_vararg (error, where, msgid, ap);
480 /* Generate a runtime error if COND is true. */
483 gfc_trans_runtime_check (bool error, bool once, tree cond, stmtblock_t * pblock,
484 locus * where, const char * msgid, ...)
492 if (integer_zerop (cond))
497 tmpvar = gfc_create_var (boolean_type_node, "print_warning");
498 TREE_STATIC (tmpvar) = 1;
499 DECL_INITIAL (tmpvar) = boolean_true_node;
500 gfc_add_expr_to_block (pblock, tmpvar);
503 gfc_start_block (&block);
505 /* The code to generate the error. */
506 va_start (ap, msgid);
507 gfc_add_expr_to_block (&block,
508 trans_runtime_error_vararg (error, where,
512 gfc_add_modify (&block, tmpvar, boolean_false_node);
514 body = gfc_finish_block (&block);
516 if (integer_onep (cond))
518 gfc_add_expr_to_block (pblock, body);
522 /* Tell the compiler that this isn't likely. */
524 cond = fold_build2_loc (where->lb->location, TRUTH_AND_EXPR,
525 long_integer_type_node, tmpvar, cond);
527 cond = fold_convert (long_integer_type_node, cond);
529 cond = gfc_unlikely (cond);
530 tmp = fold_build3_loc (where->lb->location, COND_EXPR, void_type_node,
532 build_empty_stmt (where->lb->location));
533 gfc_add_expr_to_block (pblock, tmp);
538 /* Call malloc to allocate size bytes of memory, with special conditions:
539 + if size == 0, return a malloced area of size 1,
540 + if malloc returns NULL, issue a runtime error. */
542 gfc_call_malloc (stmtblock_t * block, tree type, tree size)
544 tree tmp, msg, malloc_result, null_result, res, malloc_tree;
547 size = gfc_evaluate_now (size, block);
549 if (TREE_TYPE (size) != TREE_TYPE (size_type_node))
550 size = fold_convert (size_type_node, size);
552 /* Create a variable to hold the result. */
553 res = gfc_create_var (prvoid_type_node, NULL);
556 gfc_start_block (&block2);
558 size = fold_build2_loc (input_location, MAX_EXPR, size_type_node, size,
559 build_int_cst (size_type_node, 1));
561 malloc_tree = builtin_decl_explicit (BUILT_IN_MALLOC);
562 gfc_add_modify (&block2, res,
563 fold_convert (prvoid_type_node,
564 build_call_expr_loc (input_location,
565 malloc_tree, 1, size)));
567 /* Optionally check whether malloc was successful. */
568 if (gfc_option.rtcheck & GFC_RTCHECK_MEM)
570 null_result = fold_build2_loc (input_location, EQ_EXPR,
571 boolean_type_node, res,
572 build_int_cst (pvoid_type_node, 0));
573 msg = gfc_build_addr_expr (pchar_type_node,
574 gfc_build_localized_cstring_const ("Memory allocation failed"));
575 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
577 build_call_expr_loc (input_location,
578 gfor_fndecl_os_error, 1, msg),
579 build_empty_stmt (input_location));
580 gfc_add_expr_to_block (&block2, tmp);
583 malloc_result = gfc_finish_block (&block2);
585 gfc_add_expr_to_block (block, malloc_result);
588 res = fold_convert (type, res);
593 /* Allocate memory, using an optional status argument.
595 This function follows the following pseudo-code:
598 allocate (size_t size, integer_type stat)
605 newmem = malloc (MAX (size, 1));
609 *stat = LIBERROR_ALLOCATION;
611 runtime_error ("Allocation would exceed memory limit");
616 gfc_allocate_using_malloc (stmtblock_t * block, tree pointer,
617 tree size, tree status)
619 tree tmp, on_error, error_cond;
620 tree status_type = status ? TREE_TYPE (status) : NULL_TREE;
622 /* Evaluate size only once, and make sure it has the right type. */
623 size = gfc_evaluate_now (size, block);
624 if (TREE_TYPE (size) != TREE_TYPE (size_type_node))
625 size = fold_convert (size_type_node, size);
627 /* If successful and stat= is given, set status to 0. */
628 if (status != NULL_TREE)
629 gfc_add_expr_to_block (block,
630 fold_build2_loc (input_location, MODIFY_EXPR, status_type,
631 status, build_int_cst (status_type, 0)));
633 /* The allocation itself. */
634 gfc_add_modify (block, pointer,
635 fold_convert (TREE_TYPE (pointer),
636 build_call_expr_loc (input_location,
637 builtin_decl_explicit (BUILT_IN_MALLOC), 1,
638 fold_build2_loc (input_location,
639 MAX_EXPR, size_type_node, size,
640 build_int_cst (size_type_node, 1)))));
642 /* What to do in case of error. */
643 if (status != NULL_TREE)
644 on_error = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
645 status, build_int_cst (status_type, LIBERROR_ALLOCATION));
647 on_error = build_call_expr_loc (input_location, gfor_fndecl_os_error, 1,
648 gfc_build_addr_expr (pchar_type_node,
649 gfc_build_localized_cstring_const
650 ("Allocation would exceed memory limit")));
652 error_cond = fold_build2_loc (input_location, EQ_EXPR,
653 boolean_type_node, pointer,
654 build_int_cst (prvoid_type_node, 0));
655 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
656 gfc_unlikely (error_cond), on_error,
657 build_empty_stmt (input_location));
659 gfc_add_expr_to_block (block, tmp);
663 /* Allocate memory, using an optional status argument.
665 This function follows the following pseudo-code:
668 allocate (size_t size, void** token, int *stat, char* errmsg, int errlen)
672 newmem = _caf_register (size, regtype, token, &stat, errmsg, errlen);
676 gfc_allocate_using_lib (stmtblock_t * block, tree pointer, tree size,
677 tree token, tree status, tree errmsg, tree errlen)
681 gcc_assert (token != NULL_TREE);
683 /* Evaluate size only once, and make sure it has the right type. */
684 size = gfc_evaluate_now (size, block);
685 if (TREE_TYPE (size) != TREE_TYPE (size_type_node))
686 size = fold_convert (size_type_node, size);
688 /* The allocation itself. */
689 if (status == NULL_TREE)
690 pstat = null_pointer_node;
692 pstat = gfc_build_addr_expr (NULL_TREE, status);
694 if (errmsg == NULL_TREE)
696 gcc_assert(errlen == NULL_TREE);
697 errmsg = null_pointer_node;
698 errlen = build_int_cst (integer_type_node, 0);
701 tmp = build_call_expr_loc (input_location,
702 gfor_fndecl_caf_register, 6,
703 fold_build2_loc (input_location,
704 MAX_EXPR, size_type_node, size,
705 build_int_cst (size_type_node, 1)),
706 build_int_cst (integer_type_node,
707 GFC_CAF_COARRAY_ALLOC),
708 token, pstat, errmsg, errlen);
710 tmp = fold_build2_loc (input_location, MODIFY_EXPR,
711 TREE_TYPE (pointer), pointer,
712 fold_convert ( TREE_TYPE (pointer), tmp));
713 gfc_add_expr_to_block (block, tmp);
717 /* Generate code for an ALLOCATE statement when the argument is an
718 allocatable variable. If the variable is currently allocated, it is an
719 error to allocate it again.
721 This function follows the following pseudo-code:
724 allocate_allocatable (void *mem, size_t size, integer_type stat)
727 return allocate (size, stat);
731 stat = LIBERROR_ALLOCATION;
733 runtime_error ("Attempting to allocate already allocated variable");
737 expr must be set to the original expression being allocated for its locus
738 and variable name in case a runtime error has to be printed. */
740 gfc_allocate_allocatable (stmtblock_t * block, tree mem, tree size, tree token,
741 tree status, tree errmsg, tree errlen, tree label_finish,
744 stmtblock_t alloc_block;
745 tree tmp, null_mem, alloc, error;
746 tree type = TREE_TYPE (mem);
748 if (TREE_TYPE (size) != TREE_TYPE (size_type_node))
749 size = fold_convert (size_type_node, size);
751 null_mem = gfc_unlikely (fold_build2_loc (input_location, NE_EXPR,
752 boolean_type_node, mem,
753 build_int_cst (type, 0)));
755 /* If mem is NULL, we call gfc_allocate_using_malloc or
756 gfc_allocate_using_lib. */
757 gfc_start_block (&alloc_block);
759 if (gfc_option.coarray == GFC_FCOARRAY_LIB
760 && gfc_expr_attr (expr).codimension)
764 gfc_allocate_using_lib (&alloc_block, mem, size, token, status,
766 if (status != NULL_TREE)
768 TREE_USED (label_finish) = 1;
769 tmp = build1_v (GOTO_EXPR, label_finish);
770 cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
771 status, build_zero_cst (TREE_TYPE (status)));
772 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
773 gfc_unlikely (cond), tmp,
774 build_empty_stmt (input_location));
775 gfc_add_expr_to_block (&alloc_block, tmp);
779 gfc_allocate_using_malloc (&alloc_block, mem, size, status);
781 alloc = gfc_finish_block (&alloc_block);
783 /* If mem is not NULL, we issue a runtime error or set the
789 gcc_assert (expr->expr_type == EXPR_VARIABLE && expr->symtree);
790 varname = gfc_build_cstring_const (expr->symtree->name);
791 varname = gfc_build_addr_expr (pchar_type_node, varname);
793 error = gfc_trans_runtime_error (true, &expr->where,
794 "Attempting to allocate already"
795 " allocated variable '%s'",
799 error = gfc_trans_runtime_error (true, NULL,
800 "Attempting to allocate already allocated"
803 if (status != NULL_TREE)
805 tree status_type = TREE_TYPE (status);
807 error = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
808 status, build_int_cst (status_type, LIBERROR_ALLOCATION));
811 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, null_mem,
813 gfc_add_expr_to_block (block, tmp);
817 /* Free a given variable, if it's not NULL. */
819 gfc_call_free (tree var)
822 tree tmp, cond, call;
824 if (TREE_TYPE (var) != TREE_TYPE (pvoid_type_node))
825 var = fold_convert (pvoid_type_node, var);
827 gfc_start_block (&block);
828 var = gfc_evaluate_now (var, &block);
829 cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, var,
830 build_int_cst (pvoid_type_node, 0));
831 call = build_call_expr_loc (input_location,
832 builtin_decl_explicit (BUILT_IN_FREE),
834 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, cond, call,
835 build_empty_stmt (input_location));
836 gfc_add_expr_to_block (&block, tmp);
838 return gfc_finish_block (&block);
843 /* User-deallocate; we emit the code directly from the front-end, and the
844 logic is the same as the previous library function:
847 deallocate (void *pointer, GFC_INTEGER_4 * stat)
854 runtime_error ("Attempt to DEALLOCATE unallocated memory.");
864 In this front-end version, status doesn't have to be GFC_INTEGER_4.
865 Moreover, if CAN_FAIL is true, then we will not emit a runtime error,
866 even when no status variable is passed to us (this is used for
867 unconditional deallocation generated by the front-end at end of
870 If a runtime-message is possible, `expr' must point to the original
871 expression being deallocated for its locus and variable name.
873 For coarrays, "pointer" must be the array descriptor and not its
876 gfc_deallocate_with_status (tree pointer, tree status, tree errmsg,
877 tree errlen, tree label_finish,
878 bool can_fail, gfc_expr* expr, bool coarray)
880 stmtblock_t null, non_null;
881 tree cond, tmp, error;
882 tree status_type = NULL_TREE;
883 tree caf_decl = NULL_TREE;
887 gcc_assert (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (pointer)));
889 pointer = gfc_conv_descriptor_data_get (caf_decl);
890 STRIP_NOPS (pointer);
893 cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, pointer,
894 build_int_cst (TREE_TYPE (pointer), 0));
896 /* When POINTER is NULL, we set STATUS to 1 if it's present, otherwise
897 we emit a runtime error. */
898 gfc_start_block (&null);
903 gcc_assert (expr && expr->expr_type == EXPR_VARIABLE && expr->symtree);
905 varname = gfc_build_cstring_const (expr->symtree->name);
906 varname = gfc_build_addr_expr (pchar_type_node, varname);
908 error = gfc_trans_runtime_error (true, &expr->where,
909 "Attempt to DEALLOCATE unallocated '%s'",
913 error = build_empty_stmt (input_location);
915 if (status != NULL_TREE && !integer_zerop (status))
919 status_type = TREE_TYPE (TREE_TYPE (status));
920 cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
921 status, build_int_cst (TREE_TYPE (status), 0));
922 tmp = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
923 fold_build1_loc (input_location, INDIRECT_REF,
924 status_type, status),
925 build_int_cst (status_type, 1));
926 error = fold_build3_loc (input_location, COND_EXPR, void_type_node,
930 gfc_add_expr_to_block (&null, error);
932 /* When POINTER is not NULL, we free it. */
933 gfc_start_block (&non_null);
934 if (!coarray || gfc_option.coarray != GFC_FCOARRAY_LIB)
936 tmp = build_call_expr_loc (input_location,
937 builtin_decl_explicit (BUILT_IN_FREE), 1,
938 fold_convert (pvoid_type_node, pointer));
939 gfc_add_expr_to_block (&non_null, tmp);
941 if (status != NULL_TREE && !integer_zerop (status))
943 /* We set STATUS to zero if it is present. */
944 tree status_type = TREE_TYPE (TREE_TYPE (status));
947 cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
949 build_int_cst (TREE_TYPE (status), 0));
950 tmp = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
951 fold_build1_loc (input_location, INDIRECT_REF,
952 status_type, status),
953 build_int_cst (status_type, 0));
954 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
955 gfc_unlikely (cond2), tmp,
956 build_empty_stmt (input_location));
957 gfc_add_expr_to_block (&non_null, tmp);
962 tree caf_type, token, cond2;
963 tree pstat = null_pointer_node;
965 if (errmsg == NULL_TREE)
967 gcc_assert (errlen == NULL_TREE);
968 errmsg = null_pointer_node;
969 errlen = build_zero_cst (integer_type_node);
973 gcc_assert (errlen != NULL_TREE);
974 if (!POINTER_TYPE_P (TREE_TYPE (errmsg)))
975 errmsg = gfc_build_addr_expr (NULL_TREE, errmsg);
978 caf_type = TREE_TYPE (caf_decl);
980 if (status != NULL_TREE && !integer_zerop (status))
982 gcc_assert (status_type == integer_type_node);
986 if (GFC_DESCRIPTOR_TYPE_P (caf_type)
987 && GFC_TYPE_ARRAY_AKIND (caf_type) == GFC_ARRAY_ALLOCATABLE)
988 token = gfc_conv_descriptor_token (caf_decl);
989 else if (DECL_LANG_SPECIFIC (caf_decl)
990 && GFC_DECL_TOKEN (caf_decl) != NULL_TREE)
991 token = GFC_DECL_TOKEN (caf_decl);
994 gcc_assert (GFC_ARRAY_TYPE_P (caf_type)
995 && GFC_TYPE_ARRAY_CAF_TOKEN (caf_type) != NULL_TREE);
996 token = GFC_TYPE_ARRAY_CAF_TOKEN (caf_type);
999 token = gfc_build_addr_expr (NULL_TREE, token);
1000 tmp = build_call_expr_loc (input_location,
1001 gfor_fndecl_caf_deregister, 4,
1002 token, pstat, errmsg, errlen);
1003 gfc_add_expr_to_block (&non_null, tmp);
1005 if (status != NULL_TREE)
1007 tree stat = build_fold_indirect_ref_loc (input_location, status);
1009 TREE_USED (label_finish) = 1;
1010 tmp = build1_v (GOTO_EXPR, label_finish);
1011 cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
1012 stat, build_zero_cst (TREE_TYPE (stat)));
1013 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
1014 gfc_unlikely (cond2), tmp,
1015 build_empty_stmt (input_location));
1016 gfc_add_expr_to_block (&non_null, tmp);
1020 return fold_build3_loc (input_location, COND_EXPR, void_type_node, cond,
1021 gfc_finish_block (&null),
1022 gfc_finish_block (&non_null));
1026 /* Generate code for deallocation of allocatable scalars (variables or
1027 components). Before the object itself is freed, any allocatable
1028 subcomponents are being deallocated. */
1031 gfc_deallocate_scalar_with_status (tree pointer, tree status, bool can_fail,
1032 gfc_expr* expr, gfc_typespec ts)
1034 stmtblock_t null, non_null;
1035 tree cond, tmp, error;
1037 cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, pointer,
1038 build_int_cst (TREE_TYPE (pointer), 0));
1040 /* When POINTER is NULL, we set STATUS to 1 if it's present, otherwise
1041 we emit a runtime error. */
1042 gfc_start_block (&null);
1047 gcc_assert (expr && expr->expr_type == EXPR_VARIABLE && expr->symtree);
1049 varname = gfc_build_cstring_const (expr->symtree->name);
1050 varname = gfc_build_addr_expr (pchar_type_node, varname);
1052 error = gfc_trans_runtime_error (true, &expr->where,
1053 "Attempt to DEALLOCATE unallocated '%s'",
1057 error = build_empty_stmt (input_location);
1059 if (status != NULL_TREE && !integer_zerop (status))
1061 tree status_type = TREE_TYPE (TREE_TYPE (status));
1064 cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
1065 status, build_int_cst (TREE_TYPE (status), 0));
1066 tmp = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
1067 fold_build1_loc (input_location, INDIRECT_REF,
1068 status_type, status),
1069 build_int_cst (status_type, 1));
1070 error = fold_build3_loc (input_location, COND_EXPR, void_type_node,
1074 gfc_add_expr_to_block (&null, error);
1076 /* When POINTER is not NULL, we free it. */
1077 gfc_start_block (&non_null);
1079 /* Free allocatable components. */
1080 if (ts.type == BT_DERIVED && ts.u.derived->attr.alloc_comp)
1082 tmp = build_fold_indirect_ref_loc (input_location, pointer);
1083 tmp = gfc_deallocate_alloc_comp (ts.u.derived, tmp, 0);
1084 gfc_add_expr_to_block (&non_null, tmp);
1086 else if (ts.type == BT_CLASS
1087 && ts.u.derived->components->ts.u.derived->attr.alloc_comp)
1089 tmp = build_fold_indirect_ref_loc (input_location, pointer);
1090 tmp = gfc_deallocate_alloc_comp (ts.u.derived->components->ts.u.derived,
1092 gfc_add_expr_to_block (&non_null, tmp);
1095 tmp = build_call_expr_loc (input_location,
1096 builtin_decl_explicit (BUILT_IN_FREE), 1,
1097 fold_convert (pvoid_type_node, pointer));
1098 gfc_add_expr_to_block (&non_null, tmp);
1100 if (status != NULL_TREE && !integer_zerop (status))
1102 /* We set STATUS to zero if it is present. */
1103 tree status_type = TREE_TYPE (TREE_TYPE (status));
1106 cond2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
1107 status, build_int_cst (TREE_TYPE (status), 0));
1108 tmp = fold_build2_loc (input_location, MODIFY_EXPR, status_type,
1109 fold_build1_loc (input_location, INDIRECT_REF,
1110 status_type, status),
1111 build_int_cst (status_type, 0));
1112 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, cond2,
1113 tmp, build_empty_stmt (input_location));
1114 gfc_add_expr_to_block (&non_null, tmp);
1117 return fold_build3_loc (input_location, COND_EXPR, void_type_node, cond,
1118 gfc_finish_block (&null),
1119 gfc_finish_block (&non_null));
1123 /* Reallocate MEM so it has SIZE bytes of data. This behaves like the
1124 following pseudo-code:
1127 internal_realloc (void *mem, size_t size)
1129 res = realloc (mem, size);
1130 if (!res && size != 0)
1131 _gfortran_os_error ("Allocation would exceed memory limit");
1139 gfc_call_realloc (stmtblock_t * block, tree mem, tree size)
1141 tree msg, res, nonzero, zero, null_result, tmp;
1142 tree type = TREE_TYPE (mem);
1144 size = gfc_evaluate_now (size, block);
1146 if (TREE_TYPE (size) != TREE_TYPE (size_type_node))
1147 size = fold_convert (size_type_node, size);
1149 /* Create a variable to hold the result. */
1150 res = gfc_create_var (type, NULL);
1152 /* Call realloc and check the result. */
1153 tmp = build_call_expr_loc (input_location,
1154 builtin_decl_explicit (BUILT_IN_REALLOC), 2,
1155 fold_convert (pvoid_type_node, mem), size);
1156 gfc_add_modify (block, res, fold_convert (type, tmp));
1157 null_result = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
1158 res, build_int_cst (pvoid_type_node, 0));
1159 nonzero = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, size,
1160 build_int_cst (size_type_node, 0));
1161 null_result = fold_build2_loc (input_location, TRUTH_AND_EXPR, boolean_type_node,
1162 null_result, nonzero);
1163 msg = gfc_build_addr_expr (pchar_type_node, gfc_build_localized_cstring_const
1164 ("Allocation would exceed memory limit"));
1165 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node,
1167 build_call_expr_loc (input_location,
1168 gfor_fndecl_os_error, 1, msg),
1169 build_empty_stmt (input_location));
1170 gfc_add_expr_to_block (block, tmp);
1172 /* if (size == 0) then the result is NULL. */
1173 tmp = fold_build2_loc (input_location, MODIFY_EXPR, type, res,
1174 build_int_cst (type, 0));
1175 zero = fold_build1_loc (input_location, TRUTH_NOT_EXPR, boolean_type_node,
1177 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, zero, tmp,
1178 build_empty_stmt (input_location));
1179 gfc_add_expr_to_block (block, tmp);
1185 /* Add an expression to another one, either at the front or the back. */
1188 add_expr_to_chain (tree* chain, tree expr, bool front)
1190 if (expr == NULL_TREE || IS_EMPTY_STMT (expr))
1195 if (TREE_CODE (*chain) != STATEMENT_LIST)
1201 append_to_statement_list (tmp, chain);
1206 tree_stmt_iterator i;
1208 i = tsi_start (*chain);
1209 tsi_link_before (&i, expr, TSI_CONTINUE_LINKING);
1212 append_to_statement_list (expr, chain);
1219 /* Add a statement at the end of a block. */
1222 gfc_add_expr_to_block (stmtblock_t * block, tree expr)
1225 add_expr_to_chain (&block->head, expr, false);
1229 /* Add a statement at the beginning of a block. */
1232 gfc_prepend_expr_to_block (stmtblock_t * block, tree expr)
1235 add_expr_to_chain (&block->head, expr, true);
1239 /* Add a block the end of a block. */
1242 gfc_add_block_to_block (stmtblock_t * block, stmtblock_t * append)
1244 gcc_assert (append);
1245 gcc_assert (!append->has_scope);
1247 gfc_add_expr_to_block (block, append->head);
1248 append->head = NULL_TREE;
1252 /* Save the current locus. The structure may not be complete, and should
1253 only be used with gfc_restore_backend_locus. */
1256 gfc_save_backend_locus (locus * loc)
1258 loc->lb = XCNEW (gfc_linebuf);
1259 loc->lb->location = input_location;
1260 loc->lb->file = gfc_current_backend_file;
1264 /* Set the current locus. */
1267 gfc_set_backend_locus (locus * loc)
1269 gfc_current_backend_file = loc->lb->file;
1270 input_location = loc->lb->location;
1274 /* Restore the saved locus. Only used in conjonction with
1275 gfc_save_backend_locus, to free the memory when we are done. */
1278 gfc_restore_backend_locus (locus * loc)
1280 gfc_set_backend_locus (loc);
1285 /* Translate an executable statement. The tree cond is used by gfc_trans_do.
1286 This static function is wrapped by gfc_trans_code_cond and
1290 trans_code (gfc_code * code, tree cond)
1296 return build_empty_stmt (input_location);
1298 gfc_start_block (&block);
1300 /* Translate statements one by one into GENERIC trees until we reach
1301 the end of this gfc_code branch. */
1302 for (; code; code = code->next)
1304 if (code->here != 0)
1306 res = gfc_trans_label_here (code);
1307 gfc_add_expr_to_block (&block, res);
1310 gfc_set_backend_locus (&code->loc);
1315 case EXEC_END_BLOCK:
1316 case EXEC_END_NESTED_BLOCK:
1317 case EXEC_END_PROCEDURE:
1322 if (code->expr1->ts.type == BT_CLASS)
1323 res = gfc_trans_class_assign (code->expr1, code->expr2, code->op);
1325 res = gfc_trans_assign (code);
1328 case EXEC_LABEL_ASSIGN:
1329 res = gfc_trans_label_assign (code);
1332 case EXEC_POINTER_ASSIGN:
1333 if (code->expr1->ts.type == BT_CLASS)
1334 res = gfc_trans_class_assign (code->expr1, code->expr2, code->op);
1336 res = gfc_trans_pointer_assign (code);
1339 case EXEC_INIT_ASSIGN:
1340 if (code->expr1->ts.type == BT_CLASS)
1341 res = gfc_trans_class_init_assign (code);
1343 res = gfc_trans_init_assign (code);
1351 res = gfc_trans_critical (code);
1355 res = gfc_trans_cycle (code);
1359 res = gfc_trans_exit (code);
1363 res = gfc_trans_goto (code);
1367 res = gfc_trans_entry (code);
1371 res = gfc_trans_pause (code);
1375 case EXEC_ERROR_STOP:
1376 res = gfc_trans_stop (code, code->op == EXEC_ERROR_STOP);
1380 /* For MVBITS we've got the special exception that we need a
1381 dependency check, too. */
1383 bool is_mvbits = false;
1385 if (code->resolved_isym)
1387 res = gfc_conv_intrinsic_subroutine (code);
1388 if (res != NULL_TREE)
1392 if (code->resolved_isym
1393 && code->resolved_isym->id == GFC_ISYM_MVBITS)
1396 res = gfc_trans_call (code, is_mvbits, NULL_TREE,
1402 res = gfc_trans_call (code, false, NULL_TREE,
1406 case EXEC_ASSIGN_CALL:
1407 res = gfc_trans_call (code, true, NULL_TREE,
1412 res = gfc_trans_return (code);
1416 res = gfc_trans_if (code);
1419 case EXEC_ARITHMETIC_IF:
1420 res = gfc_trans_arithmetic_if (code);
1424 res = gfc_trans_block_construct (code);
1428 res = gfc_trans_do (code, cond);
1431 case EXEC_DO_CONCURRENT:
1432 res = gfc_trans_do_concurrent (code);
1436 res = gfc_trans_do_while (code);
1440 res = gfc_trans_select (code);
1443 case EXEC_SELECT_TYPE:
1444 /* Do nothing. SELECT TYPE statements should be transformed into
1445 an ordinary SELECT CASE at resolution stage.
1446 TODO: Add an error message here once this is done. */
1451 res = gfc_trans_flush (code);
1455 case EXEC_SYNC_IMAGES:
1456 case EXEC_SYNC_MEMORY:
1457 res = gfc_trans_sync (code, code->op);
1462 res = gfc_trans_lock_unlock (code, code->op);
1466 res = gfc_trans_forall (code);
1470 res = gfc_trans_where (code);
1474 res = gfc_trans_allocate (code);
1477 case EXEC_DEALLOCATE:
1478 res = gfc_trans_deallocate (code);
1482 res = gfc_trans_open (code);
1486 res = gfc_trans_close (code);
1490 res = gfc_trans_read (code);
1494 res = gfc_trans_write (code);
1498 res = gfc_trans_iolength (code);
1501 case EXEC_BACKSPACE:
1502 res = gfc_trans_backspace (code);
1506 res = gfc_trans_endfile (code);
1510 res = gfc_trans_inquire (code);
1514 res = gfc_trans_wait (code);
1518 res = gfc_trans_rewind (code);
1522 res = gfc_trans_transfer (code);
1526 res = gfc_trans_dt_end (code);
1529 case EXEC_OMP_ATOMIC:
1530 case EXEC_OMP_BARRIER:
1531 case EXEC_OMP_CRITICAL:
1533 case EXEC_OMP_FLUSH:
1534 case EXEC_OMP_MASTER:
1535 case EXEC_OMP_ORDERED:
1536 case EXEC_OMP_PARALLEL:
1537 case EXEC_OMP_PARALLEL_DO:
1538 case EXEC_OMP_PARALLEL_SECTIONS:
1539 case EXEC_OMP_PARALLEL_WORKSHARE:
1540 case EXEC_OMP_SECTIONS:
1541 case EXEC_OMP_SINGLE:
1543 case EXEC_OMP_TASKWAIT:
1544 case EXEC_OMP_TASKYIELD:
1545 case EXEC_OMP_WORKSHARE:
1546 res = gfc_trans_omp_directive (code);
1550 internal_error ("gfc_trans_code(): Bad statement code");
1553 gfc_set_backend_locus (&code->loc);
1555 if (res != NULL_TREE && ! IS_EMPTY_STMT (res))
1557 if (TREE_CODE (res) != STATEMENT_LIST)
1558 SET_EXPR_LOCATION (res, input_location);
1560 /* Add the new statement to the block. */
1561 gfc_add_expr_to_block (&block, res);
1565 /* Return the finished block. */
1566 return gfc_finish_block (&block);
1570 /* Translate an executable statement with condition, cond. The condition is
1571 used by gfc_trans_do to test for IO result conditions inside implied
1572 DO loops of READ and WRITE statements. See build_dt in trans-io.c. */
1575 gfc_trans_code_cond (gfc_code * code, tree cond)
1577 return trans_code (code, cond);
1580 /* Translate an executable statement without condition. */
1583 gfc_trans_code (gfc_code * code)
1585 return trans_code (code, NULL_TREE);
1589 /* This function is called after a complete program unit has been parsed
1593 gfc_generate_code (gfc_namespace * ns)
1596 if (ns->is_block_data)
1598 gfc_generate_block_data (ns);
1602 gfc_generate_function_code (ns);
1606 /* This function is called after a complete module has been parsed
1610 gfc_generate_module_code (gfc_namespace * ns)
1613 struct module_htab_entry *entry;
1615 gcc_assert (ns->proc_name->backend_decl == NULL);
1616 ns->proc_name->backend_decl
1617 = build_decl (ns->proc_name->declared_at.lb->location,
1618 NAMESPACE_DECL, get_identifier (ns->proc_name->name),
1620 entry = gfc_find_module (ns->proc_name->name);
1621 if (entry->namespace_decl)
1622 /* Buggy sourcecode, using a module before defining it? */
1623 htab_empty (entry->decls);
1624 entry->namespace_decl = ns->proc_name->backend_decl;
1626 gfc_generate_module_vars (ns);
1628 /* We need to generate all module function prototypes first, to allow
1630 for (n = ns->contained; n; n = n->sibling)
1637 gfc_create_function_decl (n, false);
1638 DECL_CONTEXT (n->proc_name->backend_decl) = ns->proc_name->backend_decl;
1639 gfc_module_add_decl (entry, n->proc_name->backend_decl);
1640 for (el = ns->entries; el; el = el->next)
1642 DECL_CONTEXT (el->sym->backend_decl) = ns->proc_name->backend_decl;
1643 gfc_module_add_decl (entry, el->sym->backend_decl);
1647 for (n = ns->contained; n; n = n->sibling)
1652 gfc_generate_function_code (n);
1657 /* Initialize an init/cleanup block with existing code. */
1660 gfc_start_wrapped_block (gfc_wrapped_block* block, tree code)
1664 block->init = NULL_TREE;
1666 block->cleanup = NULL_TREE;
1670 /* Add a new pair of initializers/clean-up code. */
1673 gfc_add_init_cleanup (gfc_wrapped_block* block, tree init, tree cleanup)
1677 /* The new pair of init/cleanup should be "wrapped around" the existing
1678 block of code, thus the initialization is added to the front and the
1679 cleanup to the back. */
1680 add_expr_to_chain (&block->init, init, true);
1681 add_expr_to_chain (&block->cleanup, cleanup, false);
1685 /* Finish up a wrapped block by building a corresponding try-finally expr. */
1688 gfc_finish_wrapped_block (gfc_wrapped_block* block)
1694 /* Build the final expression. For this, just add init and body together,
1695 and put clean-up with that into a TRY_FINALLY_EXPR. */
1696 result = block->init;
1697 add_expr_to_chain (&result, block->code, false);
1699 result = build2_loc (input_location, TRY_FINALLY_EXPR, void_type_node,
1700 result, block->cleanup);
1702 /* Clear the block. */
1703 block->init = NULL_TREE;
1704 block->code = NULL_TREE;
1705 block->cleanup = NULL_TREE;
1711 /* Helper function for marking a boolean expression tree as unlikely. */
1714 gfc_unlikely (tree cond)
1718 cond = fold_convert (long_integer_type_node, cond);
1719 tmp = build_zero_cst (long_integer_type_node);
1720 cond = build_call_expr_loc (input_location,
1721 builtin_decl_explicit (BUILT_IN_EXPECT),
1723 cond = fold_convert (boolean_type_node, cond);
1728 /* Helper function for marking a boolean expression tree as likely. */
1731 gfc_likely (tree cond)
1735 cond = fold_convert (long_integer_type_node, cond);
1736 tmp = build_one_cst (long_integer_type_node);
1737 cond = build_call_expr_loc (input_location,
1738 builtin_decl_explicit (BUILT_IN_EXPECT),
1740 cond = fold_convert (boolean_type_node, cond);