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

Bug Summary

File:	build/gcc/fortran/symbol.cc
Warning:	line 3489, column 7 Branch condition evaluates to a garbage value
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 symbol.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-bL_vDv.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc
1/* Maintain binary trees of symbols.
 Copyright (C) 2000-2023 Free Software Foundation, Inc.
 Contributed by Andy Vaught

5This file is part of GCC.

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

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

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


22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "options.h"
26#include "gfortran.h"
27#include "parse.h"
28#include "match.h"
29#include "constructor.h"


32/* Strings for all symbol attributes.  We use these for dumping the
 parse tree, in error messages, and also when reading and writing
 modules.  */

36const mstring flavors[] =
37{
minit ("UNKNOWN-FL", FL_UNKNOWN){ "UNKNOWN-FL", __null, FL_UNKNOWN }, minit ("PROGRAM", FL_PROGRAM){ "PROGRAM", __null, FL_PROGRAM },
minit ("BLOCK-DATA", FL_BLOCK_DATA){ "BLOCK-DATA", __null, FL_BLOCK_DATA }, minit ("MODULE", FL_MODULE){ "MODULE", __null, FL_MODULE },
minit ("VARIABLE", FL_VARIABLE){ "VARIABLE", __null, FL_VARIABLE }, minit ("PARAMETER", FL_PARAMETER){ "PARAMETER", __null, FL_PARAMETER },
minit ("LABEL", FL_LABEL){ "LABEL", __null, FL_LABEL }, minit ("PROCEDURE", FL_PROCEDURE){ "PROCEDURE", __null, FL_PROCEDURE },
minit ("DERIVED", FL_DERIVED){ "DERIVED", __null, FL_DERIVED }, minit ("NAMELIST", FL_NAMELIST){ "NAMELIST", __null, FL_NAMELIST },
minit ("UNION", FL_UNION){ "UNION", __null, FL_UNION }, minit ("STRUCTURE", FL_STRUCT){ "STRUCTURE", __null, FL_STRUCT },
minit (NULL, -1){ __null, __null, -1 }
45};

47const mstring procedures[] =
48{
  minit ("UNKNOWN-PROC", PROC_UNKNOWN){ "UNKNOWN-PROC", __null, PROC_UNKNOWN },
  minit ("MODULE-PROC", PROC_MODULE){ "MODULE-PROC", __null, PROC_MODULE },
  minit ("INTERNAL-PROC", PROC_INTERNAL){ "INTERNAL-PROC", __null, PROC_INTERNAL },
  minit ("DUMMY-PROC", PROC_DUMMY){ "DUMMY-PROC", __null, PROC_DUMMY },
  minit ("INTRINSIC-PROC", PROC_INTRINSIC){ "INTRINSIC-PROC", __null, PROC_INTRINSIC },
  minit ("EXTERNAL-PROC", PROC_EXTERNAL){ "EXTERNAL-PROC", __null, PROC_EXTERNAL },
  minit ("STATEMENT-PROC", PROC_ST_FUNCTION){ "STATEMENT-PROC", __null, PROC_ST_FUNCTION },
  minit (NULL, -1){ __null, __null, -1 }
57};

59const mstring intents[] =
60{
  minit ("UNKNOWN-INTENT", INTENT_UNKNOWN){ "UNKNOWN-INTENT", __null, INTENT_UNKNOWN },
  minit ("IN", INTENT_IN){ "IN", __null, INTENT_IN },
  minit ("OUT", INTENT_OUT){ "OUT", __null, INTENT_OUT },
  minit ("INOUT", INTENT_INOUT){ "INOUT", __null, INTENT_INOUT },
  minit (NULL, -1){ __null, __null, -1 }
66};

68const mstring access_types[] =
69{
  minit ("UNKNOWN-ACCESS", ACCESS_UNKNOWN){ "UNKNOWN-ACCESS", __null, ACCESS_UNKNOWN },
  minit ("PUBLIC", ACCESS_PUBLIC){ "PUBLIC", __null, ACCESS_PUBLIC },
  minit ("PRIVATE", ACCESS_PRIVATE){ "PRIVATE", __null, ACCESS_PRIVATE },
  minit (NULL, -1){ __null, __null, -1 }
74};

76const mstring ifsrc_types[] =
77{
  minit ("UNKNOWN", IFSRC_UNKNOWN){ "UNKNOWN", __null, IFSRC_UNKNOWN },
  minit ("DECL", IFSRC_DECL){ "DECL", __null, IFSRC_DECL },
  minit ("BODY", IFSRC_IFBODY){ "BODY", __null, IFSRC_IFBODY }
81};

83const mstring save_status[] =
84{
  minit ("UNKNOWN", SAVE_NONE){ "UNKNOWN", __null, SAVE_NONE },
  minit ("EXPLICIT-SAVE", SAVE_EXPLICIT){ "EXPLICIT-SAVE", __null, SAVE_EXPLICIT },
  minit ("IMPLICIT-SAVE", SAVE_IMPLICIT){ "IMPLICIT-SAVE", __null, SAVE_IMPLICIT },
88};

90/* Set the mstrings for DTIO procedure names.  */
91const mstring dtio_procs[] =
92{
  minit ("_dtio_formatted_read", DTIO_RF){ "_dtio_formatted_read", __null, DTIO_RF },
  minit ("_dtio_formatted_write", DTIO_WF){ "_dtio_formatted_write", __null, DTIO_WF },
  minit ("_dtio_unformatted_read", DTIO_RUF){ "_dtio_unformatted_read", __null, DTIO_RUF },
  minit ("_dtio_unformatted_write", DTIO_WUF){ "_dtio_unformatted_write", __null, DTIO_WUF },
97};

99/* This is to make sure the backend generates setup code in the correct
 order.  */

102static int next_dummy_order = 1;


105gfc_namespace *gfc_current_ns;
106gfc_namespace *gfc_global_ns_list;

108gfc_gsymbol *gfc_gsym_root = NULL__null;

110gfc_symbol *gfc_derived_types;

112static gfc_undo_change_set default_undo_chgset_var = { vNULL, vNULL, NULL__null };
113static gfc_undo_change_set *latest_undo_chgset = &default_undo_chgset_var;


116/*********** IMPLICIT NONE and IMPLICIT statement handlers ***********/

118/* The following static variable indicates whether a particular element has
 been explicitly set or not.  */

121static int new_flag[GFC_LETTERS26];


124/* Handle a correctly parsed IMPLICIT NONE.  */

126void
127gfc_set_implicit_none (bool type, bool external, locus *loc)
128{
int i;

if (external)
  gfc_current_ns->has_implicit_none_export = 1;

if (type)
  {
    gfc_current_ns->seen_implicit_none = 1;
    for (i = 0; i < GFC_LETTERS26; i++)
{
 if (gfc_current_ns->set_flag[i])
   {
     gfc_error_now ("IMPLICIT NONE (type) statement at %L following an "
	     "IMPLICIT statement", loc);
     return;
   }
 gfc_clear_ts (&gfc_current_ns->default_type[i]);
 gfc_current_ns->set_flag[i] = 1;
}
  }
149}


152/* Reset the implicit range flags.  */

154void
155gfc_clear_new_implicit (void)
156{
int i;

for (i = 0; i < GFC_LETTERS26; i++)
  new_flag[i] = 0;
161}


164/* Prepare for a new implicit range.  Sets flags in new_flag[].  */

166bool
167gfc_add_new_implicit_range (int c1, int c2)
168{
int i;

c1 -= 'a';
c2 -= 'a';

for (i = c1; i <= c2; i++)
  {
    if (new_flag[i])
{
 gfc_error ("Letter %qc already set in IMPLICIT statement at %C",
     i + 'A');
 return false;
}

    new_flag[i] = 1;
  }

return true;
187}


190/* Add a matched implicit range for gfc_set_implicit().  Check if merging
 the new implicit types back into the existing types will work.  */

193bool
194gfc_merge_new_implicit (gfc_typespec *ts)
195{
int i;

if (gfc_current_ns->seen_implicit_none)
  {
    gfc_error ("Cannot specify IMPLICIT at %C after IMPLICIT NONE");
    return false;
  }

for (i = 0; i < GFC_LETTERS26; i++)
  {
    if (new_flag[i])
{
 if (gfc_current_ns->set_flag[i])
   {
     gfc_error ("Letter %qc already has an IMPLICIT type at %C",
	 i + 'A');
     return false;
   }

 gfc_current_ns->default_type[i] = *ts;
 gfc_current_ns->implicit_loc[i] = gfc_current_locus;
 gfc_current_ns->set_flag[i] = 1;
}
  }
return true;
221}


224/* Given a symbol, return a pointer to the typespec for its default type.  */

226gfc_typespec *
227gfc_get_default_type (const char *name, gfc_namespace *ns)
228{
char letter;

letter = name[0];

if (flag_allow_leading_underscoreglobal_options.x_flag_allow_leading_underscore && letter == '_')
  gfc_fatal_error ("Option %<-fallow-leading-underscore%> is for use only by "
     "gfortran developers, and should not be used for "
     "implicitly typed variables");

if (letter < 'a' || letter > 'z')
  gfc_internal_error ("gfc_get_default_type(): Bad symbol %qs", name);

if (ns == NULL__null)
  ns = gfc_current_ns;

return &ns->default_type[letter - 'a'];
245}


248/* Recursively append candidate SYM to CANDIDATES.  Store the number of
 candidates in CANDIDATES_LEN.  */

251static void
252lookup_symbol_fuzzy_find_candidates (gfc_symtree *sym,
		     char **&candidates,
		     size_t &candidates_len)
255{
gfc_symtree *p;

if (sym == NULL__null)
  return;

if (sym->n.sym->ts.type != BT_UNKNOWN && sym->n.sym->ts.type != BT_PROCEDURE)
  vec_push (candidates, candidates_len, sym->name);
p = sym->left;
if (p)
  lookup_symbol_fuzzy_find_candidates (p, candidates, candidates_len);

p = sym->right;
if (p)
  lookup_symbol_fuzzy_find_candidates (p, candidates, candidates_len);
270}


273/* Lookup symbol SYM_NAME fuzzily, taking names in SYMBOL into account.  */

275static const char*
276lookup_symbol_fuzzy (const char *sym_name, gfc_symbol *symbol)
277{
char **candidates = NULL__null;
size_t candidates_len = 0;
lookup_symbol_fuzzy_find_candidates (symbol->ns->sym_root, candidates,
		       candidates_len);
return gfc_closest_fuzzy_match (sym_name, candidates);
283}


286/* Given a pointer to a symbol, set its type according to the first
 letter of its name.  Fails if the letter in question has no default
 type.  */

290bool
291gfc_set_default_type (gfc_symbol *sym, int error_flag, gfc_namespace *ns)
292{
gfc_typespec *ts;

if (sym->ts.type != BT_UNKNOWN)
  gfc_internal_error ("gfc_set_default_type(): symbol already has a type");

ts = gfc_get_default_type (sym->name, ns);

if (ts->type == BT_UNKNOWN)
  {
    if (error_flag && !sym->attr.untyped && !gfc_query_suppress_errors ())
{
 const char *guessed = lookup_symbol_fuzzy (sym->name, sym);
 if (guessed)
   gfc_error ("Symbol %qs at %L has no IMPLICIT type"
       "; did you mean %qs?",
       sym->name, &sym->declared_at, guessed);
 else
   gfc_error ("Symbol %qs at %L has no IMPLICIT type",
       sym->name, &sym->declared_at);
 sym->attr.untyped = 1; /* Ensure we only give an error once.  */
}

    return false;
  }

sym->ts = *ts;
sym->attr.implicit_type = 1;

if (ts->type == BT_CHARACTER && ts->u.cl)
  sym->ts.u.cl = gfc_new_charlen (sym->ns, ts->u.cl);
else if (ts->type == BT_CLASS
  && !gfc_build_class_symbol (&sym->ts, &sym->attr, &sym->as))
  return false;

if (sym->attr.is_bind_c == 1 && warn_c_binding_typeglobal_options.x_warn_c_binding_type)
  {
    /* BIND(C) variables should not be implicitly declared.  */
    gfc_warning_now (OPT_Wc_binding_type, "Implicitly declared BIND(C) "
       "variable %qs at %L may not be C interoperable",
       sym->name, &sym->declared_at);
    sym->ts.f90_type = sym->ts.type;
  }

if (sym->attr.dummy != 0)
  {
    if (sym->ns->proc_name != NULL__null
 && (sym->ns->proc_name->attr.subroutine != 0
     || sym->ns->proc_name->attr.function != 0)
 && sym->ns->proc_name->attr.is_bind_c != 0
 && warn_c_binding_typeglobal_options.x_warn_c_binding_type)
      {
        /* Dummy args to a BIND(C) routine may not be interoperable if
           they are implicitly typed.  */
        gfc_warning_now (OPT_Wc_binding_type, "Implicitly declared variable "
	   "%qs at %L may not be C interoperable but it is a "
	   "dummy argument to the BIND(C) procedure %qs at %L",
	   sym->name, &(sym->declared_at),
	   sym->ns->proc_name->name,
                         &(sym->ns->proc_name->declared_at));
        sym->ts.f90_type = sym->ts.type;
      }
  }

return true;
357}


360/* This function is called from parse.cc(parse_progunit) to check the
 type of the function is not implicitly typed in the host namespace
 and to implicitly type the function result, if necessary.  */

364void
365gfc_check_function_type (gfc_namespace *ns)
366{
gfc_symbol *proc = ns->proc_name;

if (!proc->attr.contained || proc->result->attr.implicit_type)
  return;

if (proc->result->ts.type == BT_UNKNOWN && proc->result->ts.interface == NULL__null)
  {
    if (gfc_set_default_type (proc->result, 0, gfc_current_ns))
{
 if (proc->result != proc)
   {
     proc->ts = proc->result->ts;
     proc->as = gfc_copy_array_spec (proc->result->as);
     proc->attr.dimension = proc->result->attr.dimension;
     proc->attr.pointer = proc->result->attr.pointer;
     proc->attr.allocatable = proc->result->attr.allocatable;
   }
}
    else if (!proc->result->attr.proc_pointer)
{
 gfc_error ("Function result %qs at %L has no IMPLICIT type",
     proc->result->name, &proc->result->declared_at);
 proc->result->attr.untyped = 1;
}
  }
392}


395/******************** Symbol attribute stuff *********************/

397/* This is a generic conflict-checker.  We do this to avoid having a
 single conflict in two places.  */

400#define conf(a, b) if (attr->a && attr->b) { a1 = a; a2 = b; goto conflict; }
401#define conf2(a) if (attr->a) { a2 = a; goto conflict; }
402#define conf_std(a, b, std) if (attr->a && attr->b)\
                            {\
                              a1 = a;\
                              a2 = b;\
                              standard = std;\
                              goto conflict_std;\
                            }

