Subversion Repositories openrisc_me

/* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.

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

   Free Software Foundation, Inc.

   Contributed by Jason Merrill <jason@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 "cp-tree.h"

#include "c-common.h"

#include "toplev.h"

#include "tree-iterator.h"

#include "gimple.h"

#include "hashtab.h"

#include "pointer-set.h"

#include "flags.h"

/* Local declarations.  */

enum bc_t { bc_break = 0, bc_continue = 1 };

/* Stack of labels which are targets for "break" or "continue",

   linked through TREE_CHAIN.  */

static tree bc_label[2];

/* Begin a scope which can be exited by a break or continue statement.  BC

   indicates which.

   Just creates a label and pushes it into the current context.  */

static tree

begin_bc_block (enum bc_t bc)

{

  tree label = create_artificial_label (input_location);

  TREE_CHAIN (label) = bc_label[bc];

  bc_label[bc] = label;

  return label;

}

/* Finish a scope which can be exited by a break or continue statement.

   LABEL was returned from the most recent call to begin_bc_block.  BODY is

   an expression for the contents of the scope.

   If we saw a break (or continue) in the scope, append a LABEL_EXPR to

   body.  Otherwise, just forget the label.  */

static gimple_seq

finish_bc_block (enum bc_t bc, tree label, gimple_seq body)

{

  gcc_assert (label == bc_label[bc]);

  if (TREE_USED (label))

    {

      gimple_seq_add_stmt (&body, gimple_build_label (label));

    }

  bc_label[bc] = TREE_CHAIN (label);

  TREE_CHAIN (label) = NULL_TREE;

  return body;

}

/* Get the LABEL_EXPR to represent a break or continue statement

   in the current block scope.  BC indicates which.  */

static tree

get_bc_label (enum bc_t bc)

{

  tree label = bc_label[bc];

  if (label == NULL_TREE)

    {

      if (bc == bc_break)

        error ("break statement not within loop or switch");

      else

        error ("continue statement not within loop or switch");

      return NULL_TREE;

    }

  /* Mark the label used for finish_bc_block.  */

  TREE_USED (label) = 1;

  return label;

}

/* Genericize a TRY_BLOCK.  */

static void

genericize_try_block (tree *stmt_p)

{

  tree body = TRY_STMTS (*stmt_p);

  tree cleanup = TRY_HANDLERS (*stmt_p);

  *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);

}

/* Genericize a HANDLER by converting to a CATCH_EXPR.  */

static void

genericize_catch_block (tree *stmt_p)

{

  tree type = HANDLER_TYPE (*stmt_p);

  tree body = HANDLER_BODY (*stmt_p);

  /* FIXME should the caught type go in TREE_TYPE?  */

  *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);

}

/* A terser interface for building a representation of an exception

   specification.  */

static tree

build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)

{

  tree t;

  /* FIXME should the allowed types go in TREE_TYPE?  */

  t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);

  append_to_statement_list (failure, &EH_FILTER_FAILURE (t));

  t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);

  append_to_statement_list (body, &TREE_OPERAND (t, 0));

  return t;

}

/* Genericize an EH_SPEC_BLOCK by converting it to a

   TRY_CATCH_EXPR/EH_FILTER_EXPR pair.  */

static void

genericize_eh_spec_block (tree *stmt_p)

{

  tree body = EH_SPEC_STMTS (*stmt_p);

  tree allowed = EH_SPEC_RAISES (*stmt_p);

  tree failure = build_call_n (call_unexpected_node, 1, build_exc_ptr ());

  *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure);

  TREE_NO_WARNING (*stmt_p) = true;

  TREE_NO_WARNING (TREE_OPERAND (*stmt_p, 1)) = true;

}

/* Genericize an IF_STMT by turning it into a COND_EXPR.  */

static void

genericize_if_stmt (tree *stmt_p)

{

  tree stmt, cond, then_, else_;

  location_t locus = EXPR_LOCATION (*stmt_p);

  stmt = *stmt_p;

  cond = IF_COND (stmt);

  then_ = THEN_CLAUSE (stmt);

  else_ = ELSE_CLAUSE (stmt);

  if (!then_)

    then_ = build_empty_stmt (locus);

  if (!else_)

    else_ = build_empty_stmt (locus);

  if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))

    stmt = then_;

  else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))

    stmt = else_;

  else

    stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);

  if (CAN_HAVE_LOCATION_P (stmt) && !EXPR_HAS_LOCATION (stmt))

    SET_EXPR_LOCATION (stmt, locus);

  *stmt_p = stmt;

}

