Subversion Repositories openrisc_2011-10-31

/* gfortran backend interface

/* gfortran backend interface

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010

   Free Software Foundation, Inc.

   Free Software Foundation, Inc.

   Contributed by Paul Brook.

   Contributed by Paul Brook.

This file is part of GCC.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

Software Foundation; either version 3, or (at your option) any later

version.

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

for more details.

You should have received a copy of the GNU General Public License

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

<http://www.gnu.org/licenses/>.  */

/* f95-lang.c-- GCC backend interface stuff */

/* f95-lang.c-- GCC backend interface stuff */

/* declare required prototypes: */

/* declare required prototypes: */

#include "config.h"

#include "config.h"

#include "system.h"

#include "system.h"

#include "ansidecl.h"

#include "ansidecl.h"

#include "system.h"

#include "system.h"

#include "coretypes.h"

#include "coretypes.h"

#include "tree.h"

#include "tree.h"

#include "gimple.h"

#include "gimple.h"

#include "flags.h"

#include "flags.h"

#include "langhooks.h"

#include "langhooks.h"

#include "langhooks-def.h"

#include "langhooks-def.h"

#include "timevar.h"

#include "timevar.h"

#include "tm.h"

#include "tm.h"

#include "function.h"

#include "function.h"

#include "ggc.h"

#include "ggc.h"

#include "toplev.h"

#include "toplev.h"

#include "target.h"

#include "target.h"

#include "debug.h"

#include "debug.h"

#include "diagnostic.h"

#include "diagnostic.h"

#include "tree-dump.h"

#include "tree-dump.h"

#include "cgraph.h"

#include "cgraph.h"

/* For gfc_maybe_initialize_eh.  */

/* For gfc_maybe_initialize_eh.  */

#include "libfuncs.h"

#include "libfuncs.h"

#include "expr.h"

#include "expr.h"

#include "except.h"

#include "except.h"

#include "gfortran.h"

#include "gfortran.h"

#include "cpp.h"

#include "cpp.h"

#include "trans.h"

#include "trans.h"

#include "trans-types.h"

#include "trans-types.h"

#include "trans-const.h"

#include "trans-const.h"

/* Language-dependent contents of an identifier.  */

/* Language-dependent contents of an identifier.  */

struct GTY(())

struct GTY(())

lang_identifier {

lang_identifier {

  struct tree_identifier common;

  struct tree_identifier common;

};

};

/* The resulting tree type.  */

/* The resulting tree type.  */

union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),

union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),

     chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))

     chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))

lang_tree_node {

lang_tree_node {

  union tree_node GTY((tag ("0"),

  union tree_node GTY((tag ("0"),

                       desc ("tree_node_structure (&%h)"))) generic;

                       desc ("tree_node_structure (&%h)"))) generic;

  struct lang_identifier GTY((tag ("1"))) identifier;

  struct lang_identifier GTY((tag ("1"))) identifier;

};

};

/* Save and restore the variables in this file and elsewhere

/* Save and restore the variables in this file and elsewhere

   that keep track of the progress of compilation of the current function.

   that keep track of the progress of compilation of the current function.

   Used for nested functions.  */

   Used for nested functions.  */

struct GTY(())

struct GTY(())

language_function {

language_function {

  /* struct gfc_language_function base; */

  /* struct gfc_language_function base; */

  struct binding_level *binding_level;

  struct binding_level *binding_level;

};

};

/* We don't have a lex/yacc lexer/parser, but toplev expects these to

/* We don't have a lex/yacc lexer/parser, but toplev expects these to

   exist anyway.  */

   exist anyway.  */

void yyerror (const char *str);

void yyerror (const char *str);

int yylex (void);

int yylex (void);

static void gfc_init_decl_processing (void);

static void gfc_init_decl_processing (void);

static void gfc_init_builtin_functions (void);

static void gfc_init_builtin_functions (void);

/* Each front end provides its own.  */

/* Each front end provides its own.  */

static bool gfc_init (void);

static bool gfc_init (void);

static void gfc_finish (void);

static void gfc_finish (void);

static void gfc_print_identifier (FILE *, tree, int);

static void gfc_print_identifier (FILE *, tree, int);

void do_function_end (void);

void do_function_end (void);

int global_bindings_p (void);

int global_bindings_p (void);

static void clear_binding_stack (void);

static void clear_binding_stack (void);

static void gfc_be_parse_file (int);

static void gfc_be_parse_file (int);

static alias_set_type gfc_get_alias_set (tree);

static alias_set_type gfc_get_alias_set (tree);

static void gfc_init_ts (void);

static void gfc_init_ts (void);

#undef LANG_HOOKS_NAME

#undef LANG_HOOKS_NAME

#undef LANG_HOOKS_INIT

#undef LANG_HOOKS_INIT

#undef LANG_HOOKS_FINISH

#undef LANG_HOOKS_FINISH

#undef LANG_HOOKS_INIT_OPTIONS

#undef LANG_HOOKS_INIT_OPTIONS

