/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc

Bug Summary

File:	build/gcc/fortran/trans-stmt.cc
Warning:	line 5609, column 46 Forming reference to null pointer
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name trans-stmt.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I fortran -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-KBirie.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc
1/* Statement translation -- generate GCC trees from gfc_code.
 Copyright (C) 2002-2023 Free Software Foundation, Inc.
 Contributed by Paul Brook <paul@nowt.org>
 and Steven Bosscher <s.bosscher@student.tudelft.nl>

6This file is part of GCC.

8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.

13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.

18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3.  If not see
20<http://www.gnu.org/licenses/>.  */


23#include "config.h"
24#include "system.h"
25#include "coretypes.h"
26#include "options.h"
27#include "tree.h"
28#include "gfortran.h"
29#include "trans.h"
30#include "stringpool.h"
31#include "fold-const.h"
32#include "trans-stmt.h"
33#include "trans-types.h"
34#include "trans-array.h"
35#include "trans-const.h"
36#include "dependency.h"

38typedef struct iter_info
39{
tree var;
tree start;
tree end;
tree step;
struct iter_info *next;
45}
46iter_info;

48typedef struct forall_info
49{
iter_info *this_loop;
tree mask;
tree maskindex;
int nvar;
tree size;
struct forall_info  *prev_nest;
bool do_concurrent;
57}
58forall_info;

60static void gfc_trans_where_2 (gfc_code *, tree, bool,
	       forall_info *, stmtblock_t *);

63/* Translate a F95 label number to a LABEL_EXPR.  */

65tree
66gfc_trans_label_here (gfc_code * code)
67{
return build1_v (LABEL_EXPR, gfc_get_label_decl (code->here))fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->here));
69}


72/* Given a variable expression which has been ASSIGNed to, find the decl
 containing the auxiliary variables.  For variables in common blocks this
 is a field_decl.  */

76void
77gfc_conv_label_variable (gfc_se * se, gfc_expr * expr)
78{
gcc_assert (expr->symtree->n.sym->attr.assign == 1)((void)(!(expr->symtree->n.sym->attr.assign == 1) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 79, __FUNCTION__), 0 : 0));
gfc_conv_expr (se, expr);
/* Deals with variable in common block. Get the field declaration.  */
if (TREE_CODE (se->expr)((enum tree_code) (se->expr)->base.code) == COMPONENT_REF)
  se->expr = TREE_OPERAND (se->expr, 1)(*((const_cast<tree*> (tree_operand_check ((se->expr
), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 83, __FUNCTION__)))));
/* Deals with dummy argument. Get the parameter declaration.  */
else if (TREE_CODE (se->expr)((enum tree_code) (se->expr)->base.code) == INDIRECT_REF)
  se->expr = TREE_OPERAND (se->expr, 0)(*((const_cast<tree*> (tree_operand_check ((se->expr
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 86, __FUNCTION__)))));
87}

89/* Translate a label assignment statement.  */

91tree
92gfc_trans_label_assign (gfc_code * code)
93{
tree label_tree;
gfc_se se;
tree len;
tree addr;
tree len_tree;
int label_len;

/* Start a new block.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);
gfc_conv_label_variable (&se, code->expr1);

len = GFC_DECL_STRING_LEN (se.expr)((contains_struct_check ((se.expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 106, __FUNCTION__))->decl_common.lang_specific)->stringlen;
addr = GFC_DECL_ASSIGN_ADDR (se.expr)((contains_struct_check ((se.expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 107, __FUNCTION__))->decl_common.lang_specific)->addr;

label_tree = gfc_get_label_decl (code->label1);

if (code->label1->defined == ST_LABEL_TARGET
    || code->label1->defined == ST_LABEL_DO_TARGET)
  {
    label_tree = gfc_build_addr_expr (pvoid_type_node, label_tree);
    len_tree = build_int_cst (gfc_charlen_type_node, -1);
  }
else
  {
    gfc_expr *format = code->label1->format;

    label_len = format->value.character.length;
    len_tree = build_int_cst (gfc_charlen_type_node, label_len);
    label_tree = gfc_build_wide_string_const (format->ts.kind, label_len + 1,
				format->value.character.string);
    label_tree = gfc_build_addr_expr (pvoid_type_node, label_tree);
  }

gfc_add_modify (&se.pre, len, fold_convert (TREE_TYPE (len), len_tree)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 128, __FUNCTION__))->typed.type), len_tree));
gfc_add_modify (&se.pre, addr, label_tree);

return gfc_finish_block (&se.pre);
132}

134/* Translate a GOTO statement.  */

136tree
137gfc_trans_goto (gfc_code * code)
138{
locus loc = code->loc;
tree assigned_goto;
tree target;
tree tmp;
gfc_se se;

if (code->label1 != NULL__null)
  return build1_v (GOTO_EXPR, gfc_get_label_decl (code->label1))fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->label1));

/* ASSIGNED GOTO.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);
gfc_conv_label_variable (&se, code->expr1);
tmp = GFC_DECL_STRING_LEN (se.expr)((contains_struct_check ((se.expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 152, __FUNCTION__))->decl_common.lang_specific)->stringlen;
tmp = fold_build2_loc (input_location, NE_EXPR, logical_type_node, tmp,
	 build_int_cst (TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 154, __FUNCTION__))->typed.type), -1));
gfc_trans_runtime_check (true, false, tmp, &se.pre, &loc,
	   "Assigned label is not a target label");

assigned_goto = GFC_DECL_ASSIGN_ADDR (se.expr)((contains_struct_check ((se.expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 158, __FUNCTION__))->decl_common.lang_specific)->addr;

/* We're going to ignore a label list.  It does not really change the
   statement's semantics (because it is just a further restriction on
   what's legal code); before, we were comparing label addresses here, but
   that's a very fragile business and may break with optimization.  So
   just ignore it.  */

target = fold_build1_loc (input_location, GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	    assigned_goto);
gfc_add_expr_to_block (&se.pre, target);
return gfc_finish_block (&se.pre);
170}


173/* Translate an ENTRY statement.  Just adds a label for this entry point.  */
174tree
175gfc_trans_entry (gfc_code * code)
176{
return build1_v (LABEL_EXPR, code->ext.entry->label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], code->ext.entry->label);
178}


181/* Replace a gfc_ss structure by another both in the gfc_se struct
 and the gfc_loopinfo struct.  This is used in gfc_conv_elemental_dependencies
 to replace a variable ss by the corresponding temporary.  */

185static void
186replace_ss (gfc_se *se, gfc_ss *old_ss, gfc_ss *new_ss)
187{
gfc_ss **sess, **loopss;

/* The old_ss is a ss for a single variable.  */
gcc_assert (old_ss->info->type == GFC_SS_SECTION)((void)(!(old_ss->info->type == GFC_SS_SECTION) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 191, __FUNCTION__), 0 : 0));

for (sess = &(se->ss); *sess != gfc_ss_terminator; sess = &((*sess)->next))
  if (*sess == old_ss)
    break;
gcc_assert (*sess != gfc_ss_terminator)((void)(!(*sess != gfc_ss_terminator) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 196, __FUNCTION__), 0 : 0));

*sess = new_ss;
new_ss->next = old_ss->next;

/* Make sure that trailing references are not lost.  */
if (old_ss->info
    && old_ss->info->data.array.ref
    && old_ss->info->data.array.ref->next
    && !(new_ss->info->data.array.ref
  && new_ss->info->data.array.ref->next))
  new_ss->info->data.array.ref = old_ss->info->data.array.ref;

for (loopss = &(se->loop->ss); *loopss != gfc_ss_terminator;
     loopss = &((*loopss)->loop_chain))
  if (*loopss == old_ss)
    break;
gcc_assert (*loopss != gfc_ss_terminator)((void)(!(*loopss != gfc_ss_terminator) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 213, __FUNCTION__), 0 : 0));

*loopss = new_ss;
new_ss->loop_chain = old_ss->loop_chain;
new_ss->loop = old_ss->loop;

gfc_free_ss (old_ss);
220}


223/* Check for dependencies between INTENT(IN) and INTENT(OUT) arguments of
 elemental subroutines.  Make temporaries for output arguments if any such
 dependencies are found.  Output arguments are chosen because internal_unpack
 can be used, as is, to copy the result back to the variable.  */
227static void
228gfc_conv_elemental_dependencies (gfc_se * se, gfc_se * loopse,
		 gfc_symbol * sym, gfc_actual_arglist * arg,
		 gfc_dep_check check_variable)
231{
gfc_actual_arglist *arg0;
gfc_expr *e;
gfc_formal_arglist *formal;
gfc_se parmse;
gfc_ss *ss;
gfc_symbol *fsym;
tree data;
tree size;
tree tmp;

if (loopse->ss == NULL__null)
  return;

ss = loopse->ss;
arg0 = arg;
formal = gfc_sym_get_dummy_args (sym);

/* Loop over all the arguments testing for dependencies.  */
for (; arg != NULL__null; arg = arg->next, formal = formal ? formal->next : NULL__null)
  {
    e = arg->expr;
    if (e == NULL__null)
continue;

    /* Obtain the info structure for the current argument.  */
    for (ss = loopse->ss; ss && ss != gfc_ss_terminator; ss = ss->next)
if (ss->info->expr == e)
 break;

    /* If there is a dependency, create a temporary and use it
instead of the variable.  */
    fsym = formal ? formal->sym : NULL__null;
    if (e->expr_type == EXPR_VARIABLE
   && e->rank && fsym
   && fsym->attr.intent != INTENT_IN
   && !fsym->attr.value
   && gfc_check_fncall_dependency (e, fsym->attr.intent,
			    sym, arg0, check_variable))
{
 tree initial, temptype;
 stmtblock_t temp_post;
 gfc_ss *tmp_ss;

 tmp_ss = gfc_get_array_ss (gfc_ss_terminator, NULL__null, ss->dimen,
		     GFC_SS_SECTION);
 gfc_mark_ss_chain_used (tmp_ss, 1);
 tmp_ss->info->expr = ss->info->expr;
 replace_ss (loopse, ss, tmp_ss);

 /* Obtain the argument descriptor for unpacking.  */
 gfc_init_se (&parmse, NULL__null);
 parmse.want_pointer = 1;
 gfc_conv_expr_descriptor (&parmse, e);
 gfc_add_block_to_block (&se->pre, &parmse.pre);

 /* If we've got INTENT(INOUT) or a derived type with INTENT(OUT),
    initialize the array temporary with a copy of the values.  */
 if (fsym->attr.intent == INTENT_INOUT
|| (fsym->ts.type ==BT_DERIVED
      && fsym->attr.intent == INTENT_OUT))
   initial = parmse.expr;
 /* For class expressions, we always initialize with the copy of
    the values.  */
 else if (e->ts.type == BT_CLASS)
   initial = parmse.expr;
 else
   initial = NULL_TREE(tree) __null;

 if (e->ts.type != BT_CLASS)
   {
    /* Find the type of the temporary to create; we don't use the type
of e itself as this breaks for subcomponent-references in e
(where the type of e is that of the final reference, but
parmse.expr's type corresponds to the full derived-type).  */
    /* TODO: Fix this somehow so we don't need a temporary of the whole
array but instead only the components referenced.  */
     temptype = TREE_TYPE (parmse.expr)((contains_struct_check ((parmse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 308, __FUNCTION__))->typed.type); /* Pointer to descriptor.  */
     gcc_assert (TREE_CODE (temptype) == POINTER_TYPE)((void)(!(((enum tree_code) (temptype)->base.code) == POINTER_TYPE
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 309, __FUNCTION__), 0 : 0));
     temptype = TREE_TYPE (temptype)((contains_struct_check ((temptype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 310, __FUNCTION__))->typed.type);
     temptype = gfc_get_element_type (temptype);
   }

 else
   /* For class arrays signal that the size of the dynamic type has to
      be obtained from the vtable, using the 'initial' expression.  */
   temptype = NULL_TREE(tree) __null;

 /* Generate the temporary.  Cleaning up the temporary should be the
    very last thing done, so we add the code to a new block and add it
    to se->post as last instructions.  */
 size = gfc_create_var (gfc_array_index_type, NULL__null);
 data = gfc_create_var (pvoid_type_node, NULL__null);
 gfc_init_block (&temp_post);
 tmp = gfc_trans_create_temp_array (&se->pre, &temp_post, tmp_ss,
			     temptype, initial, false, true,
			     false, &arg->expr->where);
 gfc_add_modify (&se->pre, size, tmp);
 tmp = fold_convert (pvoid_type_node, tmp_ss->info->data.array.data)fold_convert_loc (((location_t) 0), pvoid_type_node, tmp_ss->
info->data.array.data);
 gfc_add_modify (&se->pre, data, tmp);

 /* Update other ss' delta.  */
 gfc_set_delta (loopse->loop);

 /* Copy the result back using unpack.....  */
 if (e->ts.type != BT_CLASS)
   tmp = build_call_expr_loc (input_location,
	gfor_fndecl_in_unpack, 2, parmse.expr, data);
 else
   {
     /* ... except for class results where the copy is
 unconditional.  */
     tmp = build_fold_indirect_ref_loc (input_location, parmse.expr);
     tmp = gfc_conv_descriptor_data_get (tmp);
     tmp = build_call_expr_loc (input_location,
			 builtin_decl_explicit (BUILT_IN_MEMCPY),
			 3, tmp, data,
			 fold_convert (size_type_node, size)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], size));
   }
 gfc_add_expr_to_block (&se->post, tmp);

 /* parmse.pre is already added above.  */
 gfc_add_block_to_block (&se->post, &parmse.post);
 gfc_add_block_to_block (&se->post, &temp_post);
}
  }
357}


360/* Given an executable statement referring to an intrinsic function call,
 returns the intrinsic symbol.  */

363static gfc_intrinsic_sym *
364get_intrinsic_for_code (gfc_code *code)
365{
if (code->op == EXEC_CALL)
  {
    gfc_intrinsic_sym * const isym = code->resolved_isym;
    if (isym)
return isym;
    else
return gfc_get_intrinsic_for_expr (code->expr1);
  }

return NULL__null;
376}


379/* Translate the CALL statement.  Builds a call to an F95 subroutine.  */

381tree
382gfc_trans_call (gfc_code * code, bool dependency_check,
tree mask, tree count1, bool invert)
384{
gfc_se se;
gfc_ss * ss;
int has_alternate_specifier;
gfc_dep_check check_variable;
tree index = NULL_TREE(tree) __null;
tree maskexpr = NULL_TREE(tree) __null;
tree tmp;
bool is_intrinsic_mvbits;

/* A CALL starts a new block because the actual arguments may have to
   be evaluated first.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);

gcc_assert (code->resolved_sym)((void)(!(code->resolved_sym) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 399, __FUNCTION__), 0 : 0));

ss = gfc_ss_terminator;
if (code->resolved_sym->attr.elemental)
  ss = gfc_walk_elemental_function_args (ss, code->ext.actual,
			   get_intrinsic_for_code (code),
			   GFC_SS_REFERENCE);

/* MVBITS is inlined but needs the dependency checking found here.  */
is_intrinsic_mvbits = code->resolved_isym
	&& code->resolved_isym->id == GFC_ISYM_MVBITS;

/* Is not an elemental subroutine call with array valued arguments.  */
if (ss == gfc_ss_terminator)
  {

    if (is_intrinsic_mvbits)
{
 has_alternate_specifier = 0;
 gfc_conv_intrinsic_mvbits (&se, code->ext.actual, NULL__null);
}
    else
{
 /* Translate the call.  */
 has_alternate_specifier =
   gfc_conv_procedure_call (&se, code->resolved_sym,
		     code->ext.actual, code->expr1, NULL__null);

 /* A subroutine without side-effect, by definition, does nothing!  */
 TREE_SIDE_EFFECTS (se.expr)((non_type_check ((se.expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 428, __FUNCTION__))->base.side_effects_flag) = 1;
}

    /* Chain the pieces together and return the block.  */
    if (has_alternate_specifier)
{
 gfc_code *select_code;
 gfc_symbol *sym;
 select_code = code->next;
 gcc_assert(select_code->op == EXEC_SELECT)((void)(!(select_code->op == EXEC_SELECT) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 437, __FUNCTION__), 0 : 0));
 sym = select_code->expr1->symtree->n.sym;
 se.expr = convert (gfc_typenode_for_spec (&sym->ts), se.expr);
 if (sym->backend_decl == NULL__null)
   sym->backend_decl = gfc_get_symbol_decl (sym);
 gfc_add_modify (&se.pre, sym->backend_decl, se.expr);
}
    else
gfc_add_expr_to_block (&se.pre, se.expr);

    gfc_add_block_to_block (&se.finalblock, &se.post);
    gfc_add_block_to_block (&se.pre, &se.finalblock);
  }

else
  {
    /* An elemental subroutine call with array valued arguments has
to be scalarized.  */
    gfc_loopinfo loop;
    stmtblock_t body;
    stmtblock_t block;
    gfc_se loopse;
    gfc_se depse;

    /* gfc_walk_elemental_function_args renders the ss chain in the
reverse order to the actual argument order.  */
    ss = gfc_reverse_ss (ss);

    /* Initialize the loop.  */
    gfc_init_se (&loopse, NULL__null);
    gfc_init_loopinfo (&loop);
    gfc_add_ss_to_loop (&loop, ss);

    gfc_conv_ss_startstride (&loop);
    /* TODO: gfc_conv_loop_setup generates a temporary for vector
subscripts.  This could be prevented in the elemental case
as temporaries are handled separatedly
(below in gfc_conv_elemental_dependencies).  */
    if (code->expr1)
gfc_conv_loop_setup (&loop, &code->expr1->where);
    else
gfc_conv_loop_setup (&loop, &code->loc);

    gfc_mark_ss_chain_used (ss, 1);

    /* Convert the arguments, checking for dependencies.  */
    gfc_copy_loopinfo_to_se (&loopse, &loop);
    loopse.ss = ss;

    /* For operator assignment, do dependency checking.  */
    if (dependency_check)
check_variable = ELEM_CHECK_VARIABLE;
    else
check_variable = ELEM_DONT_CHECK_VARIABLE;

    gfc_init_se (&depse, NULL__null);
    gfc_conv_elemental_dependencies (&depse, &loopse, code->resolved_sym,
		       code->ext.actual, check_variable);

    gfc_add_block_to_block (&loop.pre,  &depse.pre);
    gfc_add_block_to_block (&loop.post, &depse.post);

    /* Generate the loop body.  */
    gfc_start_scalarized_body (&loop, &body);
    gfc_init_block (&block);

    if (mask && count1)
{
 /* Form the mask expression according to the mask.  */
 index = count1;
 maskexpr = gfc_build_array_ref (mask, index, NULL__null);
 if (invert)
   maskexpr = fold_build1_loc (input_location, TRUTH_NOT_EXPR,
			TREE_TYPE (maskexpr)((contains_struct_check ((maskexpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 510, __FUNCTION__))->typed.type), maskexpr);
}

    if (is_intrinsic_mvbits)
{
 has_alternate_specifier = 0;
 gfc_conv_intrinsic_mvbits (&loopse, code->ext.actual, &loop);
}
    else
{
 /* Add the subroutine call to the block.  */
 gfc_conv_procedure_call (&loopse, code->resolved_sym,
		   code->ext.actual, code->expr1,
		   NULL__null);
}

    if (mask && count1)
{
 tmp = build3_v (COND_EXPR, maskexpr, loopse.expr,fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], maskexpr, loopse.expr, build_empty_stmt (input_location))
	  build_empty_stmt (input_location))fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], maskexpr, loopse.expr, build_empty_stmt (input_location));
 gfc_add_expr_to_block (&loopse.pre, tmp);
 tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type,
		 count1, gfc_index_one_nodegfc_rank_cst[1]);
 gfc_add_modify (&loopse.pre, count1, tmp);
}
    else
gfc_add_expr_to_block (&loopse.pre, loopse.expr);

    gfc_add_block_to_block (&block, &loopse.pre);
    gfc_add_block_to_block (&block, &loopse.post);

    /* Finish up the loop block and the loop.  */
    gfc_add_expr_to_block (&body, gfc_finish_block (&block));
    gfc_trans_scalarizing_loops (&loop, &body);
    gfc_add_block_to_block (&se.pre, &loop.pre);
    gfc_add_block_to_block (&se.pre, &loop.post);
    gfc_add_block_to_block (&se.pre, &loopse.finalblock);
    gfc_add_block_to_block (&se.pre, &se.post);
    gfc_cleanup_loop (&loop);
  }

return gfc_finish_block (&se.pre);
553}


556/* Translate the RETURN statement.  */

558tree
559gfc_trans_return (gfc_code * code)
560{
if (code->expr1)
  {
    gfc_se se;
    tree tmp;
    tree result;

    /* If code->expr is not NULL, this return statement must appear
in a subroutine and current_fake_result_decl has already
been generated.  */

    result = gfc_get_fake_result_decl (NULL__null, 0);
    if (!result)
{
 gfc_warning (0,
       "An alternate return at %L without a * dummy argument",
       &code->expr1->where);
 return gfc_generate_return ();
}

    /* Start a new block for this statement.  */
    gfc_init_se (&se, NULL__null);
    gfc_start_block (&se.pre);

    gfc_conv_expr (&se, code->expr1);

    /* Note that the actually returned expression is a simple value and
does not depend on any pointers or such; thus we can clean-up with
se.post before returning.  */
    tmp = fold_build2_loc (input_location, MODIFY_EXPR, TREE_TYPE (result)((contains_struct_check ((result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 589, __FUNCTION__))->typed.type),
	     result, fold_convert (TREE_TYPE (result),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 590, __FUNCTION__))->typed.type), se.expr)
	     se.expr)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 590, __FUNCTION__))->typed.type), se.expr));
    gfc_add_expr_to_block (&se.pre, tmp);
    gfc_add_block_to_block (&se.pre, &se.post);

    tmp = gfc_generate_return ();
    gfc_add_expr_to_block (&se.pre, tmp);
    return gfc_finish_block (&se.pre);
  }

return gfc_generate_return ();
601}


604/* Translate the PAUSE statement.  We have to translate this statement
 to a runtime library call.  */

607tree
608gfc_trans_pause (gfc_code * code)
609{
tree gfc_int8_type_node = gfc_get_int_type (8);
gfc_se se;
tree tmp;

/* Start a new block for this statement.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);


if (code->expr1 == NULL__null)
  {
    tmp = build_int_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE], 0);
    tmp = build_call_expr_loc (input_location,
		 gfor_fndecl_pause_string, 2,
		 build_int_cst (pchar_type_node, 0), tmp);
  }
else if (code->expr1->ts.type == BT_INTEGER)
  {
    gfc_conv_expr (&se, code->expr1);
    tmp = build_call_expr_loc (input_location,
		 gfor_fndecl_pause_numeric, 1,
		 fold_convert (gfc_int8_type_node, se.expr)fold_convert_loc (((location_t) 0), gfc_int8_type_node, se.expr
));
  }
else
  {
    gfc_conv_expr_reference (&se, code->expr1);
    tmp = build_call_expr_loc (input_location,
	     gfor_fndecl_pause_string, 2,
		 se.expr, fold_convert (size_type_node,fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], se.string_length)
					se.string_length)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], se.string_length));
  }

gfc_add_expr_to_block (&se.pre, tmp);

gfc_add_block_to_block (&se.pre, &se.post);

return gfc_finish_block (&se.pre);
647}


650/* Translate the STOP statement.  We have to translate this statement
 to a runtime library call.  */

653tree
654gfc_trans_stop (gfc_code *code, bool error_stop)
655{
gfc_se se;
tree tmp;
tree quiet;

/* Start a new block for this statement.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);

if (code->expr2)
  {
    gfc_conv_expr_val (&se, code->expr2);
    quiet = fold_convert (boolean_type_node, se.expr)fold_convert_loc (((location_t) 0), global_trees[TI_BOOLEAN_TYPE
], se.expr);
  }
else
  quiet = boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];

if (code->expr1 == NULL__null)
  {
    tmp = build_int_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE], 0);
    tmp = build_call_expr_loc (input_location,
		 error_stop
		 ? (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_error_stop_str
		    : gfor_fndecl_error_stop_string)
		 : (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_stop_str
		    : gfor_fndecl_stop_string),
		 3, build_int_cst (pchar_type_node, 0), tmp,
		 quiet);
  }
else if (code->expr1->ts.type == BT_INTEGER)
  {
    gfc_conv_expr (&se, code->expr1);
    tmp = build_call_expr_loc (input_location,
		 error_stop
		 ? (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_error_stop
		    : gfor_fndecl_error_stop_numeric)
		 : (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_stop_numeric
		    : gfor_fndecl_stop_numeric), 2,
		 fold_convert (integer_type_node, se.expr)fold_convert_loc (((location_t) 0), integer_types[itk_int], se
.expr),
		 quiet);
  }
else
  {
    gfc_conv_expr_reference (&se, code->expr1);
    tmp = build_call_expr_loc (input_location,
		 error_stop
		 ? (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_error_stop_str
		    : gfor_fndecl_error_stop_string)
		 : (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB
		    ? gfor_fndecl_caf_stop_str
		    : gfor_fndecl_stop_string),
		 3, se.expr, fold_convert (size_type_node,fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], se.string_length)
					   se.string_length)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], se.string_length),
		 quiet);
  }

gfc_add_expr_to_block (&se.pre, tmp);

gfc_add_block_to_block (&se.pre, &se.post);

return gfc_finish_block (&se.pre);
721}

723/* Translate the FAIL IMAGE statement.  */

725tree
726gfc_trans_fail_image (gfc_code *code ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
727{
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  return build_call_expr_loc (input_location,
		gfor_fndecl_caf_fail_image, 0);
else
  {
    const char *name = gfc_get_string (PREFIX ("exit_i%d")"_gfortran_" "exit_i%d", 4);
    gfc_symbol *exsym = gfc_get_intrinsic_sub_symbol (name);
    tree tmp = gfc_get_symbol_decl (exsym);
    return build_call_expr_loc (input_location, tmp, 1, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
  }
738}

740/* Translate the FORM TEAM statement.  */

742tree
743gfc_trans_form_team (gfc_code *code)
744{
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    gfc_se se;
    gfc_se argse1, argse2;
    tree team_id, team_type, tmp;

    gfc_init_se (&se, NULL__null);
    gfc_init_se (&argse1, NULL__null);
    gfc_init_se (&argse2, NULL__null);
    gfc_start_block (&se.pre);

    gfc_conv_expr_val (&argse1, code->expr1);
    gfc_conv_expr_val (&argse2, code->expr2);
    team_id = fold_convert (integer_type_node, argse1.expr)fold_convert_loc (((location_t) 0), integer_types[itk_int], argse1
.expr);
    team_type = gfc_build_addr_expr (ppvoid_type_node, argse2.expr);

    gfc_add_block_to_block (&se.pre, &argse1.pre);
    gfc_add_block_to_block (&se.pre, &argse2.pre);
    tmp = build_call_expr_loc (input_location,
		 gfor_fndecl_caf_form_team, 3,
		 team_id, team_type,
		 build_int_cst (integer_type_nodeinteger_types[itk_int], 0));
    gfc_add_expr_to_block (&se.pre, tmp);
    gfc_add_block_to_block (&se.pre, &argse1.post);
    gfc_add_block_to_block (&se.pre, &argse2.post);
    return gfc_finish_block (&se.pre);
  }
else
  {
    const char *name = gfc_get_string (PREFIX ("exit_i%d")"_gfortran_" "exit_i%d", 4);
    gfc_symbol *exsym = gfc_get_intrinsic_sub_symbol (name);
    tree tmp = gfc_get_symbol_decl (exsym);
    return build_call_expr_loc (input_location, tmp, 1, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
  }
779}

781/* Translate the CHANGE TEAM statement.  */

783tree
784gfc_trans_change_team (gfc_code *code)
785{
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    gfc_se argse;
    tree team_type, tmp;

    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr1);
    team_type = gfc_build_addr_expr (ppvoid_type_node, argse.expr);

    tmp = build_call_expr_loc (input_location,
		 gfor_fndecl_caf_change_team, 2, team_type,
		 build_int_cst (integer_type_nodeinteger_types[itk_int], 0));
    gfc_add_expr_to_block (&argse.pre, tmp);
    gfc_add_block_to_block (&argse.pre, &argse.post);
    return gfc_finish_block (&argse.pre);
  }
else
  {
    const char *name = gfc_get_string (PREFIX ("exit_i%d")"_gfortran_" "exit_i%d", 4);
    gfc_symbol *exsym = gfc_get_intrinsic_sub_symbol (name);
    tree tmp = gfc_get_symbol_decl (exsym);
    return build_call_expr_loc (input_location, tmp, 1, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
  }
809}

811/* Translate the END TEAM statement.  */

813tree
814gfc_trans_end_team (gfc_code *code ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
815{
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    return build_call_expr_loc (input_location,
		  gfor_fndecl_caf_end_team, 1,
		  build_int_cst (pchar_type_node, 0));
  }
else
  {
    const char *name = gfc_get_string (PREFIX ("exit_i%d")"_gfortran_" "exit_i%d", 4);
    gfc_symbol *exsym = gfc_get_intrinsic_sub_symbol (name);
    tree tmp = gfc_get_symbol_decl (exsym);
    return build_call_expr_loc (input_location, tmp, 1, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
  }
829}

831/* Translate the SYNC TEAM statement.  */

833tree
834gfc_trans_sync_team (gfc_code *code)
835{
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    gfc_se argse;
    tree team_type, tmp;

    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr1);
    team_type = gfc_build_addr_expr (ppvoid_type_node, argse.expr);

    tmp = build_call_expr_loc (input_location,
		 gfor_fndecl_caf_sync_team, 2,
		 team_type,
		 build_int_cst (integer_type_nodeinteger_types[itk_int], 0));
    gfc_add_expr_to_block (&argse.pre, tmp);
    gfc_add_block_to_block (&argse.pre, &argse.post);
    return gfc_finish_block (&argse.pre);
  }
else
  {
    const char *name = gfc_get_string (PREFIX ("exit_i%d")"_gfortran_" "exit_i%d", 4);
    gfc_symbol *exsym = gfc_get_intrinsic_sub_symbol (name);
    tree tmp = gfc_get_symbol_decl (exsym);
    return build_call_expr_loc (input_location, tmp, 1, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
  }
860}

862tree
863gfc_trans_lock_unlock (gfc_code *code, gfc_exec_op op)
864{
gfc_se se, argse;
tree stat = NULL_TREE(tree) __null, stat2 = NULL_TREE(tree) __null;
tree lock_acquired = NULL_TREE(tree) __null, lock_acquired2 = NULL_TREE(tree) __null;

/* Short cut: For single images without STAT= or LOCK_ACQUIRED
   return early. (ERRMSG= is always untouched for -fcoarray=single.)  */
if (!code->expr2 && !code->expr4 && flag_coarrayglobal_options.x_flag_coarray != GFC_FCOARRAY_LIB)
  return NULL_TREE(tree) __null;

if (code->expr2)
  {
    gcc_assert (code->expr2->expr_type == EXPR_VARIABLE)((void)(!(code->expr2->expr_type == EXPR_VARIABLE) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 876, __FUNCTION__), 0 : 0));
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr2);
    stat = argse.expr;
  }
else if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  stat = null_pointer_nodeglobal_trees[TI_NULL_POINTER];

if (code->expr4)
  {
    gcc_assert (code->expr4->expr_type == EXPR_VARIABLE)((void)(!(code->expr4->expr_type == EXPR_VARIABLE) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 886, __FUNCTION__), 0 : 0));
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr4);
    lock_acquired = argse.expr;
  }