/* Build a generic representation of one of the C loop forms.  COND is the

   loop condition or NULL_TREE.  BODY is the (possibly compound) statement

   controlled by the loop.  INCR is the increment expression of a for-loop,

   or NULL_TREE.  COND_IS_FIRST indicates whether the condition is

   evaluated before the loop body as in while and for loops, or after the

   loop body as in do-while loops.  */

static gimple_seq

gimplify_cp_loop (tree cond, tree body, tree incr, bool cond_is_first)

{

  gimple top, entry, stmt;

  gimple_seq stmt_list, body_seq, incr_seq, exit_seq;

  tree cont_block, break_block;

  location_t stmt_locus;

  stmt_locus = input_location;

  stmt_list = NULL;

  body_seq = NULL;

  incr_seq = NULL;

  exit_seq = NULL;

  entry = NULL;

  break_block = begin_bc_block (bc_break);

  cont_block = begin_bc_block (bc_continue);

  /* If condition is zero don't generate a loop construct.  */

  if (cond && integer_zerop (cond))

    {

      top = NULL;

      if (cond_is_first)

        {

          stmt = gimple_build_goto (get_bc_label (bc_break));

          gimple_set_location (stmt, stmt_locus);

          gimple_seq_add_stmt (&stmt_list, stmt);

        }

    }

  else

    {

      /* If we use a LOOP_EXPR here, we have to feed the whole thing

         back through the main gimplifier to lower it.  Given that we

         have to gimplify the loop body NOW so that we can resolve

         break/continue stmts, seems easier to just expand to gotos.  */

      top = gimple_build_label (create_artificial_label (stmt_locus));

      /* If we have an exit condition, then we build an IF with gotos either

         out of the loop, or to the top of it.  If there's no exit condition,

         then we just build a jump back to the top.  */

      if (cond && !integer_nonzerop (cond))

        {

          if (cond != error_mark_node)

            {

              gimplify_expr (&cond, &exit_seq, NULL, is_gimple_val, fb_rvalue);

              stmt = gimple_build_cond (NE_EXPR, cond,

                                        build_int_cst (TREE_TYPE (cond), 0),

                                        gimple_label_label (top),

                                        get_bc_label (bc_break));

              gimple_seq_add_stmt (&exit_seq, stmt);

            }

          if (cond_is_first)

            {

              if (incr)

                {

                  entry = gimple_build_label

                    (create_artificial_label (stmt_locus));

                  stmt = gimple_build_goto (gimple_label_label (entry));

                }

              else

                stmt = gimple_build_goto (get_bc_label (bc_continue));

              gimple_set_location (stmt, stmt_locus);

              gimple_seq_add_stmt (&stmt_list, stmt);

            }

        }

      else

        {

          stmt = gimple_build_goto (gimple_label_label (top));

          gimple_seq_add_stmt (&exit_seq, stmt);

        }

    }

  gimplify_stmt (&body, &body_seq);

  gimplify_stmt (&incr, &incr_seq);

  body_seq = finish_bc_block (bc_continue, cont_block, body_seq);

  gimple_seq_add_stmt (&stmt_list, top);

  gimple_seq_add_seq (&stmt_list, body_seq);

  gimple_seq_add_seq (&stmt_list, incr_seq);

  gimple_seq_add_stmt (&stmt_list, entry);

  gimple_seq_add_seq (&stmt_list, exit_seq);

  annotate_all_with_location (stmt_list, stmt_locus);

  return finish_bc_block (bc_break, break_block, stmt_list);

}

/* Gimplify a FOR_STMT node.  Move the stuff in the for-init-stmt into the

   prequeue and hand off to gimplify_cp_loop.  */

static void

gimplify_for_stmt (tree *stmt_p, gimple_seq *pre_p)