410bool
411gfc_check_conflict (symbol_attribute *attr, const char *name, locus *where)
412{
static const char *dummy = "DUMMY", *save = "SAVE", *pointer = "POINTER",
  *target = "TARGET", *external = "EXTERNAL", *intent = "INTENT",
  *intent_in = "INTENT(IN)", *intrinsic = "INTRINSIC",
  *intent_out = "INTENT(OUT)", *intent_inout = "INTENT(INOUT)",
  *allocatable = "ALLOCATABLE", *elemental = "ELEMENTAL",
  *privat = "PRIVATE", *recursive = "RECURSIVE",
  *in_common = "COMMON", *result = "RESULT", *in_namelist = "NAMELIST",
  *publik = "PUBLIC", *optional = "OPTIONAL", *entry = "ENTRY",
  *function = "FUNCTION", *subroutine = "SUBROUTINE",
  *dimension = "DIMENSION", *in_equivalence = "EQUIVALENCE",
  *use_assoc = "USE ASSOCIATED", *cray_pointer = "CRAY POINTER",
  *cray_pointee = "CRAY POINTEE", *data = "DATA", *value = "VALUE",
  *volatile_ = "VOLATILE", *is_protected = "PROTECTED",
  *is_bind_c = "BIND(C)", *procedure = "PROCEDURE",
  *proc_pointer = "PROCEDURE POINTER", *abstract = "ABSTRACT",
  *asynchronous = "ASYNCHRONOUS", *codimension = "CODIMENSION",
  *contiguous = "CONTIGUOUS", *generic = "GENERIC", *automatic = "AUTOMATIC",
  *pdt_len = "LEN", *pdt_kind = "KIND";
static const char *threadprivate = "THREADPRIVATE";
static const char *omp_declare_target = "OMP DECLARE TARGET";
static const char *omp_declare_target_link = "OMP DECLARE TARGET LINK";
static const char *oacc_declare_copyin = "OACC DECLARE COPYIN";
static const char *oacc_declare_create = "OACC DECLARE CREATE";
static const char *oacc_declare_deviceptr = "OACC DECLARE DEVICEPTR";
static const char *oacc_declare_device_resident =
				"OACC DECLARE DEVICE_RESIDENT";

const char *a1, *a2;
int standard;

if (attr->artificial)
  return true;

if (where == NULL__null)
  where = &gfc_current_locus;

if (attr->pointer && attr->intent != INTENT_UNKNOWN)
  {
    a1 = pointer;
    a2 = intent;
    standard = GFC_STD_F2003(1<<4);
    goto conflict_std;
  }

if (attr->in_namelist && (attr->allocatable || attr->pointer))
  {
    a1 = in_namelist;
    a2 = attr->allocatable ? allocatable : pointer;
    standard = GFC_STD_F2003(1<<4);
    goto conflict_std;
  }

/* Check for attributes not allowed in a BLOCK DATA.  */
if (gfc_current_state ()(gfc_state_stack->state) == COMP_BLOCK_DATA)
  {
    a1 = NULL__null;

    if (attr->in_namelist)
a1 = in_namelist;
    if (attr->allocatable)
a1 = allocatable;
    if (attr->external)
a1 = external;
    if (attr->optional)
a1 = optional;
    if (attr->access == ACCESS_PRIVATE)
a1 = privat;
    if (attr->access == ACCESS_PUBLIC)
a1 = publik;
    if (attr->intent != INTENT_UNKNOWN)
a1 = intent;

    if (a1 != NULL__null)
{
 gfc_error
   ("%s attribute not allowed in BLOCK DATA program unit at %L",
    a1, where);
 return false;
}
  }

if (attr->save == SAVE_EXPLICIT)
  {
    conf (dummy, save);
    conf (in_common, save);
    conf (result, save);
    conf (automatic, save);

    switch (attr->flavor)
{
 case FL_PROGRAM:
 case FL_BLOCK_DATA:
 case FL_MODULE:
 case FL_LABEL:
 case_fl_structcase FL_DERIVED: case FL_UNION: case FL_STRUCT:
 case FL_PARAMETER:
          a1 = gfc_code2string (flavors, attr->flavor);
          a2 = save;
   goto conflict;
 case FL_NAMELIST:
   gfc_error ("Namelist group name at %L cannot have the "
       "SAVE attribute", where);
   return false;
 case FL_PROCEDURE:
   /* Conflicts between SAVE and PROCEDURE will be checked at
      resolution stage, see "resolve_fl_procedure".  */
 case FL_VARIABLE:
 default:
   break;
}
  }

/* The copying of procedure dummy arguments for module procedures in
   a submodule occur whilst the current state is COMP_CONTAINS. It
   is necessary, therefore, to let this through.  */
if (name && attr->dummy
    && (attr->function || attr->subroutine)
    && gfc_current_state ()(gfc_state_stack->state) == COMP_CONTAINS
    && !(gfc_new_block && gfc_new_block->abr_modproc_decl))
  gfc_error_now ("internal procedure %qs at %L conflicts with "
   "DUMMY argument", name, where);

conf (dummy, entry);
conf (dummy, intrinsic);
conf (dummy, threadprivate);
conf (dummy, omp_declare_target);
conf (dummy, omp_declare_target_link);
conf (pointer, target);
conf (pointer, intrinsic);
conf (pointer, elemental);
conf (pointer, codimension);
conf (allocatable, elemental);

conf (in_common, automatic);
conf (result, automatic);
conf (use_assoc, automatic);
conf (dummy, automatic);

conf (target, external);
conf (target, intrinsic);

if (!attr->if_source)
  conf (external, dimension);   /* See Fortran 95's R504.  */

conf (external, intrinsic);
conf (entry, intrinsic);
conf (abstract, intrinsic);

if ((attr->if_source == IFSRC_DECL && !attr->procedure) || attr->contained)
  conf (external, subroutine);

if (attr->proc_pointer && !gfc_notify_std (GFC_STD_F2003(1<<4),
			     "Procedure pointer at %C"))
  return false;

conf (allocatable, pointer);
conf_std (allocatable, dummy, GFC_STD_F2003(1<<4));
conf_std (allocatable, function, GFC_STD_F2003(1<<4));
conf_std (allocatable, result, GFC_STD_F2003(1<<4));
conf_std (elemental, recursive, GFC_STD_F2018(1<<9));

conf (in_common, dummy);
conf (in_common, allocatable);
conf (in_common, codimension);
conf (in_common, result);

conf (in_equivalence, use_assoc);
conf (in_equivalence, codimension);
conf (in_equivalence, dummy);
conf (in_equivalence, target);
conf (in_equivalence, pointer);
conf (in_equivalence, function);
conf (in_equivalence, result);
conf (in_equivalence, entry);
conf (in_equivalence, allocatable);
conf (in_equivalence, threadprivate);
conf (in_equivalence, omp_declare_target);
conf (in_equivalence, omp_declare_target_link);
conf (in_equivalence, oacc_declare_create);
conf (in_equivalence, oacc_declare_copyin);
conf (in_equivalence, oacc_declare_deviceptr);
conf (in_equivalence, oacc_declare_device_resident);
conf (in_equivalence, is_bind_c);

conf (dummy, result);
conf (entry, result);
conf (generic, result);
conf (generic, omp_declare_target);
conf (generic, omp_declare_target_link);

conf (function, subroutine);

if (!function && !subroutine)
  conf (is_bind_c, dummy);

conf (is_bind_c, cray_pointer);
conf (is_bind_c, cray_pointee);
conf (is_bind_c, codimension);
conf (is_bind_c, allocatable);
conf (is_bind_c, elemental);

/* Need to also get volatile attr, according to 5.1 of F2003 draft.
   Parameter conflict caught below.  Also, value cannot be specified
   for a dummy procedure.  */

/* Cray pointer/pointee conflicts.  */
conf (cray_pointer, cray_pointee);
conf (cray_pointer, dimension);
conf (cray_pointer, codimension);
conf (cray_pointer, contiguous);
conf (cray_pointer, pointer);
conf (cray_pointer, target);
conf (cray_pointer, allocatable);
conf (cray_pointer, external);
conf (cray_pointer, intrinsic);
conf (cray_pointer, in_namelist);
conf (cray_pointer, function);
conf (cray_pointer, subroutine);
conf (cray_pointer, entry);

conf (cray_pointee, allocatable);
conf (cray_pointee, contiguous);
conf (cray_pointee, codimension);
conf (cray_pointee, intent);
conf (cray_pointee, optional);
conf (cray_pointee, dummy);
conf (cray_pointee, target);
conf (cray_pointee, intrinsic);
conf (cray_pointee, pointer);
conf (cray_pointee, entry);
conf (cray_pointee, in_common);
conf (cray_pointee, in_equivalence);
conf (cray_pointee, threadprivate);
conf (cray_pointee, omp_declare_target);
conf (cray_pointee, omp_declare_target_link);
conf (cray_pointee, oacc_declare_create);
conf (cray_pointee, oacc_declare_copyin);
conf (cray_pointee, oacc_declare_deviceptr);
conf (cray_pointee, oacc_declare_device_resident);

conf (data, dummy);
conf (data, function);
conf (data, result);
conf (data, allocatable);

conf (value, pointer)
conf (value, allocatable)
conf (value, subroutine)
conf (value, function)
conf (value, volatile_)
conf (value, dimension)
conf (value, codimension)
conf (value, external)

conf (codimension, result)

if (attr->value
    && (attr->intent == INTENT_OUT || attr->intent == INTENT_INOUT))
  {
    a1 = value;
    a2 = attr->intent == INTENT_OUT ? intent_out : intent_inout;
    goto conflict;
  }

conf (is_protected, intrinsic)
conf (is_protected, in_common)

conf (asynchronous, intrinsic)
conf (asynchronous, external)

conf (volatile_, intrinsic)
conf (volatile_, external)

if (attr->volatile_ && attr->intent == INTENT_IN)
  {
    a1 = volatile_;
    a2 = intent_in;
    goto conflict;
  }

conf (procedure, allocatable)
conf (procedure, dimension)
conf (procedure, codimension)
conf (procedure, intrinsic)
conf (procedure, target)
conf (procedure, value)
conf (procedure, volatile_)
conf (procedure, asynchronous)
conf (procedure, entry)

conf (proc_pointer, abstract)
conf (proc_pointer, omp_declare_target)
conf (proc_pointer, omp_declare_target_link)

conf (entry, omp_declare_target)
conf (entry, omp_declare_target_link)
conf (entry, oacc_declare_create)
conf (entry, oacc_declare_copyin)
conf (entry, oacc_declare_deviceptr)
conf (entry, oacc_declare_device_resident)

conf (pdt_kind, allocatable)
conf (pdt_kind, pointer)
conf (pdt_kind, dimension)
conf (pdt_kind, codimension)

conf (pdt_len, allocatable)
conf (pdt_len, pointer)
conf (pdt_len, dimension)
conf (pdt_len, codimension)
conf (pdt_len, pdt_kind)

if (attr->access == ACCESS_PRIVATE)
  {
    a1 = privat;
    conf2 (pdt_kind);
    conf2 (pdt_len);
  }

a1 = gfc_code2string (flavors, attr->flavor);

if (attr->in_namelist
    && attr->flavor != FL_VARIABLE
    && attr->flavor != FL_PROCEDURE
    && attr->flavor != FL_UNKNOWN)
  {
    a2 = in_namelist;
    goto conflict;
  }

switch (attr->flavor)
  {
  case FL_PROGRAM:
  case FL_BLOCK_DATA:
  case FL_MODULE:
  case FL_LABEL:
    conf2 (codimension);
    conf2 (dimension);
    conf2 (dummy);
    conf2 (volatile_);
    conf2 (asynchronous);
    conf2 (contiguous);
    conf2 (pointer);
    conf2 (is_protected);
    conf2 (target);
    conf2 (external);
    conf2 (intrinsic);
    conf2 (allocatable);
    conf2 (result);
    conf2 (in_namelist);
    conf2 (optional);
    conf2 (function);
    conf2 (subroutine);
    conf2 (threadprivate);
    conf2 (omp_declare_target);
    conf2 (omp_declare_target_link);
    conf2 (oacc_declare_create);
    conf2 (oacc_declare_copyin);
    conf2 (oacc_declare_deviceptr);
    conf2 (oacc_declare_device_resident);

    if (attr->access == ACCESS_PUBLIC || attr->access == ACCESS_PRIVATE)
{
 a2 = attr->access == ACCESS_PUBLIC ? publik : privat;
 gfc_error ("%s attribute applied to %s %s at %L", a2, a1,
   name, where);
 return false;
}

    if (attr->is_bind_c)
{
 gfc_error_now ("BIND(C) applied to %s %s at %L", a1, name, where);
 return false;
}

    break;

  case FL_VARIABLE:
    break;

  case FL_NAMELIST:
    conf2 (result);
    break;

  case FL_PROCEDURE:
    /* Conflicts with INTENT, SAVE and RESULT will be checked
at resolution stage, see "resolve_fl_procedure".  */

    if (attr->subroutine)
{
 a1 = subroutine;
 conf2 (target);
 conf2 (allocatable);
 conf2 (volatile_);
 conf2 (asynchronous);
 conf2 (in_namelist);
 conf2 (codimension);
 conf2 (dimension);
 conf2 (function);
 if (!attr->proc_pointer)
   conf2 (threadprivate);
}

    /* Procedure pointers in COMMON blocks are allowed in F03,
     * but forbidden per F08:C5100.  */
    if (!attr->proc_pointer || (gfc_option.allow_std & GFC_STD_F2008(1<<7)))
conf2 (in_common);

    conf2 (omp_declare_target_link);

    switch (attr->proc)
{
case PROC_ST_FUNCTION:
 conf2 (dummy);
 conf2 (target);
 break;

case PROC_MODULE:
 conf2 (dummy);
 break;

case PROC_DUMMY:
 conf2 (result);
 conf2 (threadprivate);
 break;

default:
 break;
}

    break;

  case_fl_structcase FL_DERIVED: case FL_UNION: case FL_STRUCT:
    conf2 (dummy);
    conf2 (pointer);
    conf2 (target);
    conf2 (external);
    conf2 (intrinsic);
    conf2 (allocatable);
    conf2 (optional);
    conf2 (entry);
    conf2 (function);
    conf2 (subroutine);
    conf2 (threadprivate);
    conf2 (result);
    conf2 (omp_declare_target);
    conf2 (omp_declare_target_link);
    conf2 (oacc_declare_create);
    conf2 (oacc_declare_copyin);
    conf2 (oacc_declare_deviceptr);
    conf2 (oacc_declare_device_resident);

    if (attr->intent != INTENT_UNKNOWN)
{
 a2 = intent;
 goto conflict;
}
    break;

  case FL_PARAMETER:
    conf2 (external);
    conf2 (intrinsic);
    conf2 (optional);
    conf2 (allocatable);
    conf2 (function);
    conf2 (subroutine);
    conf2 (entry);
    conf2 (contiguous);
    conf2 (pointer);
    conf2 (is_protected);
    conf2 (target);
    conf2 (dummy);
    conf2 (in_common);
    conf2 (value);
    conf2 (volatile_);
    conf2 (asynchronous);
    conf2 (threadprivate);
    conf2 (value);
    conf2 (codimension);
    conf2 (result);
    if (!attr->is_iso_c)
conf2 (is_bind_c);
    break;

  default:
    break;
  }

return true;

903conflict:
if (name == NULL__null)
  gfc_error ("%s attribute conflicts with %s attribute at %L",
      a1, a2, where);
else
  gfc_error ("%s attribute conflicts with %s attribute in %qs at %L",
      a1, a2, name, where);

return false;

913conflict_std:
if (name == NULL__null)
  {
    return gfc_notify_std (standard, "%s attribute conflicts "
                           "with %s attribute at %L", a1, a2,
                           where);
  }
else
  {
    return gfc_notify_std (standard, "%s attribute conflicts "
	     "with %s attribute in %qs at %L",
                           a1, a2, name, where);
  }
926}

928#undef conf
929#undef conf2
930#undef conf_std


933/* Mark a symbol as referenced.  */

935void
936gfc_set_sym_referenced (gfc_symbol *sym)
937{

if (sym->attr.referenced)
  return;

sym->attr.referenced = 1;

/* Remember which order dummy variables are accessed in.  */
if (sym->attr.dummy)
  sym->dummy_order = next_dummy_order++;
947}


950/* Common subroutine called by attribute changing subroutines in order
 to prevent them from changing a symbol that has been
 use-associated.  Returns zero if it is OK to change the symbol,
 nonzero if not.  */

955static int
956check_used (symbol_attribute *attr, const char *name, locus *where)
957{

if (attr->use_assoc == 0)
  return 0;

if (where == NULL__null)
  where = &gfc_current_locus;

if (name == NULL__null)
  gfc_error ("Cannot change attributes of USE-associated symbol at %L",
      where);
else
  gfc_error ("Cannot change attributes of USE-associated symbol %s at %L",
      name, where);

return 1;
973}


976/* Generate an error because of a duplicate attribute.  */

978static void
979duplicate_attr (const char *attr, locus *where)
980{

if (where == NULL__null)
  where = &gfc_current_locus;

gfc_error ("Duplicate %s attribute specified at %L", attr, where);
986}


989bool
990gfc_add_ext_attribute (symbol_attribute *attr, ext_attr_id_t ext_attr,
       locus *where ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
992{
attr->ext_attr |= 1 << ext_attr;
return true;
995}


998/* Called from decl.cc (attr_decl1) to check attributes, when declared
 separately.  */

1001bool
1002gfc_add_attribute (symbol_attribute *attr, locus *where)
1003{
if (check_used (attr, NULL__null, where))
  return false;

return gfc_check_conflict (attr, NULL__null, where);
1008}


1011bool
1012gfc_add_allocatable (symbol_attribute *attr, locus *where)
1013{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->allocatable && ! gfc_submodule_procedure(attr)(gfc_state_stack->previous && gfc_state_stack->
previous->previous && gfc_state_stack->previous
->previous->state == COMP_SUBMODULE && attr->
module_procedure))
  {
    duplicate_attr ("ALLOCATABLE", where);
    return false;
  }

if (attr->flavor == FL_PROCEDURE && attr->if_source == IFSRC_IFBODY
    && !gfc_find_state (COMP_INTERFACE))
  {
    gfc_error ("ALLOCATABLE specified outside of INTERFACE body at %L",
 where);
    return false;
  }

attr->allocatable = 1;
return gfc_check_conflict (attr, NULL__null, where);
1034}


1037bool
1038gfc_add_automatic (symbol_attribute *attr, const char *name, locus *where)
1039{
if (check_used (attr, name, where))
  return false;

if (attr->automatic && !gfc_notify_std (GFC_STD_LEGACY(1<<6),
"Duplicate AUTOMATIC attribute specified at %L", where))
  return false;

attr->automatic = 1;
return gfc_check_conflict (attr, name, where);
1049}


1052bool
1053gfc_add_codimension (symbol_attribute *attr, const char *name, locus *where)
1054{

if (check_used (attr, name, where))
  return false;

if (attr->codimension)
  {
    duplicate_attr ("CODIMENSION", where);
    return false;
  }

if (attr->flavor == FL_PROCEDURE && attr->if_source == IFSRC_IFBODY
    && !gfc_find_state (COMP_INTERFACE))
  {
    gfc_error ("CODIMENSION specified for %qs outside its INTERFACE body "
 "at %L", name, where);
    return false;
  }

attr->codimension = 1;
return gfc_check_conflict (attr, name, where);
1075}


1078bool
1079gfc_add_dimension (symbol_attribute *attr, const char *name, locus *where)
1080{

if (check_used (attr, name, where))
  return false;

if (attr->dimension && ! gfc_submodule_procedure(attr)(gfc_state_stack->previous && gfc_state_stack->
previous->previous && gfc_state_stack->previous
->previous->state == COMP_SUBMODULE && attr->
module_procedure))
  {
    duplicate_attr ("DIMENSION", where);
    return false;
  }

if (attr->flavor == FL_PROCEDURE && attr->if_source == IFSRC_IFBODY
    && !gfc_find_state (COMP_INTERFACE))
  {
    gfc_error ("DIMENSION specified for %qs outside its INTERFACE body "
 "at %L", name, where);
    return false;
  }

attr->dimension = 1;
return gfc_check_conflict (attr, name, where);
1101}


1104bool
1105gfc_add_contiguous (symbol_attribute *attr, const char *name, locus *where)
1106{

if (check_used (attr, name, where))
  return false;

if (attr->contiguous)
  {
    duplicate_attr ("CONTIGUOUS", where);
    return false;
  }

attr->contiguous = 1;
return gfc_check_conflict (attr, name, where);
1119}


1122bool
1123gfc_add_external (symbol_attribute *attr, locus *where)
1124{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->external)
  {
    duplicate_attr ("EXTERNAL", where);
    return false;
  }

if (attr->pointer && attr->if_source != IFSRC_IFBODY)
  {
    attr->pointer = 0;
    attr->proc_pointer = 1;
  }

attr->external = 1;

return gfc_check_conflict (attr, NULL__null, where);
1144}


1147bool
1148gfc_add_intrinsic (symbol_attribute *attr, locus *where)
1149{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->intrinsic)
  {
    duplicate_attr ("INTRINSIC", where);
    return false;
  }

attr->intrinsic = 1;

return gfc_check_conflict (attr, NULL__null, where);
1163}


1166bool
1167gfc_add_optional (symbol_attribute *attr, locus *where)
1168{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->optional)
  {
    duplicate_attr ("OPTIONAL", where);
    return false;
  }

attr->optional = 1;
return gfc_check_conflict (attr, NULL__null, where);
1181}

1183bool
1184gfc_add_kind (symbol_attribute *attr, locus *where)
1185{
if (attr->pdt_kind)
  {
    duplicate_attr ("KIND", where);
    return false;
  }

attr->pdt_kind = 1;
return gfc_check_conflict (attr, NULL__null, where);
1194}

1196bool
1197gfc_add_len (symbol_attribute *attr, locus *where)
1198{
if (attr->pdt_len)
  {
    duplicate_attr ("LEN", where);
    return false;
  }

attr->pdt_len = 1;
return gfc_check_conflict (attr, NULL__null, where);
1207}


1210bool
1211gfc_add_pointer (symbol_attribute *attr, locus *where)
1212{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->pointer && !(attr->if_source == IFSRC_IFBODY
    && !gfc_find_state (COMP_INTERFACE))
    && ! gfc_submodule_procedure(attr)(gfc_state_stack->previous && gfc_state_stack->
previous->previous && gfc_state_stack->previous
->previous->state == COMP_SUBMODULE && attr->
module_procedure))
  {
    duplicate_attr ("POINTER", where);
    return false;
  }

if (attr->procedure || (attr->external && attr->if_source != IFSRC_IFBODY)
    || (attr->if_source == IFSRC_IFBODY
    && !gfc_find_state (COMP_INTERFACE)))
  attr->proc_pointer = 1;
else
  attr->pointer = 1;

return gfc_check_conflict (attr, NULL__null, where);
1233}


1236bool
1237gfc_add_cray_pointer (symbol_attribute *attr, locus *where)
1238{

if (check_used (attr, NULL__null, where))
  return false;

attr->cray_pointer = 1;
return gfc_check_conflict (attr, NULL__null, where);
1245}


1248bool
1249gfc_add_cray_pointee (symbol_attribute *attr, locus *where)
1250{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->cray_pointee)
  {
    gfc_error ("Cray Pointee at %L appears in multiple pointer()"
 " statements", where);
    return false;
  }

attr->cray_pointee = 1;
return gfc_check_conflict (attr, NULL__null, where);
1264}


1267bool
1268gfc_add_protected (symbol_attribute *attr, const char *name, locus *where)
1269{
if (check_used (attr, name, where))
  return false;

if (attr->is_protected)
  {
if (!gfc_notify_std (GFC_STD_LEGACY(1<<6),
	     "Duplicate PROTECTED attribute specified at %L",
	     where))
 return false;
  }

attr->is_protected = 1;
return gfc_check_conflict (attr, name, where);
1283}


1286bool
1287gfc_add_result (symbol_attribute *attr, const char *name, locus *where)
1288{

if (check_used (attr, name, where))
  return false;

attr->result = 1;
return gfc_check_conflict (attr, name, where);
1295}