#undef LANG_HOOKS_HANDLE_OPTION

#undef LANG_HOOKS_HANDLE_OPTION

#undef LANG_HOOKS_POST_OPTIONS

#undef LANG_HOOKS_POST_OPTIONS

#undef LANG_HOOKS_PRINT_IDENTIFIER

#undef LANG_HOOKS_PRINT_IDENTIFIER

#undef LANG_HOOKS_PARSE_FILE

#undef LANG_HOOKS_PARSE_FILE

#undef LANG_HOOKS_MARK_ADDRESSABLE

#undef LANG_HOOKS_MARK_ADDRESSABLE

#undef LANG_HOOKS_TYPE_FOR_MODE

#undef LANG_HOOKS_TYPE_FOR_MODE

#undef LANG_HOOKS_TYPE_FOR_SIZE

#undef LANG_HOOKS_TYPE_FOR_SIZE

#undef LANG_HOOKS_GET_ALIAS_SET

#undef LANG_HOOKS_GET_ALIAS_SET

#undef LANG_HOOKS_INIT_TS

#undef LANG_HOOKS_INIT_TS

#undef LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE

#undef LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE

#undef LANG_HOOKS_OMP_PREDETERMINED_SHARING

#undef LANG_HOOKS_OMP_PREDETERMINED_SHARING

#undef LANG_HOOKS_OMP_REPORT_DECL

#undef LANG_HOOKS_OMP_REPORT_DECL

#undef LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR

#undef LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR

#undef LANG_HOOKS_OMP_CLAUSE_COPY_CTOR

#undef LANG_HOOKS_OMP_CLAUSE_COPY_CTOR

#undef LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP

#undef LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP

#undef LANG_HOOKS_OMP_CLAUSE_DTOR

#undef LANG_HOOKS_OMP_CLAUSE_DTOR

#undef LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR

#undef LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR

#undef LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE

#undef LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE

#undef LANG_HOOKS_OMP_PRIVATE_OUTER_REF

#undef LANG_HOOKS_OMP_PRIVATE_OUTER_REF

#undef LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES

#undef LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES

#undef LANG_HOOKS_BUILTIN_FUNCTION

#undef LANG_HOOKS_BUILTIN_FUNCTION

#undef LANG_HOOKS_GET_ARRAY_DESCR_INFO

#undef LANG_HOOKS_GET_ARRAY_DESCR_INFO

/* Define lang hooks.  */

/* Define lang hooks.  */

#define LANG_HOOKS_NAME                 "GNU Fortran"

#define LANG_HOOKS_NAME                 "GNU Fortran"

#define LANG_HOOKS_INIT                 gfc_init

#define LANG_HOOKS_INIT                 gfc_init

#define LANG_HOOKS_FINISH               gfc_finish

#define LANG_HOOKS_FINISH               gfc_finish

#define LANG_HOOKS_INIT_OPTIONS         gfc_init_options

#define LANG_HOOKS_INIT_OPTIONS         gfc_init_options

#define LANG_HOOKS_HANDLE_OPTION        gfc_handle_option

#define LANG_HOOKS_HANDLE_OPTION        gfc_handle_option

#define LANG_HOOKS_POST_OPTIONS         gfc_post_options

#define LANG_HOOKS_POST_OPTIONS         gfc_post_options

#define LANG_HOOKS_PRINT_IDENTIFIER     gfc_print_identifier

#define LANG_HOOKS_PRINT_IDENTIFIER     gfc_print_identifier

#define LANG_HOOKS_PARSE_FILE           gfc_be_parse_file

#define LANG_HOOKS_PARSE_FILE           gfc_be_parse_file

#define LANG_HOOKS_TYPE_FOR_MODE        gfc_type_for_mode

#define LANG_HOOKS_TYPE_FOR_MODE        gfc_type_for_mode

#define LANG_HOOKS_TYPE_FOR_SIZE        gfc_type_for_size

#define LANG_HOOKS_TYPE_FOR_SIZE        gfc_type_for_size

#define LANG_HOOKS_GET_ALIAS_SET        gfc_get_alias_set

#define LANG_HOOKS_GET_ALIAS_SET        gfc_get_alias_set

#define LANG_HOOKS_INIT_TS              gfc_init_ts

#define LANG_HOOKS_INIT_TS              gfc_init_ts

#define LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE   gfc_omp_privatize_by_reference

#define LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE   gfc_omp_privatize_by_reference

#define LANG_HOOKS_OMP_PREDETERMINED_SHARING    gfc_omp_predetermined_sharing

#define LANG_HOOKS_OMP_PREDETERMINED_SHARING    gfc_omp_predetermined_sharing

#define LANG_HOOKS_OMP_REPORT_DECL              gfc_omp_report_decl

#define LANG_HOOKS_OMP_REPORT_DECL              gfc_omp_report_decl

#define LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR      gfc_omp_clause_default_ctor

#define LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR      gfc_omp_clause_default_ctor

#define LANG_HOOKS_OMP_CLAUSE_COPY_CTOR         gfc_omp_clause_copy_ctor

