Subversion Repositories openrisc

/* Tree lowering pass.  This pass gimplifies the tree representation built

   by the C-based front ends.  The structure of gimplified, or

   language-independent, trees is dictated by the grammar described in this

   file.

   Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008

   Free Software Foundation, Inc.

   Lowering of expressions contributed by Sebastian Pop <s.pop@laposte.net>

   Re-written to support lowering of whole function trees, documentation

   and miscellaneous cleanups by Diego Novillo <dnovillo@redhat.com>

This file is part of GCC.

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

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

version.

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

WARRANTY; without even the implied warranty of MERCHANTABILITY or

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

for more details.

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

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

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

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "varray.h"

#include "c-tree.h"

#include "c-common.h"

#include "gimple.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "tree-flow.h"

#include "tree-inline.h"

#include "diagnostic.h"

#include "langhooks.h"

#include "langhooks-def.h"

#include "flags.h"

#include "rtl.h"

#include "toplev.h"

#include "tree-dump.h"

#include "c-pretty-print.h"

#include "cgraph.h"

/*  The gimplification pass converts the language-dependent trees

    (ld-trees) emitted by the parser into language-independent trees

    (li-trees) that are the target of SSA analysis and transformations.

    Language-independent trees are based on the SIMPLE intermediate

    representation used in the McCAT compiler framework:

    "Designing the McCAT Compiler Based on a Family of Structured

    Intermediate Representations,"

    L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,

    Proceedings of the 5th International Workshop on Languages and

    Compilers for Parallel Computing, no. 757 in Lecture Notes in

    Computer Science, New Haven, Connecticut, pp. 406-420,

    Springer-Verlag, August 3-5, 1992.

    http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html

    Basically, we walk down gimplifying the nodes that we encounter.  As we

    walk back up, we check that they fit our constraints, and copy them

    into temporaries if not.  */

/* Gimplification of statement trees.  */

/* Convert the tree representation of FNDECL from C frontend trees to

   GENERIC.  */

void

c_genericize (tree fndecl)

{

  FILE *dump_orig;

  int local_dump_flags;

  struct cgraph_node *cgn;

  /* Dump the C-specific tree IR.  */

  dump_orig = dump_begin (TDI_original, &local_dump_flags);

  if (dump_orig)

    {

      fprintf (dump_orig, "\n;; Function %s",

               lang_hooks.decl_printable_name (fndecl, 2));

      fprintf (dump_orig, " (%s)\n",

               (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"

                : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));

      fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));

      fprintf (dump_orig, "\n");

      if (local_dump_flags & TDF_RAW)

        dump_node (DECL_SAVED_TREE (fndecl),

                   TDF_SLIM | local_dump_flags, dump_orig);

      else

        print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));

      fprintf (dump_orig, "\n");

      dump_end (TDI_original, dump_orig);

    }

  /* Dump all nested functions now.  */

  cgn = cgraph_node (fndecl);

  for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)

    c_genericize (cgn->decl);

}

static void

add_block_to_enclosing (tree block)

{

  unsigned i;

  tree enclosing;

  gimple bind;

  VEC(gimple, heap) *stack = gimple_bind_expr_stack ();

  for (i = 0; VEC_iterate (gimple, stack, i, bind); i++)

    if (gimple_bind_block (bind))

      break;

  enclosing = gimple_bind_block (bind);

  BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);

}

/* Genericize a scope by creating a new BIND_EXPR.

   BLOCK is either a BLOCK representing the scope or a chain of _DECLs.

     In the latter case, we need to create a new BLOCK and add it to the

     BLOCK_SUBBLOCKS of the enclosing block.

   BODY is a chain of C _STMT nodes for the contents of the scope, to be

     genericized.  */

tree

c_build_bind_expr (location_t loc, tree block, tree body)

{

  tree decls, bind;

  if (block == NULL_TREE)

    decls = NULL_TREE;

  else if (TREE_CODE (block) == BLOCK)

    decls = BLOCK_VARS (block);

  else

    {

      decls = block;

      if (DECL_ARTIFICIAL (decls))

        block = NULL_TREE;

      else

        {

          block = make_node (BLOCK);

          BLOCK_VARS (block) = decls;

          add_block_to_enclosing (block);

        }

    }

  if (!body)

    body = build_empty_stmt (loc);

  if (decls || block)

    {

      bind = build3 (BIND_EXPR, void_type_node, decls, body, block);

      TREE_SIDE_EFFECTS (bind) = 1;

      SET_EXPR_LOCATION (bind, loc);

    }

  else

    bind = body;

  return bind;

}

/* Gimplification of expression trees.  */

/* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in

   gimplify_expr.  */

int

c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,

                 gimple_seq *post_p ATTRIBUTE_UNUSED)

{

  enum tree_code code = TREE_CODE (*expr_p);

  /* This is handled mostly by gimplify.c, but we have to deal with

     not warning about int x = x; as it is a GCC extension to turn off

     this warning but only if warn_init_self is zero.  */

  if (code == DECL_EXPR

      && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL

      && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))

      && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))

      && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))

      && !warn_init_self)

    TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;

  return GS_UNHANDLED;

}