1298bool
1299gfc_add_save (symbol_attribute *attr, save_state s, const char *name,
     locus *where)
1301{

if (check_used (attr, name, where))
  return false;

if (s == SAVE_EXPLICIT && gfc_pure (NULL__null))
  {
    gfc_error
("SAVE attribute at %L cannot be specified in a PURE procedure",
where);
    return false;
  }

if (s == SAVE_EXPLICIT)
  gfc_unset_implicit_pure (NULL__null);

if (s == SAVE_EXPLICIT && attr->save == SAVE_EXPLICIT
    && (flag_automaticglobal_options.x_flag_automatic || pedanticglobal_options.x_pedantic))
  {
if (!gfc_notify_std (GFC_STD_LEGACY(1<<6),
	     "Duplicate SAVE attribute specified at %L",
	     where))
 return false;
  }

attr->save = s;
return gfc_check_conflict (attr, name, where);
1328}


1331bool
1332gfc_add_value (symbol_attribute *attr, const char *name, locus *where)
1333{

if (check_used (attr, name, where))
  return false;

if (attr->value)
  {
if (!gfc_notify_std (GFC_STD_LEGACY(1<<6),
	     "Duplicate VALUE attribute specified at %L",
	     where))
 return false;
  }

attr->value = 1;
return gfc_check_conflict (attr, name, where);
1348}


1351bool
1352gfc_add_volatile (symbol_attribute *attr, const char *name, locus *where)
1353{
/* No check_used needed as 11.2.1 of the F2003 standard allows
   that the local identifier made accessible by a use statement can be
   given a VOLATILE attribute - unless it is a coarray (F2008, C560).  */

if (attr->volatile_ && attr->volatile_ns == gfc_current_ns)
  if (!gfc_notify_std (GFC_STD_LEGACY(1<<6),
	 "Duplicate VOLATILE attribute specified at %L",
	 where))
    return false;

/* F2008:  C1282 A designator of a variable with the VOLATILE attribute
   shall not appear in a pure subprogram.

   F2018: C1588 A local variable of a pure subprogram, or of a BLOCK
   construct within a pure subprogram, shall not have the SAVE or
   VOLATILE attribute.  */
if (gfc_pure (NULL__null))
  {
    gfc_error ("VOLATILE attribute at %L cannot be specified in a "
 "PURE procedure", where);
    return false;
  }


attr->volatile_ = 1;
attr->volatile_ns = gfc_current_ns;
return gfc_check_conflict (attr, name, where);
1381}


1384bool
1385gfc_add_asynchronous (symbol_attribute *attr, const char *name, locus *where)
1386{
/* No check_used needed as 11.2.1 of the F2003 standard allows
   that the local identifier made accessible by a use statement can be
   given a ASYNCHRONOUS attribute.  */

if (attr->asynchronous && attr->asynchronous_ns == gfc_current_ns)
  if (!gfc_notify_std (GFC_STD_LEGACY(1<<6),
	 "Duplicate ASYNCHRONOUS attribute specified at %L",
	 where))
    return false;

attr->asynchronous = 1;
attr->asynchronous_ns = gfc_current_ns;
return gfc_check_conflict (attr, name, where);
1400}


1403bool
1404gfc_add_threadprivate (symbol_attribute *attr, const char *name, locus *where)
1405{

if (check_used (attr, name, where))
  return false;

if (attr->threadprivate)
  {
    duplicate_attr ("THREADPRIVATE", where);
    return false;
  }

attr->threadprivate = 1;
return gfc_check_conflict (attr, name, where);
1418}


1421bool
1422gfc_add_omp_declare_target (symbol_attribute *attr, const char *name,
	    locus *where)
1424{

if (check_used (attr, name, where))
  return false;

if (attr->omp_declare_target)
  return true;

attr->omp_declare_target = 1;
return gfc_check_conflict (attr, name, where);
1434}


1437bool
1438gfc_add_omp_declare_target_link (symbol_attribute *attr, const char *name,
		 locus *where)
1440{

if (check_used (attr, name, where))
  return false;

if (attr->omp_declare_target_link)
  return true;

attr->omp_declare_target_link = 1;
return gfc_check_conflict (attr, name, where);
1450}


1453bool
1454gfc_add_oacc_declare_create (symbol_attribute *attr, const char *name,
	     locus *where)
1456{
if (check_used (attr, name, where))
  return false;

if (attr->oacc_declare_create)
  return true;

attr->oacc_declare_create = 1;
return gfc_check_conflict (attr, name, where);
1465}


1468bool
1469gfc_add_oacc_declare_copyin (symbol_attribute *attr, const char *name,
	     locus *where)
1471{
if (check_used (attr, name, where))
  return false;

if (attr->oacc_declare_copyin)
  return true;

attr->oacc_declare_copyin = 1;
return gfc_check_conflict (attr, name, where);
1480}


1483bool
1484gfc_add_oacc_declare_deviceptr (symbol_attribute *attr, const char *name,
		locus *where)
1486{
if (check_used (attr, name, where))
  return false;

if (attr->oacc_declare_deviceptr)
  return true;

attr->oacc_declare_deviceptr = 1;
return gfc_check_conflict (attr, name, where);
1495}


1498bool
1499gfc_add_oacc_declare_device_resident (symbol_attribute *attr, const char *name,
		      locus *where)
1501{
if (check_used (attr, name, where))
  return false;

if (attr->oacc_declare_device_resident)
  return true;

attr->oacc_declare_device_resident = 1;
return gfc_check_conflict (attr, name, where);
1510}


1513bool
1514gfc_add_target (symbol_attribute *attr, locus *where)
1515{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->target)
  {
    duplicate_attr ("TARGET", where);
    return false;
  }

attr->target = 1;
return gfc_check_conflict (attr, NULL__null, where);
1528}


1531bool
1532gfc_add_dummy (symbol_attribute *attr, const char *name, locus *where)
1533{

if (check_used (attr, name, where))
  return false;

/* Duplicate dummy arguments are allowed due to ENTRY statements.  */
attr->dummy = 1;
return gfc_check_conflict (attr, name, where);
1541}


1544bool
1545gfc_add_in_common (symbol_attribute *attr, const char *name, locus *where)
1546{

if (check_used (attr, name, where))
  return false;

/* Duplicate attribute already checked for.  */
attr->in_common = 1;
return gfc_check_conflict (attr, name, where);
1554}


1557bool
1558gfc_add_in_equivalence (symbol_attribute *attr, const char *name, locus *where)
1559{

/* Duplicate attribute already checked for.  */
attr->in_equivalence = 1;
if (!gfc_check_conflict (attr, name, where))
  return false;

if (attr->flavor == FL_VARIABLE)
  return true;

return gfc_add_flavor (attr, FL_VARIABLE, name, where);
1570}


1573bool
1574gfc_add_data (symbol_attribute *attr, const char *name, locus *where)
1575{

if (check_used (attr, name, where))
  return false;

attr->data = 1;
return gfc_check_conflict (attr, name, where);
1582}


1585bool
1586gfc_add_in_namelist (symbol_attribute *attr, const char *name, locus *where)
1587{

attr->in_namelist = 1;
return gfc_check_conflict (attr, name, where);
1591}


1594bool
1595gfc_add_sequence (symbol_attribute *attr, const char *name, locus *where)
1596{

if (check_used (attr, name, where))
  return false;

attr->sequence = 1;
return gfc_check_conflict (attr, name, where);
1603}


1606bool
1607gfc_add_elemental (symbol_attribute *attr, locus *where)
1608{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->elemental)
  {
    duplicate_attr ("ELEMENTAL", where);
    return false;
  }

attr->elemental = 1;
return gfc_check_conflict (attr, NULL__null, where);
1621}


1624bool
1625gfc_add_pure (symbol_attribute *attr, locus *where)
1626{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->pure)
  {
    duplicate_attr ("PURE", where);
    return false;
  }

attr->pure = 1;
return gfc_check_conflict (attr, NULL__null, where);
1639}


1642bool
1643gfc_add_recursive (symbol_attribute *attr, locus *where)
1644{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->recursive)
  {
    duplicate_attr ("RECURSIVE", where);
    return false;
  }

attr->recursive = 1;
return gfc_check_conflict (attr, NULL__null, where);
1657}


1660bool
1661gfc_add_entry (symbol_attribute *attr, const char *name, locus *where)
1662{

if (check_used (attr, name, where))
  return false;

if (attr->entry)
  {
    duplicate_attr ("ENTRY", where);
    return false;
  }

attr->entry = 1;
return gfc_check_conflict (attr, name, where);
1675}


1678bool
1679gfc_add_function (symbol_attribute *attr, const char *name, locus *where)
1680{

if (attr->flavor != FL_PROCEDURE
    && !gfc_add_flavor (attr, FL_PROCEDURE, name, where))
  return false;

attr->function = 1;
return gfc_check_conflict (attr, name, where);
1688}


1691bool
1692gfc_add_subroutine (symbol_attribute *attr, const char *name, locus *where)
1693{

if (attr->flavor != FL_PROCEDURE
    && !gfc_add_flavor (attr, FL_PROCEDURE, name, where))
  return false;

attr->subroutine = 1;

/* If we are looking at a BLOCK DATA statement and we encounter a
   name with a leading underscore (which must be
   compiler-generated), do not check. See PR 84394.  */

if (name && *name != '_' && gfc_current_state ()(gfc_state_stack->state) != COMP_BLOCK_DATA)
  return gfc_check_conflict (attr, name, where);
else
  return true;
1709}


1712bool
1713gfc_add_generic (symbol_attribute *attr, const char *name, locus *where)
1714{

if (attr->flavor != FL_PROCEDURE
    && !gfc_add_flavor (attr, FL_PROCEDURE, name, where))
  return false;

attr->generic = 1;
return gfc_check_conflict (attr, name, where);
1722}


1725bool
1726gfc_add_proc (symbol_attribute *attr, const char *name, locus *where)
1727{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->flavor != FL_PROCEDURE
    && !gfc_add_flavor (attr, FL_PROCEDURE, name, where))
  return false;

if (attr->procedure)
  {
    duplicate_attr ("PROCEDURE", where);
    return false;
  }

attr->procedure = 1;

return gfc_check_conflict (attr, NULL__null, where);
1745}


1748bool
1749gfc_add_abstract (symbol_attribute* attr, locus* where)
1750{
if (attr->abstract)
  {
    duplicate_attr ("ABSTRACT", where);
    return false;
  }

attr->abstract = 1;

return gfc_check_conflict (attr, NULL__null, where);
1760}


1763/* Flavors are special because some flavors are not what Fortran
 considers attributes and can be reaffirmed multiple times.  */

1766bool
1767gfc_add_flavor (symbol_attribute *attr, sym_flavor f, const char *name,
locus *where)
1769{

if ((f == FL_PROGRAM || f == FL_BLOCK_DATA || f == FL_MODULE
     || f == FL_PARAMETER || f == FL_LABEL || gfc_fl_struct(f)((f) == FL_DERIVED || (f) == FL_UNION || (f) == FL_STRUCT)
     || f == FL_NAMELIST) && check_used (attr, name, where))
  return false;

if (attr->flavor == f && f == FL_VARIABLE)
  return true;

/* Copying a procedure dummy argument for a module procedure in a
   submodule results in the flavor being copied and would result in
   an error without this.  */
if (attr->flavor == f && f == FL_PROCEDURE
    && gfc_new_block && gfc_new_block->abr_modproc_decl)
  return true;

if (attr->flavor != FL_UNKNOWN)
  {
    if (where == NULL__null)
where = &gfc_current_locus;

    if (name)
      gfc_error ("%s attribute of %qs conflicts with %s attribute at %L",
   gfc_code2string (flavors, attr->flavor), name,
   gfc_code2string (flavors, f), where);
    else
      gfc_error ("%s attribute conflicts with %s attribute at %L",
   gfc_code2string (flavors, attr->flavor),
   gfc_code2string (flavors, f), where);

    return false;
  }

attr->flavor = f;

return gfc_check_conflict (attr, name, where);
1806}


1809bool
1810gfc_add_procedure (symbol_attribute *attr, procedure_type t,
   const char *name, locus *where)
1812{

if (check_used (attr, name, where))
  return false;

if (attr->flavor != FL_PROCEDURE
    && !gfc_add_flavor (attr, FL_PROCEDURE, name, where))
  return false;

if (where == NULL__null)
  where = &gfc_current_locus;

if (attr->proc != PROC_UNKNOWN && !attr->module_procedure
    && attr->access == ACCESS_UNKNOWN)
  {
    if (attr->proc == PROC_ST_FUNCTION && t == PROC_INTERNAL
 && !gfc_notification_std (GFC_STD_F2008(1<<7)))
gfc_error ("%s procedure at %L is already declared as %s "
   "procedure. \nF2008: A pointer function assignment "
   "is ambiguous if it is the first executable statement "
   "after the specification block. Please add any other "
   "kind of executable statement before it. FIXME",
 gfc_code2string (procedures, t), where,
 gfc_code2string (procedures, attr->proc));
    else
gfc_error ("%s procedure at %L is already declared as %s "
   "procedure", gfc_code2string (procedures, t), where,
   gfc_code2string (procedures, attr->proc));

    return false;
  }

attr->proc = t;

/* Statement functions are always scalar and functions.  */
if (t == PROC_ST_FUNCTION
    && ((!attr->function && !gfc_add_function (attr, name, where))
 || attr->dimension))
  return false;

return gfc_check_conflict (attr, name, where);
1853}


1856bool
1857gfc_add_intent (symbol_attribute *attr, sym_intent intent, locus *where)
1858{

if (check_used (attr, NULL__null, where))
  return false;

if (attr->intent == INTENT_UNKNOWN)
  {
    attr->intent = intent;
    return gfc_check_conflict (attr, NULL__null, where);
  }

if (where == NULL__null)
  where = &gfc_current_locus;

gfc_error ("INTENT (%s) conflicts with INTENT(%s) at %L",
    gfc_intent_string (attr->intent),
    gfc_intent_string (intent), where);

return false;
1877}


1880/* No checks for use-association in public and private statements.  */

1882bool
1883gfc_add_access (symbol_attribute *attr, gfc_access access,
const char *name, locus *where)
1885{

if (attr->access == ACCESS_UNKNOWN
|| (attr->use_assoc && attr->access != ACCESS_PRIVATE))
  {
    attr->access = access;
    return gfc_check_conflict (attr, name, where);
  }

if (where == NULL__null)
  where = &gfc_current_locus;
gfc_error ("ACCESS specification at %L was already specified", where);

return false;
1899}


1902/* Set the is_bind_c field for the given symbol_attribute.  */

1904bool
1905gfc_add_is_bind_c (symbol_attribute *attr, const char *name, locus *where,
                 int is_proc_lang_bind_spec)
1907{

if (is_proc_lang_bind_spec == 0 && attr->flavor == FL_PROCEDURE)
  gfc_error_now ("BIND(C) attribute at %L can only be used for "
   "variables or common blocks", where);
else if (attr->is_bind_c)
  gfc_error_now ("Duplicate BIND attribute specified at %L", where);
else
  attr->is_bind_c = 1;

if (where == NULL__null)
  where = &gfc_current_locus;

if (!gfc_notify_std (GFC_STD_F2003(1<<4), "BIND(C) at %L", where))
  return false;

return gfc_check_conflict (attr, name, where);
1924}


1927/* Set the extension field for the given symbol_attribute.  */

1929bool
1930gfc_add_extension (symbol_attribute *attr, locus *where)
1931{
if (where == NULL__null)
  where = &gfc_current_locus;

if (attr->extension)
  gfc_error_now ("Duplicate EXTENDS attribute specified at %L", where);
else
  attr->extension = 1;

if (!gfc_notify_std (GFC_STD_F2003(1<<4), "EXTENDS at %L", where))
  return false;

return true;
1944}


1947bool
1948gfc_add_explicit_interface (gfc_symbol *sym, ifsrc source,
	    gfc_formal_arglist * formal, locus *where)
1950{
if (check_used (&sym->attr, sym->name, where))
  return false;

/* Skip the following checks in the case of a module_procedures in a
   submodule since they will manifestly fail.  */
if (sym->attr.module_procedure == 1
    && source == IFSRC_DECL)
  goto finish;

if (where == NULL__null)
  where = &gfc_current_locus;

if (sym->attr.if_source != IFSRC_UNKNOWN
    && sym->attr.if_source != IFSRC_DECL)
  {
    gfc_error ("Symbol %qs at %L already has an explicit interface",
 sym->name, where);
    return false;
  }

if (source == IFSRC_IFBODY && (sym->attr.dimension || sym->attr.allocatable))
  {
    gfc_error ("%qs at %L has attributes specified outside its INTERFACE "
 "body", sym->name, where);
    return false;
  }

1978finish:
sym->formal = formal;
sym->attr.if_source = source;

return true;
1983}


1986/* Add a type to a symbol.  */

1988bool
1989gfc_add_type (gfc_symbol *sym, gfc_typespec *ts, locus *where)
1990{
sym_flavor flavor;
bt type;

if (where == NULL__null)
  where = &gfc_current_locus;

if (sym->result)
  type = sym->result->ts.type;
else
  type = sym->ts.type;

if (sym->attr.result && type == BT_UNKNOWN && sym->ns->proc_name)
  type = sym->ns->proc_name->ts.type;

if (type != BT_UNKNOWN && !(sym->attr.function && sym->attr.implicit_type)
    && !(gfc_state_stack->previous && gfc_state_stack->previous->previous
  && gfc_state_stack->previous->previous->state == COMP_SUBMODULE)
    && !sym->attr.module_procedure)
  {
    if (sym->attr.use_assoc)
gfc_error ("Symbol %qs at %L conflicts with symbol from module %qs, "
   "use-associated at %L", sym->name, where, sym->module,
   &sym->declared_at);
    else if (sym->attr.function && sym->attr.result)
gfc_error ("Symbol %qs at %L already has basic type of %s",
   sym->ns->proc_name->name, where, gfc_basic_typename (type));
    else
gfc_error ("Symbol %qs at %L already has basic type of %s", sym->name,
   where, gfc_basic_typename (type));
    return false;
  }

if (sym->attr.procedure && sym->ts.interface)
  {
    gfc_error ("Procedure %qs at %L may not have basic type of %s",
 sym->name, where, gfc_basic_typename (ts->type));
    return false;
  }

flavor = sym->attr.flavor;

if (flavor == FL_PROGRAM || flavor == FL_BLOCK_DATA || flavor == FL_MODULE
    || flavor == FL_LABEL
    || (flavor == FL_PROCEDURE && sym->attr.subroutine)
    || flavor == FL_DERIVED || flavor == FL_NAMELIST)
  {
    gfc_error ("Symbol %qs at %L cannot have a type",
 sym->ns->proc_name ? sym->ns->proc_name->name : sym->name,
 where);
    return false;
  }

sym->ts = *ts;
return true;
2045}


2048/* Clears all attributes.  */

2050void
2051gfc_clear_attr (symbol_attribute *attr)
2052{
memset (attr, 0, sizeof (symbol_attribute));
2054}


2057/* Check for missing attributes in the new symbol.  Currently does
 nothing, but it's not clear that it is unnecessary yet.  */