else if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  lock_acquired = null_pointer_nodeglobal_trees[TI_NULL_POINTER];

gfc_start_block (&se.pre);
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    tree tmp, token, image_index, errmsg, errmsg_len;
    tree index = build_zero_cst (gfc_array_index_type);
    tree caf_decl = gfc_get_tree_for_caf_expr (code->expr1);

    if (code->expr1->symtree->n.sym->ts.type != BT_DERIVED
 || code->expr1->symtree->n.sym->ts.u.derived->from_intmod
    != INTMOD_ISO_FORTRAN_ENV
 || code->expr1->symtree->n.sym->ts.u.derived->intmod_sym_id
    != ISOFORTRAN_LOCK_TYPE)
{
 gfc_error ("Sorry, the lock component of derived type at %L is not "
     "yet supported", &code->expr1->where);
 return NULL_TREE(tree) __null;
}

    gfc_get_caf_token_offset (&se, &token, NULL__null, caf_decl, NULL_TREE(tree) __null,
		code->expr1);

    if (gfc_is_coindexed (code->expr1))
image_index = gfc_caf_get_image_index (&se.pre, code->expr1, caf_decl);
    else
image_index = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];

    /* For arrays, obtain the array index.  */
    if (gfc_expr_attr (code->expr1).dimension)
{
 tree desc, tmp, extent, lbound, ubound;
        gfc_array_ref *ar, ar2;
        int i;

 /* TODO: Extend this, once DT components are supported.  */
 ar = &code->expr1->ref->u.ar;
 ar2 = *ar;
 memset (ar, '\0', sizeof (*ar));
 ar->as = ar2.as;
 ar->type = AR_FULL;

 gfc_init_se (&argse, NULL__null);
 argse.descriptor_only = 1;
 gfc_conv_expr_descriptor (&argse, code->expr1);
 gfc_add_block_to_block (&se.pre, &argse.pre);
 desc = argse.expr;
 *ar = ar2;

 extent = build_one_cst (gfc_array_index_type);
 for (i = 0; i < ar->dimen; i++)
   {
     gfc_init_se (&argse, NULL__null);
     gfc_conv_expr_type (&argse, ar->start[i], gfc_array_index_type);
     gfc_add_block_to_block (&argse.pre, &argse.pre);
     lbound = gfc_conv_descriptor_lbound_get (desc, gfc_rank_cst[i]);
     tmp = fold_build2_loc (input_location, MINUS_EXPR,
		     TREE_TYPE (lbound)((contains_struct_check ((lbound), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 949, __FUNCTION__))->typed.type), argse.expr, lbound);
     tmp = fold_build2_loc (input_location, MULT_EXPR,
		     TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 951, __FUNCTION__))->typed.type), extent, tmp);
     index = fold_build2_loc (input_location, PLUS_EXPR,
		       TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 953, __FUNCTION__))->typed.type), index, tmp);
     if (i < ar->dimen - 1)
{
  ubound = gfc_conv_descriptor_ubound_get (desc, gfc_rank_cst[i]);
  tmp = gfc_conv_array_extent_dim (lbound, ubound, NULL__null);
  extent = fold_build2_loc (input_location, MULT_EXPR,
			    TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 959, __FUNCTION__))->typed.type), extent, tmp);
}
   }
}

    /* errmsg.  */
    if (code->expr3)
{
 gfc_init_se (&argse, NULL__null);
 argse.want_pointer = 1;
 gfc_conv_expr (&argse, code->expr3);
 gfc_add_block_to_block (&se.pre, &argse.pre);
 errmsg = argse.expr;
 errmsg_len = fold_convert (size_type_node, argse.string_length)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], argse.string_length);
}
    else
{
 errmsg = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
 errmsg_len = build_zero_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE]);
}

    if (stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER] && TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 980, __FUNCTION__))->typed.type) != integer_type_nodeinteger_types[itk_int])
{
 stat2 = stat;
 stat = gfc_create_var (integer_type_nodeinteger_types[itk_int], "stat");
}

    if (lock_acquired != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
 && TREE_TYPE (lock_acquired)((contains_struct_check ((lock_acquired), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 987, __FUNCTION__))->typed.type) != integer_type_nodeinteger_types[itk_int])
{
 lock_acquired2 = lock_acquired;
 lock_acquired = gfc_create_var (integer_type_nodeinteger_types[itk_int], "acquired");
}

    index = fold_convert (size_type_node, index)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], index);
    if (op == EXEC_LOCK)
tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_lock, 7,
                                 token, index, image_index,
		   lock_acquired != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
		   ? gfc_build_addr_expr (NULL__null, lock_acquired)
		   : lock_acquired,
		   stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
		   ? gfc_build_addr_expr (NULL__null, stat) : stat,
		   errmsg, errmsg_len);
    else
tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_unlock, 6,
                                 token, index, image_index,
		   stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
		   ? gfc_build_addr_expr (NULL__null, stat) : stat,
		   errmsg, errmsg_len);
    gfc_add_expr_to_block (&se.pre, tmp);

    /* It guarantees memory consistency within the same segment */
    tmp = gfc_build_string_const (strlen ("memory")+1, "memory"),
    tmp = build5_loc (input_location, ASM_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	gfc_build_string_const (1, ""), NULL_TREE(tree) __null, NULL_TREE(tree) __null,
	tree_cons (NULL_TREE(tree) __null, tmp, NULL_TREE(tree) __null), NULL_TREE(tree) __null);
    ASM_VOLATILE_P (tmp)((tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1016, __FUNCTION__, (ASM_EXPR)))->base.public_flag) = 1;

    gfc_add_expr_to_block (&se.pre, tmp);

    if (stat2 != NULL_TREE(tree) __null)
gfc_add_modify (&se.pre, stat2,
	fold_convert (TREE_TYPE (stat2), stat)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(stat2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1022, __FUNCTION__))->typed.type), stat));

    if (lock_acquired2 != NULL_TREE(tree) __null)
gfc_add_modify (&se.pre, lock_acquired2,
	fold_convert (TREE_TYPE (lock_acquired2),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(lock_acquired2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1026, __FUNCTION__))->typed.type), lock_acquired)
		      lock_acquired)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(lock_acquired2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1026, __FUNCTION__))->typed.type), lock_acquired));

    return gfc_finish_block (&se.pre);
  }

if (stat != NULL_TREE(tree) __null)
  gfc_add_modify (&se.pre, stat, build_int_cst (TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1033, __FUNCTION__))->typed.type), 0));

if (lock_acquired != NULL_TREE(tree) __null)
  gfc_add_modify (&se.pre, lock_acquired,
    fold_convert (TREE_TYPE (lock_acquired),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(lock_acquired), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1037, __FUNCTION__))->typed.type), global_trees[TI_BOOLEAN_TRUE
])
		  boolean_true_node)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(lock_acquired), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1037, __FUNCTION__))->typed.type), global_trees[TI_BOOLEAN_TRUE
]));

return gfc_finish_block (&se.pre);
1041}

1043tree
1044gfc_trans_event_post_wait (gfc_code *code, gfc_exec_op op)
1045{
gfc_se se, argse;
tree stat = NULL_TREE(tree) __null, stat2 = NULL_TREE(tree) __null;
tree until_count = NULL_TREE(tree) __null;

if (code->expr2)
  {
    gcc_assert (code->expr2->expr_type == EXPR_VARIABLE)((void)(!(code->expr2->expr_type == EXPR_VARIABLE) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1052, __FUNCTION__), 0 : 0));
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr2);
    stat = argse.expr;
  }
else if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  stat = null_pointer_nodeglobal_trees[TI_NULL_POINTER];

if (code->expr4)
  {
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr4);
    until_count = fold_convert (integer_type_node, argse.expr)fold_convert_loc (((location_t) 0), integer_types[itk_int], argse
.expr);
  }
else
  until_count = integer_one_nodeglobal_trees[TI_INTEGER_ONE];

if (flag_coarrayglobal_options.x_flag_coarray != GFC_FCOARRAY_LIB)
  {
    gfc_start_block (&se.pre);
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr1);

    if (op == EXEC_EVENT_POST)
gfc_add_modify (&se.pre, argse.expr,
	fold_build2_loc (input_location, PLUS_EXPR,
		TREE_TYPE (argse.expr)((contains_struct_check ((argse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1078, __FUNCTION__))->typed.type), argse.expr,
		build_int_cst (TREE_TYPE (argse.expr)((contains_struct_check ((argse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1079, __FUNCTION__))->typed.type), 1)));
    else
gfc_add_modify (&se.pre, argse.expr,
	fold_build2_loc (input_location, MINUS_EXPR,
		TREE_TYPE (argse.expr)((contains_struct_check ((argse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1083, __FUNCTION__))->typed.type), argse.expr,
		fold_convert (TREE_TYPE (argse.expr),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(argse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1084, __FUNCTION__))->typed.type), until_count)
			      until_count)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(argse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1084, __FUNCTION__))->typed.type), until_count)));
    if (stat != NULL_TREE(tree) __null)
gfc_add_modify (&se.pre, stat, build_int_cst (TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1087, __FUNCTION__))->typed.type), 0));

    return gfc_finish_block (&se.pre);
  }

gfc_start_block (&se.pre);
tree tmp, token, image_index, errmsg, errmsg_len;
tree index = build_zero_cst (gfc_array_index_type);
tree caf_decl = gfc_get_tree_for_caf_expr (code->expr1);

if (code->expr1->symtree->n.sym->ts.type != BT_DERIVED
    || code->expr1->symtree->n.sym->ts.u.derived->from_intmod
!= INTMOD_ISO_FORTRAN_ENV
    || code->expr1->symtree->n.sym->ts.u.derived->intmod_sym_id
!= ISOFORTRAN_EVENT_TYPE)
  {
    gfc_error ("Sorry, the event component of derived type at %L is not "
 "yet supported", &code->expr1->where);
    return NULL_TREE(tree) __null;
  }

gfc_init_se (&argse, NULL__null);
gfc_get_caf_token_offset (&argse, &token, NULL__null, caf_decl, NULL_TREE(tree) __null,
	    code->expr1);
gfc_add_block_to_block (&se.pre, &argse.pre);

if (gfc_is_coindexed (code->expr1))
  image_index = gfc_caf_get_image_index (&se.pre, code->expr1, caf_decl);
else
  image_index = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];

/* For arrays, obtain the array index.  */
if (gfc_expr_attr (code->expr1).dimension)
  {
    tree desc, tmp, extent, lbound, ubound;
    gfc_array_ref *ar, ar2;
    int i;

    /* TODO: Extend this, once DT components are supported.  */
    ar = &code->expr1->ref->u.ar;
    ar2 = *ar;
    memset (ar, '\0', sizeof (*ar));
    ar->as = ar2.as;
    ar->type = AR_FULL;

    gfc_init_se (&argse, NULL__null);
    argse.descriptor_only = 1;
    gfc_conv_expr_descriptor (&argse, code->expr1);
    gfc_add_block_to_block (&se.pre, &argse.pre);
    desc = argse.expr;
    *ar = ar2;

    extent = build_one_cst (gfc_array_index_type);
    for (i = 0; i < ar->dimen; i++)
{
 gfc_init_se (&argse, NULL__null);
 gfc_conv_expr_type (&argse, ar->start[i], gfc_array_index_type);
 gfc_add_block_to_block (&argse.pre, &argse.pre);
 lbound = gfc_conv_descriptor_lbound_get (desc, gfc_rank_cst[i]);
 tmp = fold_build2_loc (input_location, MINUS_EXPR,
		 TREE_TYPE (lbound)((contains_struct_check ((lbound), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1147, __FUNCTION__))->typed.type), argse.expr, lbound);
 tmp = fold_build2_loc (input_location, MULT_EXPR,
		 TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1149, __FUNCTION__))->typed.type), extent, tmp);
 index = fold_build2_loc (input_location, PLUS_EXPR,
		   TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1151, __FUNCTION__))->typed.type), index, tmp);
 if (i < ar->dimen - 1)
   {
     ubound = gfc_conv_descriptor_ubound_get (desc, gfc_rank_cst[i]);
     tmp = gfc_conv_array_extent_dim (lbound, ubound, NULL__null);
     extent = fold_build2_loc (input_location, MULT_EXPR,
			TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1157, __FUNCTION__))->typed.type), extent, tmp);
   }
}
  }

/* errmsg.  */
if (code->expr3)
  {
    gfc_init_se (&argse, NULL__null);
    argse.want_pointer = 1;
    gfc_conv_expr (&argse, code->expr3);
    gfc_add_block_to_block (&se.pre, &argse.pre);
    errmsg = argse.expr;
    errmsg_len = fold_convert (size_type_node, argse.string_length)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], argse.string_length);
  }
else
  {
    errmsg = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
    errmsg_len = build_zero_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE]);
  }

if (stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER] && TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1178, __FUNCTION__))->typed.type) != integer_type_nodeinteger_types[itk_int])
  {
    stat2 = stat;
    stat = gfc_create_var (integer_type_nodeinteger_types[itk_int], "stat");
  }

index = fold_convert (size_type_node, index)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], index);
if (op == EXEC_EVENT_POST)
  tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_event_post, 6,
	       token, index, image_index,
	       stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
	       ? gfc_build_addr_expr (NULL__null, stat) : stat,
	       errmsg, errmsg_len);
else
  tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_event_wait, 6,
	       token, index, until_count,
	       stat != null_pointer_nodeglobal_trees[TI_NULL_POINTER]
	       ? gfc_build_addr_expr (NULL__null, stat) : stat,
	       errmsg, errmsg_len);
gfc_add_expr_to_block (&se.pre, tmp);

/* It guarantees memory consistency within the same segment */
tmp = gfc_build_string_const (strlen ("memory")+1, "memory"),
tmp = build5_loc (input_location, ASM_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
    gfc_build_string_const (1, ""), NULL_TREE(tree) __null, NULL_TREE(tree) __null,
    tree_cons (NULL_TREE(tree) __null, tmp, NULL_TREE(tree) __null), NULL_TREE(tree) __null);
ASM_VOLATILE_P (tmp)((tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1204, __FUNCTION__, (ASM_EXPR)))->base.public_flag) = 1;
gfc_add_expr_to_block (&se.pre, tmp);

if (stat2 != NULL_TREE(tree) __null)
  gfc_add_modify (&se.pre, stat2, fold_convert (TREE_TYPE (stat2), stat)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(stat2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1208, __FUNCTION__))->typed.type), stat));

return gfc_finish_block (&se.pre);
1211}

1213tree
1214gfc_trans_sync (gfc_code *code, gfc_exec_op type)
1215{
gfc_se se, argse;
tree tmp;
tree images = NULL_TREE(tree) __null, stat = NULL_TREE(tree) __null,
     errmsg = NULL_TREE(tree) __null, errmsglen = NULL_TREE(tree) __null;

/* Short cut: For single images without bound checking or without STAT=,
   return early. (ERRMSG= is always untouched for -fcoarray=single.)  */
if (!code->expr2 && !(gfc_option.rtcheck & GFC_RTCHECK_BOUNDS(1<<0))
    && flag_coarrayglobal_options.x_flag_coarray != GFC_FCOARRAY_LIB)
  return NULL_TREE(tree) __null;

gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);

if (code->expr1 && code->expr1->rank == 0)
  {
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr1);
    images = argse.expr;
  }

if (code->expr2)
  {
    gcc_assert (code->expr2->expr_type == EXPR_VARIABLE((void)(!(code->expr2->expr_type == EXPR_VARIABLE || code
->expr2->expr_type == EXPR_FUNCTION) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1240, __FUNCTION__), 0 : 0))
  || code->expr2->expr_type == EXPR_FUNCTION)((void)(!(code->expr2->expr_type == EXPR_VARIABLE || code
->expr2->expr_type == EXPR_FUNCTION) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1240, __FUNCTION__), 0 : 0));
    gfc_init_se (&argse, NULL__null);
    gfc_conv_expr_val (&argse, code->expr2);
    stat = argse.expr;
  }
else
  stat = null_pointer_nodeglobal_trees[TI_NULL_POINTER];

if (code->expr3 && flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    gcc_assert (code->expr3->expr_type == EXPR_VARIABLE((void)(!(code->expr3->expr_type == EXPR_VARIABLE || code
->expr3->expr_type == EXPR_FUNCTION) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1251, __FUNCTION__), 0 : 0))
  || code->expr3->expr_type == EXPR_FUNCTION)((void)(!(code->expr3->expr_type == EXPR_VARIABLE || code
->expr3->expr_type == EXPR_FUNCTION) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1251, __FUNCTION__), 0 : 0));
    gfc_init_se (&argse, NULL__null);
    argse.want_pointer = 1;
    gfc_conv_expr (&argse, code->expr3);
    gfc_conv_string_parameter (&argse);
    errmsg = gfc_build_addr_expr (NULL__null, argse.expr);
    errmsglen = fold_convert (size_type_node, argse.string_length)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], argse.string_length);
  }
else if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    errmsg = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
    errmsglen = build_int_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE], 0);
  }

/* Check SYNC IMAGES(imageset) for valid image index.
   FIXME: Add a check for image-set arrays.  */
if (code->expr1 && (gfc_option.rtcheck & GFC_RTCHECK_BOUNDS(1<<0))
    && code->expr1->rank == 0)
  {
    tree images2 = fold_convert (integer_type_node, images)fold_convert_loc (((location_t) 0), integer_types[itk_int], images
);
    tree cond;
    if (flag_coarrayglobal_options.x_flag_coarray != GFC_FCOARRAY_LIB)
cond = fold_build2_loc (input_location, NE_EXPR, logical_type_node,
		images, build_int_cst (TREE_TYPE (images)((contains_struct_check ((images), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1274, __FUNCTION__))->typed.type), 1));
    else
{
 tree cond2;
 tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_num_images,
		     2, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
		     build_int_cst (integer_type_nodeinteger_types[itk_int], -1));
 cond = fold_build2_loc (input_location, GT_EXPR, logical_type_node,
		  images2, tmp);
 cond2 = fold_build2_loc (input_location, LT_EXPR, logical_type_node,
		   images,
		   build_int_cst (TREE_TYPE (images)((contains_struct_check ((images), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1285, __FUNCTION__))->typed.type), 1));
 cond = fold_build2_loc (input_location, TRUTH_OR_EXPR,
		  logical_type_node, cond, cond2);
}
    gfc_trans_runtime_check (true, false, cond, &se.pre,
	       &code->expr1->where, "Invalid image number "
	       "%d in SYNC IMAGES", images2);
  }

/* Per F2008, 8.5.1, a SYNC MEMORY is implied by calling the
   image control statements SYNC IMAGES and SYNC ALL.  */
if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    tmp = gfc_build_string_const (strlen ("memory")+1, "memory"),
    tmp = build5_loc (input_location, ASM_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	gfc_build_string_const (1, ""), NULL_TREE(tree) __null, NULL_TREE(tree) __null,
	tree_cons (NULL_TREE(tree) __null, tmp, NULL_TREE(tree) __null), NULL_TREE(tree) __null);
    ASM_VOLATILE_P (tmp)((tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1302, __FUNCTION__, (ASM_EXPR)))->base.public_flag) = 1;
    gfc_add_expr_to_block (&se.pre, tmp);
  }

if (flag_coarrayglobal_options.x_flag_coarray != GFC_FCOARRAY_LIB)
  {
    /* Set STAT to zero.  */
    if (code->expr2)
gfc_add_modify (&se.pre, stat, build_int_cst (TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1310, __FUNCTION__))->typed.type), 0));
  }
else if (type == EXEC_SYNC_ALL || type == EXEC_SYNC_MEMORY)
  {
    /* SYNC ALL           =>   stat == null_pointer_node
SYNC ALL(stat=s)   =>   stat has an integer type

If "stat" has the wrong integer type, use a temp variable of
the right type and later cast the result back into "stat".  */
    if (stat == null_pointer_nodeglobal_trees[TI_NULL_POINTER] || TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1319, __FUNCTION__))->typed.type) == integer_type_nodeinteger_types[itk_int])
{
 if (TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1321, __FUNCTION__))->typed.type) == integer_type_nodeinteger_types[itk_int])
   stat = gfc_build_addr_expr (NULL__null, stat);

 if(type == EXEC_SYNC_MEMORY)
   tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_sync_memory,
		       3, stat, errmsg, errmsglen);
 else
   tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_sync_all,
		       3, stat, errmsg, errmsglen);

 gfc_add_expr_to_block (&se.pre, tmp);
}
    else
{
 tree tmp_stat = gfc_create_var (integer_type_nodeinteger_types[itk_int], "stat");

 tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_sync_all,
		     3, gfc_build_addr_expr (NULL__null, tmp_stat),
		     errmsg, errmsglen);
 gfc_add_expr_to_block (&se.pre, tmp);

 gfc_add_modify (&se.pre, stat,
	  fold_convert (TREE_TYPE (stat), tmp_stat)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1343, __FUNCTION__))->typed.type), tmp_stat));
}
  }
else
  {
    tree len;

    gcc_assert (type == EXEC_SYNC_IMAGES)((void)(!(type == EXEC_SYNC_IMAGES) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1350, __FUNCTION__), 0 : 0));

    if (!code->expr1)
{
 len = build_int_cst (integer_type_nodeinteger_types[itk_int], -1);
 images = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
}
    else if (code->expr1->rank == 0)
{
 len = build_int_cst (integer_type_nodeinteger_types[itk_int], 1);
 images = gfc_build_addr_expr (NULL_TREE(tree) __null, images);
}
    else
{
 /* FIXME.  */
 if (code->expr1->ts.kind != gfc_c_int_kind)
   gfc_fatal_error ("Sorry, only support for integer kind %d "
	     "implemented for image-set at %L",
	     gfc_c_int_kind, &code->expr1->where);

 gfc_conv_array_parameter (&se, code->expr1, true, NULL__null, NULL__null, &len);
 images = se.expr;

 tmp = gfc_typenode_for_spec (&code->expr1->ts);
 if (GFC_ARRAY_TYPE_P (tmp)((tree_class_check ((tmp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1374, __FUNCTION__))->type_common.lang_flag_2) || GFC_DESCRIPTOR_TYPE_P (tmp)((tree_class_check ((tmp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1374, __FUNCTION__))->type_common.lang_flag_1))
   tmp = gfc_get_element_type (tmp);

 len = fold_build2_loc (input_location, TRUNC_DIV_EXPR,
		 TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1378, __FUNCTION__))->typed.type), len,
		 fold_convert (TREE_TYPE (len),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1379, __FUNCTION__))->typed.type), ((tree_class_check ((
tmp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1380, __FUNCTION__))->type_common.size_unit))
			       TYPE_SIZE_UNIT (tmp))fold_convert_loc (((location_t) 0), ((contains_struct_check (
(len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1379, __FUNCTION__))->typed.type), ((tree_class_check ((
tmp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1380, __FUNCTION__))->type_common.size_unit)));
        len = fold_convert (integer_type_node, len)fold_convert_loc (((location_t) 0), integer_types[itk_int], len
);
}

    /* SYNC IMAGES(imgs)        => stat == null_pointer_node
SYNC IMAGES(imgs,stat=s) => stat has an integer type

If "stat" has the wrong integer type, use a temp variable of
the right type and later cast the result back into "stat".  */
    if (stat == null_pointer_nodeglobal_trees[TI_NULL_POINTER] || TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1389, __FUNCTION__))->typed.type) == integer_type_nodeinteger_types[itk_int])
{
 if (TREE_TYPE (stat)((contains_struct_check ((stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1391, __FUNCTION__))->typed.type) == integer_type_nodeinteger_types[itk_int])
   stat = gfc_build_addr_expr (NULL__null, stat);

 tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_sync_images,
		     5, fold_convert (integer_type_node, len)fold_convert_loc (((location_t) 0), integer_types[itk_int], len
),
		     images, stat, errmsg, errmsglen);
 gfc_add_expr_to_block (&se.pre, tmp);
}
    else
{
 tree tmp_stat = gfc_create_var (integer_type_nodeinteger_types[itk_int], "stat");

 tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_sync_images,
		     5, fold_convert (integer_type_node, len)fold_convert_loc (((location_t) 0), integer_types[itk_int], len
),
		     images, gfc_build_addr_expr (NULL__null, tmp_stat),
		     errmsg, errmsglen);
 gfc_add_expr_to_block (&se.pre, tmp);

 gfc_add_modify (&se.pre, stat,
	  fold_convert (TREE_TYPE (stat), tmp_stat)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(stat), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1410, __FUNCTION__))->typed.type), tmp_stat));
}
  }