#define LANG_HOOKS_OMP_CLAUSE_COPY_CTOR         gfc_omp_clause_copy_ctor

#define LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP         gfc_omp_clause_assign_op

#define LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP         gfc_omp_clause_assign_op

#define LANG_HOOKS_OMP_CLAUSE_DTOR              gfc_omp_clause_dtor

#define LANG_HOOKS_OMP_CLAUSE_DTOR              gfc_omp_clause_dtor

#define LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR     gfc_omp_disregard_value_expr

#define LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR     gfc_omp_disregard_value_expr

#define LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE     gfc_omp_private_debug_clause

#define LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE     gfc_omp_private_debug_clause

#define LANG_HOOKS_OMP_PRIVATE_OUTER_REF        gfc_omp_private_outer_ref

#define LANG_HOOKS_OMP_PRIVATE_OUTER_REF        gfc_omp_private_outer_ref

#define LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES \

#define LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES \

  gfc_omp_firstprivatize_type_sizes

  gfc_omp_firstprivatize_type_sizes

#define LANG_HOOKS_BUILTIN_FUNCTION          gfc_builtin_function

#define LANG_HOOKS_BUILTIN_FUNCTION          gfc_builtin_function

#define LANG_HOOKS_GET_ARRAY_DESCR_INFO      gfc_get_array_descr_info

#define LANG_HOOKS_GET_ARRAY_DESCR_INFO      gfc_get_array_descr_info

struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;

struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;

#define NULL_BINDING_LEVEL (struct binding_level *) NULL

#define NULL_BINDING_LEVEL (struct binding_level *) NULL

/* A chain of binding_level structures awaiting reuse.  */

/* A chain of binding_level structures awaiting reuse.  */

static GTY(()) struct binding_level *free_binding_level;

static GTY(()) struct binding_level *free_binding_level;

/* The elements of `ridpointers' are identifier nodes

/* The elements of `ridpointers' are identifier nodes

   for the reserved type names and storage classes.

   for the reserved type names and storage classes.

   It is indexed by a RID_... value.  */

   It is indexed by a RID_... value.  */

tree *ridpointers = NULL;

tree *ridpointers = NULL;

/* True means we've initialized exception handling.  */

/* True means we've initialized exception handling.  */

bool gfc_eh_initialized_p;

bool gfc_eh_initialized_p;

/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,

/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,

   or validate its data type for an `if' or `while' statement or ?..: exp.

   or validate its data type for an `if' or `while' statement or ?..: exp.

   This preparation consists of taking the ordinary

   This preparation consists of taking the ordinary

   representation of an expression expr and producing a valid tree

   representation of an expression expr and producing a valid tree

   boolean expression describing whether expr is nonzero.  We could

   boolean expression describing whether expr is nonzero.  We could

   simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),

   simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),

   but we optimize comparisons, &&, ||, and !.

   but we optimize comparisons, &&, ||, and !.

   The resulting type should always be `boolean_type_node'.

   The resulting type should always be `boolean_type_node'.

   This is much simpler than the corresponding C version because we have a

   This is much simpler than the corresponding C version because we have a

   distinct boolean type.  */

   distinct boolean type.  */

tree

tree

gfc_truthvalue_conversion (tree expr)

gfc_truthvalue_conversion (tree expr)

{

{

  switch (TREE_CODE (TREE_TYPE (expr)))

  switch (TREE_CODE (TREE_TYPE (expr)))

    {

    {

    case BOOLEAN_TYPE:

    case BOOLEAN_TYPE:

      if (TREE_TYPE (expr) == boolean_type_node)

      if (TREE_TYPE (expr) == boolean_type_node)

        return expr;

        return expr;

      else if (COMPARISON_CLASS_P (expr))

      else if (COMPARISON_CLASS_P (expr))

        {

        {

          TREE_TYPE (expr) = boolean_type_node;

          TREE_TYPE (expr) = boolean_type_node;

          return expr;

          return expr;

        }

        }

      else if (TREE_CODE (expr) == NOP_EXPR)

      else if (TREE_CODE (expr) == NOP_EXPR)

        return fold_build1 (NOP_EXPR,

        return fold_build1 (NOP_EXPR,

                            boolean_type_node, TREE_OPERAND (expr, 0));

                            boolean_type_node, TREE_OPERAND (expr, 0));

      else

      else

        return fold_build1 (NOP_EXPR, boolean_type_node, expr);

        return fold_build1 (NOP_EXPR, boolean_type_node, expr);

    case INTEGER_TYPE:

    case INTEGER_TYPE:

      if (TREE_CODE (expr) == INTEGER_CST)

      if (TREE_CODE (expr) == INTEGER_CST)

        return integer_zerop (expr) ? boolean_false_node : boolean_true_node;

        return integer_zerop (expr) ? boolean_false_node : boolean_true_node;

      else

      else

        return fold_build2 (NE_EXPR, boolean_type_node, expr,

        return fold_build2 (NE_EXPR, boolean_type_node, expr,

                            build_int_cst (TREE_TYPE (expr), 0));

                            build_int_cst (TREE_TYPE (expr), 0));

    default:

    default:

      internal_error ("Unexpected type in truthvalue_conversion");

      internal_error ("Unexpected type in truthvalue_conversion");

    }

    }

}

}