2060bool
2061gfc_missing_attr (symbol_attribute *attr ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  locus *where ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2063{

return true;
2066}


2069/* Copy an attribute to a symbol attribute, bit by bit.  Some
 attributes have a lot of side-effects but cannot be present given
 where we are called from, so we ignore some bits.  */

2073bool
2074gfc_copy_attr (symbol_attribute *dest, symbol_attribute *src, locus *where)
2075{
int is_proc_lang_bind_spec;

/* In line with the other attributes, we only add bits but do not remove
   them; cf. also PR 41034.  */
dest->ext_attr |= src->ext_attr;

if (src->allocatable && !gfc_add_allocatable (dest, where))
  goto fail;

if (src->automatic && !gfc_add_automatic (dest, NULL__null, where))
  goto fail;
if (src->dimension && !gfc_add_dimension (dest, NULL__null, where))
  goto fail;
if (src->codimension && !gfc_add_codimension (dest, NULL__null, where))
  goto fail;
if (src->contiguous && !gfc_add_contiguous (dest, NULL__null, where))
  goto fail;
if (src->optional && !gfc_add_optional (dest, where))
  goto fail;
if (src->pointer && !gfc_add_pointer (dest, where))
  goto fail;
if (src->is_protected && !gfc_add_protected (dest, NULL__null, where))
  goto fail;
if (src->save && !gfc_add_save (dest, src->save, NULL__null, where))
  goto fail;
if (src->value && !gfc_add_value (dest, NULL__null, where))
  goto fail;
if (src->volatile_ && !gfc_add_volatile (dest, NULL__null, where))
  goto fail;
if (src->asynchronous && !gfc_add_asynchronous (dest, NULL__null, where))
  goto fail;
if (src->threadprivate
    && !gfc_add_threadprivate (dest, NULL__null, where))
  goto fail;
if (src->omp_declare_target
    && !gfc_add_omp_declare_target (dest, NULL__null, where))
  goto fail;
if (src->omp_declare_target_link
    && !gfc_add_omp_declare_target_link (dest, NULL__null, where))
  goto fail;
if (src->oacc_declare_create
    && !gfc_add_oacc_declare_create (dest, NULL__null, where))
  goto fail;
if (src->oacc_declare_copyin
    && !gfc_add_oacc_declare_copyin (dest, NULL__null, where))
  goto fail;
if (src->oacc_declare_deviceptr
    && !gfc_add_oacc_declare_deviceptr (dest, NULL__null, where))
  goto fail;
if (src->oacc_declare_device_resident
    && !gfc_add_oacc_declare_device_resident (dest, NULL__null, where))
  goto fail;
if (src->target && !gfc_add_target (dest, where))
  goto fail;
if (src->dummy && !gfc_add_dummy (dest, NULL__null, where))
  goto fail;
if (src->result && !gfc_add_result (dest, NULL__null, where))
  goto fail;
if (src->entry)
  dest->entry = 1;

if (src->in_namelist && !gfc_add_in_namelist (dest, NULL__null, where))
  goto fail;

if (src->in_common && !gfc_add_in_common (dest, NULL__null, where))
  goto fail;

if (src->generic && !gfc_add_generic (dest, NULL__null, where))
  goto fail;
if (src->function && !gfc_add_function (dest, NULL__null, where))
  goto fail;
if (src->subroutine && !gfc_add_subroutine (dest, NULL__null, where))
  goto fail;

if (src->sequence && !gfc_add_sequence (dest, NULL__null, where))
  goto fail;
if (src->elemental && !gfc_add_elemental (dest, where))
  goto fail;
if (src->pure && !gfc_add_pure (dest, where))
  goto fail;
if (src->recursive && !gfc_add_recursive (dest, where))
  goto fail;

if (src->flavor != FL_UNKNOWN
    && !gfc_add_flavor (dest, src->flavor, NULL__null, where))
  goto fail;

if (src->intent != INTENT_UNKNOWN
    && !gfc_add_intent (dest, src->intent, where))
  goto fail;

if (src->access != ACCESS_UNKNOWN
    && !gfc_add_access (dest, src->access, NULL__null, where))
  goto fail;

if (!gfc_missing_attr (dest, where))
  goto fail;

if (src->cray_pointer && !gfc_add_cray_pointer (dest, where))
  goto fail;
if (src->cray_pointee && !gfc_add_cray_pointee (dest, where))
  goto fail;

is_proc_lang_bind_spec = (src->flavor == FL_PROCEDURE ? 1 : 0);
if (src->is_bind_c
    && !gfc_add_is_bind_c (dest, NULL__null, where, is_proc_lang_bind_spec))
  return false;

if (src->is_c_interop)
  dest->is_c_interop = 1;
if (src->is_iso_c)
  dest->is_iso_c = 1;

if (src->external && !gfc_add_external (dest, where))
  goto fail;
if (src->intrinsic && !gfc_add_intrinsic (dest, where))
  goto fail;
if (src->proc_pointer)
  dest->proc_pointer = 1;

return true;

2198fail:
return false;
2200}


2203/* A function to generate a dummy argument symbol using that from the
 interface declaration. Can be used for the result symbol as well if
 the flag is set.  */

2207int
2208gfc_copy_dummy_sym (gfc_symbol **dsym, gfc_symbol *sym, int result)
2209{
int rc;

rc = gfc_get_symbol (sym->name, NULL__null, dsym);
if (rc)
  return rc;

if (!gfc_add_type (*dsym, &(sym->ts), &gfc_current_locus))
  return 1;

if (!gfc_copy_attr (&(*dsym)->attr, &(sym->attr),
    &gfc_current_locus))
  return 1;

if ((*dsym)->attr.dimension)
  (*dsym)->as = gfc_copy_array_spec (sym->as);

(*dsym)->attr.class_ok = sym->attr.class_ok;

if ((*dsym) != NULL__null && !result
    && (!gfc_add_dummy(&(*dsym)->attr, (*dsym)->name, NULL__null)
 || !gfc_missing_attr (&(*dsym)->attr, NULL__null)))
  return 1;
else if ((*dsym) != NULL__null && result
    && (!gfc_add_result(&(*dsym)->attr, (*dsym)->name, NULL__null)
 || !gfc_missing_attr (&(*dsym)->attr, NULL__null)))
  return 1;

return 0;
2238}


2241/************** Component name management ************/

2243/* Component names of a derived type form their own little namespaces
 that are separate from all other spaces.  The space is composed of
 a singly linked list of gfc_component structures whose head is
 located in the parent symbol.  */


2249/* Add a component name to a symbol.  The call fails if the name is
 already present.  On success, the component pointer is modified to
 point to the additional component structure.  */

2253bool
2254gfc_add_component (gfc_symbol *sym, const char *name,
   gfc_component **component)
2256{
gfc_component *p, *tail;

/* Check for existing components with the same name, but not for union
   components or containers. Unions and maps are anonymous so they have
   unique internal names which will never conflict.
   Don't use gfc_find_component here because it calls gfc_use_derived,
   but the derived type may not be fully defined yet. */
tail = NULL__null;

for (p = sym->components; p; p = p->next)
  {
    if (strcmp (p->name, name) == 0)
{
 gfc_error ("Component %qs at %C already declared at %L",
     name, &p->loc);
 return false;
}

    tail = p;
  }

if (sym->attr.extension
&& gfc_find_component (sym->components->ts.u.derived,
                             name, true, true, NULL__null))
  {
    gfc_error ("Component %qs at %C already in the parent type "
 "at %L", name, &sym->components->ts.u.derived->declared_at);
    return false;
  }

/* Allocate a new component.  */
p = gfc_get_component ()((gfc_component *) xcalloc (1, sizeof (gfc_component)));

if (tail == NULL__null)
  sym->components = p;
else
  tail->next = p;

p->name = gfc_get_string ("%s", name);
p->loc = gfc_current_locus;
p->ts.type = BT_UNKNOWN;

*component = p;
return true;
2301}


2304/* Recursive function to switch derived types of all symbol in a
 namespace.  */

2307static void
2308switch_types (gfc_symtree *st, gfc_symbol *from, gfc_symbol *to)
2309{
gfc_symbol *sym;

if (st == NULL__null)
  return;

sym = st->n.sym;
if (sym->ts.type == BT_DERIVED && sym->ts.u.derived == from)
  sym->ts.u.derived = to;

switch_types (st->left, from, to);
switch_types (st->right, from, to);
2321}


2324/* This subroutine is called when a derived type is used in order to
 make the final determination about which version to use.  The
 standard requires that a type be defined before it is 'used', but
 such types can appear in IMPLICIT statements before the actual
 definition.  'Using' in this context means declaring a variable to
 be that type or using the type constructor.

 If a type is used and the components haven't been defined, then we
 have to have a derived type in a parent unit.  We find the node in
 the other namespace and point the symtree node in this namespace to
 that node.  Further reference to this name point to the correct
 node.  If we can't find the node in a parent namespace, then we have
 an error.

 This subroutine takes a pointer to a symbol node and returns a
 pointer to the translated node or NULL for an error.  Usually there
 is no translation and we return the node we were passed.  */

2342gfc_symbol *
2343gfc_use_derived (gfc_symbol *sym)
2344{
gfc_symbol *s;
gfc_typespec *t;
gfc_symtree *st;
int i;

if (!sym)
  return NULL__null;

if (sym->attr.unlimited_polymorphic)
  return sym;

if (sym->attr.generic)
  sym = gfc_find_dt_in_generic (sym);

if (sym->components != NULL__null || sym->attr.zero_comp)
  return sym;               /* Already defined.  */

if (sym->ns->parent == NULL__null)
  goto bad;

if (gfc_find_symbol (sym->name, sym->ns->parent, 1, &s))
  {
    gfc_error ("Symbol %qs at %C is ambiguous", sym->name);
    return NULL__null;
  }

if (s == NULL__null || !gfc_fl_struct (s->attr.flavor)((s->attr.flavor) == FL_DERIVED || (s->attr.flavor) == FL_UNION
 || (s->attr.flavor) == FL_STRUCT))
  goto bad;

/* Get rid of symbol sym, translating all references to s.  */
for (i = 0; i < GFC_LETTERS26; i++)
  {
    t = &sym->ns->default_type[i];
    if (t->u.derived == sym)
t->u.derived = s;
  }

st = gfc_find_symtree (sym->ns->sym_root, sym->name);
st->n.sym = s;

s->refs++;

/* Unlink from list of modified symbols.  */
gfc_commit_symbol (sym);

switch_types (sym->ns->sym_root, sym, s);

/* TODO: Also have to replace sym -> s in other lists like
   namelists, common lists and interface lists.  */
gfc_free_symbol (sym);

return s;

2398bad:
gfc_error ("Derived type %qs at %C is being used before it is defined",
    sym->name);
return NULL__null;
2402}


2405/* Find the component with the given name in the union type symbol.
 If ref is not NULL it will be set to the chain of components through which
 the component can actually be accessed. This is necessary for unions because
 intermediate structures may be maps, nested structures, or other unions,
 all of which may (or must) be 'anonymous' to user code.  */

2411static gfc_component *
2412find_union_component (gfc_symbol *un, const char *name,
                    bool noaccess, gfc_ref **ref)
2414{
gfc_component *m, *check;
gfc_ref *sref, *tmp;

for (m = un->components; m; m = m->next)
  {
    check = gfc_find_component (m->ts.u.derived, name, noaccess, true, &tmp);
    if (check == NULL__null)
      continue;

    /* Found component somewhere in m; chain the refs together.  */
    if (ref)
      {
        /* Map ref. */
        sref = gfc_get_ref ()((gfc_ref *) xcalloc (1, sizeof (gfc_ref)));
        sref->type = REF_COMPONENT;
        sref->u.c.component = m;
        sref->u.c.sym = m->ts.u.derived;
        sref->next = tmp;

        *ref = sref;
      }
    /* Other checks (such as access) were done in the recursive calls.  */
    return check;
  }
return NULL__null;
2440}


2443/* Recursively append candidate COMPONENT structures to CANDIDATES.  Store
 the number of total candidates in CANDIDATES_LEN.  */

2446static void
2447lookup_component_fuzzy_find_candidates (gfc_component *component,
			char **&candidates,
			size_t &candidates_len)
2450{
for (gfc_component *p = component; p; p = p->next)
  vec_push (candidates, candidates_len, p->name);
2453}


2456/* Lookup component MEMBER fuzzily, taking names in COMPONENT into account.  */

2458static const char*
2459lookup_component_fuzzy (const char *member, gfc_component *component)
2460{
char **candidates = NULL__null;
size_t candidates_len = 0;
lookup_component_fuzzy_find_candidates (component, candidates,
			  candidates_len);
return gfc_closest_fuzzy_match (member, candidates);
2466}


2469/* Given a derived type node and a component name, try to locate the
 component structure.  Returns the NULL pointer if the component is
 not found or the components are private.  If noaccess is set, no access
 checks are done.  If silent is set, an error will not be generated if
 the component cannot be found or accessed.

 If ref is not NULL, *ref is set to represent the chain of components
 required to get to the ultimate component.

 If the component is simply a direct subcomponent, or is inherited from a
 parent derived type in the given derived type, this is a single ref with its
 component set to the returned component.

 Otherwise, *ref is constructed as a chain of subcomponents. This occurs
 when the component is found through an implicit chain of nested union and
 map components. Unions and maps are "anonymous" substructures in FORTRAN
 which cannot be explicitly referenced, but the reference chain must be
 considered as in C for backend translation to correctly compute layouts.
 (For example, x.a may refer to x->(UNION)->(MAP)->(UNION)->(MAP)->a).  */

2489gfc_component *
2490gfc_find_component (gfc_symbol *sym, const char *name,
    bool noaccess, bool silent, gfc_ref **ref)
2492{
gfc_component *p, *check;
gfc_ref *sref = NULL__null, *tmp = NULL__null;

if (name == NULL__null || sym == NULL__null)
  return NULL__null;

if (sym->attr.flavor == FL_DERIVED)
  sym = gfc_use_derived (sym);
else
  gcc_assert (gfc_fl_struct (sym->attr.flavor))((void)(!(((sym->attr.flavor) == FL_DERIVED || (sym->attr
.flavor) == FL_UNION || (sym->attr.flavor) == FL_STRUCT)) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 2502, __FUNCTION__), 0 : 0));

if (sym == NULL__null)
  return NULL__null;

/* Handle UNIONs specially - mutually recursive with gfc_find_component. */
if (sym->attr.flavor == FL_UNION)
  return find_union_component (sym, name, noaccess, ref);

if (ref) *ref = NULL__null;
for (p = sym->components; p; p = p->next)
  {
    /* Nest search into union's maps. */
    if (p->ts.type == BT_UNION)
      {
        check = find_union_component (p->ts.u.derived, name, noaccess, &tmp);
        if (check != NULL__null)
          {
            /* Union ref. */
            if (ref)
              {
                sref = gfc_get_ref ()((gfc_ref *) xcalloc (1, sizeof (gfc_ref)));
                sref->type = REF_COMPONENT;
                sref->u.c.component = p;
                sref->u.c.sym = p->ts.u.derived;
                sref->next = tmp;
                *ref = sref;
              }
            return check;
          }
      }
    else if (strcmp (p->name, name) == 0)
      break;

    continue;
  }

if (p && sym->attr.use_assoc && !noaccess)
  {
    bool is_parent_comp = sym->attr.extension && (p == sym->components);
    if (p->attr.access == ACCESS_PRIVATE ||
 (p->attr.access != ACCESS_PUBLIC
  && sym->component_access == ACCESS_PRIVATE
  && !is_parent_comp))
{
 if (!silent)
   gfc_error ("Component %qs at %C is a PRIVATE component of %qs",
       name, sym->name);
 return NULL__null;
}
  }

if (p == NULL__null
&& sym->attr.extension
&& sym->components->ts.type == BT_DERIVED)
  {
    p = gfc_find_component (sym->components->ts.u.derived, name,
	      noaccess, silent, ref);
    /* Do not overwrite the error.  */
    if (p == NULL__null)
return p;
  }

if (p == NULL__null && !silent)
  {
    const char *guessed = lookup_component_fuzzy (name, sym->components);
    if (guessed)
gfc_error ("%qs at %C is not a member of the %qs structure"
   "; did you mean %qs?",
   name, sym->name, guessed);
    else
gfc_error ("%qs at %C is not a member of the %qs structure",
   name, sym->name);
  }

/* Component was found; build the ultimate component reference. */
if (p != NULL__null && ref)
  {
    tmp = gfc_get_ref ()((gfc_ref *) xcalloc (1, sizeof (gfc_ref)));
    tmp->type = REF_COMPONENT;
    tmp->u.c.component = p;
    tmp->u.c.sym = sym;
    /* Link the final component ref to the end of the chain of subrefs. */
    if (sref)
      {
        *ref = sref;
        for (; sref->next; sref = sref->next)
          ;
        sref->next = tmp;
      }
    else
      *ref = tmp;
  }

return p;
2597}


2600/* Given a symbol, free all of the component structures and everything
 they point to.  */

2603static void
2604free_components (gfc_component *p)
2605{
gfc_component *q;

for (; p; p = q)
  {
    q = p->next;

    gfc_free_array_spec (p->as);
    gfc_free_expr (p->initializer);
    if (p->kind_expr)
gfc_free_expr (p->kind_expr);
    if (p->param_list)
gfc_free_actual_arglist (p->param_list);
    free (p->tb);
    p->tb = NULL__null;
    free (p);
  }
2622}


2625/******************** Statement label management ********************/

2627/* Comparison function for statement labels, used for managing the
 binary tree.  */

2630static int
2631compare_st_labels (void *a1, void *b1)
2632{
int a = ((gfc_st_label *) a1)->value;
int b = ((gfc_st_label *) b1)->value;

return (b - a);
2637}


2640/* Free a single gfc_st_label structure, making sure the tree is not
 messed up.  This function is called only when some parse error
 occurs.  */

2644void
2645gfc_free_st_label (gfc_st_label *label)
2646{

if (label == NULL__null)
  return;

gfc_delete_bbt (&label->ns->st_labels, label, compare_st_labels);

if (label->format != NULL__null)
  gfc_free_expr (label->format);

free (label);
2657}


2660/* Free a whole tree of gfc_st_label structures.  */

2662static void
2663free_st_labels (gfc_st_label *label)
2664{

if (label == NULL__null)
  return;

free_st_labels (label->left);
free_st_labels (label->right);

if (label->format != NULL__null)
  gfc_free_expr (label->format);
free (label);
2675}


2678/* Given a label number, search for and return a pointer to the label
 structure, creating it if it does not exist.  */

2681gfc_st_label *
2682gfc_get_st_label (int labelno)
2683{
gfc_st_label *lp;
gfc_namespace *ns;

if (gfc_current_state ()(gfc_state_stack->state) == COMP_DERIVED)
  ns = gfc_current_block ()(gfc_state_stack->sym)->f2k_derived;
else
  {
    /* Find the namespace of the scoping unit:
If we're in a BLOCK construct, jump to the parent namespace.  */
    ns = gfc_current_ns;
    while (ns->proc_name && ns->proc_name->attr.flavor == FL_LABEL)
ns = ns->parent;
  }

/* First see if the label is already in this namespace.  */
lp = ns->st_labels;
while (lp)
  {
    if (lp->value == labelno)
return lp;

    if (lp->value < labelno)
lp = lp->left;
    else
lp = lp->right;
  }

lp = XCNEW (gfc_st_label)((gfc_st_label *) xcalloc (1, sizeof (gfc_st_label)));

lp->value = labelno;
lp->defined = ST_LABEL_UNKNOWN;
lp->referenced = ST_LABEL_UNKNOWN;
lp->ns = ns;

gfc_insert_bbt (&ns->st_labels, lp, compare_st_labels);

return lp;
2721}