return gfc_finish_block (&se.pre);
1415}


1418/* Generate GENERIC for the IF construct. This function also deals with
 the simple IF statement, because the front end translates the IF
 statement into an IF construct.

 We translate:

      IF (cond) THEN
         then_clause
      ELSEIF (cond2)
         elseif_clause
      ELSE
         else_clause
      ENDIF

 into:

      pre_cond_s;
      if (cond_s)
        {
          then_clause;
        }
      else
        {
          pre_cond_s
          if (cond_s)
            {
              elseif_clause
            }
          else
            {
              else_clause;
            }
        }

 where COND_S is the simplified version of the predicate. PRE_COND_S
 are the pre side-effects produced by the translation of the
 conditional.
 We need to build the chain recursively otherwise we run into
 problems with folding incomplete statements.  */

1458static tree
1459gfc_trans_if_1 (gfc_code * code)
1460{
gfc_se if_se;
tree stmt, elsestmt;
locus saved_loc;
location_t loc;

/* Check for an unconditional ELSE clause.  */
if (!code->expr1)
  return gfc_trans_code (code->next);

/* Initialize a statement builder for each block. Puts in NULL_TREEs.  */
gfc_init_se (&if_se, NULL__null);
gfc_start_block (&if_se.pre);

/* Calculate the IF condition expression.  */
if (code->expr1->where.lb)
  {
    gfc_save_backend_locus (&saved_loc);
    gfc_set_backend_locus (&code->expr1->where);
  }

gfc_conv_expr_val (&if_se, code->expr1);

if (code->expr1->where.lb)
  gfc_restore_backend_locus (&saved_loc);

/* Translate the THEN clause.  */
stmt = gfc_trans_code (code->next);

/* Translate the ELSE clause.  */
if (code->block)
  elsestmt = gfc_trans_if_1 (code->block);
else
  elsestmt = build_empty_stmt (input_location);

/* Build the condition expression and add it to the condition block.  */
loc = code->expr1->where.lb ? gfc_get_location (&code->expr1->where)
	      : input_location;
stmt = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], if_se.expr, stmt,
	  elsestmt);

gfc_add_expr_to_block (&if_se.pre, stmt);

/* Finish off this statement.  */
return gfc_finish_block (&if_se.pre);
1505}

1507tree
1508gfc_trans_if (gfc_code * code)
1509{
stmtblock_t body;
tree exit_label;

/* Create exit label so it is available for trans'ing the body code.  */
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
code->exit_label = exit_label;

/* Translate the actual code in code->block.  */
gfc_init_block (&body);
gfc_add_expr_to_block (&body, gfc_trans_if_1 (code->block));

/* Add exit label.  */
gfc_add_expr_to_block (&body, build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label));

return gfc_finish_block (&body);
1525}


1528/* Translate an arithmetic IF expression.

 IF (cond) label1, label2, label3 translates to

  if (cond <= 0)
    {
      if (cond < 0)
        goto label1;
      else // cond == 0
        goto label2;
    }
  else // cond > 0
    goto label3;

 An optimized version can be generated in case of equal labels.
 E.g., if label1 is equal to label2, we can translate it to

  if (cond <= 0)
    goto label1;
  else
    goto label3;
1549*/

1551tree
1552gfc_trans_arithmetic_if (gfc_code * code)
1553{
gfc_se se;
tree tmp;
tree branch1;
tree branch2;
tree zero;

/* Start a new block.  */
gfc_init_se (&se, NULL__null);
gfc_start_block (&se.pre);

/* Pre-evaluate COND.  */
gfc_conv_expr_val (&se, code->expr1);
se.expr = gfc_evaluate_now (se.expr, &se.pre);

/* Build something to compare with.  */
zero = gfc_build_const (TREE_TYPE (se.expr)((contains_struct_check ((se.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1569, __FUNCTION__))->typed.type), integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);

if (code->label1->value != code->label2->value)
  {
    /* If (cond < 0) take branch1 else take branch2.
       First build jumps to the COND .LT. 0 and the COND .EQ. 0 cases.  */
    branch1 = build1_v (GOTO_EXPR, gfc_get_label_decl (code->label1))fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->label1));
    branch2 = build1_v (GOTO_EXPR, gfc_get_label_decl (code->label2))fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->label2));

    if (code->label1->value != code->label3->value)
      tmp = fold_build2_loc (input_location, LT_EXPR, logical_type_node,
	       se.expr, zero);
    else
      tmp = fold_build2_loc (input_location, NE_EXPR, logical_type_node,
	       se.expr, zero);

    branch1 = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		 tmp, branch1, branch2);
  }
else
  branch1 = build1_v (GOTO_EXPR, gfc_get_label_decl (code->label1))fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->label1));

if (code->label1->value != code->label3->value
    && code->label2->value != code->label3->value)
  {
    /* if (cond <= 0) take branch1 else take branch2.  */
    branch2 = build1_v (GOTO_EXPR, gfc_get_label_decl (code->label3))fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], gfc_get_label_decl (code->label3));
    tmp = fold_build2_loc (input_location, LE_EXPR, logical_type_node,
	     se.expr, zero);
    branch1 = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		 tmp, branch1, branch2);
  }

/* Append the COND_EXPR to the evaluation of COND, and return.  */
gfc_add_expr_to_block (&se.pre, branch1);
return gfc_finish_block (&se.pre);
1605}


1608/* Translate a CRITICAL block.  */
1609tree
1610gfc_trans_critical (gfc_code *code)
1611{
stmtblock_t block;
tree tmp, token = NULL_TREE(tree) __null;

gfc_start_block (&block);

if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    tree zero_size = build_zero_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE]);
    token = gfc_get_symbol_decl (code->resolved_sym);
    token = GFC_TYPE_ARRAY_CAF_TOKEN (TREE_TYPE (token))(((tree_class_check ((((contains_struct_check ((token), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1621, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1621, __FUNCTION__))->type_with_lang_specific.lang_specific
)->caf_token);
    tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_lock, 7,
		 token, zero_size, integer_one_nodeglobal_trees[TI_INTEGER_ONE],
		 null_pointer_nodeglobal_trees[TI_NULL_POINTER], null_pointer_nodeglobal_trees[TI_NULL_POINTER],
		 null_pointer_nodeglobal_trees[TI_NULL_POINTER], zero_size);
    gfc_add_expr_to_block (&block, tmp);

    /* It guarantees memory consistency within the same segment */
    tmp = gfc_build_string_const (strlen ("memory")+1, "memory"),
tmp = build5_loc (input_location, ASM_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	  gfc_build_string_const (1, ""),
	  NULL_TREE(tree) __null, NULL_TREE(tree) __null,
	  tree_cons (NULL_TREE(tree) __null, tmp, NULL_TREE(tree) __null),
	  NULL_TREE(tree) __null);
    ASM_VOLATILE_P (tmp)((tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1635, __FUNCTION__, (ASM_EXPR)))->base.public_flag) = 1;

    gfc_add_expr_to_block (&block, tmp);
  }

tmp = gfc_trans_code (code->block->next);
gfc_add_expr_to_block (&block, tmp);

if (flag_coarrayglobal_options.x_flag_coarray == GFC_FCOARRAY_LIB)
  {
    tree zero_size = build_zero_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE]);
    tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_unlock, 6,
		 token, zero_size, integer_one_nodeglobal_trees[TI_INTEGER_ONE],
		 null_pointer_nodeglobal_trees[TI_NULL_POINTER], null_pointer_nodeglobal_trees[TI_NULL_POINTER],
		 zero_size);
    gfc_add_expr_to_block (&block, tmp);

    /* It guarantees memory consistency within the same segment */
    tmp = gfc_build_string_const (strlen ("memory")+1, "memory"),
tmp = build5_loc (input_location, ASM_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	  gfc_build_string_const (1, ""),
	  NULL_TREE(tree) __null, NULL_TREE(tree) __null,
	  tree_cons (NULL_TREE(tree) __null, tmp, NULL_TREE(tree) __null),
	  NULL_TREE(tree) __null);
    ASM_VOLATILE_P (tmp)((tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1659, __FUNCTION__, (ASM_EXPR)))->base.public_flag) = 1;

    gfc_add_expr_to_block (&block, tmp);
  }

return gfc_finish_block (&block);
1665}


1668/* Return true, when the class has a _len component.  */

1670static bool
1671class_has_len_component (gfc_symbol *sym)
1672{
gfc_component *comp = sym->ts.u.derived->components;
while (comp)
  {
    if (strcmp (comp->name, "_len") == 0)
return true;
    comp = comp->next;
  }
return false;
1681}