static void

static void

gfc_create_decls (void)

gfc_create_decls (void)

{

{

  /* GCC builtins.  */

  /* GCC builtins.  */

  gfc_init_builtin_functions ();

  gfc_init_builtin_functions ();

  /* Runtime/IO library functions.  */

  /* Runtime/IO library functions.  */

  gfc_build_builtin_function_decls ();

  gfc_build_builtin_function_decls ();

  gfc_init_constants ();

  gfc_init_constants ();

}

}

static void

static void

gfc_be_parse_file (int set_yydebug ATTRIBUTE_UNUSED)

gfc_be_parse_file (int set_yydebug ATTRIBUTE_UNUSED)

{

{

  int errors;

  int errors;

  int warnings;

  int warnings;

  gfc_create_decls ();

  gfc_create_decls ();

  gfc_parse_file ();

  gfc_parse_file ();

  gfc_generate_constructors ();

  gfc_generate_constructors ();

  /* Tell the frontend about any errors.  */

  /* Tell the frontend about any errors.  */

  gfc_get_errors (&warnings, &errors);

  gfc_get_errors (&warnings, &errors);

  errorcount += errors;

  errorcount += errors;

  warningcount += warnings;

  warningcount += warnings;

  clear_binding_stack ();

  clear_binding_stack ();

}

}

/* Initialize everything.  */

/* Initialize everything.  */

static bool

static bool

gfc_init (void)

gfc_init (void)

{

{

  if (!gfc_cpp_enabled ())

  if (!gfc_cpp_enabled ())

    {

    {

      linemap_add (line_table, LC_ENTER, false, gfc_source_file, 1);

      linemap_add (line_table, LC_ENTER, false, gfc_source_file, 1);

      linemap_add (line_table, LC_RENAME, false, "<built-in>", 0);

      linemap_add (line_table, LC_RENAME, false, "<built-in>", 0);

    }

    }

  else

  else

    gfc_cpp_init_0 ();

    gfc_cpp_init_0 ();

  gfc_init_decl_processing ();

  gfc_init_decl_processing ();

  gfc_static_ctors = NULL_TREE;

  gfc_static_ctors = NULL_TREE;

  if (gfc_cpp_enabled ())

  if (gfc_cpp_enabled ())

    gfc_cpp_init ();

    gfc_cpp_init ();

  gfc_init_1 ();

  gfc_init_1 ();

  if (gfc_new_file () != SUCCESS)

  if (gfc_new_file () != SUCCESS)

    fatal_error ("can't open input file: %s", gfc_source_file);

    fatal_error ("can't open input file: %s", gfc_source_file);

  return true;

  return true;

}

}

static void

static void

gfc_finish (void)

gfc_finish (void)

{

{

  gfc_cpp_done ();

  gfc_cpp_done ();

  gfc_done_1 ();

  gfc_done_1 ();

  gfc_release_include_path ();

  gfc_release_include_path ();

  return;

  return;

}

}

static void

static void

gfc_print_identifier (FILE * file ATTRIBUTE_UNUSED,

gfc_print_identifier (FILE * file ATTRIBUTE_UNUSED,

                      tree node ATTRIBUTE_UNUSED,

                      tree node ATTRIBUTE_UNUSED,

                      int indent ATTRIBUTE_UNUSED)

                      int indent ATTRIBUTE_UNUSED)

{

{

  return;

  return;

}

}

/* These functions and variables deal with binding contours.  We only

/* These functions and variables deal with binding contours.  We only

   need these functions for the list of PARM_DECLs, but we leave the

   need these functions for the list of PARM_DECLs, but we leave the

   functions more general; these are a simplified version of the

   functions more general; these are a simplified version of the

   functions from GNAT.  */

   functions from GNAT.  */

/* For each binding contour we allocate a binding_level structure which

/* For each binding contour we allocate a binding_level structure which

   records the entities defined or declared in that contour.  Contours

   records the entities defined or declared in that contour.  Contours

   include:

   include:

        the global one

        the global one

        one for each subprogram definition

        one for each subprogram definition

        one for each compound statement (declare block)

        one for each compound statement (declare block)

   Binding contours are used to create GCC tree BLOCK nodes.  */

   Binding contours are used to create GCC tree BLOCK nodes.  */

struct GTY(())

struct GTY(())