2724/* Called when a statement with a statement label is about to be
 accepted.  We add the label to the list of the current namespace,
 making sure it hasn't been defined previously and referenced
 correctly.  */

2729void
2730gfc_define_st_label (gfc_st_label *lp, gfc_sl_type type, locus *label_locus)
2731{
int labelno;

labelno = lp->value;

if (lp->defined != ST_LABEL_UNKNOWN)
  gfc_error ("Duplicate statement label %d at %L and %L", labelno,
      &lp->where, label_locus);
else
  {
    lp->where = *label_locus;

    switch (type)
{
case ST_LABEL_FORMAT:
 if (lp->referenced == ST_LABEL_TARGET
     || lp->referenced == ST_LABEL_DO_TARGET)
   gfc_error ("Label %d at %C already referenced as branch target",
       labelno);
 else
   lp->defined = ST_LABEL_FORMAT;

 break;

case ST_LABEL_TARGET:
case ST_LABEL_DO_TARGET:
 if (lp->referenced == ST_LABEL_FORMAT)
   gfc_error ("Label %d at %C already referenced as a format label",
       labelno);
 else
   lp->defined = type;

 if (lp->referenced == ST_LABEL_DO_TARGET && type != ST_LABEL_DO_TARGET
    	      && !gfc_notify_std (GFC_STD_F95_OBS(1<<1) | GFC_STD_F2018_DEL(1<<11),
		  "DO termination statement which is not END DO"
		  " or CONTINUE with label %d at %C", labelno))
   return;
 break;

default:
 lp->defined = ST_LABEL_BAD_TARGET;
 lp->referenced = ST_LABEL_BAD_TARGET;
}
  }
2775}


2778/* Reference a label.  Given a label and its type, see if that
 reference is consistent with what is known about that label,
 updating the unknown state.  Returns false if something goes
 wrong.  */

2783bool
2784gfc_reference_st_label (gfc_st_label *lp, gfc_sl_type type)
2785{
gfc_sl_type label_type;
int labelno;
bool rc;

if (lp == NULL__null)
  return true;

labelno = lp->value;

if (lp->defined != ST_LABEL_UNKNOWN)
  label_type = lp->defined;
else
  {
    label_type = lp->referenced;
    lp->where = gfc_current_locus;
  }

if (label_type == ST_LABEL_FORMAT
    && (type == ST_LABEL_TARGET || type == ST_LABEL_DO_TARGET))
  {
    gfc_error ("Label %d at %C previously used as a FORMAT label", labelno);
    rc = false;
    goto done;
  }

if ((label_type == ST_LABEL_TARGET || label_type == ST_LABEL_DO_TARGET
     || label_type == ST_LABEL_BAD_TARGET)
    && type == ST_LABEL_FORMAT)
  {
    gfc_error ("Label %d at %C previously used as branch target", labelno);
    rc = false;
    goto done;
  }

if (lp->referenced == ST_LABEL_DO_TARGET && type == ST_LABEL_DO_TARGET
    && !gfc_notify_std (GFC_STD_F95_OBS(1<<1) | GFC_STD_F2018_DEL(1<<11),
	  "Shared DO termination label %d at %C", labelno))
  return false;

if (type == ST_LABEL_DO_TARGET
    && !gfc_notify_std (GFC_STD_F2018_OBS(1<<10), "Labeled DO statement "
	  "at %L", &gfc_current_locus))
  return false;

if (lp->referenced != ST_LABEL_DO_TARGET)
  lp->referenced = type;
rc = true;

2834done:
return rc;
2836}


2839/************** Symbol table management subroutines ****************/

2841/* Basic details: Fortran 95 requires a potentially unlimited number
 of distinct namespaces when compiling a program unit.  This case
 occurs during a compilation of internal subprograms because all of
 the internal subprograms must be read before we can start
 generating code for the host.

 Given the tricky nature of the Fortran grammar, we must be able to
 undo changes made to a symbol table if the current interpretation
 of a statement is found to be incorrect.  Whenever a symbol is
 looked up, we make a copy of it and link to it.  All of these
 symbols are kept in a vector so that we can commit or
 undo the changes at a later time.

 A symtree may point to a symbol node outside of its namespace.  In
 this case, that symbol has been used as a host associated variable
 at some previous time.  */

2858/* Allocate a new namespace structure.  Copies the implicit types from
 PARENT if PARENT_TYPES is set.  */

2861gfc_namespace *
2862gfc_get_namespace (gfc_namespace *parent, int parent_types)
2863{
gfc_namespace *ns;
gfc_typespec *ts;
int in;
int i;

ns = XCNEW (gfc_namespace)((gfc_namespace *) xcalloc (1, sizeof (gfc_namespace)));
ns->sym_root = NULL__null;
ns->uop_root = NULL__null;
ns->tb_sym_root = NULL__null;
ns->finalizers = NULL__null;
ns->default_access = ACCESS_UNKNOWN;
ns->parent = parent;

for (in = GFC_INTRINSIC_BEGIN; in != GFC_INTRINSIC_END; in++)
  {
    ns->operator_access[in] = ACCESS_UNKNOWN;
    ns->tb_op[in] = NULL__null;
  }

/* Initialize default implicit types.  */
for (i = 'a'; i <= 'z'; i++)
  {
    ns->set_flag[i - 'a'] = 0;
    ts = &ns->default_type[i - 'a'];

    if (parent_types && ns->parent != NULL__null)
{
 /* Copy parent settings.  */
 *ts = ns->parent->default_type[i - 'a'];
 continue;
}

    if (flag_implicit_noneglobal_options.x_flag_implicit_none != 0)
{
 gfc_clear_ts (ts);
 continue;
}

    if ('i' <= i && i <= 'n')
{
 ts->type = BT_INTEGER;
 ts->kind = gfc_default_integer_kind;
}
    else
{
 ts->type = BT_REAL;
 ts->kind = gfc_default_real_kind;
}
  }

ns->refs = 1;

return ns;
2917}


2920/* Comparison function for symtree nodes.  */

2922static int
2923compare_symtree (void *_st1, void *_st2)
2924{
gfc_symtree *st1, *st2;

st1 = (gfc_symtree *) _st1;
st2 = (gfc_symtree *) _st2;

return strcmp (st1->name, st2->name);
2931}


2934/* Allocate a new symtree node and associate it with the new symbol.  */

2936gfc_symtree *
2937gfc_new_symtree (gfc_symtree **root, const char *name)
2938{
gfc_symtree *st;

st = XCNEW (gfc_symtree)((gfc_symtree *) xcalloc (1, sizeof (gfc_symtree)));
st->name = gfc_get_string ("%s", name);

gfc_insert_bbt (root, st, compare_symtree);
return st;
2946}


2949/* Delete a symbol from the tree.  Does not free the symbol itself!  */

2951void
2952gfc_delete_symtree (gfc_symtree **root, const char *name)
2953{
gfc_symtree st, *st0;
const char *p;

/* Submodules are marked as mod.submod.  When freeing a submodule
   symbol, the symtree only has "submod", so adjust that here.  */

p = strrchr(name, '.');
if (p)
  p++;
else
  p = name;

st0 = gfc_find_symtree (*root, p);

st.name = gfc_get_string ("%s", p);
gfc_delete_bbt (root, &st, compare_symtree);

free (st0);
2972}


2975/* Given a root symtree node and a name, try to find the symbol within
 the namespace.  Returns NULL if the symbol is not found.  */

2978gfc_symtree *
2979gfc_find_symtree (gfc_symtree *st, const char *name)
2980{
int c;

while (st != NULL__null)
  {
    c = strcmp (name, st->name);
    if (c == 0)
return st;

    st = (c < 0) ? st->left : st->right;
  }

return NULL__null;
2993}


2996/* Return a symtree node with a name that is guaranteed to be unique
 within the namespace and corresponds to an illegal fortran name.  */

2999gfc_symtree *
3000gfc_get_unique_symtree (gfc_namespace *ns)
3001{
char name[GFC_MAX_SYMBOL_LEN63 + 1];
static int serial = 0;

sprintf (name, "@%d", serial++);
return gfc_new_symtree (&ns->sym_root, name);
3007}


3010/* Given a name find a user operator node, creating it if it doesn't
 exist.  These are much simpler than symbols because they can't be
 ambiguous with one another.  */

3014gfc_user_op *
3015gfc_get_uop (const char *name)
3016{
gfc_user_op *uop;
gfc_symtree *st;
gfc_namespace *ns = gfc_current_ns;

if (ns->omp_udr_ns)
  ns = ns->parent;
st = gfc_find_symtree (ns->uop_root, name);
if (st != NULL__null)
  return st->n.uop;

st = gfc_new_symtree (&ns->uop_root, name);

uop = st->n.uop = XCNEW (gfc_user_op)((gfc_user_op *) xcalloc (1, sizeof (gfc_user_op)));
uop->name = gfc_get_string ("%s", name);
uop->access = ACCESS_UNKNOWN;
uop->ns = ns;

return uop;
3035}


3038/* Given a name find the user operator node.  Returns NULL if it does
 not exist.  */

3041gfc_user_op *
3042gfc_find_uop (const char *name, gfc_namespace *ns)
3043{
gfc_symtree *st;

if (ns == NULL__null)
  ns = gfc_current_ns;

st = gfc_find_symtree (ns->uop_root, name);
return (st == NULL__null) ? NULL__null : st->n.uop;
3051}


3054/* Update a symbol's common_block field, and take care of the associated
 memory management.  */

3057static void
3058set_symbol_common_block (gfc_symbol *sym, gfc_common_head *common_block)
3059{
if (sym->common_block == common_block)
  return;

if (sym->common_block && sym->common_block->name[0] != '\0')
  {
    sym->common_block->refs--;
    if (sym->common_block->refs == 0)
free (sym->common_block);
  }
sym->common_block = common_block;
3070}


3073/* Remove a gfc_symbol structure and everything it points to.  */

3075void
3076gfc_free_symbol (gfc_symbol *&sym)
3077{

if (sym == NULL__null)
  return;

gfc_free_array_spec (sym->as);

free_components (sym->components);

gfc_free_expr (sym->value);

gfc_free_namelist (sym->namelist);

if (sym->ns != sym->formal_ns)
  gfc_free_namespace (sym->formal_ns);

if (!sym->attr.generic_copy)
  gfc_free_interface (sym->generic);

gfc_free_formal_arglist (sym->formal);

gfc_free_namespace (sym->f2k_derived);

set_symbol_common_block (sym, NULL__null);

if (sym->param_list)
  gfc_free_actual_arglist (sym->param_list);

free (sym);
sym = NULL__null;
3107}


3110/* Decrease the reference counter and free memory when we reach zero.  */

3112void
3113gfc_release_symbol (gfc_symbol *&sym)
3114{
if (sym == NULL__null)
  return;

if (sym->formal_ns != NULL__null && sym->refs == 2 && sym->formal_ns != sym->ns
    && (!sym->attr.entry || !sym->module))
  {
    /* As formal_ns contains a reference to sym, delete formal_ns just
before the deletion of sym.  */
    gfc_namespace *ns = sym->formal_ns;
    sym->formal_ns = NULL__null;
    gfc_free_namespace (ns);
  }

sym->refs--;
if (sym->refs > 0)
  return;

gcc_assert (sym->refs == 0)((void)(!(sym->refs == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3132, __FUNCTION__), 0 : 0));
gfc_free_symbol (sym);
3134}


3137/* Allocate and initialize a new symbol node.  */

3139gfc_symbol *
3140gfc_new_symbol (const char *name, gfc_namespace *ns)
3141{
gfc_symbol *p;

p = XCNEW (gfc_symbol)((gfc_symbol *) xcalloc (1, sizeof (gfc_symbol)));

gfc_clear_ts (&p->ts);
gfc_clear_attr (&p->attr);
p->ns = ns;
p->declared_at = gfc_current_locus;
p->name = gfc_get_string ("%s", name);

return p;
3153}


3156/* Generate an error if a symbol is ambiguous, and set the error flag
 on it.  */

3159static void
3160ambiguous_symbol (const char *name, gfc_symtree *st)
3161{

if (st->n.sym->error)
  return;

if (st->n.sym->module)
  gfc_error ("Name %qs at %C is an ambiguous reference to %qs "
      "from module %qs", name, st->n.sym->name, st->n.sym->module);
else
  gfc_error ("Name %qs at %C is an ambiguous reference to %qs "
      "from current program unit", name, st->n.sym->name);

st->n.sym->error = 1;
3174}


3177/* If we're in a SELECT TYPE block, check if the variable 'st' matches any
 selector on the stack. If yes, replace it by the corresponding temporary.  */

3180static void
3181select_type_insert_tmp (gfc_symtree **st)
3182{
gfc_select_type_stack *stack = select_type_stack;
for (; stack; stack = stack->prev)
  if ((*st)->n.sym == stack->selector && stack->tmp)
    {
      *st = stack->tmp;
      select_type_insert_tmp (st);
      return;
    }
3191}


3194/* Look for a symtree in the current procedure -- that is, go up to
 parent namespaces but only if inside a BLOCK.  Returns NULL if not found.  */

3197gfc_symtree*
3198gfc_find_symtree_in_proc (const char* name, gfc_namespace* ns)
3199{
while (ns)
  {
    gfc_symtree* st = gfc_find_symtree (ns->sym_root, name);
    if (st)
return st;

    if (!ns->construct_entities)
break;
    ns = ns->parent;
  }

return NULL__null;
3212}


3215/* Search for a symtree starting in the current namespace, resorting to
 any parent namespaces if requested by a nonzero parent_flag.
 Returns nonzero if the name is ambiguous.  */

3219int
3220gfc_find_sym_tree (const char *name, gfc_namespace *ns, int parent_flag,
   gfc_symtree **result)
3222{
gfc_symtree *st;

if (ns == NULL__null)
  ns = gfc_current_ns;

do
  {
    st = gfc_find_symtree (ns->sym_root, name);
    if (st != NULL__null)
{
 select_type_insert_tmp (&st);

 *result = st;
 /* Ambiguous generic interfaces are permitted, as long
    as the specific interfaces are different.  */
 if (st->ambiguous && !st->n.sym->attr.generic)
   {
     ambiguous_symbol (name, st);
     return 1;
   }

 return 0;
}

    if (!parent_flag)
break;

    /* Don't escape an interface block.  */
    if (ns && !ns->has_import_set
        && ns->proc_name && ns->proc_name->attr.if_source == IFSRC_IFBODY)
break;

    ns = ns->parent;
  }
while (ns != NULL__null);

if (gfc_current_state()(gfc_state_stack->state) == COMP_DERIVED
    && gfc_current_block ()(gfc_state_stack->sym)->attr.pdt_template)
  {
    gfc_symbol *der = gfc_current_block ()(gfc_state_stack->sym);
    for (; der; der = gfc_get_derived_super_type (der))
{
 if (der->f2k_derived && der->f2k_derived->sym_root)
   {
     st = gfc_find_symtree (der->f2k_derived->sym_root, name);
     if (st)
break;
   }
}
    *result = st;
    return 0;
  }

*result = NULL__null;

return 0;
3279}


3282/* Same, but returns the symbol instead.  */

3284int
3285gfc_find_symbol (const char *name, gfc_namespace *ns, int parent_flag,
 gfc_symbol **result)
3287{
gfc_symtree *st;
int i;

i = gfc_find_sym_tree (name, ns, parent_flag, &st);

if (st == NULL__null)
  *result = NULL__null;
else
  *result = st->n.sym;

return i;
3299}


3302/* Tells whether there is only one set of changes in the stack.  */

3304static bool
3305single_undo_checkpoint_p (void)
3306{
if (latest_undo_chgset == &default_undo_chgset_var)
  {
    gcc_assert (latest_undo_chgset->previous == NULL)((void)(!(latest_undo_chgset->previous == __null) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3309, __FUNCTION__), 0 : 0));
    return true;
  }
else
  {
    gcc_assert (latest_undo_chgset->previous != NULL)((void)(!(latest_undo_chgset->previous != __null) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3314, __FUNCTION__), 0 : 0));
    return false;
  }
3317}

3319/* Save symbol with the information necessary to back it out.  */

3321void
3322gfc_save_symbol_data (gfc_symbol *sym)
3323{
gfc_symbol *s;
unsigned i;

if (!single_undo_checkpoint_p ())
  {
    /* If there is more than one change set, look for the symbol in the
       current one.  If it is found there, we can reuse it.  */
    FOR_EACH_VEC_ELT (latest_undo_chgset->syms, i, s)for (i = 0; (latest_undo_chgset->syms).iterate ((i), &
(s)); ++(i))
if (s == sym)
 {
   gcc_assert (sym->gfc_new || sym->old_symbol != NULL)((void)(!(sym->gfc_new || sym->old_symbol != __null) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3334, __FUNCTION__), 0 : 0));
   return;
 }
  }
else if (sym->gfc_new || sym->old_symbol != NULL__null)
  return;

s = XCNEW (gfc_symbol)((gfc_symbol *) xcalloc (1, sizeof (gfc_symbol)));
*s = *sym;
sym->old_symbol = s;
sym->gfc_new = 0;

latest_undo_chgset->syms.safe_push (sym);
3347}


3350/* Given a name, find a symbol, or create it if it does not exist yet
 in the current namespace.  If the symbol is found we make sure that
 it's OK.

 The integer return code indicates
   0   All OK
   1   The symbol name was ambiguous
   2   The name meant to be established was already host associated.

 So if the return value is nonzero, then an error was issued.  */

3361int
3362gfc_get_sym_tree (const char *name, gfc_namespace *ns, gfc_symtree **result,
  bool allow_subroutine)
3364{
gfc_symtree *st;
gfc_symbol *p;

/* This doesn't usually happen during resolution.  */
if (ns == NULL__null)
  ns = gfc_current_ns;

/* Try to find the symbol in ns.  */
st = gfc_find_symtree (ns->sym_root, name);

if (st == NULL__null && ns->omp_udr_ns)
  {
    ns = ns->parent;
    st = gfc_find_symtree (ns->sym_root, name);
  }

if (st == NULL__null)
  {
    /* If not there, create a new symbol.  */
    p = gfc_new_symbol (name, ns);

    /* Add to the list of tentative symbols.  */
    p->old_symbol = NULL__null;
    p->mark = 1;
    p->gfc_new = 1;
    latest_undo_chgset->syms.safe_push (p);

    st = gfc_new_symtree (&ns->sym_root, name);
    st->n.sym = p;
    p->refs++;

  }
else
  {
    /* Make sure the existing symbol is OK.  Ambiguous
generic interfaces are permitted, as long as the
specific interfaces are different.  */
    if (st->ambiguous && !st->n.sym->attr.generic)
{
 ambiguous_symbol (name, st);
 return 1;
}

    p = st->n.sym;
    if (p->ns != ns && (!p->attr.function || ns->proc_name != p)
 && !(allow_subroutine && p->attr.subroutine)
 && !(ns->proc_name && ns->proc_name->attr.if_source == IFSRC_IFBODY
 && (ns->has_import_set || p->attr.imported)))
{
 /* Symbol is from another namespace.  */
 gfc_error ("Symbol %qs at %C has already been host associated",
     name);
 return 2;
}

    p->mark = 1;

    /* Copy in case this symbol is changed.  */
    gfc_save_symbol_data (p);
  }

*result = st;
return 0;
3428}