1684static void
1685copy_descriptor (stmtblock_t *block, tree dst, tree src, int rank)
1686{
int n;
tree dim;
tree tmp;
tree tmp2;
tree size;
tree offset;

offset = gfc_index_zero_nodegfc_rank_cst[0];

/* Use memcpy to copy the descriptor. The size is the minimum of
   the sizes of 'src' and 'dst'. This avoids a non-trivial conversion.  */
tmp = TYPE_SIZE_UNIT (TREE_TYPE (src))((tree_class_check ((((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1698, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1698, __FUNCTION__))->type_common.size_unit);
tmp2 = TYPE_SIZE_UNIT (TREE_TYPE (dst))((tree_class_check ((((contains_struct_check ((dst), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1699, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1699, __FUNCTION__))->type_common.size_unit);
size = fold_build2_loc (input_location, MIN_EXPR,
	  TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1701, __FUNCTION__))->typed.type), tmp, tmp2);
tmp = builtin_decl_explicit (BUILT_IN_MEMCPY);
tmp = build_call_expr_loc (input_location, tmp, 3,
	     gfc_build_addr_expr (NULL_TREE(tree) __null, dst),
	     gfc_build_addr_expr (NULL_TREE(tree) __null, src),
	     fold_convert (size_type_node, size)fold_convert_loc (((location_t) 0), global_trees[TI_SIZE_TYPE
], size));
gfc_add_expr_to_block (block, tmp);

/* Set the offset correctly.  */
for (n = 0; n < rank; n++)
  {
    dim = gfc_rank_cst[n];
    tmp = gfc_conv_descriptor_lbound_get (src, dim);
    tmp2 = gfc_conv_descriptor_stride_get (src, dim);
    tmp = fold_build2_loc (input_location, MULT_EXPR, TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1715, __FUNCTION__))->typed.type),
	     tmp, tmp2);
    offset = fold_build2_loc (input_location, MINUS_EXPR,
	TREE_TYPE (offset)((contains_struct_check ((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1718, __FUNCTION__))->typed.type), offset, tmp);
    offset = gfc_evaluate_now (offset, block);
  }

gfc_conv_descriptor_offset_set (block, dst, offset);
1723}


1726/* Do proper initialization for ASSOCIATE names.  */

1728static void
1729trans_associate_var (gfc_symbol *sym, gfc_wrapped_block *block)
1730{
gfc_expr *e;
tree tmp;
bool class_target;
bool unlimited;
tree desc;
tree offset;
tree dim;
int n;
tree charlen;
bool need_len_assign;
bool whole_array = true;
gfc_ref *ref;
gfc_symbol *sym2;

gcc_assert (sym->assoc)((void)(!(sym->assoc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1745, __FUNCTION__), 0 : 0));
e = sym->assoc->target;

class_target = (e->expr_type == EXPR_VARIABLE)
    && (gfc_is_class_scalar_expr (e)
	|| gfc_is_class_array_ref (e, NULL__null));

unlimited = UNLIMITED_POLY (e)(e != __null && e->ts.type == BT_CLASS && e
->ts.u.derived->components && e->ts.u.derived
->components->ts.u.derived && e->ts.u.derived
->components->ts.u.derived->attr.unlimited_polymorphic
);

for (ref = e->ref; ref; ref = ref->next)
  if (ref->type == REF_ARRAY
&& ref->u.ar.type == AR_FULL
&& ref->next)
    {
whole_array =  false;
break;
    }

/* Assignments to the string length need to be generated, when
   ( sym is a char array or
     sym has a _len component)
   and the associated expression is unlimited polymorphic, which is
   not (yet) correctly in 'unlimited', because for an already associated
   BT_DERIVED the u-poly flag is not set, i.e.,
    __tmp_CHARACTER_0_1 => w => arg
     ^ generated temp      ^ from code, the w does not have the u-poly
   flag set, where UNLIMITED_POLY(e) expects it.  */
need_len_assign = ((unlimited || (e->ts.type == BT_DERIVED
                   && e->ts.u.derived->attr.unlimited_polymorphic))
    && (sym->ts.type == BT_CHARACTER
        || ((sym->ts.type == BT_CLASS || sym->ts.type == BT_DERIVED)
            && class_has_len_component (sym)))
    && !sym->attr.select_rank_temporary);

/* Do a `pointer assignment' with updated descriptor (or assign descriptor
   to array temporary) for arrays with either unknown shape or if associating
   to a variable. Select rank temporaries need somewhat different treatment
   to other associate names and case temporaries. This because the selector
   is assumed rank and so the offset in particular has to be changed. Also,
   the case temporaries carry both allocatable and target attributes if
   present in the selector. This means that an allocatation or change of
   association can occur and so has to be dealt with.  */
if (sym->attr.select_rank_temporary)
  {
    gfc_se se;
    tree class_decl = NULL_TREE(tree) __null;
    int rank = 0;
    bool class_ptr;

    sym2 = e->symtree->n.sym;
    gfc_init_se (&se, NULL__null);
    if (e->ts.type == BT_CLASS)
{
 /* Go straight to the class data.  */
 if (sym2->attr.dummy && !sym2->attr.optional)
   {
     class_decl = sym2->backend_decl;
     if (DECL_LANG_SPECIFIC (class_decl)((contains_struct_check ((class_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1802, __FUNCTION__))->decl_common.lang_specific)
  && GFC_DECL_SAVED_DESCRIPTOR (class_decl)(((contains_struct_check ((class_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1803, __FUNCTION__))->decl_common.lang_specific)->saved_descriptor
))
class_decl = GFC_DECL_SAVED_DESCRIPTOR (class_decl)(((contains_struct_check ((class_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1804, __FUNCTION__))->decl_common.lang_specific)->saved_descriptor
);
     if (POINTER_TYPE_P (TREE_TYPE (class_decl))(((enum tree_code) (((contains_struct_check ((class_decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1805, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((class_decl),
 (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1805, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
class_decl = build_fold_indirect_ref_loc (input_location,
					  class_decl);
     gcc_assert (GFC_CLASS_TYPE_P (TREE_TYPE (class_decl)))((void)(!(((tree_class_check ((((contains_struct_check ((class_decl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1808, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1808, __FUNCTION__))->type_common.lang_flag_4)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1808, __FUNCTION__), 0 : 0));
     se.expr = gfc_class_data_get (class_decl);
   }
 else
   {
     class_decl = sym2->backend_decl;
     gfc_conv_expr_descriptor (&se, e);
     if (POINTER_TYPE_P (TREE_TYPE (se.expr))(((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1815, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1815, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
se.expr = build_fold_indirect_ref_loc (input_location,
				       se.expr);
   }

 if (CLASS_DATA (sym)sym->ts.u.derived->components->as && CLASS_DATA (sym)sym->ts.u.derived->components->as->rank > 0)
   rank = CLASS_DATA (sym)sym->ts.u.derived->components->as->rank;
}
    else
{
 gfc_conv_expr_descriptor (&se, e);
 if (sym->as && sym->as->rank > 0)
   rank = sym->as->rank;
}

    desc = sym->backend_decl;

    /* The SELECT TYPE mechanisms turn class temporaries into pointers, which
point to the selector. */
    class_ptr = class_decl != NULL_TREE(tree) __null && POINTER_TYPE_P (TREE_TYPE (desc))(((enum tree_code) (((contains_struct_check ((desc), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1834, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((desc), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1834, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
);
    if (class_ptr)
{
 tmp = gfc_create_var (TREE_TYPE (TREE_TYPE (desc))((contains_struct_check ((((contains_struct_check ((desc), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1837, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1837, __FUNCTION__))->typed.type), "class");
 tmp = gfc_build_addr_expr (NULL__null, tmp);
 gfc_add_modify (&se.pre, desc, tmp);

 tmp = gfc_class_vptr_get (class_decl);
 gfc_add_modify (&se.pre, gfc_class_vptr_get (desc), tmp);
 if (UNLIMITED_POLY (sym)(sym != __null && sym->ts.type == BT_CLASS &&
 sym->ts.u.derived->components && sym->ts.u.
derived->components->ts.u.derived && sym->ts
.u.derived->components->ts.u.derived->attr.unlimited_polymorphic
))
   gfc_add_modify (&se.pre, gfc_class_len_get (desc),
	    gfc_class_len_get (class_decl));

 desc = gfc_class_data_get (desc);
}

    /* SELECT RANK temporaries can carry the allocatable and pointer
attributes so the selector descriptor must be copied in and
copied out.  */
    if (rank > 0)
copy_descriptor (&se.pre, desc, se.expr, rank);
    else
{
 tmp = gfc_conv_descriptor_data_get (se.expr);
 gfc_add_modify (&se.pre, desc,
	  fold_convert (TREE_TYPE (desc), tmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(desc), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1859, __FUNCTION__))->typed.type), tmp));
}

    /* Deal with associate_name => selector. Class associate names are
treated in the same way as in SELECT TYPE.  */
    sym2 = sym->assoc->target->symtree->n.sym;
    if (sym2->assoc && sym->assoc->target && sym2->ts.type != BT_CLASS)
{
 sym2 = sym2->assoc->target->symtree->n.sym;
 se.expr = sym2->backend_decl;

 if (POINTER_TYPE_P (TREE_TYPE (se.expr))(((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1870, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1870, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
   se.expr = build_fold_indirect_ref_loc (input_location,
				   se.expr);
}

    /* There could have been reallocation.  Copy descriptor back to the
selector and update the offset.  */
    if (sym->attr.allocatable || sym->attr.pointer
 || (sym->ts.type == BT_CLASS
     && (CLASS_DATA (sym)sym->ts.u.derived->components->attr.allocatable
  || CLASS_DATA (sym)sym->ts.u.derived->components->attr.pointer)))
{
 if (rank > 0)
   copy_descriptor (&se.post, se.expr, desc, rank);
 else
   gfc_conv_descriptor_data_set (&se.post, se.expr, desc);

 /* The dynamic type could have changed too.  */
 if (sym->ts.type == BT_CLASS)
   {
     tmp = sym->backend_decl;
     if (class_ptr)
tmp = build_fold_indirect_ref_loc (input_location, tmp);
     gfc_add_modify (&se.post, gfc_class_vptr_get (class_decl),
	      gfc_class_vptr_get (tmp));
     if (UNLIMITED_POLY (sym)(sym != __null && sym->ts.type == BT_CLASS &&
 sym->ts.u.derived->components && sym->ts.u.
derived->components->ts.u.derived && sym->ts
.u.derived->components->ts.u.derived->attr.unlimited_polymorphic
))
gfc_add_modify (&se.post, gfc_class_len_get (class_decl),
		gfc_class_len_get (tmp));
   }
}

    tmp = gfc_finish_block (&se.post);

    gfc_add_init_cleanup (block, gfc_finish_block (&se.pre), tmp);
  }
/* Now all the other kinds of associate variable.  */
else if (sym->attr.dimension && !class_target
  && (sym->as->type == AS_DEFERRED || sym->assoc->variable))
  {
    gfc_se se;
    tree desc;
    bool cst_array_ctor;

    desc = sym->backend_decl;
    cst_array_ctor = e->expr_type == EXPR_ARRAY
     && gfc_constant_array_constructor_p (e->value.constructor)
     && e->ts.type != BT_CHARACTER;

    /* If association is to an expression, evaluate it and create temporary.
Otherwise, get descriptor of target for pointer assignment.  */
    gfc_init_se (&se, NULL__null);

    if (sym->assoc->variable || cst_array_ctor)
{
 se.direct_byref = 1;
 se.use_offset = 1;
 se.expr = desc;
 GFC_DECL_PTR_ARRAY_P (sym->backend_decl)((contains_struct_check ((sym->backend_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1927, __FUNCTION__))->decl_common.lang_flag_6) = 1;
}

    gfc_conv_expr_descriptor (&se, e);

    if (sym->ts.type == BT_CHARACTER
 && sym->ts.deferred
 && !sym->attr.select_type_temporary
 && VAR_P (sym->ts.u.cl->backend_decl)(((enum tree_code) (sym->ts.u.cl->backend_decl)->base
.code) == VAR_DECL)
 && se.string_length != sym->ts.u.cl->backend_decl)
{
 gfc_add_modify (&se.pre, sym->ts.u.cl->backend_decl,
	  fold_convert (TREE_TYPE (sym->ts.u.cl->backend_decl),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(sym->ts.u.cl->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1939, __FUNCTION__))->typed.type), se.string_length)
			se.string_length)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(sym->ts.u.cl->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1939, __FUNCTION__))->typed.type), se.string_length));
}

    /* If we didn't already do the pointer assignment, set associate-name
descriptor to the one generated for the temporary.  */
    if ((!sym->assoc->variable && !cst_array_ctor)
 || !whole_array)
{
 int dim;

 if (whole_array)
   gfc_add_modify (&se.pre, desc, se.expr);

 /* The generated descriptor has lower bound zero (as array
    temporary), shift bounds so we get lower bounds of 1.  */
 for (dim = 0; dim < e->rank; ++dim)
   gfc_conv_shift_descriptor_lbound (&se.pre, desc,
			      dim, gfc_index_one_nodegfc_rank_cst[1]);
}

    /* If this is a subreference array pointer associate name use the
associate variable element size for the value of 'span'.  */
    if (sym->attr.subref_array_pointer && !se.direct_byref)
{
 gcc_assert (e->expr_type == EXPR_VARIABLE)((void)(!(e->expr_type == EXPR_VARIABLE) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 1964, __FUNCTION__), 0 : 0));
 tmp = gfc_get_array_span (se.expr, e);

 gfc_conv_descriptor_span_set (&se.pre, desc, tmp);
}

    if (e->expr_type == EXPR_FUNCTION
 && sym->ts.type == BT_DERIVED
 && sym->ts.u.derived
 && sym->ts.u.derived->attr.pdt_type)
{
 tmp = gfc_deallocate_pdt_comp (sym->ts.u.derived, se.expr,
			 sym->as->rank);
 gfc_add_expr_to_block (&se.post, tmp);
}

    /* Done, register stuff as init / cleanup code.  */
    gfc_add_init_cleanup (block, gfc_finish_block (&se.pre),
	    gfc_finish_block (&se.post));
  }

/* Temporaries, arising from TYPE IS, just need the descriptor of class
   arrays to be assigned directly.  */
else if (class_target && sym->attr.dimension
  && (sym->ts.type == BT_DERIVED || unlimited))
  {
    gfc_se se;

    gfc_init_se (&se, NULL__null);
    se.descriptor_only = 1;
    /* In a select type the (temporary) associate variable shall point to
a standard fortran array (lower bound == 1), but conv_expr ()
just maps to the input array in the class object, whose lbound may
be arbitrary.  conv_expr_descriptor solves this by inserting a
temporary array descriptor.  */
    gfc_conv_expr_descriptor (&se, e);

    gcc_assert (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (se.expr))((void)(!(((tree_class_check ((((contains_struct_check ((se.expr
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2001, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2001, __FUNCTION__))->type_common.lang_flag_1) || ((tree_class_check
 ((((contains_struct_check ((se.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__))->type_common.lang_flag_2)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__), 0 : 0))
  || GFC_ARRAY_TYPE_P (TREE_TYPE (se.expr)))((void)(!(((tree_class_check ((((contains_struct_check ((se.expr
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2001, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2001, __FUNCTION__))->type_common.lang_flag_1) || ((tree_class_check
 ((((contains_struct_check ((se.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__))->type_common.lang_flag_2)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2002, __FUNCTION__), 0 : 0));
    gcc_assert (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (sym->backend_decl)))((void)(!(((tree_class_check ((((contains_struct_check ((sym->
backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2003, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2003, __FUNCTION__))->type_common.lang_flag_1)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2003, __FUNCTION__), 0 : 0));

    if (GFC_ARRAY_TYPE_P (TREE_TYPE (se.expr))((tree_class_check ((((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2005, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2005, __FUNCTION__))->type_common.lang_flag_2))
{
 if (INDIRECT_REF_P (se.expr)(((enum tree_code) (se.expr)->base.code) == INDIRECT_REF))
   tmp = TREE_OPERAND (se.expr, 0)(*((const_cast<tree*> (tree_operand_check ((se.expr), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2008, __FUNCTION__)))));
 else
   tmp = se.expr;

 gfc_add_modify (&se.pre, sym->backend_decl,
	  gfc_class_data_get (GFC_DECL_SAVED_DESCRIPTOR (tmp)(((contains_struct_check ((tmp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2013, __FUNCTION__))->decl_common.lang_specific)->saved_descriptor
)));
}
    else
gfc_add_modify (&se.pre, sym->backend_decl, se.expr);

    if (unlimited)
{
 /* Recover the dtype, which has been overwritten by the
    assignment from an unlimited polymorphic object.  */
 tmp = gfc_conv_descriptor_dtype (sym->backend_decl);
 gfc_add_modify (&se.pre, tmp,
	  gfc_get_dtype (TREE_TYPE (sym->backend_decl)((contains_struct_check ((sym->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2024, __FUNCTION__))->typed.type)));
}

    gfc_add_init_cleanup (block, gfc_finish_block (&se.pre),
	    gfc_finish_block (&se.post));
  }

/* Do a scalar pointer assignment; this is for scalar variable targets.  */
else if (gfc_is_associate_pointer (sym))
  {
    gfc_se se;

    gcc_assert (!sym->attr.dimension)((void)(!(!sym->attr.dimension) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2036, __FUNCTION__), 0 : 0));

    gfc_init_se (&se, NULL__null);

    /* Class associate-names come this way because they are
unconditionally associate pointers and the symbol is scalar.  */
    if (sym->ts.type == BT_CLASS && CLASS_DATA (sym)sym->ts.u.derived->components->attr.dimension)
{
 tree target_expr;
 /* For a class array we need a descriptor for the selector.  */
 gfc_conv_expr_descriptor (&se, e);
 /* Needed to get/set the _len component below.  */
 target_expr = se.expr;

 /* Obtain a temporary class container for the result.  */
 gfc_conv_class_to_class (&se, e, sym->ts, false, true, false, false);
 se.expr = build_fold_indirect_ref_loc (input_location, se.expr);

 /* Set the offset.  */
 desc = gfc_class_data_get (se.expr);
 offset = gfc_index_zero_nodegfc_rank_cst[0];
 for (n = 0; n < e->rank; n++)
   {
     dim = gfc_rank_cst[n];
     tmp = fold_build2_loc (input_location, MULT_EXPR,
		     gfc_array_index_type,
		     gfc_conv_descriptor_stride_get (desc, dim),
		     gfc_conv_descriptor_lbound_get (desc, dim));
     offset = fold_build2_loc (input_location, MINUS_EXPR,
		        gfc_array_index_type,
		        offset, tmp);
   }
 if (need_len_assign)
   {
     if (e->symtree
  && DECL_LANG_SPECIFIC (e->symtree->n.sym->backend_decl)((contains_struct_check ((e->symtree->n.sym->backend_decl
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2071, __FUNCTION__))->decl_common.lang_specific)
  && GFC_DECL_SAVED_DESCRIPTOR (e->symtree->n.sym->backend_decl)(((contains_struct_check ((e->symtree->n.sym->backend_decl
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2072, __FUNCTION__))->decl_common.lang_specific)->saved_descriptor
)
  && TREE_CODE (target_expr)((enum tree_code) (target_expr)->base.code) != COMPONENT_REF)
/* Use the original class descriptor stored in the saved
   descriptor to get the target_expr.  */
target_expr =
    GFC_DECL_SAVED_DESCRIPTOR (e->symtree->n.sym->backend_decl)(((contains_struct_check ((e->symtree->n.sym->backend_decl
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2077, __FUNCTION__))->decl_common.lang_specific)->saved_descriptor
);
     else
/* Strip the _data component from the target_expr.  */
target_expr = TREE_OPERAND (target_expr, 0)(*((const_cast<tree*> (tree_operand_check ((target_expr
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2080, __FUNCTION__)))));
     /* Add a reference to the _len comp to the target expr.  */
     tmp = gfc_class_len_get (target_expr);
     /* Get the component-ref for the temp structure's _len comp.  */
     charlen = gfc_class_len_get (se.expr);
     /* Add the assign to the beginning of the block...  */
     gfc_add_modify (&se.pre, charlen,
	      fold_convert (TREE_TYPE (charlen), tmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(charlen), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2087, __FUNCTION__))->typed.type), tmp));
     /* and the oposite way at the end of the block, to hand changes
 on the string length back.  */
     gfc_add_modify (&se.post, tmp,
	      fold_convert (TREE_TYPE (tmp), charlen)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2091, __FUNCTION__))->typed.type), charlen));
     /* Length assignment done, prevent adding it again below.  */
     need_len_assign = false;
   }
 gfc_conv_descriptor_offset_set (&se.pre, desc, offset);
}
    else if (sym->ts.type == BT_CLASS && e->ts.type == BT_CLASS
      && CLASS_DATA (e)e->ts.u.derived->components->attr.dimension)
{
 /* This is bound to be a class array element.  */
 gfc_conv_expr_reference (&se, e);
 /* Get the _vptr component of the class object.  */
 tmp = gfc_get_vptr_from_expr (se.expr);
 /* Obtain a temporary class container for the result.  */
 gfc_conv_derived_to_class (&se, e, sym->ts, tmp, false, false);
 se.expr = build_fold_indirect_ref_loc (input_location, se.expr);
 need_len_assign = false;
}
    else
{
 /* For BT_CLASS and BT_DERIVED, this boils down to a pointer assign,
    which has the string length included.  For CHARACTERS it is still
    needed and will be done at the end of this routine.  */
 gfc_conv_expr (&se, e);
 need_len_assign = need_len_assign && sym->ts.type == BT_CHARACTER;
}

    if (sym->ts.type == BT_CHARACTER
 && !sym->attr.select_type_temporary
 && VAR_P (sym->ts.u.cl->backend_decl)(((enum tree_code) (sym->ts.u.cl->backend_decl)->base
.code) == VAR_DECL)
 && se.string_length != sym->ts.u.cl->backend_decl)
{
 gfc_add_modify (&se.pre, sym->ts.u.cl->backend_decl,
	  fold_convert (TREE_TYPE (sym->ts.u.cl->backend_decl),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(sym->ts.u.cl->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2124, __FUNCTION__))->typed.type), se.string_length)
			se.string_length)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(sym->ts.u.cl->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2124, __FUNCTION__))->typed.type), se.string_length));
 if (e->expr_type == EXPR_FUNCTION)
   {
     tmp = gfc_call_free (sym->backend_decl);
     gfc_add_expr_to_block (&se.post, tmp);
   }
}

    if (sym->ts.type == BT_CHARACTER && e->ts.type == BT_CHARACTER
 && POINTER_TYPE_P (TREE_TYPE (se.expr))(((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2134, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2134, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 /* These are pointer types already.  */
 tmp = fold_convert (TREE_TYPE (sym->backend_decl), se.expr)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(sym->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2137, __FUNCTION__))->typed.type), se.expr);
}
    else
{
 tree ctree = gfc_get_class_from_expr (se.expr);
 tmp = TREE_TYPE (sym->backend_decl)((contains_struct_check ((sym->backend_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2142, __FUNCTION__))->typed.type);

 /* Coarray scalar component expressions can emerge from
    the front end as array elements of the _data field.  */
 if (sym->ts.type == BT_CLASS
     && e->ts.type == BT_CLASS && e->rank == 0
     && !GFC_CLASS_TYPE_P (TREE_TYPE (se.expr))((tree_class_check ((((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2148, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2148, __FUNCTION__))->type_common.lang_flag_4) && ctree)
   {
     tree stmp;
     tree dtmp;

     se.expr = ctree;
     dtmp = TREE_TYPE (TREE_TYPE (sym->backend_decl))((contains_struct_check ((((contains_struct_check ((sym->backend_decl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2154, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2154, __FUNCTION__))->typed.type);
     ctree = gfc_create_var (dtmp, "class");

     stmp = gfc_class_data_get (se.expr);
     gcc_assert (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (stmp)))((void)(!(((tree_class_check ((((contains_struct_check ((stmp
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2158, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2158, __FUNCTION__))->type_common.lang_flag_1)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2158, __FUNCTION__), 0 : 0));

     /* Set the fields of the target class variable.  */
     stmp = gfc_conv_descriptor_data_get (stmp);
     dtmp = gfc_class_data_get (ctree);
     stmp = fold_convert (TREE_TYPE (dtmp), stmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(dtmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2163, __FUNCTION__))->typed.type), stmp);
     gfc_add_modify (&se.pre, dtmp, stmp);
     stmp = gfc_class_vptr_get (se.expr);
     dtmp = gfc_class_vptr_get (ctree);
     stmp = fold_convert (TREE_TYPE (dtmp), stmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(dtmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2167, __FUNCTION__))->typed.type), stmp);
     gfc_add_modify (&se.pre, dtmp, stmp);
     if (UNLIMITED_POLY (sym)(sym != __null && sym->ts.type == BT_CLASS &&
 sym->ts.u.derived->components && sym->ts.u.
derived->components->ts.u.derived && sym->ts
.u.derived->components->ts.u.derived->attr.unlimited_polymorphic
))
{
  stmp = gfc_class_len_get (se.expr);
  dtmp = gfc_class_len_get (ctree);
  stmp = fold_convert (TREE_TYPE (dtmp), stmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(dtmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2173, __FUNCTION__))->typed.type), stmp);
  gfc_add_modify (&se.pre, dtmp, stmp);
}
     se.expr = ctree;
   }
 tmp = gfc_build_addr_expr (tmp, se.expr);
}

    gfc_add_modify (&se.pre, sym->backend_decl, tmp);

    gfc_add_init_cleanup (block, gfc_finish_block( &se.pre),
	    gfc_finish_block (&se.post));
  }

/* Do a simple assignment.  This is for scalar expressions, where we
   can simply use expression assignment.  */
else
  {
    gfc_expr *lhs;
    tree res;
    gfc_se se;
    stmtblock_t final_block;

    gfc_init_se (&se, NULL__null);

    /* resolve.cc converts some associate names to allocatable so that
allocation can take place automatically in gfc_trans_assignment.
The frontend prevents them from being either allocated,
deallocated or reallocated.  */
    if (sym->ts.type == BT_DERIVED
 && sym->ts.u.derived->attr.alloc_comp)
{
 tmp = sym->backend_decl;
 tmp = gfc_nullify_alloc_comp (sym->ts.u.derived, tmp,
		sym->attr.dimension ? sym->as->rank : 0);
 gfc_add_expr_to_block (&se.pre, tmp);
}

    if (sym->attr.allocatable)
{
 tmp = sym->backend_decl;
 if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (tmp))((tree_class_check ((((contains_struct_check ((tmp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2214, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2214, __FUNCTION__))->type_common.lang_flag_1))
   tmp = gfc_conv_descriptor_data_get (tmp);
 gfc_add_modify (&se.pre, tmp, fold_convert (TREE_TYPE (tmp),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2216, __FUNCTION__))->typed.type), global_trees[TI_NULL_POINTER
])
				    null_pointer_node)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2216, __FUNCTION__))->typed.type), global_trees[TI_NULL_POINTER
]));
}

    lhs = gfc_lval_expr_from_sym (sym);
    lhs->must_finalize = 0;
    res = gfc_trans_assignment (lhs, e, false, true);
    gfc_add_expr_to_block (&se.pre, res);

    gfc_init_block (&final_block);

    if (sym->attr.associate_var
 && sym->ts.type == BT_DERIVED
 && sym->ts.u.derived->attr.defined_assign_comp
 && gfc_may_be_finalized (sym->ts)
 && e->expr_type == EXPR_FUNCTION)
{
 gfc_expr *ef;
 ef = gfc_lval_expr_from_sym (sym);
 gfc_add_finalizer_call (&final_block, ef);
 gfc_free_expr (ef);
}

    if (sym->ts.type == BT_DERIVED
 && sym->ts.u.derived->attr.alloc_comp)
{
 tmp = sym->backend_decl;
 tmp = gfc_deallocate_alloc_comp (sym->ts.u.derived,
			   tmp, 0);
 gfc_add_expr_to_block (&final_block, tmp);
}

    tmp = sym->backend_decl;
    if (e->expr_type == EXPR_FUNCTION
 && sym->ts.type == BT_DERIVED
 && sym->ts.u.derived
 && sym->ts.u.derived->attr.pdt_type)
{
 tmp = gfc_deallocate_pdt_comp (sym->ts.u.derived, tmp,
			 0);
}
    else if (e->expr_type == EXPR_FUNCTION
      && sym->ts.type == BT_CLASS
      && CLASS_DATA (sym)sym->ts.u.derived->components->ts.u.derived
      && CLASS_DATA (sym)sym->ts.u.derived->components->ts.u.derived->attr.pdt_type)
{
 tmp = gfc_class_data_get (tmp);
 tmp = gfc_deallocate_pdt_comp (CLASS_DATA (sym)sym->ts.u.derived->components->ts.u.derived,
			 tmp, 0);
}
    else if (sym->attr.allocatable)
{
 tmp = sym->backend_decl;

 if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (tmp))((tree_class_check ((((contains_struct_check ((tmp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2270, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2270, __FUNCTION__))->type_common.lang_flag_1))
   tmp = gfc_conv_descriptor_data_get (tmp);

 /* A simple call to free suffices here.  */
 tmp = gfc_call_free (tmp);

 /* Make sure that reallocation on assignment cannot occur.  */
 sym->attr.allocatable = 0;
}
    else
tmp = NULL_TREE(tree) __null;

    gfc_add_expr_to_block (&final_block, tmp);
    tmp = gfc_finish_block (&final_block);
    res = gfc_finish_block (&se.pre);
    gfc_add_init_cleanup (block, res, tmp);
    gfc_free_expr (lhs);
  }

/* Set the stringlength, when needed.  */
if (need_len_assign)
  {
    gfc_se se;
    gfc_init_se (&se, NULL__null);
    if (e->symtree->n.sym->ts.type == BT_CHARACTER)
{
 /* Deferred strings are dealt with in the preceeding.  */
 gcc_assert (!e->symtree->n.sym->ts.deferred)((void)(!(!e->symtree->n.sym->ts.deferred) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2297, __FUNCTION__), 0 : 0));
 tmp = e->symtree->n.sym->ts.u.cl->backend_decl;
}
    else if (e->symtree->n.sym->attr.function
      && e->symtree->n.sym == e->symtree->n.sym->result)
{
 tmp = gfc_get_fake_result_decl (e->symtree->n.sym, 0);
 tmp = gfc_class_len_get (tmp);
}
    else
tmp = gfc_class_len_get (gfc_get_symbol_decl (e->symtree->n.sym));
    gfc_get_symbol_decl (sym);
    charlen = sym->ts.type == BT_CHARACTER ? sym->ts.u.cl->backend_decl
			: gfc_class_len_get (sym->backend_decl);
    /* Prevent adding a noop len= len.  */
    if (tmp != charlen)
{
 gfc_add_modify (&se.pre, charlen,
	  fold_convert (TREE_TYPE (charlen), tmp)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(charlen), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2315, __FUNCTION__))->typed.type), tmp));
 gfc_add_init_cleanup (block, gfc_finish_block (&se.pre),
		gfc_finish_block (&se.post));
}
  }
2320}


2323/* Translate a BLOCK construct.  This is basically what we would do for a
 procedure body.  */

2326tree
2327gfc_trans_block_construct (gfc_code* code)
2328{
gfc_namespace* ns;
gfc_symbol* sym;
gfc_wrapped_block block;
tree exit_label;
stmtblock_t body;
gfc_association_list *ass;

ns = code->ext.block.ns;
gcc_assert (ns)((void)(!(ns) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2337, __FUNCTION__), 0 : 0));
sym = ns->proc_name;
gcc_assert (sym)((void)(!(sym) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2339, __FUNCTION__), 0 : 0));

/* Process local variables.  */
gcc_assert (!sym->tlink)((void)(!(!sym->tlink) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2342, __FUNCTION__), 0 : 0));
sym->tlink = sym;
gfc_process_block_locals (ns);

/* Generate code including exit-label.  */
gfc_init_block (&body);
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
code->exit_label = exit_label;

finish_oacc_declare (ns, sym, true);

gfc_add_expr_to_block (&body, gfc_trans_code (ns->code));
gfc_add_expr_to_block (&body, build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label));

/* Finish everything.  */
gfc_start_wrapped_block (&block, gfc_finish_block (&body));
gfc_trans_deferred_vars (sym, &block);
for (ass = code->ext.block.assoc; ass; ass = ass->next)
  trans_associate_var (ass->st->n.sym, &block);

return gfc_finish_wrapped_block (&block);
2363}

2365/* Translate the simple DO construct in a C-style manner.
 This is where the loop variable has integer type and step +-1.
 Following code will generate infinite loop in case where TO is INT_MAX
 (for +1 step) or INT_MIN (for -1 step)

 We translate a do loop from:

 DO dovar = from, to, step
    body
 END DO

 to:

 [Evaluate loop bounds and step]
  dovar = from;
  for (;;)
    {
if (dovar > to)
 goto end_label;
body;
cycle_label:
dovar += step;
    }
  end_label:

 This helps the optimizers by avoiding the extra pre-header condition and
 we save a register as we just compare the updated IV (not a value in
 previous step).  */

2394static tree
2395gfc_trans_simple_do (gfc_code * code, stmtblock_t *pblock, tree dovar,
     tree from, tree to, tree step, tree exit_cond)
2397{
stmtblock_t body;
tree type;
tree cond;
tree tmp;
tree saved_dovar = NULL__null;
tree cycle_label;
tree exit_label;
location_t loc;
type = TREE_TYPE (dovar)((contains_struct_check ((dovar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2406, __FUNCTION__))->typed.type);
bool is_step_positive = tree_int_cst_sgn (step) > 0;

loc = gfc_get_location (&code->ext.iterator->start->where);

/* Initialize the DO variable: dovar = from.  */
gfc_add_modify_loc (loc, pblock, dovar,
      fold_convert (TREE_TYPE (dovar), from)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(dovar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2413, __FUNCTION__))->typed.type), from));

/* Save value for do-tinkering checking.  */
if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    saved_dovar = gfc_create_var (type, ".saved_dovar");
    gfc_add_modify_loc (loc, pblock, saved_dovar, dovar);
  }

/* Cycle and exit statements are implemented with gotos.  */
cycle_label = gfc_build_label_decl (NULL_TREE(tree) __null);
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);

/* Put the labels where they can be found later.  See gfc_trans_do().  */
code->cycle_label = cycle_label;
code->exit_label = exit_label;

/* Loop body.  */
gfc_start_block (&body);

/* Exit the loop if there is an I/O result condition or error.  */
if (exit_cond)
  {
    tmp = build1_v (GOTO_EXPR, exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
    tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	     exit_cond, tmp,
	     build_empty_stmt (loc));
    gfc_add_expr_to_block (&body, tmp);
  }

/* Evaluate the loop condition.  */
if (is_step_positive)
  cond = fold_build2_loc (loc, GT_EXPR, logical_type_node, dovar,
	    fold_convert (type, to)fold_convert_loc (((location_t) 0), type, to));
else
  cond = fold_build2_loc (loc, LT_EXPR, logical_type_node, dovar,
	    fold_convert (type, to)fold_convert_loc (((location_t) 0), type, to));

cond = gfc_evaluate_now_loc (loc, cond, &body);
if (code->ext.iterator->unroll && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond
    = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2454, __FUNCTION__))->typed.type), cond,
build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_unroll_kind),
build_int_cst (integer_type_nodeinteger_types[itk_int], code->ext.iterator->unroll));

if (code->ext.iterator->ivdep && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2459, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_ivdep_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
if (code->ext.iterator->vector && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2463, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_vector_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
if (code->ext.iterator->novector && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2467, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_no_vector_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);

/* The loop exit.  */
tmp = fold_build1_loc (loc, GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], exit_label);
TREE_USED (exit_label)((exit_label)->base.used_flag) = 1;
tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	 cond, tmp, build_empty_stmt (loc));
gfc_add_expr_to_block (&body, tmp);

/* Check whether the induction variable is equal to INT_MAX
   (respectively to INT_MIN).  */
if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    tree boundary = is_step_positive ? TYPE_MAX_VALUE (type)((tree_check5 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2482, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
: TYPE_MIN_VALUE (type)((tree_check5 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2483, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);

    tmp = fold_build2_loc (loc, EQ_EXPR, logical_type_node,
	     dovar, boundary);
    gfc_trans_runtime_check (true, false, tmp, &body, &code->loc,
	       "Loop iterates infinitely");
  }

/* Main loop body.  */
tmp = gfc_trans_code_cond (code->block->next, exit_cond);
gfc_add_expr_to_block (&body, tmp);

/* Label for cycle statements (if needed).  */
if (TREE_USED (cycle_label)((cycle_label)->base.used_flag))
  {
    tmp = build1_v (LABEL_EXPR, cycle_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], cycle_label);
    gfc_add_expr_to_block (&body, tmp);
  }

/* Check whether someone has modified the loop variable.  */
if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    tmp = fold_build2_loc (loc, NE_EXPR, logical_type_node,
	     dovar, saved_dovar);
    gfc_trans_runtime_check (true, false, tmp, &body, &code->loc,
	       "Loop variable has been modified");
  }

/* Increment the loop variable.  */
tmp = fold_build2_loc (loc, PLUS_EXPR, type, dovar, step);
gfc_add_modify_loc (loc, &body, dovar, tmp);

if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  gfc_add_modify_loc (loc, &body, saved_dovar, dovar);

/* Finish the loop body.  */
tmp = gfc_finish_block (&body);
tmp = fold_build1_loc (loc, LOOP_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], tmp);

gfc_add_expr_to_block (pblock, tmp);

/* Add the exit label.  */
tmp = build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
gfc_add_expr_to_block (pblock, tmp);

return gfc_finish_block (pblock);
2529}

2531/* Translate the DO construct.  This obviously is one of the most
 important ones to get right with any compiler, but especially
 so for Fortran.

 We special case some loop forms as described in gfc_trans_simple_do.
 For other cases we implement them with a separate loop count,
 as described in the standard.

 We translate a do loop from:

 DO dovar = from, to, step
    body
 END DO

 to:

 [evaluate loop bounds and step]
 empty = (step > 0 ? to < from : to > from);
 countm1 = (to - from) / step;
 dovar = from;
 if (empty) goto exit_label;
 for (;;)
   {
     body;
2555cycle_label:
     dovar += step
     countm1t = countm1;
     countm1--;
     if (countm1t == 0) goto exit_label;
   }
2561exit_label:

 countm1 is an unsigned integer.  It is equal to the loop count minus one,
 because the loop count itself can overflow.  */

2566tree
2567gfc_trans_do (gfc_code * code, tree exit_cond)
2568{
gfc_se se;
tree dovar;
tree saved_dovar = NULL__null;
tree from;
tree to;
tree step;
tree countm1;
tree type;
tree utype;
tree cond;
tree cycle_label;
tree exit_label;
tree tmp;
stmtblock_t block;
stmtblock_t body;
location_t loc;

gfc_start_block (&block);

loc = gfc_get_location (&code->ext.iterator->start->where);

/* Evaluate all the expressions in the iterator.  */
gfc_init_se (&se, NULL__null);
gfc_conv_expr_lhs (&se, code->ext.iterator->var);
gfc_add_block_to_block (&block, &se.pre);
dovar = se.expr;
type = TREE_TYPE (dovar)((contains_struct_check ((dovar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2595, __FUNCTION__))->typed.type);

gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->ext.iterator->start);
gfc_add_block_to_block (&block, &se.pre);
from = gfc_evaluate_now (se.expr, &block);

gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->ext.iterator->end);
gfc_add_block_to_block (&block, &se.pre);
to = gfc_evaluate_now (se.expr, &block);

gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->ext.iterator->step);
gfc_add_block_to_block (&block, &se.pre);
step = gfc_evaluate_now (se.expr, &block);

if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    tmp = fold_build2_loc (input_location, EQ_EXPR, logical_type_node, step,
	     build_zero_cst (type));
    gfc_trans_runtime_check (true, false, tmp, &block, &code->loc,
	       "DO step value is zero");
  }

/* Special case simple loops.  */
if (TREE_CODE (type)((enum tree_code) (type)->base.code) == INTEGER_TYPE
    && (integer_onep (step)
|| tree_int_cst_equal (step, integer_minus_one_nodeglobal_trees[TI_INTEGER_MINUS_ONE])))
  return gfc_trans_simple_do (code, &block, dovar, from, to, step,
		exit_cond);

if (TREE_CODE (type)((enum tree_code) (type)->base.code) == INTEGER_TYPE)
  utype = unsigned_type_for (type);
else
  utype = unsigned_type_for (gfc_array_index_type);
countm1 = gfc_create_var (utype, "countm1");

/* Cycle and exit statements are implemented with gotos.  */
cycle_label = gfc_build_label_decl (NULL_TREE(tree) __null);
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
TREE_USED (exit_label)((exit_label)->base.used_flag) = 1;

/* Put these labels where they can be found later.  */
code->cycle_label = cycle_label;
code->exit_label = exit_label;

/* Initialize the DO variable: dovar = from.  */
gfc_add_modify (&block, dovar, from);

/* Save value for do-tinkering checking.  */
if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    saved_dovar = gfc_create_var (type, ".saved_dovar");
    gfc_add_modify_loc (loc, &block, saved_dovar, dovar);
  }

/* Initialize loop count and jump to exit label if the loop is empty.
   This code is executed before we enter the loop body. We generate:
   if (step > 0)
     {
countm1 = (to - from) / step;
if (to < from)
  goto exit_label;
     }
   else
     {
countm1 = (from - to) / -step;
if (to > from)
  goto exit_label;
     }
 */

if (TREE_CODE (type)((enum tree_code) (type)->base.code) == INTEGER_TYPE)
  {
    tree pos, neg, tou, fromu, stepu, tmp2;

    /* The distance from FROM to TO cannot always be represented in a signed
       type, thus use unsigned arithmetic, also to avoid any undefined
overflow issues.  */
    tou = fold_convert (utype, to)fold_convert_loc (((location_t) 0), utype, to);
    fromu = fold_convert (utype, from)fold_convert_loc (((location_t) 0), utype, from);
    stepu = fold_convert (utype, step)fold_convert_loc (((location_t) 0), utype, step);

    /* For a positive step, when to < from, exit, otherwise compute
       countm1 = ((unsigned)to - (unsigned)from) / (unsigned)step  */
    tmp = fold_build2_loc (loc, LT_EXPR, logical_type_node, to, from);
    tmp2 = fold_build2_loc (loc, TRUNC_DIV_EXPR, utype,
	      fold_build2_loc (loc, MINUS_EXPR, utype,
			       tou, fromu),
	      stepu);
    pos = build2 (COMPOUND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
    fold_build2 (MODIFY_EXPR, void_type_node,fold_build2_loc (((location_t) 0), MODIFY_EXPR, global_trees[
TI_VOID_TYPE], countm1, tmp2 )
		 countm1, tmp2)fold_build2_loc (((location_t) 0), MODIFY_EXPR, global_trees[
TI_VOID_TYPE], countm1, tmp2 ),
    build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		gfc_unlikely (tmp, PRED_FORTRAN_LOOP_PREHEADER),
		build1_loc (loc, GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
			    exit_label), NULL_TREE(tree) __null));

    /* For a negative step, when to > from, exit, otherwise compute
       countm1 = ((unsigned)from - (unsigned)to) / -(unsigned)step  */
    tmp = fold_build2_loc (loc, GT_EXPR, logical_type_node, to, from);
    tmp2 = fold_build2_loc (loc, TRUNC_DIV_EXPR, utype,
	      fold_build2_loc (loc, MINUS_EXPR, utype,
			       fromu, tou),
	      fold_build1_loc (loc, NEGATE_EXPR, utype, stepu));
    neg = build2 (COMPOUND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
    fold_build2 (MODIFY_EXPR, void_type_node,fold_build2_loc (((location_t) 0), MODIFY_EXPR, global_trees[
TI_VOID_TYPE], countm1, tmp2 )
		 countm1, tmp2)fold_build2_loc (((location_t) 0), MODIFY_EXPR, global_trees[
TI_VOID_TYPE], countm1, tmp2 ),
    build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		gfc_unlikely (tmp, PRED_FORTRAN_LOOP_PREHEADER),
		build1_loc (loc, GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
			    exit_label), NULL_TREE(tree) __null));

    tmp = fold_build2_loc (loc, LT_EXPR, logical_type_node, step,
	     build_int_cst (TREE_TYPE (step)((contains_struct_check ((step), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2710, __FUNCTION__))->typed.type), 0));
    tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], tmp, neg, pos);

    gfc_add_expr_to_block (&block, tmp);
  }
else
  {
    tree pos_step;

    /* TODO: We could use the same width as the real type.
This would probably cause more problems that it solves
when we implement "long double" types.  */

    tmp = fold_build2_loc (loc, MINUS_EXPR, type, to, from);
    tmp = fold_build2_loc (loc, RDIV_EXPR, type, tmp, step);
    tmp = fold_build1_loc (loc, FIX_TRUNC_EXPR, utype, tmp);
    gfc_add_modify (&block, countm1, tmp);

    /* We need a special check for empty loops:
empty = (step > 0 ? to < from : to > from);  */
    pos_step = fold_build2_loc (loc, GT_EXPR, logical_type_node, step,
		  build_zero_cst (type));
    tmp = fold_build3_loc (loc, COND_EXPR, logical_type_node, pos_step,
	     fold_build2_loc (loc, LT_EXPR,
			      logical_type_node, to, from),
	     fold_build2_loc (loc, GT_EXPR,
			      logical_type_node, to, from));
    /* If the loop is empty, go directly to the exit label.  */
    tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], tmp,
	 build1_v (GOTO_EXPR, exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], exit_label),
	 build_empty_stmt (input_location));
    gfc_add_expr_to_block (&block, tmp);
  }

/* Loop body.  */
gfc_start_block (&body);

/* Main loop body.  */
tmp = gfc_trans_code_cond (code->block->next, exit_cond);
gfc_add_expr_to_block (&body, tmp);

/* Label for cycle statements (if needed).  */
if (TREE_USED (cycle_label)((cycle_label)->base.used_flag))
  {
    tmp = build1_v (LABEL_EXPR, cycle_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], cycle_label);
    gfc_add_expr_to_block (&body, tmp);
  }

/* Check whether someone has modified the loop variable.  */
if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  {
    tmp = fold_build2_loc (loc, NE_EXPR, logical_type_node, dovar,
	     saved_dovar);
    gfc_trans_runtime_check (true, false, tmp, &body, &code->loc,
	       "Loop variable has been modified");
  }

/* Exit the loop if there is an I/O result condition or error.  */
if (exit_cond)
  {
    tmp = build1_v (GOTO_EXPR, exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
    tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	     exit_cond, tmp,
	     build_empty_stmt (input_location));
    gfc_add_expr_to_block (&body, tmp);
  }

/* Increment the loop variable.  */
tmp = fold_build2_loc (loc, PLUS_EXPR, type, dovar, step);
gfc_add_modify_loc (loc, &body, dovar, tmp);

if (gfc_option.rtcheck & GFC_RTCHECK_DO(1<<3))
  gfc_add_modify_loc (loc, &body, saved_dovar, dovar);

/* Initialize countm1t.  */
tree countm1t = gfc_create_var (utype, "countm1t");
gfc_add_modify_loc (loc, &body, countm1t, countm1);

/* Decrement the loop count.  */
tmp = fold_build2_loc (loc, MINUS_EXPR, utype, countm1,
	 build_int_cst (utype, 1));
gfc_add_modify_loc (loc, &body, countm1, tmp);

/* End with the loop condition.  Loop until countm1t == 0.  */
cond = fold_build2_loc (loc, EQ_EXPR, logical_type_node, countm1t,
	  build_int_cst (utype, 0));
if (code->ext.iterator->unroll && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond
    = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2798, __FUNCTION__))->typed.type), cond,
build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_unroll_kind),
build_int_cst (integer_type_nodeinteger_types[itk_int], code->ext.iterator->unroll));

if (code->ext.iterator->ivdep && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2803, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_ivdep_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
if (code->ext.iterator->vector && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2807, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_vector_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
if (code->ext.iterator->novector && cond != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2811, __FUNCTION__))->typed.type), cond,
   build_int_cst (integer_type_nodeinteger_types[itk_int], annot_expr_no_vector_kind),
   integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);

tmp = fold_build1_loc (loc, GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], exit_label);
tmp = fold_build3_loc (loc, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	 cond, tmp, build_empty_stmt (loc));
gfc_add_expr_to_block (&body, tmp);

/* End of loop body.  */
tmp = gfc_finish_block (&body);

/* The for loop itself.  */
tmp = fold_build1_loc (loc, LOOP_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], tmp);
gfc_add_expr_to_block (&block, tmp);

/* Add the exit label.  */
tmp = build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
gfc_add_expr_to_block (&block, tmp);

return gfc_finish_block (&block);
2832}


2835/* Translate the DO WHILE construct.

 We translate

 DO WHILE (cond)
    body
 END DO

 to:

 for ( ; ; )
   {
     pre_cond;
     if (! cond) goto exit_label;
     body;
2850cycle_label:
   }
2852exit_label:

 Because the evaluation of the exit condition `cond' may have side
 effects, we can't do much for empty loop bodies.  The backend optimizers
 should be smart enough to eliminate any dead loops.  */

2858tree
2859gfc_trans_do_while (gfc_code * code)
2860{
gfc_se cond;
tree tmp;
tree cycle_label;
tree exit_label;
stmtblock_t block;

/* Everything we build here is part of the loop body.  */
gfc_start_block (&block);

/* Cycle and exit statements are implemented with gotos.  */
cycle_label = gfc_build_label_decl (NULL_TREE(tree) __null);
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);

/* Put the labels where they can be found later. See gfc_trans_do().  */
code->cycle_label = cycle_label;
code->exit_label = exit_label;

/* Create a GIMPLE version of the exit condition.  */
gfc_init_se (&cond, NULL__null);
gfc_conv_expr_val (&cond, code->expr1);
gfc_add_block_to_block (&block, &cond.pre);
cond.expr = fold_build1_loc (gfc_get_location (&code->expr1->where),
	       TRUTH_NOT_EXPR, TREE_TYPE (cond.expr)((contains_struct_check ((cond.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2883, __FUNCTION__))->typed.type),
	       cond.expr);

/* Build "IF (! cond) GOTO exit_label".  */
tmp = build1_v (GOTO_EXPR, exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
TREE_USED (exit_label)((exit_label)->base.used_flag) = 1;
tmp = fold_build3_loc (gfc_get_location (&code->expr1->where), COND_EXPR,
	 void_type_nodeglobal_trees[TI_VOID_TYPE], cond.expr, tmp,
	 build_empty_stmt (gfc_get_location (
			     &code->expr1->where)));
gfc_add_expr_to_block (&block, tmp);

/* The main body of the loop.  */
tmp = gfc_trans_code (code->block->next);
gfc_add_expr_to_block (&block, tmp);

/* Label for cycle statements (if needed).  */
if (TREE_USED (cycle_label)((cycle_label)->base.used_flag))
  {
    tmp = build1_v (LABEL_EXPR, cycle_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], cycle_label);
    gfc_add_expr_to_block (&block, tmp);
  }

/* End of loop body.  */
tmp = gfc_finish_block (&block);

gfc_init_block (&block);
/* Build the loop.  */
tmp = fold_build1_loc (gfc_get_location (&code->expr1->where), LOOP_EXPR,
	 void_type_nodeglobal_trees[TI_VOID_TYPE], tmp);
gfc_add_expr_to_block (&block, tmp);

/* Add the exit label.  */
tmp = build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
gfc_add_expr_to_block (&block, tmp);

return gfc_finish_block (&block);
2920}


2923/* Deal with the particular case of SELECT_TYPE, where the vtable
 addresses are used for the selection. Since these are not sorted,
 the selection has to be made by a series of if statements.  */

2927static tree
2928gfc_trans_select_type_cases (gfc_code * code)
2929{
gfc_code *c;
gfc_case *cp;
tree tmp;
tree cond;
tree low;
tree high;
gfc_se se;
gfc_se cse;
stmtblock_t block;
stmtblock_t body;
bool def = false;
gfc_expr *e;
gfc_start_block (&block);

/* Calculate the switch expression.  */
gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->expr1);
gfc_add_block_to_block (&block, &se.pre);

/* Generate an expression for the selector hash value, for
   use to resolve character cases.  */
e = gfc_copy_expr (code->expr1->value.function.actual->expr);
gfc_add_hash_component (e)gfc_add_component_ref(e,"_hash");

TREE_USED (code->exit_label)((code->exit_label)->base.used_flag) = 0;

2956repeat:
for (c = code->block; c; c = c->block)
  {
    cp = c->ext.block.case_list;

    /* Assume it's the default case.  */
    low = NULL_TREE(tree) __null;
    high = NULL_TREE(tree) __null;
    tmp = NULL_TREE(tree) __null;

    /* Put the default case at the end.  */
    if ((!def && !cp->low) || (def && cp->low))
continue;

    if (cp->low && (cp->ts.type == BT_CLASS
      || cp->ts.type == BT_DERIVED))
{
 gfc_init_se (&cse, NULL__null);
 gfc_conv_expr_val (&cse, cp->low);
 gfc_add_block_to_block (&block, &cse.pre);
 low = cse.expr;
}
    else if (cp->ts.type != BT_UNKNOWN)
{
 gcc_assert (cp->high)((void)(!(cp->high) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 2980, __FUNCTION__), 0 : 0));
 gfc_init_se (&cse, NULL__null);
 gfc_conv_expr_val (&cse, cp->high);
 gfc_add_block_to_block (&block, &cse.pre);
 high = cse.expr;
}

    gfc_init_block (&body);

    /* Add the statements for this case.  */
    tmp = gfc_trans_code (c->next);
    gfc_add_expr_to_block (&body, tmp);

    /* Break to the end of the SELECT TYPE construct.  The default
case just falls through.  */
    if (!def)
{
 TREE_USED (code->exit_label)((code->exit_label)->base.used_flag) = 1;
 tmp = build1_v (GOTO_EXPR, code->exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], code->exit_label);
 gfc_add_expr_to_block (&body, tmp);
}

    tmp = gfc_finish_block (&body);

    if (low != NULL_TREE(tree) __null)
{
 /* Compare vtable pointers.  */
 cond = fold_build2_loc (input_location, EQ_EXPR,
		  TREE_TYPE (se.expr)((contains_struct_check ((se.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3008, __FUNCTION__))->typed.type), se.expr, low);
 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		 cond, tmp,
		 build_empty_stmt (input_location));
}
    else if (high != NULL_TREE(tree) __null)
{
 /* Compare hash values for character cases.  */
 gfc_init_se (&cse, NULL__null);
 gfc_conv_expr_val (&cse, e);
 gfc_add_block_to_block (&block, &cse.pre);

 cond = fold_build2_loc (input_location, EQ_EXPR,
		  TREE_TYPE (se.expr)((contains_struct_check ((se.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3021, __FUNCTION__))->typed.type), high, cse.expr);
 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		 cond, tmp,
		 build_empty_stmt (input_location));
}

    gfc_add_expr_to_block (&block, tmp);
  }

if (!def)
  {
    def = true;
    goto repeat;
  }

gfc_free_expr (e);

return gfc_finish_block (&block);
3039}


3042/* Translate the SELECT CASE construct for INTEGER case expressions,
 without killing all potential optimizations.  The problem is that
 Fortran allows unbounded cases, but the back-end does not, so we
 need to intercept those before we enter the equivalent SWITCH_EXPR
 we can build.

 For example, we translate this,

 SELECT CASE (expr)
    CASE (:100,101,105:115)
block_1
    CASE (190:199,200:)
block_2
    CASE (300)
block_3
    CASE DEFAULT
block_4
 END SELECT

 to the GENERIC equivalent,

   switch (expr)
     {
case (minimum value for typeof(expr) ... 100:
case 101:
case 105 ... 114:
  block1:
  goto end_label;

case 200 ... (maximum value for typeof(expr):
case 190 ... 199:
  block2;
  goto end_label;

case 300:
  block_3;
  goto end_label;

default:
  block_4;
  goto end_label;
     }

   end_label:  */

3087static tree
3088gfc_trans_integer_select (gfc_code * code)
3089{
gfc_code *c;
gfc_case *cp;
tree end_label;
tree tmp;
gfc_se se;
stmtblock_t block;
stmtblock_t body;

gfc_start_block (&block);

/* Calculate the switch expression.  */
gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->expr1);
gfc_add_block_to_block (&block, &se.pre);

end_label = gfc_build_label_decl (NULL_TREE(tree) __null);

gfc_init_block (&body);

for (c = code->block; c; c = c->block)
  {
    for (cp = c->ext.block.case_list; cp; cp = cp->next)
{
 tree low, high;
        tree label;

 /* Assume it's the default case.  */
 low = high = NULL_TREE(tree) __null;

 if (cp->low)
   {
     low = gfc_conv_mpz_to_tree (cp->low->value.integer,
			  cp->low->ts.kind);

     /* If there's only a lower bound, set the high bound to the
 maximum value of the case expression.  */
     if (!cp->high)
high = TYPE_MAX_VALUE (TREE_TYPE (se.expr))((tree_check5 ((((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3127, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3127, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
);
   }

 if (cp->high)
   {
     /* Three cases are possible here:

 1) There is no lower bound, e.g. CASE (:N).
 2) There is a lower bound .NE. high bound, that is
    a case range, e.g. CASE (N:M) where M>N (we make
    sure that M>N during type resolution).
 3) There is a lower bound, and it has the same value
    as the high bound, e.g. CASE (N:N).  This is our
    internal representation of CASE(N).

 In the first and second case, we need to set a value for
 high.  In the third case, we don't because the GCC middle
 end represents a single case value by just letting high be
 a NULL_TREE.  We can't do that because we need to be able
 to represent unbounded cases.  */

     if (!cp->low
  || (mpz_cmp__gmpz_cmp (cp->low->value.integer,
		cp->high->value.integer) != 0))
high = gfc_conv_mpz_to_tree (cp->high->value.integer,
			     cp->high->ts.kind);

     /* Unbounded case.  */
     if (!cp->low)
low = TYPE_MIN_VALUE (TREE_TYPE (se.expr))((tree_check5 ((((contains_struct_check ((se.expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3156, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3156, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);
   }

        /* Build a label.  */
        label = gfc_build_label_decl (NULL_TREE(tree) __null);

 /* Add this case label.
           Add parameter 'label', make it match GCC backend.  */
 tmp = build_case_label (low, high, label);
 gfc_add_expr_to_block (&body, tmp);
}

    /* Add the statements for this case.  */
    tmp = gfc_trans_code (c->next);
    gfc_add_expr_to_block (&body, tmp);

    /* Break to the end of the construct.  */
    tmp = build1_v (GOTO_EXPR, end_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], end_label);
    gfc_add_expr_to_block (&body, tmp);
  }

tmp = gfc_finish_block (&body);
tmp = fold_build2_loc (input_location, SWITCH_EXPR, NULL_TREE(tree) __null, se.expr, tmp);
gfc_add_expr_to_block (&block, tmp);

tmp = build1_v (LABEL_EXPR, end_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], end_label);
gfc_add_expr_to_block (&block, tmp);

return gfc_finish_block (&block);
3185}


3188/* Translate the SELECT CASE construct for LOGICAL case expressions.

 There are only two cases possible here, even though the standard
 does allow three cases in a LOGICAL SELECT CASE construct: .TRUE.,
 .FALSE., and DEFAULT.

 We never generate more than two blocks here.  Instead, we always
 try to eliminate the DEFAULT case.  This way, we can translate this
 kind of SELECT construct to a simple

 if {} else {};

 expression in GENERIC.  */

3202static tree
3203gfc_trans_logical_select (gfc_code * code)
3204{
gfc_code *c;
gfc_code *t, *f, *d;
gfc_case *cp;
gfc_se se;
stmtblock_t block;

/* Assume we don't have any cases at all.  */
t = f = d = NULL__null;

/* Now see which ones we actually do have.  We can have at most two
   cases in a single case list: one for .TRUE. and one for .FALSE.
   The default case is always separate.  If the cases for .TRUE. and
   .FALSE. are in the same case list, the block for that case list
   always executed, and we don't generate code a COND_EXPR.  */
for (c = code->block; c; c = c->block)
  {
    for (cp = c->ext.block.case_list; cp; cp = cp->next)
{
 if (cp->low)
   {
     if (cp->low->value.logical == 0) /* .FALSE.  */
f = c;
     else /* if (cp->value.logical != 0), thus .TRUE.  */
t = c;
   }
 else
   d = c;
}
  }

/* Start a new block.  */
gfc_start_block (&block);

/* Calculate the switch expression.  We always need to do this
   because it may have side effects.  */
gfc_init_se (&se, NULL__null);
gfc_conv_expr_val (&se, code->expr1);
gfc_add_block_to_block (&block, &se.pre);

if (t == f && t != NULL__null)
  {
    /* Cases for .TRUE. and .FALSE. are in the same block.  Just
       translate the code for these cases, append it to the current
       block.  */
    gfc_add_expr_to_block (&block, gfc_trans_code (t->next));
  }
else
  {
    tree true_tree, false_tree, stmt;

    true_tree = build_empty_stmt (input_location);
    false_tree = build_empty_stmt (input_location);

    /* If we have a case for .TRUE. and for .FALSE., discard the default case.
        Otherwise, if .TRUE. or .FALSE. is missing and there is a default case,
        make the missing case the default case.  */
    if (t != NULL__null && f != NULL__null)
d = NULL__null;
    else if (d != NULL__null)
      {
 if (t == NULL__null)
   t = d;
 else
   f = d;
}

    /* Translate the code for each of these blocks, and append it to
       the current block.  */
    if (t != NULL__null)
      true_tree = gfc_trans_code (t->next);

    if (f != NULL__null)
false_tree = gfc_trans_code (f->next);

    stmt = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	      se.expr, true_tree, false_tree);
    gfc_add_expr_to_block (&block, stmt);
  }

return gfc_finish_block (&block);
3285}


3288/* The jump table types are stored in static variables to avoid
 constructing them from scratch every single time.  */
3290static GTY(()) tree select_struct[2];

3292/* Translate the SELECT CASE construct for CHARACTER case expressions.
 Instead of generating compares and jumps, it is far simpler to
 generate a data structure describing the cases in order and call a
 library subroutine that locates the right case.
 This is particularly true because this is the only case where we
 might have to dispose of a temporary.
 The library subroutine returns a pointer to jump to or NULL if no
 branches are to be taken.  */

3301static tree
3302gfc_trans_character_select (gfc_code *code)
3303{
tree init, end_label, tmp, type, case_num, label, fndecl;
stmtblock_t block, body;
gfc_case *cp, *d;
gfc_code *c;
gfc_se se, expr1se;
int n, k;
vec<constructor_elt, va_gc> *inits = NULL__null;

tree pchartype = gfc_get_pchar_type (code->expr1->ts.kind);

/* The jump table types are stored in static variables to avoid
   constructing them from scratch every single time.  */
static tree ss_string1[2], ss_string1_len[2];
static tree ss_string2[2], ss_string2_len[2];
static tree ss_target[2];

cp = code->block->ext.block.case_list;
while (cp->left != NULL__null)
  cp = cp->left;

/* Generate the body */
gfc_start_block (&block);
gfc_init_se (&expr1se, NULL__null);
gfc_conv_expr_reference (&expr1se, code->expr1);

gfc_add_block_to_block (&block, &expr1se.pre);

end_label = gfc_build_label_decl (NULL_TREE(tree) __null);

gfc_init_block (&body);

/* Attempt to optimize length 1 selects.  */
if (integer_onep (expr1se.string_length))
  {
    for (d = cp; d; d = d->right)
{
 gfc_charlen_t i;
 if (d->low)
   {
     gcc_assert (d->low->expr_type == EXPR_CONSTANT((void)(!(d->low->expr_type == EXPR_CONSTANT &&
 d->low->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3344, __FUNCTION__), 0 : 0))
	  && d->low->ts.type == BT_CHARACTER)((void)(!(d->low->expr_type == EXPR_CONSTANT &&
 d->low->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3344, __FUNCTION__), 0 : 0));
     if (d->low->value.character.length > 1)
{
  for (i = 1; i < d->low->value.character.length; i++)
    if (d->low->value.character.string[i] != ' ')
      break;
  if (i != d->low->value.character.length)
    {
      if (optimizeglobal_options.x_optimize && d->high && i == 1)
	{
	  gcc_assert (d->high->expr_type == EXPR_CONSTANT((void)(!(d->high->expr_type == EXPR_CONSTANT &&
 d->high->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3355, __FUNCTION__), 0 : 0))
		      && d->high->ts.type == BT_CHARACTER)((void)(!(d->high->expr_type == EXPR_CONSTANT &&
 d->high->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3355, __FUNCTION__), 0 : 0));
	  if (d->high->value.character.length > 1
	      && (d->low->value.character.string[0]
		  == d->high->value.character.string[0])
	      && d->high->value.character.string[1] != ' '
	      && ((d->low->value.character.string[1] < ' ')
		  == (d->high->value.character.string[1]
		      < ' ')))
	    continue;
	}
      break;
    }
}
   }
 if (d->high)
   {
     gcc_assert (d->high->expr_type == EXPR_CONSTANT((void)(!(d->high->expr_type == EXPR_CONSTANT &&
 d->high->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3372, __FUNCTION__), 0 : 0))
	  && d->high->ts.type == BT_CHARACTER)((void)(!(d->high->expr_type == EXPR_CONSTANT &&
 d->high->ts.type == BT_CHARACTER) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3372, __FUNCTION__), 0 : 0));
     if (d->high->value.character.length > 1)
{
  for (i = 1; i < d->high->value.character.length; i++)
    if (d->high->value.character.string[i] != ' ')
      break;
  if (i != d->high->value.character.length)
    break;
}
   }
}
    if (d == NULL__null)
{
 tree ctype = gfc_get_char_type (code->expr1->ts.kind);

 for (c = code->block; c; c = c->block)
   {
     for (cp = c->ext.block.case_list; cp; cp = cp->next)
{
  tree low, high;
  tree label;
  gfc_char_t r;

  /* Assume it's the default case.  */
  low = high = NULL_TREE(tree) __null;

  if (cp->low)
    {
      /* CASE ('ab') or CASE ('ab':'az') will never match
	 any length 1 character.  */
      if (cp->low->value.character.length > 1
	  && cp->low->value.character.string[1] != ' ')
	continue;

      if (cp->low->value.character.length > 0)
	r = cp->low->value.character.string[0];
      else
	r = ' ';
      low = build_int_cst (ctype, r);

      /* If there's only a lower bound, set the high bound
	 to the maximum value of the case expression.  */
      if (!cp->high)
	high = TYPE_MAX_VALUE (ctype)((tree_check5 ((ctype), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3415, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
);
    }

  if (cp->high)
    {
      if (!cp->low
	  || (cp->low->value.character.string[0]
	      != cp->high->value.character.string[0]))
	{
	  if (cp->high->value.character.length > 0)
	    r = cp->high->value.character.string[0];
	  else
	    r = ' ';
	  high = build_int_cst (ctype, r);
	}

      /* Unbounded case.  */
      if (!cp->low)
	low = TYPE_MIN_VALUE (ctype)((tree_check5 ((ctype), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3433, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);
    }

  /* Build a label.  */
  label = gfc_build_label_decl (NULL_TREE(tree) __null);

  /* Add this case label.
     Add parameter 'label', make it match GCC backend.  */
  tmp = build_case_label (low, high, label);
  gfc_add_expr_to_block (&body, tmp);
}

     /* Add the statements for this case.  */
     tmp = gfc_trans_code (c->next);
     gfc_add_expr_to_block (&body, tmp);

     /* Break to the end of the construct.  */
     tmp = build1_v (GOTO_EXPR, end_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], end_label);
     gfc_add_expr_to_block (&body, tmp);
   }

 tmp = gfc_string_to_single_character (expr1se.string_length,
				expr1se.expr,
				code->expr1->ts.kind);
 case_num = gfc_create_var (ctype, "case_num");
 gfc_add_modify (&block, case_num, tmp);

 gfc_add_block_to_block (&block, &expr1se.post);

 tmp = gfc_finish_block (&body);
 tmp = fold_build2_loc (input_location, SWITCH_EXPR, NULL_TREE(tree) __null,
		 case_num, tmp);
 gfc_add_expr_to_block (&block, tmp);

 tmp = build1_v (LABEL_EXPR, end_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], end_label);
 gfc_add_expr_to_block (&block, tmp);

 return gfc_finish_block (&block);
}
  }

if (code->expr1->ts.kind == 1)
  k = 0;
else if (code->expr1->ts.kind == 4)
  k = 1;
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3479, __FUNCTION__));

if (select_struct[k] == NULL__null)
  {
    tree *chain = NULL__null;
    select_struct[k] = make_node (RECORD_TYPE);

    if (code->expr1->ts.kind == 1)
TYPE_NAME (select_struct[k])((tree_class_check ((select_struct[k]), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3487, __FUNCTION__))->type_common.name) = get_identifier ("_jump_struct_char1")(__builtin_constant_p ("_jump_struct_char1") ? get_identifier_with_length
 (("_jump_struct_char1"), strlen ("_jump_struct_char1")) : get_identifier
 ("_jump_struct_char1"));
    else if (code->expr1->ts.kind == 4)
TYPE_NAME (select_struct[k])((tree_class_check ((select_struct[k]), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3489, __FUNCTION__))->type_common.name) = get_identifier ("_jump_struct_char4")(__builtin_constant_p ("_jump_struct_char4") ? get_identifier_with_length
 (("_jump_struct_char4"), strlen ("_jump_struct_char4")) : get_identifier
 ("_jump_struct_char4"));
    else
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3491, __FUNCTION__));

3493#undef ADD_FIELD
3494#define ADD_FIELD(NAME, TYPE)						    \
ss_##NAME[k] = gfc_add_field_to_struct (select_struct[k],		    \
			  get_identifier (stringize(NAME))(__builtin_constant_p ("NAME") ? get_identifier_with_length (
("NAME"), strlen ("NAME")) : get_identifier ("NAME")), \
			  TYPE,				    \
			  &chain)

    ADD_FIELD (string1, pchartype);
    ADD_FIELD (string1_len, gfc_charlen_type_node);

    ADD_FIELD (string2, pchartype);
    ADD_FIELD (string2_len, gfc_charlen_type_node);

    ADD_FIELD (target, integer_type_nodeinteger_types[itk_int]);
3507#undef ADD_FIELD

    gfc_finish_type (select_struct[k]);
  }

n = 0;
for (d = cp; d; d = d->right)
  d->n = n++;

for (c = code->block; c; c = c->block)
  {
    for (d = c->ext.block.case_list; d; d = d->next)
      {
 label = gfc_build_label_decl (NULL_TREE(tree) __null);
 tmp = build_case_label ((d->low == NULL__null && d->high == NULL__null)
		  ? NULL__null
		  : build_int_cst (integer_type_nodeinteger_types[itk_int], d->n),
		  NULL__null, label);
        gfc_add_expr_to_block (&body, tmp);
      }

    tmp = gfc_trans_code (c->next);
    gfc_add_expr_to_block (&body, tmp);

    tmp = build1_v (GOTO_EXPR, end_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], end_label);
    gfc_add_expr_to_block (&body, tmp);
  }

/* Generate the structure describing the branches */
for (d = cp; d; d = d->right)
  {
    vec<constructor_elt, va_gc> *node = NULL__null;

    gfc_init_se (&se, NULL__null);

    if (d->low == NULL__null)
      {
        CONSTRUCTOR_APPEND_ELT (node, ss_string1[k], null_pointer_node)do { constructor_elt _ce___ = {ss_string1[k], global_trees[TI_NULL_POINTER
]}; vec_safe_push ((node), _ce___); } while (0);
        CONSTRUCTOR_APPEND_ELT (node, ss_string1_len[k], build_zero_cst (gfc_charlen_type_node))do { constructor_elt _ce___ = {ss_string1_len[k], build_zero_cst
 (gfc_charlen_type_node)}; vec_safe_push ((node), _ce___); } while
 (0);
      }
    else
      {
        gfc_conv_expr_reference (&se, d->low);

        CONSTRUCTOR_APPEND_ELT (node, ss_string1[k], se.expr)do { constructor_elt _ce___ = {ss_string1[k], se.expr}; vec_safe_push
 ((node), _ce___); } while (0);
        CONSTRUCTOR_APPEND_ELT (node, ss_string1_len[k], se.string_length)do { constructor_elt _ce___ = {ss_string1_len[k], se.string_length
}; vec_safe_push ((node), _ce___); } while (0);
      }

    if (d->high == NULL__null)
      {
        CONSTRUCTOR_APPEND_ELT (node, ss_string2[k], null_pointer_node)do { constructor_elt _ce___ = {ss_string2[k], global_trees[TI_NULL_POINTER
]}; vec_safe_push ((node), _ce___); } while (0);
        CONSTRUCTOR_APPEND_ELT (node, ss_string2_len[k], build_zero_cst (gfc_charlen_type_node))do { constructor_elt _ce___ = {ss_string2_len[k], build_zero_cst
 (gfc_charlen_type_node)}; vec_safe_push ((node), _ce___); } while
 (0);
      }
    else
      {
        gfc_init_se (&se, NULL__null);
        gfc_conv_expr_reference (&se, d->high);

        CONSTRUCTOR_APPEND_ELT (node, ss_string2[k], se.expr)do { constructor_elt _ce___ = {ss_string2[k], se.expr}; vec_safe_push
 ((node), _ce___); } while (0);
        CONSTRUCTOR_APPEND_ELT (node, ss_string2_len[k], se.string_length)do { constructor_elt _ce___ = {ss_string2_len[k], se.string_length
}; vec_safe_push ((node), _ce___); } while (0);
      }

    CONSTRUCTOR_APPEND_ELT (node, ss_target[k],do { constructor_elt _ce___ = {ss_target[k], build_int_cst (integer_types
[itk_int], d->n)}; vec_safe_push ((node), _ce___); } while
 (0)
                            build_int_cst (integer_type_node, d->n))do { constructor_elt _ce___ = {ss_target[k], build_int_cst (integer_types
[itk_int], d->n)}; vec_safe_push ((node), _ce___); } while
 (0);

    tmp = build_constructor (select_struct[k], node);
    CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, tmp)do { constructor_elt _ce___ = {(tree) __null, tmp}; vec_safe_push
 ((inits), _ce___); } while (0);
  }

type = build_array_type (select_struct[k],
	   build_index_type (size_int (n-1)size_int_kind (n-1, stk_sizetype)));

init = build_constructor (type, inits);
TREE_CONSTANT (init)((non_type_check ((init), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3580, __FUNCTION__))->base.constant_flag) = 1;
TREE_STATIC (init)((init)->base.static_flag) = 1;
/* Create a static variable to hold the jump table.  */
tmp = gfc_create_var (type, "jumptable");
TREE_CONSTANT (tmp)((non_type_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3584, __FUNCTION__))->base.constant_flag) = 1;
TREE_STATIC (tmp)((tmp)->base.static_flag) = 1;
TREE_READONLY (tmp)((non_type_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3586, __FUNCTION__))->base.readonly_flag) = 1;
DECL_INITIAL (tmp)((contains_struct_check ((tmp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3587, __FUNCTION__))->decl_common.initial) = init;
init = tmp;

/* Build the library call */
init = gfc_build_addr_expr (pvoid_type_node, init);

if (code->expr1->ts.kind == 1)
  fndecl = gfor_fndecl_select_string;
else if (code->expr1->ts.kind == 4)
  fndecl = gfor_fndecl_select_string_char4;
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3598, __FUNCTION__));

tmp = build_call_expr_loc (input_location,
	 fndecl, 4, init,
	 build_int_cst (gfc_charlen_type_node, n),
	 expr1se.expr, expr1se.string_length);
case_num = gfc_create_var (integer_type_nodeinteger_types[itk_int], "case_num");
gfc_add_modify (&block, case_num, tmp);

gfc_add_block_to_block (&block, &expr1se.post);

tmp = gfc_finish_block (&body);
tmp = fold_build2_loc (input_location, SWITCH_EXPR, NULL_TREE(tree) __null,
	 case_num, tmp);
gfc_add_expr_to_block (&block, tmp);

tmp = build1_v (LABEL_EXPR, end_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], end_label);
gfc_add_expr_to_block (&block, tmp);

return gfc_finish_block (&block);
3618}


3621/* Translate the three variants of the SELECT CASE construct.

 SELECT CASEs with INTEGER case expressions can be translated to an
 equivalent GENERIC switch statement, and for LOGICAL case
 expressions we build one or two if-else compares.

 SELECT CASEs with CHARACTER case expressions are a whole different
 story, because they don't exist in GENERIC.  So we sort them and
 do a binary search at runtime.

 Fortran has no BREAK statement, and it does not allow jumps from
 one case block to another.  That makes things a lot easier for
 the optimizers.  */

3635tree
3636gfc_trans_select (gfc_code * code)
3637{
stmtblock_t block;
tree body;
tree exit_label;

gcc_assert (code && code->expr1)((void)(!(code && code->expr1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3642, __FUNCTION__), 0 : 0));
gfc_init_block (&block);

/* Build the exit label and hang it in.  */
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
code->exit_label = exit_label;

/* Empty SELECT constructs are legal.  */
if (code->block == NULL__null)
  body = build_empty_stmt (input_location);

/* Select the correct translation function.  */
else
  switch (code->expr1->ts.type)
    {
    case BT_LOGICAL:
body = gfc_trans_logical_select (code);
break;

    case BT_INTEGER:
body = gfc_trans_integer_select (code);
break;

    case BT_CHARACTER:
body = gfc_trans_character_select (code);
break;

    default:
gfc_internal_error ("gfc_trans_select(): Bad type for case expr.");
/* Not reached */
    }

/* Build everything together.  */
gfc_add_expr_to_block (&block, body);
gfc_add_expr_to_block (&block, build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label));

return gfc_finish_block (&block);
3679}

3681tree
3682gfc_trans_select_type (gfc_code * code)
3683{
stmtblock_t block;
tree body;
tree exit_label;

gcc_assert (code && code->expr1)((void)(!(code && code->expr1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3688, __FUNCTION__), 0 : 0));
gfc_init_block (&block);

/* Build the exit label and hang it in.  */
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
code->exit_label = exit_label;

/* Empty SELECT constructs are legal.  */
if (code->block == NULL__null)
  body = build_empty_stmt (input_location);
else
  body = gfc_trans_select_type_cases (code);

/* Build everything together.  */
gfc_add_expr_to_block (&block, body);

if (TREE_USED (exit_label)((exit_label)->base.used_flag))
  gfc_add_expr_to_block (&block, build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label));

return gfc_finish_block (&block);
3708}


3711static tree
3712gfc_trans_select_rank_cases (gfc_code * code)
3713{
gfc_code *c;
gfc_case *cp;
tree tmp;
tree cond;
tree low;
tree rank;
gfc_se se;
gfc_se cse;
stmtblock_t block;
stmtblock_t body;
bool def = false;

gfc_start_block (&block);

/* Calculate the switch expression.  */
gfc_init_se (&se, NULL__null);
gfc_conv_expr_descriptor (&se, code->expr1);
rank = gfc_conv_descriptor_rank (se.expr);
rank = gfc_evaluate_now (rank, &block);
symbol_attribute attr = gfc_expr_attr (code->expr1);
if (!attr.pointer && !attr.allocatable)
  {
    /* Special case for assumed-rank ('rank(*)', internally -1):
rank = (rank == 0 || ubound[rank-1] != -1) ? rank : -1.  */
    cond = fold_build2_loc (input_location, EQ_EXPR, logical_type_node,
	      rank, build_int_cst (TREE_TYPE (rank)((contains_struct_check ((rank), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3739, __FUNCTION__))->typed.type), 0));
    tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
	     fold_convert (gfc_array_index_type, rank)fold_convert_loc (((location_t) 0), gfc_array_index_type, rank
),
	     gfc_index_one_nodegfc_rank_cst[1]);
    tmp = gfc_conv_descriptor_ubound_get (se.expr, tmp);
    tmp = fold_build2_loc (input_location, NE_EXPR, logical_type_node,
	     tmp, build_int_cst (TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3745, __FUNCTION__))->typed.type), -1));
    cond = fold_build2_loc (input_location, TRUTH_ORIF_EXPR,
	      logical_type_node, cond, tmp);
    tmp = fold_build3_loc (input_location, COND_EXPR, TREE_TYPE (rank)((contains_struct_check ((rank), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3748, __FUNCTION__))->typed.type),
	     cond, rank, build_int_cst (TREE_TYPE (rank)((contains_struct_check ((rank), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3749, __FUNCTION__))->typed.type), -1));
    rank = gfc_evaluate_now (tmp, &block);
  }
TREE_USED (code->exit_label)((code->exit_label)->base.used_flag) = 0;

3754repeat:
for (c = code->block; c; c = c->block)
  {
    cp = c->ext.block.case_list;

    /* Assume it's the default case.  */
    low = NULL_TREE(tree) __null;
    tmp = NULL_TREE(tree) __null;

    /* Put the default case at the end.  */
    if ((!def && !cp->low) || (def && cp->low))
continue;

    if (cp->low)
{
 gfc_init_se (&cse, NULL__null);
 gfc_conv_expr_val (&cse, cp->low);
 gfc_add_block_to_block (&block, &cse.pre);
 low = cse.expr;
}

    gfc_init_block (&body);

    /* Add the statements for this case.  */
    tmp = gfc_trans_code (c->next);
    gfc_add_expr_to_block (&body, tmp);

    /* Break to the end of the SELECT RANK construct.  The default
case just falls through.  */
    if (!def)
{
 TREE_USED (code->exit_label)((code->exit_label)->base.used_flag) = 1;
 tmp = build1_v (GOTO_EXPR, code->exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], code->exit_label);
 gfc_add_expr_to_block (&body, tmp);
}

    tmp = gfc_finish_block (&body);

    if (low != NULL_TREE(tree) __null)
{
 cond = fold_build2_loc (input_location, EQ_EXPR,
		  TREE_TYPE (rank)((contains_struct_check ((rank), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3795, __FUNCTION__))->typed.type), rank,
		  fold_convert (TREE_TYPE (rank), low)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(rank), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3796, __FUNCTION__))->typed.type), low));
 tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
		 cond, tmp,
		 build_empty_stmt (input_location));
}

    gfc_add_expr_to_block (&block, tmp);
  }