binding_level {

binding_level {

  /* A chain of ..._DECL nodes for all variables, constants, functions,

  /* A chain of ..._DECL nodes for all variables, constants, functions,

     parameters and type declarations.  These ..._DECL nodes are chained

     parameters and type declarations.  These ..._DECL nodes are chained

     through the TREE_CHAIN field. Note that these ..._DECL nodes are stored

     through the TREE_CHAIN field. Note that these ..._DECL nodes are stored

     in the reverse of the order supplied to be compatible with the

     in the reverse of the order supplied to be compatible with the

     back-end.  */

     back-end.  */

  tree names;

  tree names;

  /* For each level (except the global one), a chain of BLOCK nodes for all

  /* For each level (except the global one), a chain of BLOCK nodes for all

     the levels that were entered and exited one level down from this one.  */

     the levels that were entered and exited one level down from this one.  */

  tree blocks;

  tree blocks;

  /* The binding level containing this one (the enclosing binding level).  */

  /* The binding level containing this one (the enclosing binding level).  */

  struct binding_level *level_chain;

  struct binding_level *level_chain;

};

};

/* The binding level currently in effect.  */

/* The binding level currently in effect.  */

static GTY(()) struct binding_level *current_binding_level = NULL;

static GTY(()) struct binding_level *current_binding_level = NULL;

/* The outermost binding level. This binding level is created when the

/* The outermost binding level. This binding level is created when the

   compiler is started and it will exist through the entire compilation.  */

   compiler is started and it will exist through the entire compilation.  */

static GTY(()) struct binding_level *global_binding_level;

static GTY(()) struct binding_level *global_binding_level;

/* Binding level structures are initialized by copying this one.  */

/* Binding level structures are initialized by copying this one.  */

static struct binding_level clear_binding_level = { NULL, NULL, NULL };

static struct binding_level clear_binding_level = { NULL, NULL, NULL };

/* Return nonzero if we are currently in the global binding level.  */

/* Return nonzero if we are currently in the global binding level.  */

int

int

global_bindings_p (void)

global_bindings_p (void)

{

{

  return current_binding_level == global_binding_level ? -1 : 0;

  return current_binding_level == global_binding_level ? -1 : 0;

}

}

tree

tree

getdecls (void)

getdecls (void)

{

{

  return current_binding_level->names;

  return current_binding_level->names;

}

}

/* Enter a new binding level. The input parameter is ignored, but has to be

/* Enter a new binding level. The input parameter is ignored, but has to be

   specified for back-end compatibility.  */

   specified for back-end compatibility.  */

void

void

pushlevel (int ignore ATTRIBUTE_UNUSED)

pushlevel (int ignore ATTRIBUTE_UNUSED)

{

{

  struct binding_level *newlevel

  struct binding_level *newlevel

    = (struct binding_level *) ggc_alloc (sizeof (struct binding_level));

    = (struct binding_level *) ggc_alloc (sizeof (struct binding_level));

  *newlevel = clear_binding_level;

  *newlevel = clear_binding_level;

  /* Add this level to the front of the chain (stack) of levels that are

  /* Add this level to the front of the chain (stack) of levels that are

     active.  */

     active.  */

  newlevel->level_chain = current_binding_level;

  newlevel->level_chain = current_binding_level;

  current_binding_level = newlevel;

  current_binding_level = newlevel;

}

}

/* Exit a binding level.

/* Exit a binding level.

   Pop the level off, and restore the state of the identifier-decl mappings

   Pop the level off, and restore the state of the identifier-decl mappings

   that were in effect when this level was entered.

   that were in effect when this level was entered.

   If KEEP is nonzero, this level had explicit declarations, so

   If KEEP is nonzero, this level had explicit declarations, so

   and create a "block" (a BLOCK node) for the level

   and create a "block" (a BLOCK node) for the level

   to record its declarations and subblocks for symbol table output.

   to record its declarations and subblocks for symbol table output.

   If FUNCTIONBODY is nonzero, this level is the body of a function,

   If FUNCTIONBODY is nonzero, this level is the body of a function,

   so create a block as if KEEP were set and also clear out all

   so create a block as if KEEP were set and also clear out all

   label names.

   label names.

   If REVERSE is nonzero, reverse the order of decls before putting

   If REVERSE is nonzero, reverse the order of decls before putting

   them into the BLOCK.  */

   them into the BLOCK.  */

tree

tree

poplevel (int keep, int reverse, int functionbody)

poplevel (int keep, int reverse, int functionbody)