3431int
3432gfc_get_symbol (const char *name, gfc_namespace *ns, gfc_symbol **result)
3433{
gfc_symtree *st;
int i;

i = gfc_get_sym_tree (name, ns, &st, false);
if (i != 0)
  return i;

if (st)
  *result = st->n.sym;
else
  *result = NULL__null;
return i;
3446}


3449/* Subroutine that searches for a symbol, creating it if it doesn't
 exist, but tries to host-associate the symbol if possible.  */

3452int
3453gfc_get_ha_sym_tree (const char *name, gfc_symtree **result)
3454{
gfc_symtree *st;
int i;

i = gfc_find_sym_tree (name, gfc_current_ns, 0, &st);

if (st != NULL__null)
3
←
Assuming 'st' is equal to NULL→
4
←
Taking false branch→
  {
    gfc_save_symbol_data (st->n.sym);
    *result = st;
    return i;
  }

i = gfc_find_sym_tree (name, gfc_current_ns, 1, &st);
if (i)
5
←
Assuming 'i' is not equal to 0→
6
←
Taking true branch→
  return i;
7
←
Returning without writing to '*result'→

if (st != NULL__null)
  {
    *result = st;
    return 0;
  }

return gfc_get_sym_tree (name, gfc_current_ns, result, false);
3478}


3481int
3482gfc_get_ha_symbol (const char *name, gfc_symbol **result)
3483{
int i;
gfc_symtree *st;
1
'st' declared without an initial value→

i = gfc_get_ha_sym_tree (name, &st);
2
←
Calling 'gfc_get_ha_sym_tree'→
8
←
Returning from 'gfc_get_ha_sym_tree'→

if (st)
9
←
Branch condition evaluates to a garbage value
  *result = st->n.sym;
else
  *result = NULL__null;

return i;
3495}


3498/* Search for the symtree belonging to a gfc_common_head; we cannot use
 head->name as the common_root symtree's name might be mangled.  */

3501static gfc_symtree *
3502find_common_symtree (gfc_symtree *st, gfc_common_head *head)
3503{

gfc_symtree *result;

if (st == NULL__null)
  return NULL__null;

if (st->n.common == head)
  return st;

result = find_common_symtree (st->left, head);
if (!result)
  result = find_common_symtree (st->right, head);

return result;
3518}


3521/* Restore previous state of symbol.  Just copy simple stuff.  */

3523static void
3524restore_old_symbol (gfc_symbol *p)
3525{
gfc_symbol *old;

p->mark = 0;
old = p->old_symbol;

p->ts.type = old->ts.type;
p->ts.kind = old->ts.kind;

p->attr = old->attr;

if (p->value != old->value)
  {
    gcc_checking_assert (old->value == NULL)((void)(!(old->value == __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3538, __FUNCTION__), 0 : 0));
    gfc_free_expr (p->value);
    p->value = NULL__null;
  }

if (p->as != old->as)
  {
    if (p->as)
gfc_free_array_spec (p->as);
    p->as = old->as;
  }

p->generic = old->generic;
p->component_access = old->component_access;

if (p->namelist != NULL__null && old->namelist == NULL__null)
  {
    gfc_free_namelist (p->namelist);
    p->namelist = NULL__null;
  }
else
  {
    if (p->namelist_tail != old->namelist_tail)
{
 gfc_free_namelist (old->namelist_tail->next);
 old->namelist_tail->next = NULL__null;
}
  }

p->namelist_tail = old->namelist_tail;

if (p->formal != old->formal)
  {
    gfc_free_formal_arglist (p->formal);
    p->formal = old->formal;
  }

set_symbol_common_block (p, old->common_block);
p->common_head = old->common_head;

p->old_symbol = old->old_symbol;
free (old);
3580}


3583/* Frees the internal data of a gfc_undo_change_set structure.  Doesn't free
 the structure itself.  */

3586static void
3587free_undo_change_set_data (gfc_undo_change_set &cs)
3588{
cs.syms.release ();
cs.tbps.release ();
3591}


3594/* Given a change set pointer, free its target's contents and update it with
 the address of the previous change set.  Note that only the contents are
 freed, not the target itself (the contents' container).  It is not a problem
 as the latter will be a local variable usually.  */

3599static void
3600pop_undo_change_set (gfc_undo_change_set *&cs)
3601{
free_undo_change_set_data (*cs);
cs = cs->previous;
3604}


3607static void free_old_symbol (gfc_symbol *sym);


3610/* Merges the current change set into the previous one.  The changes themselves
 are left untouched; only one checkpoint is forgotten.  */

3613void
3614gfc_drop_last_undo_checkpoint (void)
3615{
gfc_symbol *s, *t;
unsigned i, j;

FOR_EACH_VEC_ELT (latest_undo_chgset->syms, i, s)for (i = 0; (latest_undo_chgset->syms).iterate ((i), &
(s)); ++(i))
  {
    /* No need to loop in this case.  */
    if (s->old_symbol == NULL__null)
      continue;

    /* Remove the duplicate symbols.  */
    FOR_EACH_VEC_ELT (latest_undo_chgset->previous->syms, j, t)for (j = 0; (latest_undo_chgset->previous->syms).iterate
 ((j), &(t)); ++(j))
if (t == s)
 {
   latest_undo_chgset->previous->syms.unordered_remove (j);

   /* S->OLD_SYMBOL is the backup symbol for S as it was at the
      last checkpoint.  We drop that checkpoint, so S->OLD_SYMBOL
      shall contain from now on the backup symbol for S as it was
      at the checkpoint before.  */
   if (s->old_symbol->gfc_new)
     {
gcc_assert (s->old_symbol->old_symbol == NULL)((void)(!(s->old_symbol->old_symbol == __null) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3637, __FUNCTION__), 0 : 0));
s->gfc_new = s->old_symbol->gfc_new;
free_old_symbol (s);
     }
   else
     restore_old_symbol (s->old_symbol);
   break;
 }
  }

latest_undo_chgset->previous->syms.safe_splice (latest_undo_chgset->syms);
latest_undo_chgset->previous->tbps.safe_splice (latest_undo_chgset->tbps);

pop_undo_change_set (latest_undo_chgset);
3651}


3654/* Undoes all the changes made to symbols since the previous checkpoint.
 This subroutine is made simpler due to the fact that attributes are
 never removed once added.  */

3658void
3659gfc_restore_last_undo_checkpoint (void)
3660{
gfc_symbol *p;
unsigned i;

FOR_EACH_VEC_ELT (latest_undo_chgset->syms, i, p)for (i = 0; (latest_undo_chgset->syms).iterate ((i), &
(p)); ++(i))
  {
    /* Symbol in a common block was new. Or was old and just put in common */
    if (p->common_block
 && (p->gfc_new || !p->old_symbol->common_block))
{
 /* If the symbol was added to any common block, it
    needs to be removed to stop the resolver looking
    for a (possibly) dead symbol.  */
 if (p->common_block->head == p && !p->common_next)
   {
     gfc_symtree st, *st0;
     st0 = find_common_symtree (p->ns->common_root,
			 p->common_block);
     if (st0)
{
  st.name = st0->name;
  gfc_delete_bbt (&p->ns->common_root, &st, compare_symtree);
  free (st0);
}
   }

 if (p->common_block->head == p)
   p->common_block->head = p->common_next;
 else
   {
     gfc_symbol *cparent, *csym;

     cparent = p->common_block->head;
     csym = cparent->common_next;

     while (csym != p)
{
  cparent = csym;
  csym = csym->common_next;
}

     gcc_assert(cparent->common_next == p)((void)(!(cparent->common_next == p) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3701, __FUNCTION__), 0 : 0));
     cparent->common_next = csym->common_next;
   }
 p->common_next = NULL__null;
}
    if (p->gfc_new)
{
 /* The derived type is saved in the symtree with the first
    letter capitalized; the all lower-case version to the
    derived type contains its associated generic function.  */
 if (gfc_fl_struct (p->attr.flavor)((p->attr.flavor) == FL_DERIVED || (p->attr.flavor) == FL_UNION
 || (p->attr.flavor) == FL_STRUCT))
   gfc_delete_symtree (&p->ns->sym_root,gfc_dt_upper_string (p->name));
        else
   gfc_delete_symtree (&p->ns->sym_root, p->name);

 gfc_release_symbol (p);
}
    else
restore_old_symbol (p);
  }

latest_undo_chgset->syms.truncate (0);
latest_undo_chgset->tbps.truncate (0);

if (!single_undo_checkpoint_p ())
  pop_undo_change_set (latest_undo_chgset);
3727}


3730/* Makes sure that there is only one set of changes; in other words we haven't
 forgotten to pair a call to gfc_new_checkpoint with a call to either
 gfc_drop_last_undo_checkpoint or gfc_restore_last_undo_checkpoint.  */

3734static void
3735enforce_single_undo_checkpoint (void)
3736{
gcc_checking_assert (single_undo_checkpoint_p ())((void)(!(single_undo_checkpoint_p ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 3737, __FUNCTION__), 0 : 0));
3738}


3741/* Undoes all the changes made to symbols in the current statement.  */

3743void
3744gfc_undo_symbols (void)
3745{
enforce_single_undo_checkpoint ();
gfc_restore_last_undo_checkpoint ();
3748}


3751/* Free sym->old_symbol. sym->old_symbol is mostly a shallow copy of sym; the
 components of old_symbol that might need deallocation are the "allocatables"
 that are restored in gfc_undo_symbols(), with two exceptions: namelist and
 namelist_tail.  In case these differ between old_symbol and sym, it's just
 because sym->namelist has gotten a few more items.  */

3757static void
3758free_old_symbol (gfc_symbol *sym)
3759{

if (sym->old_symbol == NULL__null)
  return;

if (sym->old_symbol->as != NULL__null
    && sym->old_symbol->as != sym->as
    && !(sym->ts.type == BT_CLASS
  && sym->ts.u.derived->attr.is_class
  && sym->old_symbol->as == CLASS_DATA (sym)sym->ts.u.derived->components->as))
  gfc_free_array_spec (sym->old_symbol->as);

if (sym->old_symbol->value != sym->value)
  gfc_free_expr (sym->old_symbol->value);

if (sym->old_symbol->formal != sym->formal)
  gfc_free_formal_arglist (sym->old_symbol->formal);

free (sym->old_symbol);
sym->old_symbol = NULL__null;
3779}


3782/* Makes the changes made in the current statement permanent-- gets
 rid of undo information.  */

3785void
3786gfc_commit_symbols (void)
3787{
gfc_symbol *p;
gfc_typebound_proc *tbp;
unsigned i;

enforce_single_undo_checkpoint ();

FOR_EACH_VEC_ELT (latest_undo_chgset->syms, i, p)for (i = 0; (latest_undo_chgset->syms).iterate ((i), &
(p)); ++(i))
  {
    p->mark = 0;
    p->gfc_new = 0;
    free_old_symbol (p);
  }
latest_undo_chgset->syms.truncate (0);

FOR_EACH_VEC_ELT (latest_undo_chgset->tbps, i, tbp)for (i = 0; (latest_undo_chgset->tbps).iterate ((i), &
(tbp)); ++(i))
  tbp->error = 0;
latest_undo_chgset->tbps.truncate (0);
3805}


3808/* Makes the changes made in one symbol permanent -- gets rid of undo
 information.  */

3811void
3812gfc_commit_symbol (gfc_symbol *sym)
3813{
gfc_symbol *p;
unsigned i;

enforce_single_undo_checkpoint ();

FOR_EACH_VEC_ELT (latest_undo_chgset->syms, i, p)for (i = 0; (latest_undo_chgset->syms).iterate ((i), &
(p)); ++(i))
  if (p == sym)
    {
latest_undo_chgset->syms.unordered_remove (i);
break;
    }

sym->mark = 0;
sym->gfc_new = 0;

free_old_symbol (sym);
3830}


3833/* Recursively free trees containing type-bound procedures.  */

3835static void
3836free_tb_tree (gfc_symtree *t)
3837{
if (t == NULL__null)
  return;

free_tb_tree (t->left);
free_tb_tree (t->right);

/* TODO: Free type-bound procedure u.generic  */
free (t->n.tb);
t->n.tb = NULL__null;
free (t);
3848}


3851/* Recursive function that deletes an entire tree and all the common
 head structures it points to.  */

3854static void
3855free_common_tree (gfc_symtree * common_tree)
3856{
if (common_tree == NULL__null)
  return;

free_common_tree (common_tree->left);
free_common_tree (common_tree->right);

free (common_tree);
3864}


3867/* Recursive function that deletes an entire tree and all the common
 head structures it points to.  */

3870static void
3871free_omp_udr_tree (gfc_symtree * omp_udr_tree)
3872{
if (omp_udr_tree == NULL__null)
  return;

free_omp_udr_tree (omp_udr_tree->left);
free_omp_udr_tree (omp_udr_tree->right);

gfc_free_omp_udr (omp_udr_tree->n.omp_udr);
free (omp_udr_tree);
3881}


3884/* Recursive function that deletes an entire tree and all the user
 operator nodes that it contains.  */

3887static void
3888free_uop_tree (gfc_symtree *uop_tree)
3889{
if (uop_tree == NULL__null)
  return;

free_uop_tree (uop_tree->left);
free_uop_tree (uop_tree->right);

gfc_free_interface (uop_tree->n.uop->op);
free (uop_tree->n.uop);
free (uop_tree);
3899}


3902/* Recursive function that deletes an entire tree and all the symbols
 that it contains.  */

3905static void
3906free_sym_tree (gfc_symtree *sym_tree)
3907{
if (sym_tree == NULL__null)
  return;

free_sym_tree (sym_tree->left);
free_sym_tree (sym_tree->right);

gfc_release_symbol (sym_tree->n.sym);
free (sym_tree);
3916}


3919/* Free the gfc_equiv_info's.  */

3921static void
3922gfc_free_equiv_infos (gfc_equiv_info *s)
3923{
if (s == NULL__null)
  return;
gfc_free_equiv_infos (s->next);
free (s);
3928}


3931/* Free the gfc_equiv_lists.  */

3933static void
3934gfc_free_equiv_lists (gfc_equiv_list *l)
3935{
if (l == NULL__null)
  return;
gfc_free_equiv_lists (l->next);
gfc_free_equiv_infos (l->equiv);
free (l);
3941}


3944/* Free a finalizer procedure list.  */

3946void
3947gfc_free_finalizer (gfc_finalizer* el)
3948{
if (el)
  {
    gfc_release_symbol (el->proc_sym);
    free (el);
  }
3954}

3956static void
3957gfc_free_finalizer_list (gfc_finalizer* list)
3958{
while (list)
  {
    gfc_finalizer* current = list;
    list = list->next;
    gfc_free_finalizer (current);
  }
3965}


3968/* Create a new gfc_charlen structure and add it to a namespace.
 If 'old_cl' is given, the newly created charlen will be a copy of it.  */

3971gfc_charlen*
3972gfc_new_charlen (gfc_namespace *ns, gfc_charlen *old_cl)
3973{
gfc_charlen *cl;

cl = gfc_get_charlen ()((gfc_charlen *) xcalloc (1, sizeof (gfc_charlen)));

/* Copy old_cl.  */
if (old_cl)
  {
    cl->length = gfc_copy_expr (old_cl->length);
    cl->length_from_typespec = old_cl->length_from_typespec;
    cl->backend_decl = old_cl->backend_decl;
    cl->passed_length = old_cl->passed_length;
    cl->resolved = old_cl->resolved;
  }

/* Put into namespace.  */
cl->next = ns->cl_list;
ns->cl_list = cl;

return cl;
3993}


3996/* Free the charlen list from cl to end (end is not freed).
 Free the whole list if end is NULL.  */

3999static void
4000gfc_free_charlen (gfc_charlen *cl, gfc_charlen *end)
4001{
gfc_charlen *cl2;

for (; cl != end; cl = cl2)
  {
    gcc_assert (cl)((void)(!(cl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4006, __FUNCTION__), 0 : 0));

    cl2 = cl->next;
    gfc_free_expr (cl->length);
    free (cl);
  }
4012}


4015/* Free entry list structs.  */

4017static void
4018free_entry_list (gfc_entry_list *el)
4019{
gfc_entry_list *next;

if (el == NULL__null)
  return;

next = el->next;
free (el);
free_entry_list (next);
4028}


4031/* Free a namespace structure and everything below it.  Interface
 lists associated with intrinsic operators are not freed.  These are
 taken care of when a specific name is freed.  */

4035void
4036gfc_free_namespace (gfc_namespace *&ns)
4037{
gfc_namespace *p, *q;
int i;
gfc_was_finalized *f;

if (ns == NULL__null)
  return;

ns->refs--;
if (ns->refs > 0)
  return;

gcc_assert (ns->refs == 0)((void)(!(ns->refs == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4049, __FUNCTION__), 0 : 0));

gfc_free_statements (ns->code);

free_sym_tree (ns->sym_root);
free_uop_tree (ns->uop_root);
free_common_tree (ns->common_root);
free_omp_udr_tree (ns->omp_udr_root);
free_tb_tree (ns->tb_sym_root);
free_tb_tree (ns->tb_uop_root);
gfc_free_finalizer_list (ns->finalizers);
gfc_free_omp_declare_simd_list (ns->omp_declare_simd);
gfc_free_omp_declare_variant_list (ns->omp_declare_variant);
gfc_free_charlen (ns->cl_list, NULL__null);
free_st_labels (ns->st_labels);

free_entry_list (ns->entries);
gfc_free_equiv (ns->equiv);
gfc_free_equiv_lists (ns->equiv_lists);
gfc_free_use_stmts (ns->use_stmts);

for (i = GFC_INTRINSIC_BEGIN; i != GFC_INTRINSIC_END; i++)
  gfc_free_interface (ns->op[i]);

gfc_free_data (ns->data);

/* Free all the expr + component combinations that have been
   finalized.  */
f = ns->was_finalized;
while (f)
  {
    gfc_was_finalized* current = f;
    f = f->next;
    free (current);
  }
if (ns->omp_assumes)
  {
    free (ns->omp_assumes->absent);
    free (ns->omp_assumes->contains);
    gfc_free_expr_list (ns->omp_assumes->holds);
    free (ns->omp_assumes);
  }
p = ns->contained;
free (ns);
ns = NULL__null;

/* Recursively free any contained namespaces.  */
while (p != NULL__null)
  {
    q = p;
    p = p->sibling;
    gfc_free_namespace (q);
  }
4102}


4105void
4106gfc_symbol_init_2 (void)
4107{

gfc_current_ns = gfc_get_namespace (NULL__null, 0);
4110}


4113void
4114gfc_symbol_done_2 (void)
4115{
if (gfc_current_ns != NULL__null)
  {
    /* free everything from the root.  */
    while (gfc_current_ns->parent != NULL__null)
gfc_current_ns = gfc_current_ns->parent;
    gfc_free_namespace (gfc_current_ns);
    gfc_current_ns = NULL__null;
  }
gfc_derived_types = NULL__null;

enforce_single_undo_checkpoint ();
free_undo_change_set_data (*latest_undo_chgset);
4128}


4131/* Count how many nodes a symtree has.  */

4133static unsigned
4134count_st_nodes (const gfc_symtree *st)
4135{
unsigned nodes;
if (!st)
  return 0;

nodes = count_st_nodes (st->left);
nodes++;
nodes += count_st_nodes (st->right);

return nodes;
4145}


4148/* Convert symtree tree into symtree vector.  */

4150static unsigned
4151fill_st_vector (gfc_symtree *st, gfc_symtree **st_vec, unsigned node_cntr)
4152{
if (!st)
  return node_cntr;

node_cntr = fill_st_vector (st->left, st_vec, node_cntr);
st_vec[node_cntr++] = st;
node_cntr = fill_st_vector (st->right, st_vec, node_cntr);

return node_cntr;
4161}