if (!def)
  {
    def = true;
    goto repeat;
  }

return gfc_finish_block (&block);
3812}


3815tree
3816gfc_trans_select_rank (gfc_code * code)
3817{
stmtblock_t block;
tree body;
tree exit_label;

gcc_assert (code && code->expr1)((void)(!(code && code->expr1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3822, __FUNCTION__), 0 : 0));
gfc_init_block (&block);

/* Build the exit label and hang it in.  */
exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
code->exit_label = exit_label;

/* Empty SELECT constructs are legal.  */
if (code->block == NULL__null)
  body = build_empty_stmt (input_location);
else
  body = gfc_trans_select_rank_cases (code);

/* Build everything together.  */
gfc_add_expr_to_block (&block, body);

if (TREE_USED (exit_label)((exit_label)->base.used_flag))
  gfc_add_expr_to_block (&block, build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label));

return gfc_finish_block (&block);
3842}


3845/* Traversal function to substitute a replacement symtree if the symbol
 in the expression is the same as that passed.  f == 2 signals that
 that variable itself is not to be checked - only the references.
 This group of functions is used when the variable expression in a
 FORALL assignment has internal references.  For example:
FORALL (i = 1:4) p(p(i)) = i
 The only recourse here is to store a copy of 'p' for the index
 expression.  */