{

{

  /* Points to a BLOCK tree node. This is the BLOCK node constructed for the

  /* Points to a BLOCK tree node. This is the BLOCK node constructed for the

     binding level that we are about to exit and which is returned by this

     binding level that we are about to exit and which is returned by this

     routine.  */

     routine.  */

  tree block_node = NULL_TREE;

  tree block_node = NULL_TREE;

  tree decl_chain;

  tree decl_chain;

  tree subblock_chain = current_binding_level->blocks;

  tree subblock_chain = current_binding_level->blocks;

  tree subblock_node;

  tree subblock_node;

  /* Reverse the list of XXXX_DECL nodes if desired.  Note that the ..._DECL

  /* Reverse the list of XXXX_DECL nodes if desired.  Note that the ..._DECL

     nodes chained through the `names' field of current_binding_level are in

     nodes chained through the `names' field of current_binding_level are in

     reverse order except for PARM_DECL node, which are explicitly stored in

     reverse order except for PARM_DECL node, which are explicitly stored in

     the right order.  */

     the right order.  */

  decl_chain = (reverse) ? nreverse (current_binding_level->names)

  decl_chain = (reverse) ? nreverse (current_binding_level->names)

                         : current_binding_level->names;

                         : current_binding_level->names;

  /* If there were any declarations in the current binding level, or if this

  /* If there were any declarations in the current binding level, or if this

     binding level is a function body, or if there are any nested blocks then

     binding level is a function body, or if there are any nested blocks then

     create a BLOCK node to record them for the life of this function.  */

     create a BLOCK node to record them for the life of this function.  */

  if (keep || functionbody)

  if (keep || functionbody)

    block_node = build_block (keep ? decl_chain : 0, subblock_chain, 0, 0);

    block_node = build_block (keep ? decl_chain : 0, subblock_chain, 0, 0);

  /* Record the BLOCK node just built as the subblock its enclosing scope.  */

  /* Record the BLOCK node just built as the subblock its enclosing scope.  */

  for (subblock_node = subblock_chain; subblock_node;

  for (subblock_node = subblock_chain; subblock_node;

       subblock_node = TREE_CHAIN (subblock_node))

       subblock_node = TREE_CHAIN (subblock_node))

    BLOCK_SUPERCONTEXT (subblock_node) = block_node;

    BLOCK_SUPERCONTEXT (subblock_node) = block_node;

  /* Clear out the meanings of the local variables of this level.  */

  /* Clear out the meanings of the local variables of this level.  */

  for (subblock_node = decl_chain; subblock_node;

  for (subblock_node = decl_chain; subblock_node;

       subblock_node = TREE_CHAIN (subblock_node))

       subblock_node = TREE_CHAIN (subblock_node))

    if (DECL_NAME (subblock_node) != 0)

    if (DECL_NAME (subblock_node) != 0)

      /* If the identifier was used or addressed via a local extern decl,

      /* If the identifier was used or addressed via a local extern decl,

         don't forget that fact.  */

         don't forget that fact.  */

      if (DECL_EXTERNAL (subblock_node))

      if (DECL_EXTERNAL (subblock_node))

        {

        {

          if (TREE_USED (subblock_node))

          if (TREE_USED (subblock_node))

            TREE_USED (DECL_NAME (subblock_node)) = 1;

            TREE_USED (DECL_NAME (subblock_node)) = 1;

          if (TREE_ADDRESSABLE (subblock_node))

          if (TREE_ADDRESSABLE (subblock_node))

            TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (subblock_node)) = 1;

            TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (subblock_node)) = 1;

        }

        }

  /* Pop the current level.  */

  /* Pop the current level.  */

  current_binding_level = current_binding_level->level_chain;

  current_binding_level = current_binding_level->level_chain;

  if (functionbody)

  if (functionbody)

    /* This is the top level block of a function. */

    /* This is the top level block of a function. */

    DECL_INITIAL (current_function_decl) = block_node;

    DECL_INITIAL (current_function_decl) = block_node;

  else if (current_binding_level == global_binding_level)

  else if (current_binding_level == global_binding_level)

    /* When using gfc_start_block/gfc_finish_block from middle-end hooks,

    /* When using gfc_start_block/gfc_finish_block from middle-end hooks,

       don't add newly created BLOCKs as subblocks of global_binding_level.  */

       don't add newly created BLOCKs as subblocks of global_binding_level.  */

    ;

    ;

  else if (block_node)

  else if (block_node)

    {

    {

      current_binding_level->blocks

      current_binding_level->blocks

        = chainon (current_binding_level->blocks, block_node);

        = chainon (current_binding_level->blocks, block_node);

    }

    }

  /* If we did not make a block for the level just exited, any blocks made for

  /* If we did not make a block for the level just exited, any blocks made for

     inner levels (since they cannot be recorded as subblocks in that level)

     inner levels (since they cannot be recorded as subblocks in that level)

     must be carried forward so they will later become subblocks of something

     must be carried forward so they will later become subblocks of something

     else.  */

     else.  */

  else if (subblock_chain)

  else if (subblock_chain)

    current_binding_level->blocks

    current_binding_level->blocks

      = chainon (current_binding_level->blocks, subblock_chain);

      = chainon (current_binding_level->blocks, subblock_chain);

  if (block_node)

  if (block_node)

    TREE_USED (block_node) = 1;

    TREE_USED (block_node) = 1;

  return block_node;

  return block_node;

}

}

/* Records a ..._DECL node DECL as belonging to the current lexical scope.

/* Records a ..._DECL node DECL as belonging to the current lexical scope.

   Returns the ..._DECL node.  */

   Returns the ..._DECL node.  */

tree

tree

pushdecl (tree decl)

pushdecl (tree decl)