4164/* Traverse namespace.  As the functions might modify the symtree, we store the
 symtree as a vector and operate on this vector.  Note: We assume that
 sym_func or st_func never deletes nodes from the symtree - only adding is
 allowed. Additionally, newly added nodes are not traversed.  */

4169static void
4170do_traverse_symtree (gfc_symtree *st, void (*st_func) (gfc_symtree *),
     void (*sym_func) (gfc_symbol *))
4172{
gfc_symtree **st_vec;
unsigned nodes, i, node_cntr;

gcc_assert ((st_func && !sym_func) || (!st_func && sym_func))((void)(!((st_func && !sym_func) || (!st_func &&
 sym_func)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4176, __FUNCTION__), 0 : 0));
nodes = count_st_nodes (st);
st_vec = XALLOCAVEC (gfc_symtree *, nodes)((gfc_symtree * *) __builtin_alloca(sizeof (gfc_symtree *) * (
nodes)));
node_cntr = 0;
fill_st_vector (st, st_vec, node_cntr);

if (sym_func)
  {
    /* Clear marks.  */
    for (i = 0; i < nodes; i++)
st_vec[i]->n.sym->mark = 0;
    for (i = 0; i < nodes; i++)
if (!st_vec[i]->n.sym->mark)
 {
   (*sym_func) (st_vec[i]->n.sym);
   st_vec[i]->n.sym->mark = 1;
 }
   }
 else
    for (i = 0; i < nodes; i++)
(*st_func) (st_vec[i]);
4197}


4200/* Recursively traverse the symtree nodes.  */

4202void
4203gfc_traverse_symtree (gfc_symtree *st, void (*st_func) (gfc_symtree *))
4204{
do_traverse_symtree (st, st_func, NULL__null);
4206}


4209/* Call a given function for all symbols in the namespace.  We take
 care that each gfc_symbol node is called exactly once.  */

4212void
4213gfc_traverse_ns (gfc_namespace *ns, void (*sym_func) (gfc_symbol *))
4214{
do_traverse_symtree (ns->sym_root, NULL__null, sym_func);
4216}


4219/* Return TRUE when name is the name of an intrinsic type.  */

4221bool
4222gfc_is_intrinsic_typename (const char *name)
4223{
if (strcmp (name, "integer") == 0
    || strcmp (name, "real") == 0
    || strcmp (name, "character") == 0
    || strcmp (name, "logical") == 0
    || strcmp (name, "complex") == 0
    || strcmp (name, "doubleprecision") == 0
    || strcmp (name, "doublecomplex") == 0)
  return true;
else
  return false;
4234}


4237/* Return TRUE if the symbol is an automatic variable.  */

4239static bool
4240gfc_is_var_automatic (gfc_symbol *sym)
4241{
/* Pointer and allocatable variables are never automatic.  */
if (sym->attr.pointer || sym->attr.allocatable)
  return false;
/* Check for arrays with non-constant size.  */
if (sym->attr.dimension && sym->as
    && !gfc_is_compile_time_shape (sym->as))
  return true;
/* Check for non-constant length character variables.  */
if (sym->ts.type == BT_CHARACTER
    && sym->ts.u.cl
    && !gfc_is_constant_expr (sym->ts.u.cl->length))
  return true;
/* Variables with explicit AUTOMATIC attribute.  */
if (sym->attr.automatic)
    return true;

return false;
4259}

4261/* Given a symbol, mark it as SAVEd if it is allowed.  */

4263static void
4264save_symbol (gfc_symbol *sym)
4265{

if (sym->attr.use_assoc)
  return;

if (sym->attr.in_common
    || sym->attr.in_equivalence
    || sym->attr.dummy
    || sym->attr.result
    || sym->attr.flavor != FL_VARIABLE)
  return;
/* Automatic objects are not saved.  */
if (gfc_is_var_automatic (sym))
  return;
gfc_add_save (&sym->attr, SAVE_EXPLICIT, sym->name, &sym->declared_at);
4280}


4283/* Mark those symbols which can be SAVEd as such.  */

4285void
4286gfc_save_all (gfc_namespace *ns)
4287{
gfc_traverse_ns (ns, save_symbol);
4289}


4292/* Make sure that no changes to symbols are pending.  */

4294void
4295gfc_enforce_clean_symbol_state(void)
4296{
enforce_single_undo_checkpoint ();
gcc_assert (latest_undo_chgset->syms.is_empty ())((void)(!(latest_undo_chgset->syms.is_empty ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4298, __FUNCTION__), 0 : 0));
4299}


4302/************** Global symbol handling ************/


4305/* Search a tree for the global symbol.  */

4307gfc_gsymbol *
4308gfc_find_gsymbol (gfc_gsymbol *symbol, const char *name)
4309{
int c;

if (symbol == NULL__null)
  return NULL__null;

while (symbol)
  {
    c = strcmp (name, symbol->name);
    if (!c)
return symbol;

    symbol = (c < 0) ? symbol->left : symbol->right;
  }

return NULL__null;
4325}


4328/* Case insensitive search a tree for the global symbol.  */

4330gfc_gsymbol *
4331gfc_find_case_gsymbol (gfc_gsymbol *symbol, const char *name)
4332{
int c;

if (symbol == NULL__null)
  return NULL__null;

while (symbol)
  {
    c = strcasecmp (name, symbol->name);
    if (!c)
return symbol;

    symbol = (c < 0) ? symbol->left : symbol->right;
  }

return NULL__null;
4348}


4351/* Compare two global symbols. Used for managing the BB tree.  */

4353static int
4354gsym_compare (void *_s1, void *_s2)
4355{
gfc_gsymbol *s1, *s2;

s1 = (gfc_gsymbol *) _s1;
s2 = (gfc_gsymbol *) _s2;
return strcmp (s1->name, s2->name);
4361}


4364/* Get a global symbol, creating it if it doesn't exist.  */

4366gfc_gsymbol *
4367gfc_get_gsymbol (const char *name, bool bind_c)
4368{
gfc_gsymbol *s;

s = gfc_find_gsymbol (gfc_gsym_root, name);
if (s != NULL__null)
  return s;

s = XCNEW (gfc_gsymbol)((gfc_gsymbol *) xcalloc (1, sizeof (gfc_gsymbol)));
s->type = GSYM_UNKNOWN;
s->name = gfc_get_string ("%s", name);
s->bind_c = bind_c;

gfc_insert_bbt (&gfc_gsym_root, s, gsym_compare);

return s;
4383}

4385void
4386gfc_traverse_gsymbol (gfc_gsymbol *gsym,
      void (*do_something) (gfc_gsymbol *, void *),
      void *data)
4389{
if (gsym->left)
  gfc_traverse_gsymbol (gsym->left, do_something, data);

(*do_something) (gsym, data);

if (gsym->right)
  gfc_traverse_gsymbol (gsym->right, do_something, data);
4397}

4399static gfc_symbol *
4400get_iso_c_binding_dt (int sym_id)
4401{
gfc_symbol *dt_list = gfc_derived_types;

/* Loop through the derived types in the name list, searching for
   the desired symbol from iso_c_binding.  Search the parent namespaces
   if necessary and requested to (parent_flag).  */
if (dt_list)
  {
    while (dt_list->dt_next != gfc_derived_types)
{
 if (dt_list->from_intmod != INTMOD_NONE
     && dt_list->intmod_sym_id == sym_id)
   return dt_list;

 dt_list = dt_list->dt_next;
}
  }

return NULL__null;
4420}


4423/* Verifies that the given derived type symbol, derived_sym, is interoperable
 with C.  This is necessary for any derived type that is BIND(C) and for
 derived types that are parameters to functions that are BIND(C).  All
 fields of the derived type are required to be interoperable, and are tested
 for such.  If an error occurs, the errors are reported here, allowing for
 multiple errors to be handled for a single derived type.  */

4430bool
4431verify_bind_c_derived_type (gfc_symbol *derived_sym)
4432{
gfc_component *curr_comp = NULL__null;
bool is_c_interop = false;
bool retval = true;

if (derived_sym == NULL__null)
  gfc_internal_error ("verify_bind_c_derived_type(): Given symbol is "
                      "unexpectedly NULL");

/* If we've already looked at this derived symbol, do not look at it again
   so we don't repeat warnings/errors.  */
if (derived_sym->ts.is_c_interop)
  return true;

/* The derived type must have the BIND attribute to be interoperable
   J3/04-007, Section 15.2.3.  */
if (derived_sym->attr.is_bind_c != 1)
  {
    derived_sym->ts.is_c_interop = 0;
    gfc_error_now ("Derived type %qs declared at %L must have the BIND "
                   "attribute to be C interoperable", derived_sym->name,
                   &(derived_sym->declared_at));
    retval = false;
  }

curr_comp = derived_sym->components;

/* Fortran 2003 allows an empty derived type.  C99 appears to disallow an
   empty struct.  Section 15.2 in Fortran 2003 states:  "The following
   subclauses define the conditions under which a Fortran entity is
   interoperable.  If a Fortran entity is interoperable, an equivalent
   entity may be defined by means of C and the Fortran entity is said
   to be interoperable with the C entity.  There does not have to be such
   an interoperating C entity."
*/
if (curr_comp == NULL__null)
  {
    gfc_warning (0, "Derived type %qs with BIND(C) attribute at %L is empty, "
   "and may be inaccessible by the C companion processor",
   derived_sym->name, &(derived_sym->declared_at));
    derived_sym->ts.is_c_interop = 1;
    derived_sym->attr.is_bind_c = 1;
    return true;
  }


/* Initialize the derived type as being C interoperable.
   If we find an error in the components, this will be set false.  */
derived_sym->ts.is_c_interop = 1;

/* Loop through the list of components to verify that the kind of
   each is a C interoperable type.  */
do
  {
    /* The components cannot be pointers (fortran sense).
       J3/04-007, Section 15.2.3, C1505.	*/
    if (curr_comp->attr.pointer != 0)
      {
        gfc_error ("Component %qs at %L cannot have the "
                   "POINTER attribute because it is a member "
                   "of the BIND(C) derived type %qs at %L",
                   curr_comp->name, &(curr_comp->loc),
                   derived_sym->name, &(derived_sym->declared_at));
        retval = false;
      }

    if (curr_comp->attr.proc_pointer != 0)
{
 gfc_error ("Procedure pointer component %qs at %L cannot be a member"
     " of the BIND(C) derived type %qs at %L", curr_comp->name,
     &curr_comp->loc, derived_sym->name,
     &derived_sym->declared_at);
        retval = false;
      }

    /* The components cannot be allocatable.
       J3/04-007, Section 15.2.3, C1505.	*/
    if (curr_comp->attr.allocatable != 0)
      {
        gfc_error ("Component %qs at %L cannot have the "
                   "ALLOCATABLE attribute because it is a member "
                   "of the BIND(C) derived type %qs at %L",
                   curr_comp->name, &(curr_comp->loc),
                   derived_sym->name, &(derived_sym->declared_at));
        retval = false;
      }

    /* BIND(C) derived types must have interoperable components.  */
    if (curr_comp->ts.type == BT_DERIVED
 && curr_comp->ts.u.derived->ts.is_iso_c != 1
        && curr_comp->ts.u.derived != derived_sym)
      {
        /* This should be allowed; the draft says a derived-type cannot
           have type parameters if it is has the BIND attribute.  Type
           parameters seem to be for making parameterized derived types.
           There's no need to verify the type if it is c_ptr/c_funptr.  */
        retval = verify_bind_c_derived_type (curr_comp->ts.u.derived);
}
    else
{
 /* Grab the typespec for the given component and test the kind.  */
 is_c_interop = gfc_verify_c_interop (&(curr_comp->ts));

 if (!is_c_interop)
   {
     /* Report warning and continue since not fatal.  The
 draft does specify a constraint that requires all fields
 to interoperate, but if the user says real(4), etc., it
 may interoperate with *something* in C, but the compiler
 most likely won't know exactly what.  Further, it may not
 interoperate with the same data type(s) in C if the user
 recompiles with different flags (e.g., -m32 and -m64 on
 x86_64 and using integer(4) to claim interop with a
 C_LONG).  */
     if (derived_sym->attr.is_bind_c == 1 && warn_c_binding_typeglobal_options.x_warn_c_binding_type)
/* If the derived type is bind(c), all fields must be
   interop.  */
gfc_warning (OPT_Wc_binding_type,
	     "Component %qs in derived type %qs at %L "
                           "may not be C interoperable, even though "
                           "derived type %qs is BIND(C)",
                           curr_comp->name, derived_sym->name,
                           &(curr_comp->loc), derived_sym->name);
     else if (warn_c_binding_typeglobal_options.x_warn_c_binding_type)
/* If derived type is param to bind(c) routine, or to one
   of the iso_c_binding procs, it must be interoperable, so
   all fields must interop too.	 */
gfc_warning (OPT_Wc_binding_type,
	     "Component %qs in derived type %qs at %L "
                           "may not be C interoperable",
                           curr_comp->name, derived_sym->name,
                           &(curr_comp->loc));
   }
}

    curr_comp = curr_comp->next;
  } while (curr_comp != NULL__null);

if (derived_sym->attr.sequence != 0)
  {
    gfc_error ("Derived type %qs at %L cannot have the SEQUENCE "
               "attribute because it is BIND(C)", derived_sym->name,
               &(derived_sym->declared_at));
    retval = false;
  }

/* Mark the derived type as not being C interoperable if we found an
   error.  If there were only warnings, proceed with the assumption
   it's interoperable.  */
if (!retval)
  derived_sym->ts.is_c_interop = 0;

return retval;
4585}


4588/* Generate symbols for the named constants c_null_ptr and c_null_funptr.  */

4590static bool
4591gen_special_c_interop_ptr (gfc_symbol *tmp_sym, gfc_symtree *dt_symtree)
4592{
gfc_constructor *c;

gcc_assert (tmp_sym && dt_symtree && dt_symtree->n.sym)((void)(!(tmp_sym && dt_symtree && dt_symtree
->n.sym) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4595, __FUNCTION__), 0 : 0));
dt_symtree->n.sym->attr.referenced = 1;

tmp_sym->attr.is_c_interop = 1;
tmp_sym->attr.is_bind_c = 1;
tmp_sym->ts.is_c_interop = 1;
tmp_sym->ts.is_iso_c = 1;
tmp_sym->ts.type = BT_DERIVED;
tmp_sym->ts.f90_type = BT_VOID;
tmp_sym->attr.flavor = FL_PARAMETER;
tmp_sym->ts.u.derived = dt_symtree->n.sym;

/* Set the c_address field of c_null_ptr and c_null_funptr to
   the value of NULL.	 */
tmp_sym->value = gfc_get_expr ();
tmp_sym->value->expr_type = EXPR_STRUCTURE;
tmp_sym->value->ts.type = BT_DERIVED;
tmp_sym->value->ts.f90_type = BT_VOID;
tmp_sym->value->ts.u.derived = tmp_sym->ts.u.derived;
gfc_constructor_append_expr (&tmp_sym->value->value.constructor, NULL__null, NULL__null);
c = gfc_constructor_first (tmp_sym->value->value.constructor);
c->expr = gfc_get_int_expr (gfc_index_integer_kind, NULL__null, 0);
c->expr->ts.is_iso_c = 1;

return true;
4620}


4623/* Add a formal argument, gfc_formal_arglist, to the
 end of the given list of arguments.	Set the reference to the
 provided symbol, param_sym, in the argument.  */

4627static void
4628add_formal_arg (gfc_formal_arglist **head,
              gfc_formal_arglist **tail,
              gfc_formal_arglist *formal_arg,
              gfc_symbol *param_sym)
4632{
/* Put in list, either as first arg or at the tail (curr arg).  */
if (*head == NULL__null)
  *head = *tail = formal_arg;
else
  {
    (*tail)->next = formal_arg;
    (*tail) = formal_arg;
  }

(*tail)->sym = param_sym;
(*tail)->next = NULL__null;

return;
4646}


4649/* Add a procedure interface to the given symbol (i.e., store a
 reference to the list of formal arguments).  */

4652static void
4653add_proc_interface (gfc_symbol *sym, ifsrc source, gfc_formal_arglist *formal)
4654{

sym->formal = formal;
sym->attr.if_source = source;
4658}


4661/* Copy the formal args from an existing symbol, src, into a new
 symbol, dest.  New formal args are created, and the description of
 each arg is set according to the existing ones.  This function is
 used when creating procedure declaration variables from a procedure
 declaration statement (see match_proc_decl()) to create the formal
 args based on the args of a given named interface.

 When an actual argument list is provided, skip the absent arguments
 unless copy_type is true.
 To be used together with gfc_se->ignore_optional.  */

4672void
4673gfc_copy_formal_args_intr (gfc_symbol *dest, gfc_intrinsic_sym *src,
	   gfc_actual_arglist *actual, bool copy_type)
4675{
gfc_formal_arglist *head = NULL__null;
gfc_formal_arglist *tail = NULL__null;
gfc_formal_arglist *formal_arg = NULL__null;
gfc_intrinsic_arg *curr_arg = NULL__null;
gfc_formal_arglist *formal_prev = NULL__null;
gfc_actual_arglist *act_arg = actual;
/* Save current namespace so we can change it for formal args.  */
gfc_namespace *parent_ns = gfc_current_ns;

/* Create a new namespace, which will be the formal ns (namespace
   of the formal args).  */
gfc_current_ns = gfc_get_namespace (parent_ns, 0);
gfc_current_ns->proc_name = dest;

for (curr_arg = src->formal; curr_arg; curr_arg = curr_arg->next)
  {
    /* Skip absent arguments.  */
    if (actual)
{
 gcc_assert (act_arg != NULL)((void)(!(act_arg != __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4695, __FUNCTION__), 0 : 0));
 if (act_arg->expr == NULL__null)
   {
     act_arg = act_arg->next;
     continue;
   }
}
    formal_arg = gfc_get_formal_arglist ()((gfc_formal_arglist *) xcalloc (1, sizeof (gfc_formal_arglist
)));
    gfc_get_symbol (curr_arg->name, gfc_current_ns, &(formal_arg->sym));

    /* May need to copy more info for the symbol.  */
    if (copy_type && act_arg->expr != NULL__null)
{
 formal_arg->sym->ts = act_arg->expr->ts;
 if (act_arg->expr->rank > 0)
   {
     formal_arg->sym->attr.dimension = 1;
     formal_arg->sym->as = gfc_get_array_spec()((gfc_array_spec *) xcalloc (1, sizeof (gfc_array_spec)));
     formal_arg->sym->as->rank = -1;
     formal_arg->sym->as->type = AS_ASSUMED_RANK;
   }
 if (act_arg->name && strcmp (act_arg->name, "%VAL") == 0)
   formal_arg->sym->pass_as_value = 1;
}
    else
formal_arg->sym->ts = curr_arg->ts;

    formal_arg->sym->attr.optional = curr_arg->optional;
    formal_arg->sym->attr.value = curr_arg->value;
    formal_arg->sym->attr.intent = curr_arg->intent;
    formal_arg->sym->attr.flavor = FL_VARIABLE;
    formal_arg->sym->attr.dummy = 1;

    if (formal_arg->sym->ts.type == BT_CHARACTER)
formal_arg->sym->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL__null);

    /* If this isn't the first arg, set up the next ptr.  For the
      last arg built, the formal_arg->next will never get set to
      anything other than NULL.  */
    if (formal_prev != NULL__null)
formal_prev->next = formal_arg;
    else
formal_arg->next = NULL__null;

    formal_prev = formal_arg;

    /* Add arg to list of formal args.  */
    add_formal_arg (&head, &tail, formal_arg, formal_arg->sym);

    /* Validate changes.  */
    gfc_commit_symbol (formal_arg->sym);
    if (actual)
act_arg = act_arg->next;
  }