3854static gfc_symtree *new_symtree;
3855static gfc_symtree *old_symtree;

3857static bool
3858forall_replace (gfc_expr *expr, gfc_symbol *sym, int *f)
3859{
if (expr->expr_type != EXPR_VARIABLE)
  return false;

if (*f == 2)
  *f = 1;
else if (expr->symtree->n.sym == sym)
  expr->symtree = new_symtree;

return false;
3869}

3871static void
3872forall_replace_symtree (gfc_expr *e, gfc_symbol *sym, int f)
3873{
gfc_traverse_expr (e, sym, forall_replace, f);
3875}

3877static bool
3878forall_restore (gfc_expr *expr,
gfc_symbol *sym ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
int *f ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3881{
if (expr->expr_type != EXPR_VARIABLE)
  return false;

if (expr->symtree == new_symtree)
  expr->symtree = old_symtree;

return false;
3889}

3891static void
3892forall_restore_symtree (gfc_expr *e)
3893{
gfc_traverse_expr (e, NULL__null, forall_restore, 0);
3895}

3897static void
3898forall_make_variable_temp (gfc_code *c, stmtblock_t *pre, stmtblock_t *post)
3899{
gfc_se tse;
gfc_se rse;
gfc_expr *e;
gfc_symbol *new_sym;
gfc_symbol *old_sym;
gfc_symtree *root;
tree tmp;

/* Build a copy of the lvalue.  */
old_symtree = c->expr1->symtree;
old_sym = old_symtree->n.sym;
e = gfc_lval_expr_from_sym (old_sym);
if (old_sym->attr.dimension)
  {
    gfc_init_se (&tse, NULL__null);
    gfc_conv_subref_array_arg (&tse, e, 0, INTENT_IN, false);
    gfc_add_block_to_block (pre, &tse.pre);
    gfc_add_block_to_block (post, &tse.post);
    tse.expr = build_fold_indirect_ref_loc (input_location, tse.expr);

    if (c->expr1->ref->u.ar.type != AR_SECTION)
{
 /* Use the variable offset for the temporary.  */
 tmp = gfc_conv_array_offset (old_sym->backend_decl);
 gfc_conv_descriptor_offset_set (pre, tse.expr, tmp);
}
  }
else
  {
    gfc_init_se (&tse, NULL__null);
    gfc_init_se (&rse, NULL__null);
    gfc_conv_expr (&rse, e);
    if (e->ts.type == BT_CHARACTER)
{
 tse.string_length = rse.string_length;
 tmp = gfc_get_character_type_len (gfc_default_character_kind,
			    tse.string_length);
 tse.expr = gfc_conv_string_tmp (&tse, build_pointer_type (tmp),
			  rse.string_length);
 gfc_add_block_to_block (pre, &tse.pre);
 gfc_add_block_to_block (post, &tse.post);
}
    else
{
 tmp = gfc_typenode_for_spec (&e->ts);
 tse.expr = gfc_create_var (tmp, "temp");
}

    tmp = gfc_trans_scalar_assign (&tse, &rse, e->ts,
		     e->expr_type == EXPR_VARIABLE, false);
    gfc_add_expr_to_block (pre, tmp);
  }
gfc_free_expr (e);

/* Create a new symbol to represent the lvalue.  */
new_sym = gfc_new_symbol (old_sym->name, NULL__null);
new_sym->ts = old_sym->ts;
new_sym->attr.referenced = 1;
new_sym->attr.temporary = 1;
new_sym->attr.dimension = old_sym->attr.dimension;
new_sym->attr.flavor = old_sym->attr.flavor;

/* Use the temporary as the backend_decl.  */
new_sym->backend_decl = tse.expr;

/* Create a fake symtree for it.  */
root = NULL__null;
new_symtree = gfc_new_symtree (&root, old_sym->name);
new_symtree->n.sym = new_sym;
gcc_assert (new_symtree == root)((void)(!(new_symtree == root) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 3969, __FUNCTION__), 0 : 0));

/* Go through the expression reference replacing the old_symtree
   with the new.  */
forall_replace_symtree (c->expr1, old_sym, 2);

/* Now we have made this temporary, we might as well use it for
the right hand side.  */
forall_replace_symtree (c->expr2, old_sym, 1);
3978}


3981/* Handles dependencies in forall assignments.  */
3982static int
3983check_forall_dependencies (gfc_code *c, stmtblock_t *pre, stmtblock_t *post)
3984{
gfc_ref *lref;
gfc_ref *rref;
int need_temp;
gfc_symbol *lsym;

lsym = c->expr1->symtree->n.sym;
need_temp = gfc_check_dependency (c->expr1, c->expr2, 0);

/* Now check for dependencies within the 'variable'
   expression itself.  These are treated by making a complete
   copy of variable and changing all the references to it
   point to the copy instead.  Note that the shallow copy of
   the variable will not suffice for derived types with
   pointer components.  We therefore leave these to their
   own devices.  Likewise for allocatable components.  */
if (lsym->ts.type == BT_DERIVED
    && (lsym->ts.u.derived->attr.pointer_comp
 || lsym->ts.u.derived->attr.alloc_comp))
  return need_temp;

new_symtree = NULL__null;
if (find_forall_index (c->expr1, lsym, 2))
  {
    forall_make_variable_temp (c, pre, post);
    need_temp = 0;
  }

/* Substrings with dependencies are treated in the same
   way.  */
if (c->expr1->ts.type == BT_CHARACTER
&& c->expr1->ref
&& c->expr2->expr_type == EXPR_VARIABLE
&& lsym == c->expr2->symtree->n.sym)
  {
    for (lref = c->expr1->ref; lref; lref = lref->next)
if (lref->type == REF_SUBSTRING)
 break;
    for (rref = c->expr2->ref; rref; rref = rref->next)
if (rref->type == REF_SUBSTRING)
 break;

    if (rref && lref
   && gfc_dep_compare_expr (rref->u.ss.start, lref->u.ss.start) < 0)
{
 forall_make_variable_temp (c, pre, post);
 need_temp = 0;
}
  }
return need_temp;
4034}


4037static void
4038cleanup_forall_symtrees (gfc_code *c)
4039{
forall_restore_symtree (c->expr1);
forall_restore_symtree (c->expr2);
free (new_symtree->n.sym);
free (new_symtree);
4044}


4047/* Generate the loops for a FORALL block, specified by FORALL_TMP.  BODY
 is the contents of the FORALL block/stmt to be iterated.  MASK_FLAG
 indicates whether we should generate code to test the FORALLs mask
 array.  OUTER is the loop header to be used for initializing mask
 indices.

 The generated loop format is:
  count = (end - start + step) / step
  loopvar = start
  while (1)
    {
      if (count <=0 )
        goto end_of_loop
      <body>
      loopvar += step
      count --
    }
  end_of_loop:  */

4066static tree
4067gfc_trans_forall_loop (forall_info *forall_tmp, tree body,
                     int mask_flag, stmtblock_t *outer)
4069{
int n, nvar;
tree tmp;
tree cond;
stmtblock_t block;
tree exit_label;
tree count;
tree var, start, end, step;
iter_info *iter;

/* Initialize the mask index outside the FORALL nest.  */
if (mask_flag && forall_tmp->mask)
  gfc_add_modify (outer, forall_tmp->maskindex, gfc_index_zero_nodegfc_rank_cst[0]);

iter = forall_tmp->this_loop;
nvar = forall_tmp->nvar;
for (n = 0; n < nvar; n++)
  {
    var = iter->var;
    start = iter->start;
    end = iter->end;
    step = iter->step;

    exit_label = gfc_build_label_decl (NULL_TREE(tree) __null);
    TREE_USED (exit_label)((exit_label)->base.used_flag) = 1;

    /* The loop counter.  */
    count = gfc_create_var (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4096, __FUNCTION__))->typed.type), "count");

    /* The body of the loop.  */
    gfc_init_block (&block);

    /* The exit condition.  */
    cond = fold_build2_loc (input_location, LE_EXPR, logical_type_node,
	      count, build_int_cst (TREE_TYPE (count)((contains_struct_check ((count), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4103, __FUNCTION__))->typed.type), 0));

    /* PR 83064 means that we cannot use annot_expr_parallel_kind until
     the autoparallelizer can hande this.  */
    if (forall_tmp->do_concurrent)
cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4108, __FUNCTION__))->typed.type), cond,
       build_int_cst (integer_type_nodeinteger_types[itk_int],
		      annot_expr_ivdep_kind),
       integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);

    tmp = build1_v (GOTO_EXPR, exit_label)fold_build1_loc (input_location, GOTO_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
    tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	     cond, tmp, build_empty_stmt (input_location));
    gfc_add_expr_to_block (&block, tmp);

    /* The main loop body.  */
    gfc_add_expr_to_block (&block, body);

    /* Increment the loop variable.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4122, __FUNCTION__))->typed.type), var,
	     step);
    gfc_add_modify (&block, var, tmp);

    /* Advance to the next mask element.  Only do this for the
innermost loop.  */
    if (n == 0 && mask_flag && forall_tmp->mask)
{
 tree maskindex = forall_tmp->maskindex;
 tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
		 maskindex, gfc_index_one_nodegfc_rank_cst[1]);
 gfc_add_modify (&block, maskindex, tmp);
}

    /* Decrement the loop counter.  */
    tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4137, __FUNCTION__))->typed.type), count,
	     build_int_cst (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4138, __FUNCTION__))->typed.type), 1));
    gfc_add_modify (&block, count, tmp);

    body = gfc_finish_block (&block);

    /* Loop var initialization.  */
    gfc_init_block (&block);
    gfc_add_modify (&block, var, start);


    /* Initialize the loop counter.  */
    tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4149, __FUNCTION__))->typed.type), step,
	     start);
    tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4151, __FUNCTION__))->typed.type), end,
	     tmp);
    tmp = fold_build2_loc (input_location, TRUNC_DIV_EXPR, TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4153, __FUNCTION__))->typed.type),
	     tmp, step);
    gfc_add_modify (&block, count, tmp);

    /* The loop expression.  */
    tmp = build1_v (LOOP_EXPR, body)fold_build1_loc (input_location, LOOP_EXPR, global_trees[TI_VOID_TYPE
], body);
    gfc_add_expr_to_block (&block, tmp);

    /* The exit label.  */
    tmp = build1_v (LABEL_EXPR, exit_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], exit_label);
    gfc_add_expr_to_block (&block, tmp);

    body = gfc_finish_block (&block);
    iter = iter->next;
  }
return body;
4169}


4172/* Generate the body and loops according to MASK_FLAG.  If MASK_FLAG
 is nonzero, the body is controlled by all masks in the forall nest.
 Otherwise, the innermost loop is not controlled by it's mask.  This
 is used for initializing that mask.  */

4177static tree
4178gfc_trans_nested_forall_loop (forall_info * nested_forall_info, tree body,
                            int mask_flag)
4180{
tree tmp;
stmtblock_t header;
forall_info *forall_tmp;
tree mask, maskindex;

gfc_start_block (&header);

forall_tmp = nested_forall_info;
while (forall_tmp != NULL__null)
  {
    /* Generate body with masks' control.  */
    if (mask_flag)
      {
        mask = forall_tmp->mask;
        maskindex = forall_tmp->maskindex;

        /* If a mask was specified make the assignment conditional.  */
        if (mask)
          {
            tmp = gfc_build_array_ref (mask, maskindex, NULL__null);
            body = build3_v (COND_EXPR, tmp, body,fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], tmp, body, build_empty_stmt (input_location))
	       build_empty_stmt (input_location))fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], tmp, body, build_empty_stmt (input_location));
          }
      }
    body = gfc_trans_forall_loop (forall_tmp, body, mask_flag, &header);
    forall_tmp = forall_tmp->prev_nest;
    mask_flag = 1;
  }

gfc_add_expr_to_block (&header, body);
return gfc_finish_block (&header);
4212}


4215/* Allocate data for holding a temporary array.  Returns either a local
 temporary array or a pointer variable.  */

4218static tree
4219gfc_do_allocate (tree bytesize, tree size, tree * pdata, stmtblock_t * pblock,
               tree elem_type)
4221{
tree tmpvar;
tree type;
tree tmp;

if (INTEGER_CST_P (size)(((enum tree_code) (size)->base.code) == INTEGER_CST))
  tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
	   size, gfc_index_one_nodegfc_rank_cst[1]);
else
  tmp = NULL_TREE(tree) __null;

type = build_range_type (gfc_array_index_type, gfc_index_zero_nodegfc_rank_cst[0], tmp);
type = build_array_type (elem_type, type);
if (gfc_can_put_var_on_stack (bytesize) && INTEGER_CST_P (size)(((enum tree_code) (size)->base.code) == INTEGER_CST))
  {
    tmpvar = gfc_create_var (type, "temp");
    *pdata = NULL_TREE(tree) __null;
  }
else
  {
    tmpvar = gfc_create_var (build_pointer_type (type), "temp");
    *pdata = convert (pvoid_type_node, tmpvar);

    tmp = gfc_call_malloc (pblock, TREE_TYPE (tmpvar)((contains_struct_check ((tmpvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4244, __FUNCTION__))->typed.type), bytesize);
    gfc_add_modify (pblock, tmpvar, tmp);
  }
return tmpvar;
4248}


4251/* Generate codes to copy the temporary to the actual lhs.  */

4253static tree
4254generate_loop_for_temp_to_lhs (gfc_expr *expr, tree tmp1, tree count3,
	       tree count1,
	       gfc_ss *lss, gfc_ss *rss,
	       tree wheremask, bool invert)
4258{
stmtblock_t block, body1;
gfc_loopinfo loop;
gfc_se lse;
gfc_se rse;
tree tmp;
tree wheremaskexpr;

(void) rss; /* TODO: unused.  */

gfc_start_block (&block);

gfc_init_se (&rse, NULL__null);
gfc_init_se (&lse, NULL__null);

if (lss == gfc_ss_terminator)
  {
    gfc_init_block (&body1);
    gfc_conv_expr (&lse, expr);
    rse.expr = gfc_build_array_ref (tmp1, count1, NULL__null);
  }
else
  {
    /* Initialize the loop.  */
    gfc_init_loopinfo (&loop);

    /* We may need LSS to determine the shape of the expression.  */
    gfc_add_ss_to_loop (&loop, lss);

    gfc_conv_ss_startstride (&loop);
    gfc_conv_loop_setup (&loop, &expr->where);

    gfc_mark_ss_chain_used (lss, 1);
    /* Start the loop body.  */
    gfc_start_scalarized_body (&loop, &body1);

    /* Translate the expression.  */
    gfc_copy_loopinfo_to_se (&lse, &loop);
    lse.ss = lss;
    gfc_conv_expr (&lse, expr);

    /* Form the expression of the temporary.  */
    rse.expr = gfc_build_array_ref (tmp1, count1, NULL__null);
  }

/* Use the scalar assignment.  */
rse.string_length = lse.string_length;
tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts,
		 expr->expr_type == EXPR_VARIABLE, false);

/* Form the mask expression according to the mask tree list.  */
if (wheremask)
  {
    wheremaskexpr = gfc_build_array_ref (wheremask, count3, NULL__null);
    if (invert)
wheremaskexpr = fold_build1_loc (input_location, TRUTH_NOT_EXPR,
			 TREE_TYPE (wheremaskexpr)((contains_struct_check ((wheremaskexpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4314, __FUNCTION__))->typed.type),
			 wheremaskexpr);
    tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	     wheremaskexpr, tmp,
	     build_empty_stmt (input_location));
  }

gfc_add_expr_to_block (&body1, tmp);

tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (count1)((contains_struct_check ((count1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4323, __FUNCTION__))->typed.type),
	 count1, gfc_index_one_nodegfc_rank_cst[1]);
gfc_add_modify (&body1, count1, tmp);

if (lss == gfc_ss_terminator)
    gfc_add_block_to_block (&block, &body1);
else
  {
    /* Increment count3.  */
    if (count3)
{
 tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type,
		 count3, gfc_index_one_nodegfc_rank_cst[1]);
 gfc_add_modify (&body1, count3, tmp);
}

    /* Generate the copying loops.  */
    gfc_trans_scalarizing_loops (&loop, &body1);

    gfc_add_block_to_block (&block, &loop.pre);
    gfc_add_block_to_block (&block, &loop.post);

    gfc_cleanup_loop (&loop);
    /* TODO: Reuse lss and rss when copying temp->lhs.  Need to be careful
as tree nodes in SS may not be valid in different scope.  */
  }

tmp = gfc_finish_block (&block);
return tmp;
4353}


4356/* Generate codes to copy rhs to the temporary. TMP1 is the address of
 temporary, LSS and RSS are formed in function compute_inner_temp_size(),
 and should not be freed.  WHEREMASK is the conditional execution mask
 whose sense may be inverted by INVERT.  */