{

{

  /* External objects aren't nested, other objects may be.  */

  /* External objects aren't nested, other objects may be.  */

  if ((DECL_EXTERNAL (decl)) || (decl == current_function_decl))

  if ((DECL_EXTERNAL (decl)) || (decl == current_function_decl))

    DECL_CONTEXT (decl) = 0;

    DECL_CONTEXT (decl) = 0;

  else

  else

    DECL_CONTEXT (decl) = current_function_decl;

    DECL_CONTEXT (decl) = current_function_decl;

  /* Put the declaration on the list.  The list of declarations is in reverse

  /* Put the declaration on the list.  The list of declarations is in reverse

     order. The list will be reversed later if necessary.  This needs to be

     order. The list will be reversed later if necessary.  This needs to be

     this way for compatibility with the back-end.  */

     this way for compatibility with the back-end.  */

  TREE_CHAIN (decl) = current_binding_level->names;

  TREE_CHAIN (decl) = current_binding_level->names;

  current_binding_level->names = decl;

  current_binding_level->names = decl;

  /* For the declaration of a type, set its name if it is not already set.  */

  /* For the declaration of a type, set its name if it is not already set.  */

  if (TREE_CODE (decl) == TYPE_DECL && TYPE_NAME (TREE_TYPE (decl)) == 0)

  if (TREE_CODE (decl) == TYPE_DECL && TYPE_NAME (TREE_TYPE (decl)) == 0)

    {

    {

      if (DECL_SOURCE_LINE (decl) == 0)

      if (DECL_SOURCE_LINE (decl) == 0)

        TYPE_NAME (TREE_TYPE (decl)) = decl;

        TYPE_NAME (TREE_TYPE (decl)) = decl;

      else

      else

        TYPE_NAME (TREE_TYPE (decl)) = DECL_NAME (decl);

        TYPE_NAME (TREE_TYPE (decl)) = DECL_NAME (decl);

    }

    }

  return decl;

  return decl;

}

}

/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL.  */

/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL.  */

tree

tree

pushdecl_top_level (tree x)

pushdecl_top_level (tree x)

{

{

  tree t;

  tree t;

  struct binding_level *b = current_binding_level;

  struct binding_level *b = current_binding_level;

  current_binding_level = global_binding_level;

  current_binding_level = global_binding_level;

  t = pushdecl (x);

  t = pushdecl (x);

  current_binding_level = b;

  current_binding_level = b;

  return t;

  return t;

}

}

/* Clear the binding stack.  */

/* Clear the binding stack.  */

static void

static void

clear_binding_stack (void)

clear_binding_stack (void)

{

{

  while (!global_bindings_p ())

  while (!global_bindings_p ())

    poplevel (0, 0, 0);

    poplevel (0, 0, 0);

}

}

#ifndef CHAR_TYPE_SIZE

#ifndef CHAR_TYPE_SIZE

#define CHAR_TYPE_SIZE BITS_PER_UNIT

#define CHAR_TYPE_SIZE BITS_PER_UNIT

#endif

#endif

#ifndef INT_TYPE_SIZE

#ifndef INT_TYPE_SIZE

#define INT_TYPE_SIZE BITS_PER_WORD

#define INT_TYPE_SIZE BITS_PER_WORD

#endif

#endif

#undef SIZE_TYPE

#undef SIZE_TYPE

#define SIZE_TYPE "long unsigned int"

#define SIZE_TYPE "long unsigned int"

/* Create tree nodes for the basic scalar types of Fortran 95,

/* Create tree nodes for the basic scalar types of Fortran 95,

   and some nodes representing standard constants (0, 1, (void *) 0).

   and some nodes representing standard constants (0, 1, (void *) 0).

   Initialize the global binding level.

   Initialize the global binding level.

   Make definitions for built-in primitive functions.  */

   Make definitions for built-in primitive functions.  */

static void

static void

gfc_init_decl_processing (void)

gfc_init_decl_processing (void)