{

  tree stmt = *stmt_p;

  if (FOR_INIT_STMT (stmt))

    gimplify_and_add (FOR_INIT_STMT (stmt), pre_p);

  gimple_seq_add_seq (pre_p,

                      gimplify_cp_loop (FOR_COND (stmt), FOR_BODY (stmt),

                                        FOR_EXPR (stmt), 1));

  *stmt_p = NULL_TREE;

}

/* Gimplify a WHILE_STMT node.  */

static void

gimplify_while_stmt (tree *stmt_p, gimple_seq *pre_p)

{

  tree stmt = *stmt_p;

  gimple_seq_add_seq (pre_p,

                      gimplify_cp_loop (WHILE_COND (stmt), WHILE_BODY (stmt),

                                        NULL_TREE, 1));

  *stmt_p = NULL_TREE;

}

/* Gimplify a DO_STMT node.  */

static void

gimplify_do_stmt (tree *stmt_p, gimple_seq *pre_p)

{

  tree stmt = *stmt_p;

  gimple_seq_add_seq (pre_p,

                      gimplify_cp_loop (DO_COND (stmt), DO_BODY (stmt),

                                        NULL_TREE, 0));

  *stmt_p = NULL_TREE;

}

/* Genericize a SWITCH_STMT by turning it into a SWITCH_EXPR.  */

static void

gimplify_switch_stmt (tree *stmt_p, gimple_seq *pre_p)

{

  tree stmt = *stmt_p;

  tree break_block, body, t;

  location_t stmt_locus = input_location;

  gimple_seq seq = NULL;

  break_block = begin_bc_block (bc_break);

  body = SWITCH_STMT_BODY (stmt);

  if (!body)

    body = build_empty_stmt (stmt_locus);

  t = build3 (SWITCH_EXPR, SWITCH_STMT_TYPE (stmt),

              SWITCH_STMT_COND (stmt), body, NULL_TREE);

  SET_EXPR_LOCATION (t, stmt_locus);

  gimplify_and_add (t, &seq);

  seq = finish_bc_block (bc_break, break_block, seq);

  gimple_seq_add_seq (pre_p, seq);

  *stmt_p = NULL_TREE;

}

/* Hook into the middle of gimplifying an OMP_FOR node.  This is required

   in order to properly gimplify CONTINUE statements.  Here we merely

   manage the continue stack; the rest of the job is performed by the

   regular gimplifier.  */

static enum gimplify_status

cp_gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)

{

  tree for_stmt = *expr_p;

  tree cont_block;

  gimple stmt;

  gimple_seq seq = NULL;

  /* Protect ourselves from recursion.  */

  if (OMP_FOR_GIMPLIFYING_P (for_stmt))

    return GS_UNHANDLED;

  OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;

  /* Note that while technically the continue label is enabled too soon

     here, we should have already diagnosed invalid continues nested within

     statement expressions within the INIT, COND, or INCR expressions.  */

  cont_block = begin_bc_block (bc_continue);

  gimplify_and_add (for_stmt, &seq);

  stmt = gimple_seq_last_stmt (seq);

  if (gimple_code (stmt) == GIMPLE_OMP_FOR)

    gimple_omp_set_body (stmt, finish_bc_block (bc_continue, cont_block,

                                                gimple_omp_body (stmt)));

  else

    seq = finish_bc_block (bc_continue, cont_block, seq);

  gimple_seq_add_seq (pre_p, seq);

  OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;

  return GS_ALL_DONE;

}

/*  Gimplify an EXPR_STMT node.  */

static void

gimplify_expr_stmt (tree *stmt_p)

{

  tree stmt = EXPR_STMT_EXPR (*stmt_p);

  if (stmt == error_mark_node)

    stmt = NULL;

  /* Gimplification of a statement expression will nullify the

     statement if all its side effects are moved to *PRE_P and *POST_P.

     In this case we will not want to emit the gimplified statement.

     However, we may still want to emit a warning, so we do that before

     gimplification.  */

  if (stmt && warn_unused_value)

    {

      if (!TREE_SIDE_EFFECTS (stmt))

        {

          if (!IS_EMPTY_STMT (stmt)

              && !VOID_TYPE_P (TREE_TYPE (stmt))

              && !TREE_NO_WARNING (stmt))

            warning (OPT_Wunused_value, "statement with no effect");

        }

      else

        warn_if_unused_value (stmt, input_location);

    }

  if (stmt == NULL_TREE)

    stmt = alloc_stmt_list ();

  *stmt_p = stmt;

}