4361static tree
4362generate_loop_for_rhs_to_temp (gfc_expr *expr2, tree tmp1, tree count3,
	       tree count1, gfc_ss *lss, gfc_ss *rss,
	       tree wheremask, bool invert)
4365{
stmtblock_t block, body1;
gfc_loopinfo loop;
gfc_se lse;
gfc_se rse;
tree tmp;
tree wheremaskexpr;

gfc_start_block (&block);

gfc_init_se (&rse, NULL__null);
gfc_init_se (&lse, NULL__null);

if (lss == gfc_ss_terminator)
  {
    gfc_init_block (&body1);
    gfc_conv_expr (&rse, expr2);
    lse.expr = gfc_build_array_ref (tmp1, count1, NULL__null);
  }
else
  {
    /* Initialize the loop.  */
    gfc_init_loopinfo (&loop);

    /* We may need LSS to determine the shape of the expression.  */
    gfc_add_ss_to_loop (&loop, lss);
    gfc_add_ss_to_loop (&loop, rss);

    gfc_conv_ss_startstride (&loop);
    gfc_conv_loop_setup (&loop, &expr2->where);

    gfc_mark_ss_chain_used (rss, 1);
    /* Start the loop body.  */
    gfc_start_scalarized_body (&loop, &body1);

    /* Translate the expression.  */
    gfc_copy_loopinfo_to_se (&rse, &loop);
    rse.ss = rss;
    gfc_conv_expr (&rse, expr2);

    /* Form the expression of the temporary.  */
    lse.expr = gfc_build_array_ref (tmp1, count1, NULL__null);
  }

/* Use the scalar assignment.  */
lse.string_length = rse.string_length;
tmp = gfc_trans_scalar_assign (&lse, &rse, expr2->ts,
		 expr2->expr_type == EXPR_VARIABLE, false);

/* Form the mask expression according to the mask tree list.  */
if (wheremask)
  {
    wheremaskexpr = gfc_build_array_ref (wheremask, count3, NULL__null);
    if (invert)
wheremaskexpr = fold_build1_loc (input_location, TRUTH_NOT_EXPR,
			 TREE_TYPE (wheremaskexpr)((contains_struct_check ((wheremaskexpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4420, __FUNCTION__))->typed.type),
			 wheremaskexpr);
    tmp = fold_build3_loc (input_location, COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE],
	     wheremaskexpr, tmp,
	     build_empty_stmt (input_location));
  }

gfc_add_expr_to_block (&body1, tmp);

if (lss == gfc_ss_terminator)
  {
    gfc_add_block_to_block (&block, &body1);

    /* Increment count1.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (count1)((contains_struct_check ((count1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4434, __FUNCTION__))->typed.type),
	     count1, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&block, count1, tmp);
  }
else
  {
    /* Increment count1.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count1, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body1, count1, tmp);

    /* Increment count3.  */
    if (count3)
{
 tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type,
		 count3, gfc_index_one_nodegfc_rank_cst[1]);
 gfc_add_modify (&body1, count3, tmp);
}

    /* Generate the copying loops.  */
    gfc_trans_scalarizing_loops (&loop, &body1);

    gfc_add_block_to_block (&block, &loop.pre);
    gfc_add_block_to_block (&block, &loop.post);

    gfc_cleanup_loop (&loop);
    /* TODO: Reuse lss and rss when copying temp->lhs.  Need to be careful
as tree nodes in SS may not be valid in different scope.  */
  }

tmp = gfc_finish_block (&block);
return tmp;
4467}


4470/* Calculate the size of temporary needed in the assignment inside forall.
 LSS and RSS are filled in this function.  */

4473static tree
4474compute_inner_temp_size (gfc_expr *expr1, gfc_expr *expr2,
	 stmtblock_t * pblock,
                       gfc_ss **lss, gfc_ss **rss)
4477{
gfc_loopinfo loop;
tree size;
int i;
int save_flag;
tree tmp;

*lss = gfc_walk_expr (expr1);
*rss = NULL__null;

size = gfc_index_one_nodegfc_rank_cst[1];
if (*lss != gfc_ss_terminator)
  {
    gfc_init_loopinfo (&loop);

    /* Walk the RHS of the expression.  */
    *rss = gfc_walk_expr (expr2);
    if (*rss == gfc_ss_terminator)
/* The rhs is scalar.  Add a ss for the expression.  */
*rss = gfc_get_scalar_ss (gfc_ss_terminator, expr2);

    /* Associate the SS with the loop.  */
    gfc_add_ss_to_loop (&loop, *lss);
    /* We don't actually need to add the rhs at this point, but it might
       make guessing the loop bounds a bit easier.  */
    gfc_add_ss_to_loop (&loop, *rss);

    /* We only want the shape of the expression, not rest of the junk
       generated by the scalarizer.  */
    loop.array_parameter = 1;

    /* Calculate the bounds of the scalarization.  */
    save_flag = gfc_option.rtcheck;
    gfc_option.rtcheck &= ~GFC_RTCHECK_BOUNDS(1<<0);
    gfc_conv_ss_startstride (&loop);
    gfc_option.rtcheck = save_flag;
    gfc_conv_loop_setup (&loop, &expr2->where);

    /* Figure out how many elements we need.  */
    for (i = 0; i < loop.dimen; i++)
      {
 tmp = fold_build2_loc (input_location, MINUS_EXPR,
		 gfc_array_index_type,
		 gfc_index_one_nodegfc_rank_cst[1], loop.from[i]);
        tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type, tmp, loop.to[i]);
        size = fold_build2_loc (input_location, MULT_EXPR,
		  gfc_array_index_type, size, tmp);
      }
    gfc_add_block_to_block (pblock, &loop.pre);
    size = gfc_evaluate_now (size, pblock);
    gfc_add_block_to_block (pblock, &loop.post);

    /* TODO: write a function that cleans up a loopinfo without freeing
       the SS chains.  Currently a NOP.  */
  }

return size;
4535}


4538/* Calculate the overall iterator number of the nested forall construct.
 This routine actually calculates the number of times the body of the
 nested forall specified by NESTED_FORALL_INFO is executed and multiplies
 that by the expression INNER_SIZE.  The BLOCK argument specifies the
 block in which to calculate the result, and the optional INNER_SIZE_BODY
 argument contains any statements that need to executed (inside the loop)
 to initialize or calculate INNER_SIZE.  */

4546static tree
4547compute_overall_iter_number (forall_info *nested_forall_info, tree inner_size,
	     stmtblock_t *inner_size_body, stmtblock_t *block)
4549{
forall_info *forall_tmp = nested_forall_info;
tree tmp, number;
stmtblock_t body;

/* We can eliminate the innermost unconditional loops with constant
   array bounds.  */
if (INTEGER_CST_P (inner_size)(((enum tree_code) (inner_size)->base.code) == INTEGER_CST
))
  {
    while (forall_tmp
    && !forall_tmp->mask
    && INTEGER_CST_P (forall_tmp->size)(((enum tree_code) (forall_tmp->size)->base.code) == INTEGER_CST
))
{
 inner_size = fold_build2_loc (input_location, MULT_EXPR,
			gfc_array_index_type,
			inner_size, forall_tmp->size);
 forall_tmp = forall_tmp->prev_nest;
}

    /* If there are no loops left, we have our constant result.  */
    if (!forall_tmp)
return inner_size;
  }

/* Otherwise, create a temporary variable to compute the result.  */
number = gfc_create_var (gfc_array_index_type, "num");
gfc_add_modify (block, number, gfc_index_zero_nodegfc_rank_cst[0]);

gfc_start_block (&body);
if (inner_size_body)
  gfc_add_block_to_block (&body, inner_size_body);
if (forall_tmp)
  tmp = fold_build2_loc (input_location, PLUS_EXPR,
	   gfc_array_index_type, number, inner_size);
else
  tmp = inner_size;
gfc_add_modify (&body, number, tmp);
tmp = gfc_finish_block (&body);

/* Generate loops.  */
if (forall_tmp != NULL__null)
  tmp = gfc_trans_nested_forall_loop (forall_tmp, tmp, 1);

gfc_add_expr_to_block (block, tmp);

return number;
4595}


4598/* Allocate temporary for forall construct.  SIZE is the size of temporary
 needed.  PTEMP1 is returned for space free.  */

4601static tree
4602allocate_temp_for_forall_nest_1 (tree type, tree size, stmtblock_t * block,
		 tree * ptemp1)
4604{
tree bytesize;
tree unit;
tree tmp;

unit = fold_convert (gfc_array_index_type, TYPE_SIZE_UNIT (type))fold_convert_loc (((location_t) 0), gfc_array_index_type, ((tree_class_check
 ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4609, __FUNCTION__))->type_common.size_unit));
if (!integer_onep (unit))
  bytesize = fold_build2_loc (input_location, MULT_EXPR,
		gfc_array_index_type, size, unit);
else
  bytesize = size;

*ptemp1 = NULL__null;
tmp = gfc_do_allocate (bytesize, size, ptemp1, block, type);

if (*ptemp1)
  tmp = build_fold_indirect_ref_loc (input_location, tmp);
return tmp;
4622}


4625/* Allocate temporary for forall construct according to the information in
 nested_forall_info.  INNER_SIZE is the size of temporary needed in the
 assignment inside forall.  PTEMP1 is returned for space free.  */

4629static tree
4630allocate_temp_for_forall_nest (forall_info * nested_forall_info, tree type,
	       tree inner_size, stmtblock_t * inner_size_body,
	       stmtblock_t * block, tree * ptemp1)
4633{
tree size;

/* Calculate the total size of temporary needed in forall construct.  */
size = compute_overall_iter_number (nested_forall_info, inner_size,
		      inner_size_body, block);

return allocate_temp_for_forall_nest_1 (type, size, block, ptemp1);
4641}


4644/* Handle assignments inside forall which need temporary.

  forall (i=start:end:stride; maskexpr)
    e<i> = f<i>
  end forall
 (where e,f<i> are arbitrary expressions possibly involving i
  and there is a dependency between e<i> and f<i>)
 Translates to:
  masktmp(:) = maskexpr(:)

  maskindex = 0;
  count1 = 0;
  num = 0;
  for (i = start; i <= end; i += stride)
    num += SIZE (f<i>)
  count1 = 0;
  ALLOCATE (tmp(num))
  for (i = start; i <= end; i += stride)
    {
if (masktmp[maskindex++])
 tmp[count1++] = f<i>
    }
  maskindex = 0;
  count1 = 0;
  for (i = start; i <= end; i += stride)
    {
if (masktmp[maskindex++])
 e<i> = tmp[count1++]
    }
  DEALLOCATE (tmp)
*/
4675static void
4676gfc_trans_assign_need_temp (gfc_expr * expr1, gfc_expr * expr2,
	    tree wheremask, bool invert,
                          forall_info * nested_forall_info,
                          stmtblock_t * block)
4680{
tree type;
tree inner_size;
gfc_ss *lss, *rss;
tree count, count1;
tree tmp, tmp1;
tree ptemp1;
stmtblock_t inner_size_body;

/* Create vars. count1 is the current iterator number of the nested
   forall.  */
count1 = gfc_create_var (gfc_array_index_type, "count1");

/* Count is the wheremask index.  */
if (wheremask)
  {
    count = gfc_create_var (gfc_array_index_type, "count");
    gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);
  }
else
  count = NULL__null;

/* Initialize count1.  */
gfc_add_modify (block, count1, gfc_index_zero_nodegfc_rank_cst[0]);

/* Calculate the size of temporary needed in the assignment. Return loop, lss
   and rss which are used in function generate_loop_for_rhs_to_temp().  */
/* The type of LHS. Used in function allocate_temp_for_forall_nest */
if (expr1->ts.type == BT_CHARACTER)
  {
    type = NULL__null;
    if (expr1->ref && expr1->ref->type == REF_SUBSTRING)
{
 gfc_se ssse;
 gfc_init_se (&ssse, NULL__null);
 gfc_conv_expr (&ssse, expr1);
 type = gfc_get_character_type_len (gfc_default_character_kind,
			     ssse.string_length);
}
    else
{
 if (!expr1->ts.u.cl->backend_decl)
   {
     gfc_se tse;
     gcc_assert (expr1->ts.u.cl->length)((void)(!(expr1->ts.u.cl->length) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4724, __FUNCTION__), 0 : 0));
     gfc_init_se (&tse, NULL__null);
     gfc_conv_expr (&tse, expr1->ts.u.cl->length);
     expr1->ts.u.cl->backend_decl = tse.expr;
   }
 type = gfc_get_character_type_len (gfc_default_character_kind,
			     expr1->ts.u.cl->backend_decl);
}
  }
else
  type = gfc_typenode_for_spec (&expr1->ts);

gfc_init_block (&inner_size_body);
inner_size = compute_inner_temp_size (expr1, expr2, &inner_size_body,
			&lss, &rss);

/* Allocate temporary for nested forall construct according to the
   information in nested_forall_info and inner_size.  */
tmp1 = allocate_temp_for_forall_nest (nested_forall_info, type, inner_size,
			&inner_size_body, block, &ptemp1);

/* Generate codes to copy rhs to the temporary .  */
tmp = generate_loop_for_rhs_to_temp (expr2, tmp1, count, count1, lss, rss,
		       wheremask, invert);

/* Generate body and loops according to the information in
   nested_forall_info.  */
tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
gfc_add_expr_to_block (block, tmp);

/* Reset count1.  */
gfc_add_modify (block, count1, gfc_index_zero_nodegfc_rank_cst[0]);

/* Reset count.  */
if (wheremask)
  gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);

/* TODO: Second call to compute_inner_temp_size to initialize lss and
   rss;  there must be a better way.  */
inner_size = compute_inner_temp_size (expr1, expr2, &inner_size_body,
			&lss, &rss);

/* Generate codes to copy the temporary to lhs.  */
tmp = generate_loop_for_temp_to_lhs (expr1, tmp1, count, count1,
		       lss, rss,
		       wheremask, invert);

/* Generate body and loops according to the information in
   nested_forall_info.  */
tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
gfc_add_expr_to_block (block, tmp);

if (ptemp1)
  {
    /* Free the temporary.  */
    tmp = gfc_call_free (ptemp1);
    gfc_add_expr_to_block (block, tmp);
  }
4782}


4785/* Translate pointer assignment inside FORALL which need temporary.  */

4787static void
4788gfc_trans_pointer_assign_need_temp (gfc_expr * expr1, gfc_expr * expr2,
                                  forall_info * nested_forall_info,
                                  stmtblock_t * block)
4791{
tree type;
tree inner_size;
gfc_ss *lss, *rss;
gfc_se lse;
gfc_se rse;
gfc_array_info *info;
gfc_loopinfo loop;
tree desc;
tree parm;
tree parmtype;
stmtblock_t body;
tree count;
tree tmp, tmp1, ptemp1;

count = gfc_create_var (gfc_array_index_type, "count");
gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);

inner_size = gfc_index_one_nodegfc_rank_cst[1];
lss = gfc_walk_expr (expr1);
rss = gfc_walk_expr (expr2);
if (lss == gfc_ss_terminator)
  {
    type = gfc_typenode_for_spec (&expr1->ts);
    type = build_pointer_type (type);

    /* Allocate temporary for nested forall construct according to the
       information in nested_forall_info and inner_size.  */
    tmp1 = allocate_temp_for_forall_nest (nested_forall_info, type,
			    inner_size, NULL__null, block, &ptemp1);
    gfc_start_block (&body);
    gfc_init_se (&lse, NULL__null);
    lse.expr = gfc_build_array_ref (tmp1, count, NULL__null);
    gfc_init_se (&rse, NULL__null);
    rse.want_pointer = 1;
    gfc_conv_expr (&rse, expr2);
    gfc_add_block_to_block (&body, &rse.pre);
    gfc_add_modify (&body, lse.expr,
	   fold_convert (TREE_TYPE (lse.expr), rse.expr)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(lse.expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4829, __FUNCTION__))->typed.type), rse.expr));
    gfc_add_block_to_block (&body, &rse.post);

    /* Increment count.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, count, tmp);

    tmp = gfc_finish_block (&body);

    /* Generate body and loops according to the information in
       nested_forall_info.  */
    tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
    gfc_add_expr_to_block (block, tmp);

    /* Reset count.  */
    gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);

    gfc_start_block (&body);
    gfc_init_se (&lse, NULL__null);
    gfc_init_se (&rse, NULL__null);
    rse.expr = gfc_build_array_ref (tmp1, count, NULL__null);
    lse.want_pointer = 1;
    gfc_conv_expr (&lse, expr1);
    gfc_add_block_to_block (&body, &lse.pre);
    gfc_add_modify (&body, lse.expr, rse.expr);
    gfc_add_block_to_block (&body, &lse.post);
    /* Increment count.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, count, tmp);
    tmp = gfc_finish_block (&body);

    /* Generate body and loops according to the information in
       nested_forall_info.  */
    tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
    gfc_add_expr_to_block (block, tmp);
  }
else
  {
    gfc_init_loopinfo (&loop);

    /* Associate the SS with the loop.  */
    gfc_add_ss_to_loop (&loop, rss);

    /* Setup the scalarizing loops and bounds.  */
    gfc_conv_ss_startstride (&loop);

    gfc_conv_loop_setup (&loop, &expr2->where);

    info = &rss->info->data.array;
    desc = info->descriptor;

    /* Make a new descriptor.  */
    parmtype = gfc_get_element_type (TREE_TYPE (desc)((contains_struct_check ((desc), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 4883, __FUNCTION__))->typed.type));
    parmtype = gfc_get_array_type_bounds (parmtype, loop.dimen, 0,
                                          loop.from, loop.to, 1,
			    GFC_ARRAY_UNKNOWN, true);

    /* Allocate temporary for nested forall construct.  */
    tmp1 = allocate_temp_for_forall_nest (nested_forall_info, parmtype,
			    inner_size, NULL__null, block, &ptemp1);
    gfc_start_block (&body);
    gfc_init_se (&lse, NULL__null);
    lse.expr = gfc_build_array_ref (tmp1, count, NULL__null);
    lse.direct_byref = 1;
    gfc_conv_expr_descriptor (&lse, expr2);

    gfc_add_block_to_block (&body, &lse.pre);
    gfc_add_block_to_block (&body, &lse.post);

    /* Increment count.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, count, tmp);

    tmp = gfc_finish_block (&body);

    /* Generate body and loops according to the information in
       nested_forall_info.  */
    tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
    gfc_add_expr_to_block (block, tmp);

    /* Reset count.  */
    gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);

    parm = gfc_build_array_ref (tmp1, count, NULL__null);
    gfc_init_se (&lse, NULL__null);
    gfc_conv_expr_descriptor (&lse, expr1);
    gfc_add_modify (&lse.pre, lse.expr, parm);
    gfc_start_block (&body);
    gfc_add_block_to_block (&body, &lse.pre);
    gfc_add_block_to_block (&body, &lse.post);

    /* Increment count.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, count, tmp);

    tmp = gfc_finish_block (&body);

    tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
    gfc_add_expr_to_block (block, tmp);
  }
/* Free the temporary.  */
if (ptemp1)
  {
    tmp = gfc_call_free (ptemp1);
    gfc_add_expr_to_block (block, tmp);
  }
4939}


4942/* FORALL and WHERE statements are really nasty, especially when you nest
 them. All the rhs of a forall assignment must be evaluated before the
 actual assignments are performed. Presumably this also applies to all the
 assignments in an inner where statement.  */

4947/* Generate code for a FORALL statement.  Any temporaries are allocated as a
 linear array, relying on the fact that we process in the same order in all
 loops.

  forall (i=start:end:stride; maskexpr)
    e<i> = f<i>
    g<i> = h<i>
  end forall
 (where e,f,g,h<i> are arbitrary expressions possibly involving i)
 Translates to:
  count = ((end + 1 - start) / stride)
  masktmp(:) = maskexpr(:)

  maskindex = 0;
  for (i = start; i <= end; i += stride)
    {
      if (masktmp[maskindex++])
        e<i> = f<i>
    }
  maskindex = 0;
  for (i = start; i <= end; i += stride)
    {
      if (masktmp[maskindex++])
        g<i> = h<i>
    }

  Note that this code only works when there are no dependencies.
  Forall loop with array assignments and data dependencies are a real pain,
  because the size of the temporary cannot always be determined before the
  loop is executed.  This problem is compounded by the presence of nested
  FORALL constructs.
*/

4980static tree
4981gfc_trans_forall_1 (gfc_code * code, forall_info * nested_forall_info)
4982{
stmtblock_t pre;
stmtblock_t post;
stmtblock_t block;
stmtblock_t body;
tree *var;
tree *start;
tree *end;
tree *step;
gfc_expr **varexpr;
tree tmp;
tree assign;
tree size;
tree maskindex;
tree mask;
tree pmask;
tree cycle_label = NULL_TREE(tree) __null;
int n;
int nvar;
int need_temp;
gfc_forall_iterator *fa;
gfc_se se;
gfc_code *c;
gfc_saved_var *saved_vars;
iter_info *this_forall;
forall_info *info;
bool need_mask;

/* Do nothing if the mask is false.  */
if (code->expr1
    && code->expr1->expr_type == EXPR_CONSTANT
    && !code->expr1->value.logical)
  return build_empty_stmt (input_location);

n = 0;
/* Count the FORALL index number.  */
for (fa = code->ext.forall_iterator; fa; fa = fa->next)
  n++;
nvar = n;

/* Allocate the space for var, start, end, step, varexpr.  */
var = XCNEWVEC (tree, nvar)((tree *) xcalloc ((nvar), sizeof (tree)));
start = XCNEWVEC (tree, nvar)((tree *) xcalloc ((nvar), sizeof (tree)));
end = XCNEWVEC (tree, nvar)((tree *) xcalloc ((nvar), sizeof (tree)));
step = XCNEWVEC (tree, nvar)((tree *) xcalloc ((nvar), sizeof (tree)));
varexpr = XCNEWVEC (gfc_expr *, nvar)((gfc_expr * *) xcalloc ((nvar), sizeof (gfc_expr *)));
saved_vars = XCNEWVEC (gfc_saved_var, nvar)((gfc_saved_var *) xcalloc ((nvar), sizeof (gfc_saved_var)));

/* Allocate the space for info.  */
info = XCNEW (forall_info)((forall_info *) xcalloc (1, sizeof (forall_info)));

gfc_start_block (&pre);
gfc_init_block (&post);
gfc_init_block (&block);

n = 0;
for (fa = code->ext.forall_iterator; fa; fa = fa->next)
  {
    gfc_symbol *sym = fa->var->symtree->n.sym;

    /* Allocate space for this_forall.  */
    this_forall = XCNEW (iter_info)((iter_info *) xcalloc (1, sizeof (iter_info)));

    /* Create a temporary variable for the FORALL index.  */
    tmp = gfc_typenode_for_spec (&sym->ts);
    var[n] = gfc_create_var (tmp, sym->name);
    gfc_shadow_sym (sym, var[n], &saved_vars[n]);

    /* Record it in this_forall.  */
    this_forall->var = var[n];

    /* Replace the index symbol's backend_decl with the temporary decl.  */
    sym->backend_decl = var[n];

    /* Work out the start, end and stride for the loop.  */
    gfc_init_se (&se, NULL__null);
    gfc_conv_expr_val (&se, fa->start);
    /* Record it in this_forall.  */
    this_forall->start = se.expr;
    gfc_add_block_to_block (&block, &se.pre);
    start[n] = se.expr;

    gfc_init_se (&se, NULL__null);
    gfc_conv_expr_val (&se, fa->end);
    /* Record it in this_forall.  */
    this_forall->end = se.expr;
    gfc_make_safe_expr (&se);
    gfc_add_block_to_block (&block, &se.pre);
    end[n] = se.expr;

    gfc_init_se (&se, NULL__null);
    gfc_conv_expr_val (&se, fa->stride);
    /* Record it in this_forall.  */
    this_forall->step = se.expr;
    gfc_make_safe_expr (&se);
    gfc_add_block_to_block (&block, &se.pre);
    step[n] = se.expr;

    /* Set the NEXT field of this_forall to NULL.  */
    this_forall->next = NULL__null;
    /* Link this_forall to the info construct.  */
    if (info->this_loop)
      {
        iter_info *iter_tmp = info->this_loop;
        while (iter_tmp->next != NULL__null)
          iter_tmp = iter_tmp->next;
        iter_tmp->next = this_forall;
      }
    else
      info->this_loop = this_forall;

    n++;
  }
nvar = n;

/* Calculate the size needed for the current forall level.  */
size = gfc_index_one_nodegfc_rank_cst[1];
for (n = 0; n < nvar; n++)
  {
    /* size = (end + step - start) / step.  */
    tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (start[n])((contains_struct_check ((start[n]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5102, __FUNCTION__))->typed.type),
	     step[n], start[n]);
    tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (end[n])((contains_struct_check ((end[n]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5104, __FUNCTION__))->typed.type),
	     end[n], tmp);
    tmp = fold_build2_loc (input_location, FLOOR_DIV_EXPR, TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5106, __FUNCTION__))->typed.type),
	     tmp, step[n]);
    tmp = convert (gfc_array_index_type, tmp);

    size = fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type,
	      size, tmp);
  }

/* Record the nvar and size of current forall level.  */
info->nvar = nvar;
info->size = size;

if (code->expr1)
  {
    /* If the mask is .true., consider the FORALL unconditional.  */
    if (code->expr1->expr_type == EXPR_CONSTANT
 && code->expr1->value.logical)
need_mask = false;
    else
need_mask = true;
  }
else
  need_mask = false;

/* First we need to allocate the mask.  */
if (need_mask)
  {
    /* As the mask array can be very big, prefer compact boolean types.  */
    tree mask_type = gfc_get_logical_type (gfc_logical_kinds[0].kind);
    mask = allocate_temp_for_forall_nest (nested_forall_info, mask_type,
			    size, NULL__null, &block, &pmask);
    maskindex = gfc_create_var_np (gfc_array_index_type, "mi");

    /* Record them in the info structure.  */
    info->maskindex = maskindex;
    info->mask = mask;
  }
else
  {
    /* No mask was specified.  */
    maskindex = NULL_TREE(tree) __null;
    mask = pmask = NULL_TREE(tree) __null;
  }

/* Link the current forall level to nested_forall_info.  */
info->prev_nest = nested_forall_info;
nested_forall_info = info;

/* Copy the mask into a temporary variable if required.
   For now we assume a mask temporary is needed.  */
if (need_mask)
  {
    /* As the mask array can be very big, prefer compact boolean types.  */
    tree mask_type = gfc_get_logical_type (gfc_logical_kinds[0].kind);

    gfc_add_modify (&block, maskindex, gfc_index_zero_nodegfc_rank_cst[0]);

    /* Start of mask assignment loop body.  */
    gfc_start_block (&body);

    /* Evaluate the mask expression.  */
    gfc_init_se (&se, NULL__null);
    gfc_conv_expr_val (&se, code->expr1);
    gfc_add_block_to_block (&body, &se.pre);

    /* Store the mask.  */
    se.expr = convert (mask_type, se.expr);

    tmp = gfc_build_array_ref (mask, maskindex, NULL__null);
    gfc_add_modify (&body, tmp, se.expr);

    /* Advance to the next mask element.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     maskindex, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, maskindex, tmp);

    /* Generate the loops.  */
    tmp = gfc_finish_block (&body);
    tmp = gfc_trans_nested_forall_loop (info, tmp, 0);
    gfc_add_expr_to_block (&block, tmp);
  }