{

{

  current_function_decl = NULL;

  current_function_decl = NULL;

  current_binding_level = NULL_BINDING_LEVEL;

  current_binding_level = NULL_BINDING_LEVEL;

  free_binding_level = NULL_BINDING_LEVEL;

  free_binding_level = NULL_BINDING_LEVEL;

  /* Make the binding_level structure for global names. We move all

  /* Make the binding_level structure for global names. We move all

     variables that are in a COMMON block to this binding level.  */

     variables that are in a COMMON block to this binding level.  */

  pushlevel (0);

  pushlevel (0);

  global_binding_level = current_binding_level;

  global_binding_level = current_binding_level;

  /* Build common tree nodes. char_type_node is unsigned because we

  /* Build common tree nodes. char_type_node is unsigned because we

     only use it for actual characters, not for INTEGER(1). Also, we

     only use it for actual characters, not for INTEGER(1). Also, we

     want double_type_node to actually have double precision.  */

     want double_type_node to actually have double precision.  */

  build_common_tree_nodes (false, false);

  build_common_tree_nodes (false, false);

  /* x86_64 mingw32 has a sizetype of "unsigned long long", most other hosts

  /* x86_64 mingw32 has a sizetype of "unsigned long long", most other hosts

     have a sizetype of "unsigned long". Therefore choose the correct size

     have a sizetype of "unsigned long". Therefore choose the correct size

     in mostly target independent way.  */

     in mostly target independent way.  */

  if (TYPE_MODE (long_unsigned_type_node) == ptr_mode)

  if (TYPE_MODE (long_unsigned_type_node) == ptr_mode)

    set_sizetype (long_unsigned_type_node);

    set_sizetype (long_unsigned_type_node);

  else if (TYPE_MODE (long_long_unsigned_type_node) == ptr_mode)

  else if (TYPE_MODE (long_long_unsigned_type_node) == ptr_mode)

    set_sizetype (long_long_unsigned_type_node);

    set_sizetype (long_long_unsigned_type_node);

  else

  else

    set_sizetype (long_unsigned_type_node);

    set_sizetype (long_unsigned_type_node);

  build_common_tree_nodes_2 (0);

  build_common_tree_nodes_2 (0);

  void_list_node = build_tree_list (NULL_TREE, void_type_node);

  void_list_node = build_tree_list (NULL_TREE, void_type_node);

  /* Set up F95 type nodes.  */

  /* Set up F95 type nodes.  */

  gfc_init_kinds ();

  gfc_init_kinds ();

  gfc_init_types ();

  gfc_init_types ();

}

}

/* Return the typed-based alias set for T, which may be an expression

/* Return the typed-based alias set for T, which may be an expression

   or a type.  Return -1 if we don't do anything special.  */

   or a type.  Return -1 if we don't do anything special.  */

static alias_set_type

static alias_set_type

gfc_get_alias_set (tree t)

gfc_get_alias_set (tree t)

{

{

  tree u;

  tree u;

  /* Permit type-punning when accessing an EQUIVALENCEd variable or

  /* Permit type-punning when accessing an EQUIVALENCEd variable or

     mixed type entry master's return value.  */

     mixed type entry master's return value.  */

  for (u = t; handled_component_p (u); u = TREE_OPERAND (u, 0))

  for (u = t; handled_component_p (u); u = TREE_OPERAND (u, 0))

    if (TREE_CODE (u) == COMPONENT_REF

    if (TREE_CODE (u) == COMPONENT_REF

        && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)

        && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)

      return 0;

      return 0;

  return -1;

  return -1;

}

}

/* press the big red button - garbage (ggc) collection is on */

/* press the big red button - garbage (ggc) collection is on */

int ggc_p = 1;

int ggc_p = 1;

/* Builtin function initialization.  */

/* Builtin function initialization.  */

tree

tree

gfc_builtin_function (tree decl)

gfc_builtin_function (tree decl)

{

{

  make_decl_rtl (decl);

  make_decl_rtl (decl);

  pushdecl (decl);

  pushdecl (decl);

  return decl;

  return decl;

}

}

static void

static void

gfc_define_builtin (const char *name,

gfc_define_builtin (const char *name,

                    tree type,

                    tree type,

                    int code,

                    int code,

                    const char *library_name,

                    const char *library_name,

                    bool const_p)

                    bool const_p)

{

{

  tree decl;

  tree decl;

  decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,

  decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,

                               library_name, NULL_TREE);

                               library_name, NULL_TREE);

  if (const_p)

  if (const_p)

    TREE_READONLY (decl) = 1;

    TREE_READONLY (decl) = 1;

  TREE_NOTHROW (decl) = 1;

  TREE_NOTHROW (decl) = 1;

  built_in_decls[code] = decl;

  built_in_decls[code] = decl;

  implicit_built_in_decls[code] = decl;

  implicit_built_in_decls[code] = decl;

}

}

#define DO_DEFINE_MATH_BUILTIN(code, name, argtype, tbase) \

#define DO_DEFINE_MATH_BUILTIN(code, name, argtype, tbase) \

    gfc_define_builtin ("__builtin_" name "l", tbase##longdouble[argtype], \

    gfc_define_builtin ("__builtin_" name "l", tbase##longdouble[argtype], \

                       BUILT_IN_ ## code ## L, name "l", true); \

                       BUILT_IN_ ## code ## L, name "l", true); \

    gfc_define_builtin ("__builtin_" name, tbase##double[argtype], \

    gfc_define_builtin ("__builtin_" name, tbase##double[argtype], \

                        BUILT_IN_ ## code, name, true); \

                        BUILT_IN_ ## code, name, true); \

    gfc_define_builtin ("__builtin_" name "f", tbase##float[argtype], \

    gfc_define_builtin ("__builtin_" name "f", tbase##float[argtype], \

                        BUILT_IN_ ## code ## F, name "f", true);

                        BUILT_IN_ ## code ## F, name "f", true);

#define DEFINE_MATH_BUILTIN(code, name, argtype) \

#define DEFINE_MATH_BUILTIN(code, name, argtype) \

    DO_DEFINE_MATH_BUILTIN (code, name, argtype, mfunc_)

    DO_DEFINE_MATH_BUILTIN (code, name, argtype, mfunc_)