/* Add the interface to the symbol.  */
add_proc_interface (dest, IFSRC_DECL, head);

/* Store the formal namespace information.  */
if (dest->formal != NULL__null)
  /* The current ns should be that for the dest proc.  */
  dest->formal_ns = gfc_current_ns;
/* Restore the current namespace to what it was on entry.  */
gfc_current_ns = parent_ns;
4759}


4762static int
4763std_for_isocbinding_symbol (int id)
4764{
switch (id)
  {
4767#define NAMED_INTCST(a,b,c,d) \
    case a:\
      return d;
4770#include "iso-c-binding.def"
4771#undef NAMED_INTCST

4773#define NAMED_FUNCTION(a,b,c,d) \
    case a:\
      return d;
4776#define NAMED_SUBROUTINE(a,b,c,d) \
    case a:\
      return d;
4779#include "iso-c-binding.def"
4780#undef NAMED_FUNCTION
4781#undef NAMED_SUBROUTINE

     default:
       return GFC_STD_F2003(1<<4);
  }
4786}

4788/* Generate the given set of C interoperable kind objects, or all
 interoperable kinds.  This function will only be given kind objects
 for valid iso_c_binding defined types because this is verified when
 the 'use' statement is parsed.  If the user gives an 'only' clause,
 the specific kinds are looked up; if they don't exist, an error is
 reported.  If the user does not give an 'only' clause, all
 iso_c_binding symbols are generated.  If a list of specific kinds
 is given, it must have a NULL in the first empty spot to mark the
 end of the list. For C_null_(fun)ptr, dt_symtree has to be set and
 point to the symtree for c_(fun)ptr.  */

4799gfc_symtree *
4800generate_isocbinding_symbol (const char *mod_name, iso_c_binding_symbol s,
	     const char *local_name, gfc_symtree *dt_symtree,
	     bool hidden)
4803{
const char *const name = (local_name && local_name[0])
	   ? local_name : c_interop_kinds_table[s].name;
gfc_symtree *tmp_symtree;
gfc_symbol *tmp_sym = NULL__null;
int index;

if (gfc_notification_std (std_for_isocbinding_symbol (s)) == ERROR)
  return NULL__null;

tmp_symtree = gfc_find_symtree (gfc_current_ns->sym_root, name);
if (hidden
    && (!tmp_symtree || !tmp_symtree->n.sym
 || tmp_symtree->n.sym->from_intmod != INTMOD_ISO_C_BINDING
 || tmp_symtree->n.sym->intmod_sym_id != s))
  tmp_symtree = NULL__null;

/* Already exists in this scope so don't re-add it.  */
if (tmp_symtree != NULL__null && (tmp_sym = tmp_symtree->n.sym) != NULL__null
    && (!tmp_sym->attr.generic
 || (tmp_sym = gfc_find_dt_in_generic (tmp_sym)) != NULL__null)
    && tmp_sym->from_intmod == INTMOD_ISO_C_BINDING)
  {
    if (tmp_sym->attr.flavor == FL_DERIVED
 && !get_iso_c_binding_dt (tmp_sym->intmod_sym_id))
{
 if (gfc_derived_types)
   {
     tmp_sym->dt_next = gfc_derived_types->dt_next;
     gfc_derived_types->dt_next = tmp_sym;
   }
 else
   {
     tmp_sym->dt_next = tmp_sym;
   }
 gfc_derived_types = tmp_sym;
      }

    return tmp_symtree;
  }

/* Create the sym tree in the current ns.  */
if (hidden)
  {
    tmp_symtree = gfc_get_unique_symtree (gfc_current_ns);
    tmp_sym = gfc_new_symbol (name, gfc_current_ns);

    /* Add to the list of tentative symbols.  */
    latest_undo_chgset->syms.safe_push (tmp_sym);
    tmp_sym->old_symbol = NULL__null;
    tmp_sym->mark = 1;
    tmp_sym->gfc_new = 1;

    tmp_symtree->n.sym = tmp_sym;
    tmp_sym->refs++;
  }
else
  {
    gfc_get_sym_tree (name, gfc_current_ns, &tmp_symtree, false);
    gcc_assert (tmp_symtree)((void)(!(tmp_symtree) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4862, __FUNCTION__), 0 : 0));
    tmp_sym = tmp_symtree->n.sym;
  }

/* Say what module this symbol belongs to.  */
tmp_sym->module = gfc_get_string ("%s", mod_name);
tmp_sym->from_intmod = INTMOD_ISO_C_BINDING;
tmp_sym->intmod_sym_id = s;
tmp_sym->attr.is_iso_c = 1;
tmp_sym->attr.use_assoc = 1;

gcc_assert (dt_symtree == NULL || s == ISOCBINDING_NULL_FUNPTR((void)(!(dt_symtree == __null || s == ISOCBINDING_NULL_FUNPTR
 || s == ISOCBINDING_NULL_PTR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4874, __FUNCTION__), 0 : 0))
     || s == ISOCBINDING_NULL_PTR)((void)(!(dt_symtree == __null || s == ISOCBINDING_NULL_FUNPTR
 || s == ISOCBINDING_NULL_PTR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4874, __FUNCTION__), 0 : 0));

switch (s)
  {

4879#define NAMED_INTCST(a,b,c,d) case a :
4880#define NAMED_REALCST(a,b,c,d) case a :
4881#define NAMED_CMPXCST(a,b,c,d) case a :
4882#define NAMED_LOGCST(a,b,c) case a :
4883#define NAMED_CHARKNDCST(a,b,c) case a :
4884#include "iso-c-binding.def"

tmp_sym->value = gfc_get_int_expr (gfc_default_integer_kind, NULL__null,
		 	   c_interop_kinds_table[s].value);

/* Initialize an integer constant expression node.  */
tmp_sym->attr.flavor = FL_PARAMETER;
tmp_sym->ts.type = BT_INTEGER;
tmp_sym->ts.kind = gfc_default_integer_kind;

/* Mark this type as a C interoperable one.  */
tmp_sym->ts.is_c_interop = 1;
tmp_sym->ts.is_iso_c = 1;
tmp_sym->value->ts.is_c_interop = 1;
tmp_sym->value->ts.is_iso_c = 1;
tmp_sym->attr.is_c_interop = 1;

/* Tell what f90 type this c interop kind is valid.  */
tmp_sym->ts.f90_type = c_interop_kinds_table[s].f90_type;

break;


4907#define NAMED_CHARCST(a,b,c) case a :
4908#include "iso-c-binding.def"

/* Initialize an integer constant expression node for the
  length of the character.  */
tmp_sym->value = gfc_get_character_expr (gfc_default_character_kind,
				 &gfc_current_locus, NULL__null, 1);
tmp_sym->value->ts.is_c_interop = 1;
tmp_sym->value->ts.is_iso_c = 1;
tmp_sym->value->value.character.length = 1;
tmp_sym->value->value.character.string[0]
 = (gfc_char_t) c_interop_kinds_table[s].value;
tmp_sym->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL__null);
tmp_sym->ts.u.cl->length = gfc_get_int_expr (gfc_charlen_int_kind,
				     NULL__null, 1);

/* May not need this in both attr and ts, but do need in
  attr for writing module file.  */
tmp_sym->attr.is_c_interop = 1;

tmp_sym->attr.flavor = FL_PARAMETER;
tmp_sym->ts.type = BT_CHARACTER;

/* Need to set it to the C_CHAR kind.  */
tmp_sym->ts.kind = gfc_default_character_kind;

/* Mark this type as a C interoperable one.  */
tmp_sym->ts.is_c_interop = 1;
tmp_sym->ts.is_iso_c = 1;

/* Tell what f90 type this c interop kind is valid.  */
tmp_sym->ts.f90_type = BT_CHARACTER;

break;

    case ISOCBINDING_PTR:
    case ISOCBINDING_FUNPTR:
{
 gfc_symbol *dt_sym;
 gfc_component *tmp_comp = NULL__null;

 /* Generate real derived type.  */
 if (hidden)
   dt_sym = tmp_sym;
 else
   {
     const char *hidden_name;
     gfc_interface *intr, *head;

     hidden_name = gfc_dt_upper_string (tmp_sym->name);
     tmp_symtree = gfc_find_symtree (gfc_current_ns->sym_root,
			      hidden_name);
     gcc_assert (tmp_symtree == NULL)((void)(!(tmp_symtree == __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 4959, __FUNCTION__), 0 : 0));
     gfc_get_sym_tree (hidden_name, gfc_current_ns, &tmp_symtree, false);
     dt_sym = tmp_symtree->n.sym;
     dt_sym->name = gfc_get_string (s == ISOCBINDING_PTR
			     ? "c_ptr" : "c_funptr");

     /* Generate an artificial generic function.  */
     head = tmp_sym->generic;
     intr = gfc_get_interface ()((gfc_interface *) xcalloc (1, sizeof (gfc_interface)));
     intr->sym = dt_sym;
     intr->where = gfc_current_locus;
     intr->next = head;
     tmp_sym->generic = intr;

     if (!tmp_sym->attr.generic
  && !gfc_add_generic (&tmp_sym->attr, tmp_sym->name, NULL__null))
return NULL__null;

     if (!tmp_sym->attr.function
  && !gfc_add_function (&tmp_sym->attr, tmp_sym->name, NULL__null))
return NULL__null;
   }

 /* Say what module this symbol belongs to.  */
 dt_sym->module = gfc_get_string ("%s", mod_name);
 dt_sym->from_intmod = INTMOD_ISO_C_BINDING;
 dt_sym->intmod_sym_id = s;
        dt_sym->attr.use_assoc = 1;

 /* Initialize an integer constant expression node.  */
 dt_sym->attr.flavor = FL_DERIVED;
 dt_sym->ts.is_c_interop = 1;
 dt_sym->attr.is_c_interop = 1;
 dt_sym->attr.private_comp = 1;
 dt_sym->component_access = ACCESS_PRIVATE;
 dt_sym->ts.is_iso_c = 1;
 dt_sym->ts.type = BT_DERIVED;
 dt_sym->ts.f90_type = BT_VOID;

 /* A derived type must have the bind attribute to be
    interoperable (J3/04-007, Section 15.2.3), even though
    the binding label is not used.  */
 dt_sym->attr.is_bind_c = 1;

 dt_sym->attr.referenced = 1;
 dt_sym->ts.u.derived = dt_sym;

 /* Add the symbol created for the derived type to the current ns.  */
 if (gfc_derived_types)
   {
     dt_sym->dt_next = gfc_derived_types->dt_next;
     gfc_derived_types->dt_next = dt_sym;
   }
 else
   {
     dt_sym->dt_next = dt_sym;
   }
 gfc_derived_types = dt_sym;

 gfc_add_component (dt_sym, "c_address", &tmp_comp);
 if (tmp_comp == NULL__null)
   gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5020, __FUNCTION__));

 tmp_comp->ts.type = BT_INTEGER;

 /* Set this because the module will need to read/write this field.  */
 tmp_comp->ts.f90_type = BT_INTEGER;

 /* The kinds for c_ptr and c_funptr are the same.  */
 index = get_c_kind ("c_ptr", c_interop_kinds_table);
 tmp_comp->ts.kind = c_interop_kinds_table[index].value;
 tmp_comp->attr.access = ACCESS_PRIVATE;

 /* Mark the component as C interoperable.  */
 tmp_comp->ts.is_c_interop = 1;
}

break;

    case ISOCBINDING_NULL_PTR:
    case ISOCBINDING_NULL_FUNPTR:
      gen_special_c_interop_ptr (tmp_sym, dt_symtree);
      break;

    default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5044, __FUNCTION__));
  }
gfc_commit_symbol (tmp_sym);
return tmp_symtree;
5048}


5051/* Check that a symbol is already typed.  If strict is not set, an untyped
 symbol is acceptable for non-standard-conforming mode.  */

5054bool
5055gfc_check_symbol_typed (gfc_symbol* sym, gfc_namespace* ns,
	bool strict, locus where)
5057{
gcc_assert (sym)((void)(!(sym) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5058, __FUNCTION__), 0 : 0));

if (gfc_matching_prefix)
  return true;

/* Check for the type and try to give it an implicit one.  */
if (sym->ts.type == BT_UNKNOWN
    && !gfc_set_default_type (sym, 0, ns))
  {
    if (strict)
{
 gfc_error ("Symbol %qs is used before it is typed at %L",
     sym->name, &where);
 return false;
}

    if (!gfc_notify_std (GFC_STD_GNU(1<<5), "Symbol %qs is used before"
	   " it is typed at %L", sym->name, &where))
return false;
  }

/* Everything is ok.  */
return true;
5081}


5084/* Construct a typebound-procedure structure.  Those are stored in a tentative
 list and marked `error' until symbols are committed.  */

5087gfc_typebound_proc*
5088gfc_get_typebound_proc (gfc_typebound_proc *tb0)
5089{
gfc_typebound_proc *result;

result = XCNEW (gfc_typebound_proc)((gfc_typebound_proc *) xcalloc (1, sizeof (gfc_typebound_proc
)));
if (tb0)
  *result = *tb0;
result->error = 1;

latest_undo_chgset->tbps.safe_push (result);

return result;
5100}


5103/* Get the super-type of a given derived type.  */

5105gfc_symbol*
5106gfc_get_derived_super_type (gfc_symbol* derived)
5107{
gcc_assert (derived)((void)(!(derived) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5108, __FUNCTION__), 0 : 0));

if (derived->attr.generic)
  derived = gfc_find_dt_in_generic (derived);

if (!derived->attr.extension)
  return NULL__null;

gcc_assert (derived->components)((void)(!(derived->components) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5116, __FUNCTION__), 0 : 0));
gcc_assert (derived->components->ts.type == BT_DERIVED)((void)(!(derived->components->ts.type == BT_DERIVED) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5117, __FUNCTION__), 0 : 0));
gcc_assert (derived->components->ts.u.derived)((void)(!(derived->components->ts.u.derived) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5118, __FUNCTION__), 0 : 0));

if (derived->components->ts.u.derived->attr.generic)
  return gfc_find_dt_in_generic (derived->components->ts.u.derived);

return derived->components->ts.u.derived;
5124}


5127/* Check if a derived type t2 is an extension of (or equal to) a type t1.  */

5129bool
5130gfc_type_is_extension_of (gfc_symbol *t1, gfc_symbol *t2)
5131{
while (!gfc_compare_derived_types (t1, t2) && t2->attr.extension)
  t2 = gfc_get_derived_super_type (t2);
return gfc_compare_derived_types (t1, t2);
5135}


5138/* Check if two typespecs are type compatible (F03:5.1.1.2):
 If ts1 is nonpolymorphic, ts2 must be the same type.
 If ts1 is polymorphic (CLASS), ts2 must be an extension of ts1.  */

5142bool
5143gfc_type_compatible (gfc_typespec *ts1, gfc_typespec *ts2)
5144{
bool is_class1 = (ts1->type == BT_CLASS);
bool is_class2 = (ts2->type == BT_CLASS);
bool is_derived1 = (ts1->type == BT_DERIVED);
bool is_derived2 = (ts2->type == BT_DERIVED);
bool is_union1 = (ts1->type == BT_UNION);
bool is_union2 = (ts2->type == BT_UNION);

/* A boz-literal-constant has no type.  */
if (ts1->type == BT_BOZ || ts2->type == BT_BOZ)
  return false;

if (is_class1
    && ts1->u.derived->components
    && ((ts1->u.derived->attr.is_class
  && ts1->u.derived->components->ts.u.derived->attr
					.unlimited_polymorphic)
 || ts1->u.derived->attr.unlimited_polymorphic))
  return 1;

if (!is_derived1 && !is_derived2 && !is_class1 && !is_class2
    && !is_union1 && !is_union2)
  return (ts1->type == ts2->type);

if ((is_derived1 && is_derived2) || (is_union1 && is_union2))
  return gfc_compare_derived_types (ts1->u.derived, ts2->u.derived);

if (is_derived1 && is_class2)
  return gfc_compare_derived_types (ts1->u.derived,
		      ts2->u.derived->attr.is_class ?
		      ts2->u.derived->components->ts.u.derived
		      : ts2->u.derived);
if (is_class1 && is_derived2)
  return gfc_type_is_extension_of (ts1->u.derived->attr.is_class ?
		       ts1->u.derived->components->ts.u.derived
		     : ts1->u.derived,
		     ts2->u.derived);
else if (is_class1 && is_class2)
  return gfc_type_is_extension_of (ts1->u.derived->attr.is_class ?
		       ts1->u.derived->components->ts.u.derived
		     : ts1->u.derived,
		     ts2->u.derived->attr.is_class ?
		       ts2->u.derived->components->ts.u.derived
		     : ts2->u.derived);
else
  return 0;
5190}


5193/* Find the parent-namespace of the current function.  If we're inside
 BLOCK constructs, it may not be the current one.  */

5196gfc_namespace*
5197gfc_find_proc_namespace (gfc_namespace* ns)
5198{
while (ns->construct_entities)
  {
    ns = ns->parent;
    gcc_assert (ns)((void)(!(ns) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/fortran/symbol.cc"
, 5202, __FUNCTION__), 0 : 0));
  }

return ns;
5206}


5209/* Check if an associate-variable should be translated as an `implicit' pointer
 internally (if it is associated to a variable and not an array with
 descriptor).  */

5213bool
5214gfc_is_associate_pointer (gfc_symbol* sym)
5215{
if (!sym->assoc)
  return false;

if (sym->ts.type == BT_CLASS)
  return true;

if (sym->ts.type == BT_CHARACTER
    && sym->ts.deferred
    && sym->assoc->target
    && sym->assoc->target->expr_type == EXPR_FUNCTION)
  return true;

if (!sym->assoc->variable)
  return false;

if (sym->attr.dimension && sym->as->type != AS_EXPLICIT)
  return false;

return true;
5235}


5238gfc_symbol *
5239gfc_find_dt_in_generic (gfc_symbol *sym)
5240{
gfc_interface *intr = NULL__null;

if (!sym || gfc_fl_struct (sym->attr.flavor)((sym->attr.flavor) == FL_DERIVED || (sym->attr.flavor)
 == FL_UNION || (sym->attr.flavor) == FL_STRUCT))
  return sym;

if (sym->attr.generic)
  for (intr = sym->generic; intr; intr = intr->next)
    if (gfc_fl_struct (intr->sym->attr.flavor)((intr->sym->attr.flavor) == FL_DERIVED || (intr->sym
->attr.flavor) == FL_UNION || (intr->sym->attr.flavor
) == FL_STRUCT))
      break;
return intr ? intr->sym : NULL__null;
5251}


5254/* Get the dummy arguments from a procedure symbol. If it has been declared
 via a PROCEDURE statement with a named interface, ts.interface will be set
 and the arguments need to be taken from there.  */

5258gfc_formal_arglist *
5259gfc_sym_get_dummy_args (gfc_symbol *sym)
5260{
gfc_formal_arglist *dummies;

if (sym == NULL__null)
  return NULL__null;

dummies = sym->formal;
if (dummies == NULL__null && sym->ts.interface != NULL__null)
  dummies = sym->ts.interface->formal;

return dummies;
5271}