if (code->op == EXEC_DO_CONCURRENT)
  {
    gfc_init_block (&body);
    cycle_label = gfc_build_label_decl (NULL_TREE(tree) __null);
    code->cycle_label = cycle_label;
    tmp = gfc_trans_code (code->block->next);
    gfc_add_expr_to_block (&body, tmp);

    if (TREE_USED (cycle_label)((cycle_label)->base.used_flag))
{
 tmp = build1_v (LABEL_EXPR, cycle_label)fold_build1_loc (input_location, LABEL_EXPR, global_trees[TI_VOID_TYPE
], cycle_label);
 gfc_add_expr_to_block (&body, tmp);
}

    tmp = gfc_finish_block (&body);
    nested_forall_info->do_concurrent = true;
    tmp = gfc_trans_nested_forall_loop (nested_forall_info, tmp, 1);
    gfc_add_expr_to_block (&block, tmp);
    goto done;
  }

c = code->block->next;

/* TODO: loop merging in FORALL statements.  */
/* Now that we've got a copy of the mask, generate the assignment loops.  */
while (c)
  {
    switch (c->op)
{
case EXEC_ASSIGN:
        /* A scalar or array assignment.  DO the simple check for
    lhs to rhs dependencies.  These make a temporary for the
    rhs and form a second forall block to copy to variable.  */
 need_temp = check_forall_dependencies(c, &pre, &post);

        /* Temporaries due to array assignment data dependencies introduce
           no end of problems.  */
 if (need_temp || flag_test_forall_tempglobal_options.x_flag_test_forall_temp)
   gfc_trans_assign_need_temp (c->expr1, c->expr2, NULL__null, false,
                                      nested_forall_info, &block);
        else
          {
            /* Use the normal assignment copying routines.  */
            assign = gfc_trans_assignment (c->expr1, c->expr2, false, true);

            /* Generate body and loops.  */
            tmp = gfc_trans_nested_forall_loop (nested_forall_info,
				  assign, 1);
            gfc_add_expr_to_block (&block, tmp);
          }

 /* Cleanup any temporary symtrees that have been made to deal
    with dependencies.  */
 if (new_symtree)
   cleanup_forall_symtrees (c);

 break;

      case EXEC_WHERE:
 /* Translate WHERE or WHERE construct nested in FORALL.  */
 gfc_trans_where_2 (c, NULL__null, false, nested_forall_info, &block);
 break;

      /* Pointer assignment inside FORALL.  */
case EXEC_POINTER_ASSIGN:
        need_temp = gfc_check_dependency (c->expr1, c->expr2, 0);
 /* Avoid cases where a temporary would never be needed and where
    the temp code is guaranteed to fail.  */
 if (need_temp
     || (flag_test_forall_tempglobal_options.x_flag_test_forall_temp
  && c->expr2->expr_type != EXPR_CONSTANT
  && c->expr2->expr_type != EXPR_NULL))
          gfc_trans_pointer_assign_need_temp (c->expr1, c->expr2,
                                              nested_forall_info, &block);
        else
          {
            /* Use the normal assignment copying routines.  */
            assign = gfc_trans_pointer_assignment (c->expr1, c->expr2);

            /* Generate body and loops.  */
            tmp = gfc_trans_nested_forall_loop (nested_forall_info,
				  assign, 1);
            gfc_add_expr_to_block (&block, tmp);
          }
        break;

case EXEC_FORALL:
 tmp = gfc_trans_forall_1 (c, nested_forall_info);
        gfc_add_expr_to_block (&block, tmp);
        break;

/* Explicit subroutine calls are prevented by the frontend but interface
  assignments can legitimately produce them.  */
case EXEC_ASSIGN_CALL:
 assign = gfc_trans_call (c, true, NULL_TREE(tree) __null, NULL_TREE(tree) __null, false);
        tmp = gfc_trans_nested_forall_loop (nested_forall_info, assign, 1);
        gfc_add_expr_to_block (&block, tmp);
        break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5288, __FUNCTION__));
}

    c = c->next;
  }

5294done:
/* Restore the original index variables.  */
for (fa = code->ext.forall_iterator, n = 0; fa; fa = fa->next, n++)
  gfc_restore_sym (fa->var->symtree->n.sym, &saved_vars[n]);

/* Free the space for var, start, end, step, varexpr.  */
free (var);
free (start);
free (end);
free (step);
free (varexpr);
free (saved_vars);

for (this_forall = info->this_loop; this_forall;)
  {
    iter_info *next = this_forall->next;
    free (this_forall);
    this_forall = next;
  }

/* Free the space for this forall_info.  */
free (info);

if (pmask)
  {
    /* Free the temporary for the mask.  */
    tmp = gfc_call_free (pmask);
    gfc_add_expr_to_block (&block, tmp);
  }
if (maskindex)
  pushdecl (maskindex);

gfc_add_block_to_block (&pre, &block);
gfc_add_block_to_block (&pre, &post);

return gfc_finish_block (&pre);
5330}


5333/* Translate the FORALL statement or construct.  */

5335tree gfc_trans_forall (gfc_code * code)
5336{
return gfc_trans_forall_1 (code, NULL__null);
5338}


5341/* Translate the DO CONCURRENT construct.  */

5343tree gfc_trans_do_concurrent (gfc_code * code)
5344{
return gfc_trans_forall_1 (code, NULL__null);
5346}


5349/* Evaluate the WHERE mask expression, copy its value to a temporary.
 If the WHERE construct is nested in FORALL, compute the overall temporary
 needed by the WHERE mask expression multiplied by the iterator number of
 the nested forall.
 ME is the WHERE mask expression.
 MASK is the current execution mask upon input, whose sense may or may
 not be inverted as specified by the INVERT argument.
 CMASK is the updated execution mask on output, or NULL if not required.
 PMASK is the pending execution mask on output, or NULL if not required.
 BLOCK is the block in which to place the condition evaluation loops.  */

5360static void
5361gfc_evaluate_where_mask (gfc_expr * me, forall_info * nested_forall_info,
                       tree mask, bool invert, tree cmask, tree pmask,
                       tree mask_type, stmtblock_t * block)
5364{
tree tmp, tmp1;
gfc_ss *lss, *rss;
gfc_loopinfo loop;
stmtblock_t body, body1;
tree count, cond, mtmp;
gfc_se lse, rse;

gfc_init_loopinfo (&loop);

lss = gfc_walk_expr (me);
rss = gfc_walk_expr (me);

/* Variable to index the temporary.  */
count = gfc_create_var (gfc_array_index_type, "count");
/* Initialize count.  */
gfc_add_modify (block, count, gfc_index_zero_nodegfc_rank_cst[0]);

gfc_start_block (&body);

gfc_init_se (&rse, NULL__null);
gfc_init_se (&lse, NULL__null);

if (lss == gfc_ss_terminator)
  {
    gfc_init_block (&body1);
  }
else
  {
    /* Initialize the loop.  */
    gfc_init_loopinfo (&loop);

    /* We may need LSS to determine the shape of the expression.  */
    gfc_add_ss_to_loop (&loop, lss);
    gfc_add_ss_to_loop (&loop, rss);

    gfc_conv_ss_startstride (&loop);
    gfc_conv_loop_setup (&loop, &me->where);

    gfc_mark_ss_chain_used (rss, 1);
    /* Start the loop body.  */
    gfc_start_scalarized_body (&loop, &body1);

    /* Translate the expression.  */
    gfc_copy_loopinfo_to_se (&rse, &loop);
    rse.ss = rss;
    gfc_conv_expr (&rse, me);
  }

/* Variable to evaluate mask condition.  */
cond = gfc_create_var (mask_type, "cond");
if (mask && (cmask || pmask))
  mtmp = gfc_create_var (mask_type, "mask");
else mtmp = NULL_TREE(tree) __null;

gfc_add_block_to_block (&body1, &lse.pre);
gfc_add_block_to_block (&body1, &rse.pre);

gfc_add_modify (&body1, cond, fold_convert (mask_type, rse.expr)fold_convert_loc (((location_t) 0), mask_type, rse.expr));

if (mask && (cmask || pmask))
  {
    tmp = gfc_build_array_ref (mask, count, NULL__null);
    if (invert)
tmp = fold_build1_loc (input_location, TRUTH_NOT_EXPR, mask_type, tmp);
    gfc_add_modify (&body1, mtmp, tmp);
  }

if (cmask)
  {
    tmp1 = gfc_build_array_ref (cmask, count, NULL__null);
    tmp = cond;
    if (mask)
tmp = fold_build2_loc (input_location, TRUTH_AND_EXPR, mask_type,
	       mtmp, tmp);
    gfc_add_modify (&body1, tmp1, tmp);
  }

if (pmask)
  {
    tmp1 = gfc_build_array_ref (pmask, count, NULL__null);
    tmp = fold_build1_loc (input_location, TRUTH_NOT_EXPR, mask_type, cond);
    if (mask)
tmp = fold_build2_loc (input_location, TRUTH_AND_EXPR, mask_type, mtmp,
	       tmp);
    gfc_add_modify (&body1, tmp1, tmp);
  }

gfc_add_block_to_block (&body1, &lse.post);
gfc_add_block_to_block (&body1, &rse.post);

if (lss == gfc_ss_terminator)
  {
    gfc_add_block_to_block (&body, &body1);
  }
else
  {
    /* Increment count.  */
    tmp1 = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	      count, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body1, count, tmp1);

    /* Generate the copying loops.  */
    gfc_trans_scalarizing_loops (&loop, &body1);

    gfc_add_block_to_block (&body, &loop.pre);
    gfc_add_block_to_block (&body, &loop.post);

    gfc_cleanup_loop (&loop);
    /* TODO: Reuse lss and rss when copying temp->lhs.  Need to be careful
       as tree nodes in SS may not be valid in different scope.  */
  }

tmp1 = gfc_finish_block (&body);
/* If the WHERE construct is inside FORALL, fill the full temporary.  */
if (nested_forall_info != NULL__null)
  tmp1 = gfc_trans_nested_forall_loop (nested_forall_info, tmp1, 1);

gfc_add_expr_to_block (block, tmp1);
5483}


5486/* Translate an assignment statement in a WHERE statement or construct
 statement. The MASK expression is used to control which elements
 of EXPR1 shall be assigned.  The sense of MASK is specified by
 INVERT.  */

5491static tree
5492gfc_trans_where_assign (gfc_expr *expr1, gfc_expr *expr2,
	tree mask, bool invert,
                      tree count1, tree count2,
	gfc_code *cnext)
5496{
gfc_se lse;
gfc_se rse;
gfc_ss *lss;
gfc_ss *lss_section;
gfc_ss *rss;

gfc_loopinfo loop;
tree tmp;
stmtblock_t block;
stmtblock_t body;
tree index, maskexpr;

/* A defined assignment.  */
if (cnext29.1
'cnext' is non-null
 && cnext->resolved_sym)
30
←
Assuming field 'resolved_sym' is null→
31
←
Taking false branch→
  return gfc_trans_call (cnext, true, mask, count1, invert);

5513#if 0
/* TODO: handle this special case.
   Special case a single function returning an array.  */
if (expr2->expr_type == EXPR_FUNCTION && expr2->rank > 0)
  {
    tmp = gfc_trans_arrayfunc_assign (expr1, expr2);
    if (tmp)
      return tmp;
  }
5522#endif

/* Assignment of the form lhs = rhs.  */
gfc_start_block (&block);

gfc_init_se (&lse, NULL__null);
gfc_init_se (&rse, NULL__null);

/* Walk the lhs.  */
lss = gfc_walk_expr (expr1);
rss = NULL__null;

/* In each where-assign-stmt, the mask-expr and the variable being
   defined shall be arrays of the same shape.  */
gcc_assert (lss != gfc_ss_terminator)((void)(!(lss != gfc_ss_terminator) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5536, __FUNCTION__), 0 : 0));
32
←
Assuming 'lss' is not equal to 'gfc_ss_terminator'→
33
←
'?' condition is false→

/* The assignment needs scalarization.  */
lss_section = lss;

/* Find a non-scalar SS from the lhs.  */
while (lss_section33.1
'lss_section' is not equal to 'gfc_ss_terminator'
 != gfc_ss_terminator
35
←
Loop condition is false. Execution continues on line 5546→
&& lss_section->info->type != GFC_SS_SECTION)
34
←
Assuming field 'type' is equal to GFC_SS_SECTION→
  lss_section = lss_section->next;

gcc_assert (lss_section != gfc_ss_terminator)((void)(!(lss_section != gfc_ss_terminator) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5546, __FUNCTION__), 0 : 0));
36
←
'?' condition is false→

/* Initialize the scalarizer.  */
gfc_init_loopinfo (&loop);

/* Walk the rhs.  */
rss = gfc_walk_expr (expr2);
if (rss == gfc_ss_terminator)
37
←
Assuming 'rss' is not equal to 'gfc_ss_terminator'→
38
←
Taking false branch→
  {
    /* The rhs is scalar.  Add a ss for the expression.  */
    rss = gfc_get_scalar_ss (gfc_ss_terminator, expr2);
    rss->info->where = 1;
  }

/* Associate the SS with the loop.  */
gfc_add_ss_to_loop (&loop, lss);
gfc_add_ss_to_loop (&loop, rss);

/* Calculate the bounds of the scalarization.  */
gfc_conv_ss_startstride (&loop);

/* Resolve any data dependencies in the statement.  */
gfc_conv_resolve_dependencies (&loop, lss_section, rss);

/* Setup the scalarizing loops.  */
gfc_conv_loop_setup (&loop, &expr2->where);

/* Setup the gfc_se structures.  */
gfc_copy_loopinfo_to_se (&lse, &loop);
gfc_copy_loopinfo_to_se (&rse, &loop);

rse.ss = rss;
gfc_mark_ss_chain_used (rss, 1);
if (loop.temp_ss == NULL__null)
39
←
Assuming field 'temp_ss' is equal to NULL→
40
←
Taking true branch→
  {
    lse.ss = lss;
    gfc_mark_ss_chain_used (lss, 1);
  }
else
  {
    lse.ss = loop.temp_ss;
    gfc_mark_ss_chain_used (lss, 3);
    gfc_mark_ss_chain_used (loop.temp_ss, 3);
  }

/* Start the scalarized loop body.  */
gfc_start_scalarized_body (&loop, &body);

/* Translate the expression.  */
gfc_conv_expr (&rse, expr2);
if (lss40.1
'lss' is not equal to 'gfc_ss_terminator'
 != gfc_ss_terminator && loop.temp_ss != NULL__null)
41
←
Assuming field 'temp_ss' is not equal to NULL→
42
←
Taking true branch→
  gfc_conv_tmp_array_ref (&lse);
else
  gfc_conv_expr (&lse, expr1);

/* Form the mask expression according to the mask.  */
index = count1;
maskexpr = gfc_build_array_ref (mask, index, NULL__null);
if (invert42.1
'invert' is true
)
43
←
Taking true branch→
  maskexpr = fold_build1_loc (input_location, TRUTH_NOT_EXPR,
		TREE_TYPE (maskexpr)((contains_struct_check ((maskexpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5606, __FUNCTION__))->typed.type), maskexpr);

/* Use the scalar assignment as is.  */
tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts,
44
←
Forming reference to null pointer
		 false, loop.temp_ss == NULL__null);

tmp = build3_v (COND_EXPR, maskexpr, tmp, build_empty_stmt (input_location))fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], maskexpr, tmp, build_empty_stmt (input_location));

gfc_add_expr_to_block (&body, tmp);

if (lss == gfc_ss_terminator)
  {
    /* Increment count1.  */
    tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
	     count1, gfc_index_one_nodegfc_rank_cst[1]);
    gfc_add_modify (&body, count1, tmp);

    /* Use the scalar assignment as is.  */
    gfc_add_block_to_block (&block, &body);
  }
else
  {
    gcc_assert (lse.ss == gfc_ss_terminator((void)(!(lse.ss == gfc_ss_terminator && rse.ss == gfc_ss_terminator
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5629, __FUNCTION__), 0 : 0))
  && rse.ss == gfc_ss_terminator)((void)(!(lse.ss == gfc_ss_terminator && rse.ss == gfc_ss_terminator
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5629, __FUNCTION__), 0 : 0));

    if (loop.temp_ss != NULL__null)
      {
        /* Increment count1 before finish the main body of a scalarized
           expression.  */
        tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type, count1, gfc_index_one_nodegfc_rank_cst[1]);
        gfc_add_modify (&body, count1, tmp);
        gfc_trans_scalarized_loop_boundary (&loop, &body);

        /* We need to copy the temporary to the actual lhs.  */
        gfc_init_se (&lse, NULL__null);
        gfc_init_se (&rse, NULL__null);
        gfc_copy_loopinfo_to_se (&lse, &loop);
        gfc_copy_loopinfo_to_se (&rse, &loop);

        rse.ss = loop.temp_ss;
        lse.ss = lss;

        gfc_conv_tmp_array_ref (&rse);
        gfc_conv_expr (&lse, expr1);

        gcc_assert (lse.ss == gfc_ss_terminator((void)(!(lse.ss == gfc_ss_terminator && rse.ss == gfc_ss_terminator
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5653, __FUNCTION__), 0 : 0))
      && rse.ss == gfc_ss_terminator)((void)(!(lse.ss == gfc_ss_terminator && rse.ss == gfc_ss_terminator
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5653, __FUNCTION__), 0 : 0));

        /* Form the mask expression according to the mask tree list.  */
        index = count2;
        maskexpr = gfc_build_array_ref (mask, index, NULL__null);
 if (invert)
   maskexpr = fold_build1_loc (input_location, TRUTH_NOT_EXPR,
			TREE_TYPE (maskexpr)((contains_struct_check ((maskexpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5660, __FUNCTION__))->typed.type), maskexpr);

        /* Use the scalar assignment as is.  */
        tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts, false, true);
        tmp = build3_v (COND_EXPR, maskexpr, tmp,fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], maskexpr, tmp, build_empty_stmt (input_location))
	  build_empty_stmt (input_location))fold_build3_loc (input_location, COND_EXPR, global_trees[TI_VOID_TYPE
], maskexpr, tmp, build_empty_stmt (input_location));
        gfc_add_expr_to_block (&body, tmp);

        /* Increment count2.  */
        tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type, count2,
		 gfc_index_one_nodegfc_rank_cst[1]);
        gfc_add_modify (&body, count2, tmp);
      }
    else
      {
        /* Increment count1.  */
        tmp = fold_build2_loc (input_location, PLUS_EXPR,
		 gfc_array_index_type, count1,
		 gfc_index_one_nodegfc_rank_cst[1]);
        gfc_add_modify (&body, count1, tmp);
      }

    /* Generate the copying loops.  */
    gfc_trans_scalarizing_loops (&loop, &body);

    /* Wrap the whole thing up.  */
    gfc_add_block_to_block (&block, &loop.pre);
    gfc_add_block_to_block (&block, &loop.post);
    gfc_cleanup_loop (&loop);
  }

return gfc_finish_block (&block);
5693}


5696/* Translate the WHERE construct or statement.
 This function can be called iteratively to translate the nested WHERE
 construct or statement.
 MASK is the control mask.  */

5701static void
5702gfc_trans_where_2 (gfc_code * code, tree mask, bool invert,
   forall_info * nested_forall_info, stmtblock_t * block)
5704{
stmtblock_t inner_size_body;
tree inner_size, size;
gfc_ss *lss, *rss;
tree mask_type;
gfc_expr *expr1;
gfc_expr *expr2;
gfc_code *cblock;
gfc_code *cnext;
tree tmp;
tree cond;
tree count1, count2;
bool need_cmask;
bool need_pmask;
int need_temp;
tree pcmask = NULL_TREE(tree) __null;
tree ppmask = NULL_TREE(tree) __null;
tree cmask = NULL_TREE(tree) __null;
tree pmask = NULL_TREE(tree) __null;
gfc_actual_arglist *arg;

/* the WHERE statement or the WHERE construct statement.  */
cblock = code->block;

/* As the mask array can be very big, prefer compact boolean types.  */
mask_type = gfc_get_logical_type (gfc_logical_kinds[0].kind);

/* Determine which temporary masks are needed.  */
if (!cblock->block)
3
←
Assuming field 'block' is non-null→
4
←
Taking false branch→
  {
    /* One clause: No ELSEWHEREs.  */
    need_cmask = (cblock->next != 0);
    need_pmask = false;
  }
else if (cblock->block->block)
5
←
Assuming field 'block' is null→
6
←
Taking false branch→
  {
    /* Three or more clauses: Conditional ELSEWHEREs.  */
    need_cmask = true;
    need_pmask = true;
  }
else if (cblock->next6.1
Field 'next' is null
)
7
←
Taking false branch→
  {
    /* Two clauses, the first non-empty.  */
    need_cmask = true;
    need_pmask = (mask != NULL_TREE(tree) __null
    && cblock->block->next != 0);
  }
else if (!cblock->block->next)
8
←
Assuming field 'next' is non-null→
9
←
Taking false branch→
  {
    /* Two clauses, both empty.  */
    need_cmask = false;
    need_pmask = false;
  }
/* Two clauses, the first empty, the second non-empty.  */
else if (mask9.1
'mask' is null
)
10
←
Taking false branch→
  {
    need_cmask = (cblock->block->expr1 != 0);
    need_pmask = true;
  }
else
  {
    need_cmask = true;
    need_pmask = false;
  }

if (need_cmask10.1
'need_cmask' is true
 || need_pmask)
  {
    /* Calculate the size of temporary needed by the mask-expr.  */
    gfc_init_block (&inner_size_body);
    inner_size = compute_inner_temp_size (cblock->expr1, cblock->expr1,
			    &inner_size_body, &lss, &rss);

    gfc_free_ss_chain (lss);
    gfc_free_ss_chain (rss);

    /* Calculate the total size of temporary needed.  */
    size = compute_overall_iter_number (nested_forall_info, inner_size,
			  &inner_size_body, block);

    /* Check whether the size is negative.  */
    cond = fold_build2_loc (input_location, LE_EXPR, logical_type_node, size,
	      gfc_index_zero_nodegfc_rank_cst[0]);
    size = fold_build3_loc (input_location, COND_EXPR, gfc_array_index_type,
	      cond, gfc_index_zero_nodegfc_rank_cst[0], size);
    size = gfc_evaluate_now (size, block);

    /* Allocate temporary for WHERE mask if needed.  */
    if (need_cmask10.2
'need_cmask' is true
)
11
←
Taking true branch→
cmask = allocate_temp_for_forall_nest_1 (mask_type, size, block,
				 &pcmask);

    /* Allocate temporary for !mask if needed.  */
    if (need_pmask11.1
'need_pmask' is false
)
12
←
Taking false branch→
pmask = allocate_temp_for_forall_nest_1 (mask_type, size, block,
				 &ppmask);
  }

while (cblock)
13
←
Loop condition is true.  Entering loop body→
18
←
Loop condition is true.  Entering loop body→
  {
    /* Each time around this loop, the where clause is conditional
on the value of mask and invert, which are updated at the
bottom of the loop.  */

    /* Has mask-expr.  */
    if (cblock->expr1)
14
←
Assuming field 'expr1' is null→
15
←
Taking false branch→
19
←
Assuming field 'expr1' is null→
20
←
Taking false branch→
      {
        /* Ensure that the WHERE mask will be evaluated exactly once.
    If there are no statements in this WHERE/ELSEWHERE clause,
    then we don't need to update the control mask (cmask).
    If this is the last clause of the WHERE construct, then
    we don't need to update the pending control mask (pmask).  */
 if (mask)
   gfc_evaluate_where_mask (cblock->expr1, nested_forall_info,
		     mask, invert,
		     cblock->next  ? cmask : NULL_TREE(tree) __null,
		     cblock->block ? pmask : NULL_TREE(tree) __null,
		     mask_type, block);
 else
   gfc_evaluate_where_mask (cblock->expr1, nested_forall_info,
		     NULL_TREE(tree) __null, false,
		     (cblock->next || cblock->block)
		     ? cmask : NULL_TREE(tree) __null,
		     NULL_TREE(tree) __null, mask_type, block);

 invert = false;
      }
    /* It's a final elsewhere-stmt. No mask-expr is present.  */
    else
      cmask = mask;

    /* The body of this where clause are controlled by cmask with
sense specified by invert.  */

    /* Get the assignment statement of a WHERE statement, or the first
       statement in where-body-construct of a WHERE construct.  */
    cnext = cblock->next;
    while (cnext)
16
←
Loop condition is false. Execution continues on line 5921→
21
←
Loop condition is true.  Entering loop body→
      {
        switch (cnext->op)
22
←
Control jumps to 'case EXEC_ASSIGN_CALL:'  at line 5845→
          {
          /* WHERE assignment statement.  */
   case EXEC_ASSIGN_CALL:

     arg = cnext->ext.actual;
     expr1 = expr2 = NULL__null;
23
←
Null pointer value stored to 'expr2'→
24
←
Null pointer value stored to 'expr1'→
     for (; arg; arg = arg->next)
25
←
Loop condition is false. Execution continues on line 5858→
{
  if (!arg->expr)
    continue;
  if (expr1 == NULL__null)
    expr1 = arg->expr;
  else
    expr2 = arg->expr;
}
     goto evaluate;
26
←
Control jumps to line 5864→

          case EXEC_ASSIGN:
            expr1 = cnext->expr1;
            expr2 = cnext->expr2;
  evaluate:
            if (nested_forall_info26.1
'nested_forall_info' is equal to NULL
 != NULL__null)
27
←
Taking false branch→
              {
                need_temp = gfc_check_dependency (expr1, expr2, 0);
  if ((need_temp || flag_test_forall_tempglobal_options.x_flag_test_forall_temp)
    && cnext->op != EXEC_ASSIGN_CALL)
                  gfc_trans_assign_need_temp (expr1, expr2,
				cmask, invert,
                                              nested_forall_info, block);
                else
                  {
                    /* Variables to control maskexpr.  */
                    count1 = gfc_create_var (gfc_array_index_type, "count1");
                    count2 = gfc_create_var (gfc_array_index_type, "count2");
                    gfc_add_modify (block, count1, gfc_index_zero_nodegfc_rank_cst[0]);
                    gfc_add_modify (block, count2, gfc_index_zero_nodegfc_rank_cst[0]);

                    tmp = gfc_trans_where_assign (expr1, expr2,
				    cmask, invert,
				    count1, count2,
				    cnext);

                    tmp = gfc_trans_nested_forall_loop (nested_forall_info,
                                                        tmp, 1);
                    gfc_add_expr_to_block (block, tmp);
                  }
              }
            else
              {
                /* Variables to control maskexpr.  */
                count1 = gfc_create_var (gfc_array_index_type, "count1");
                count2 = gfc_create_var (gfc_array_index_type, "count2");
                gfc_add_modify (block, count1, gfc_index_zero_nodegfc_rank_cst[0]);
                gfc_add_modify (block, count2, gfc_index_zero_nodegfc_rank_cst[0]);

                tmp = gfc_trans_where_assign (expr1, expr2,
28
←
Passing null pointer value via 1st parameter 'expr1'→
29
←
Calling 'gfc_trans_where_assign'→
				cmask, invert,
				count1, count2,
				cnext);
                gfc_add_expr_to_block (block, tmp);

              }
            break;

          /* WHERE or WHERE construct is part of a where-body-construct.  */
          case EXEC_WHERE:
     gfc_trans_where_2 (cnext, cmask, invert,
		 nested_forall_info, block);
     break;

          default:
            gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/trans-stmt.cc"
, 5914, __FUNCTION__));
          }

       /* The next statement within the same where-body-construct.  */
       cnext = cnext->next;
     }
  /* The next masked-elsewhere-stmt, elsewhere-stmt, or end-where-stmt.  */
  <