/* Gimplify initialization from an AGGR_INIT_EXPR.  */

static void

cp_gimplify_init_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)

{

  tree from = TREE_OPERAND (*expr_p, 1);

  tree to = TREE_OPERAND (*expr_p, 0);

  tree t;

  /* What about code that pulls out the temp and uses it elsewhere?  I

     think that such code never uses the TARGET_EXPR as an initializer.  If

     I'm wrong, we'll abort because the temp won't have any RTL.  In that

     case, I guess we'll need to replace references somehow.  */

  if (TREE_CODE (from) == TARGET_EXPR)

    from = TARGET_EXPR_INITIAL (from);

  /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them

     inside the TARGET_EXPR.  */

  for (t = from; t; )

    {

      tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t;

      /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and

         replace the slot operand with our target.

         Should we add a target parm to gimplify_expr instead?  No, as in this

         case we want to replace the INIT_EXPR.  */

      if (TREE_CODE (sub) == AGGR_INIT_EXPR

          || TREE_CODE (sub) == VEC_INIT_EXPR)

        {

          gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue);

          if (TREE_CODE (sub) == AGGR_INIT_EXPR)

            AGGR_INIT_EXPR_SLOT (sub) = to;

          else

            VEC_INIT_EXPR_SLOT (sub) = to;

          *expr_p = from;

          /* The initialization is now a side-effect, so the container can

             become void.  */

          if (from != sub)

            TREE_TYPE (from) = void_type_node;

        }

      if (t == sub)

        break;

      else

        t = TREE_OPERAND (t, 1);

    }

}

/* Gimplify a MUST_NOT_THROW_EXPR.  */

static enum gimplify_status

gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)

{

  tree stmt = *expr_p;

  tree temp = voidify_wrapper_expr (stmt, NULL);

  tree body = TREE_OPERAND (stmt, 0);

  gimple_seq try_ = NULL;

  gimple_seq catch_ = NULL;

  gimple mnt;

  gimplify_and_add (body, &try_);

  mnt = gimple_build_eh_must_not_throw (terminate_node);

  gimplify_seq_add_stmt (&catch_, mnt);

  mnt = gimple_build_try (try_, catch_, GIMPLE_TRY_CATCH);

  gimplify_seq_add_stmt (pre_p, mnt);

  if (temp)

    {

      *expr_p = temp;

      return GS_OK;

    }

  *expr_p = NULL;

  return GS_ALL_DONE;

}

/* Do C++-specific gimplification.  Args are as for gimplify_expr.  */

int

cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)

{

  int saved_stmts_are_full_exprs_p = 0;

  enum tree_code code = TREE_CODE (*expr_p);

  enum gimplify_status ret;

  if (STATEMENT_CODE_P (code))

    {

      saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();

      current_stmt_tree ()->stmts_are_full_exprs_p

        = STMT_IS_FULL_EXPR_P (*expr_p);

    }

  switch (code)

    {

    case PTRMEM_CST:

      *expr_p = cplus_expand_constant (*expr_p);

      ret = GS_OK;

      break;

    case AGGR_INIT_EXPR:

      simplify_aggr_init_expr (expr_p);

      ret = GS_OK;

      break;

    case VEC_INIT_EXPR:

      {

        location_t loc = input_location;

        gcc_assert (EXPR_HAS_LOCATION (*expr_p));

        input_location = EXPR_LOCATION (*expr_p);

        *expr_p = build_vec_init (VEC_INIT_EXPR_SLOT (*expr_p), NULL_TREE,

                                  VEC_INIT_EXPR_INIT (*expr_p), false, 1,

                                  tf_warning_or_error);

        ret = GS_OK;

        input_location = loc;

      }

      break;

    case THROW_EXPR:

      /* FIXME communicate throw type to back end, probably by moving

         THROW_EXPR into ../tree.def.  */

      *expr_p = TREE_OPERAND (*expr_p, 0);

      ret = GS_OK;

      break;

    case MUST_NOT_THROW_EXPR:

      ret = gimplify_must_not_throw_expr (expr_p, pre_p);

      break;

      /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the

         LHS of an assignment might also be involved in the RHS, as in bug

         25979.  */

    case INIT_EXPR:

      cp_gimplify_init_expr (expr_p, pre_p, post_p);

      if (TREE_CODE (*expr_p) != INIT_EXPR)

        return GS_OK;

      /* Otherwise fall through.  */

    case MODIFY_EXPR:

      {

        /* If the back end isn't clever enough to know that the lhs and rhs

           types are the same, add an explicit conversion.  */

        tree op0 = TREE_OPERAND (*expr_p, 0);

        tree op1 = TREE_OPERAND (*expr_p, 1);

        if (!error_operand_p (op0)

            && !error_operand_p (op1)

            && (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op0))

                || TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op1)))

            && !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0)))

          TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR,

                                              TREE_TYPE (op0), op1);

        else if ((rhs_predicate_for (op0)) (op1)

                 && !(TREE_CODE (op1) == CALL_EXPR

                      && CALL_EXPR_RETURN_SLOT_OPT (op1))

                 && is_really_empty_class (TREE_TYPE (op0)))

          {

            /* Remove any copies of empty classes.  We check that the RHS

               has a simple form so that TARGET_EXPRs and CONSTRUCTORs get

               reduced properly, and we leave the return slot optimization

               alone because it isn't a copy.

               Also drop volatile variables on the RHS to avoid infinite

               recursion from gimplify_expr trying to load the value.  */

            if (!TREE_SIDE_EFFECTS (op1)

                || (DECL_P (op1) && TREE_THIS_VOLATILE (op1)))

              *expr_p = op0;

            else

              *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),

                                op0, op1);

          }

      }

      ret = GS_OK;

      break;

    case EMPTY_CLASS_EXPR:

      /* We create an empty CONSTRUCTOR with RECORD_TYPE.  */

      *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);

      ret = GS_OK;

      break;

    case BASELINK:

      *expr_p = BASELINK_FUNCTIONS (*expr_p);

      ret = GS_OK;

      break;

    case TRY_BLOCK:

      genericize_try_block (expr_p);

      ret = GS_OK;

      break;

    case HANDLER:

      genericize_catch_block (expr_p);

      ret = GS_OK;

      break;

    case EH_SPEC_BLOCK:

      genericize_eh_spec_block (expr_p);

      ret = GS_OK;

      break;

    case USING_STMT:

      gcc_unreachable ();

    case FOR_STMT:

      gimplify_for_stmt (expr_p, pre_p);

      ret = GS_OK;

      break;

    case WHILE_STMT:

      gimplify_while_stmt (expr_p, pre_p);

      ret = GS_OK;

      break;

    case DO_STMT:

      gimplify_do_stmt (expr_p, pre_p);

      ret = GS_OK;

      break;

    case SWITCH_STMT:

      gimplify_switch_stmt (expr_p, pre_p);

      ret = GS_OK;

      break;

    case OMP_FOR:

      ret = cp_gimplify_omp_for (expr_p, pre_p);

      break;

    case CONTINUE_STMT:

      gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_CONTINUE, NOT_TAKEN));

      gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_continue)));

      *expr_p = NULL_TREE;

      ret = GS_ALL_DONE;

      break;

    case BREAK_STMT:

      gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_break)));

      *expr_p = NULL_TREE;

      ret = GS_ALL_DONE;

      break;

    case EXPR_STMT:

      gimplify_expr_stmt (expr_p);

      ret = GS_OK;

      break;

    case UNARY_PLUS_EXPR:

      {

        tree arg = TREE_OPERAND (*expr_p, 0);

        tree type = TREE_TYPE (*expr_p);

        *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)

                                            : arg;

        ret = GS_OK;

      }

      break;

    default:

      ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);

      break;

    }

  /* Restore saved state.  */

  if (STATEMENT_CODE_P (code))

    current_stmt_tree ()->stmts_are_full_exprs_p

      = saved_stmts_are_full_exprs_p;

  return ret;

}

static inline bool

is_invisiref_parm (const_tree t)

{

  return ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)

          && DECL_BY_REFERENCE (t));

}

/* Return true if the uid in both int tree maps are equal.  */

int