gcc/c-family/c-semantics.c

   1 /* This file contains subroutine used by the C front-end to construct GENERIC.
   2    Copyright (C) 2000-2018 Free Software Foundation, Inc.
   3    Written by Benjamin Chelf (chelf@codesourcery.com).
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "c-common.h"
  25 #include "tree-iterator.h"
  26
  27 /* Create an empty statement tree rooted at T.  */
  28
  29 tree
  30 push_stmt_list (void)
  31 {
  32   tree t;
  33   t = alloc_stmt_list ();
  34   vec_safe_push (stmt_list_stack, t);
  35   return t;
  36 }
  37
  38 /* Return TRUE if, after I, there are any nondebug stmts.  */
  39
  40 static inline bool
  41 only_debug_stmts_after_p (tree_stmt_iterator i)
  42 {
  43   for (tsi_next (&i); !tsi_end_p (i); tsi_next (&i))
  44     if (TREE_CODE (tsi_stmt (i)) != DEBUG_BEGIN_STMT)
  45       return false;
  46   return true;
  47 }
  48
  49 /* Finish the statement tree rooted at T.  */
  50
  51 tree
  52 pop_stmt_list (tree t)
  53 {
  54   tree u = NULL_TREE;
  55
  56   /* Pop statement lists until we reach the target level.  The extra
  57      nestings will be due to outstanding cleanups.  */
  58   while (1)
  59     {
  60       u = stmt_list_stack->pop ();
  61       if (!stmt_list_stack->is_empty ())
  62         {
  63           tree x = stmt_list_stack->last ();
  64           STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
  65         }
  66       if (t == u)
  67         break;
  68     }
  69
  70   gcc_assert (u != NULL_TREE);
  71
  72   /* If the statement list is completely empty, just return it.  This is
  73      just as good small as build_empty_stmt, with the advantage that
  74      statement lists are merged when they appended to one another.  So
  75      using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
  76      statements.  */
  77   if (TREE_SIDE_EFFECTS (t))
  78     {
  79       tree_stmt_iterator i = tsi_start (t);
  80
  81       /* If the statement list contained exactly one statement, then
  82          extract it immediately.  */
  83       if (tsi_one_before_end_p (i))
  84         {
  85           u = tsi_stmt (i);
  86           tsi_delink (&i);
  87           free_stmt_list (t);
  88           t = u;
  89         }
  90       /* If the statement list contained a debug begin stmt and a
  91          statement list, move the debug begin stmt into the statement
  92          list and return it.  */
  93       else if (!tsi_end_p (i)
  94                && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
  95         {
  96           u = tsi_stmt (i);
  97           tsi_next (&i);
  98           if (tsi_one_before_end_p (i)
  99               && TREE_CODE (tsi_stmt (i)) == STATEMENT_LIST)
 100             {
 101               tree l = tsi_stmt (i);
 102               tsi_prev (&i);
 103               tsi_delink (&i);
 104               tsi_delink (&i);
 105               i = tsi_start (l);
 106               free_stmt_list (t);
 107               t = l;
 108               tsi_link_before (&i, u, TSI_SAME_STMT);
 109             }
 110           while (!tsi_end_p (i)
 111                  && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
 112             tsi_next (&i);
 113           /* If there are only debug stmts in the list, without them
 114              we'd have an empty stmt without side effects.  If there's
 115              only one nondebug stmt, we'd have extracted the stmt and
 116              dropped the list, and we'd take TREE_SIDE_EFFECTS from
 117              that statement.  In either case, keep the list's
 118              TREE_SIDE_EFFECTS in sync.  */
 119           if (tsi_end_p (i))
 120             TREE_SIDE_EFFECTS (t) = 0;
 121           else if (only_debug_stmts_after_p (i))
 122             TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (tsi_stmt (i));
 123         }
 124     }
 125
 126   return t;
 127 }
 128
 129 /* Build a generic statement based on the given type of node and
 130    arguments. Similar to `build_nt', except that we set
 131    EXPR_LOCATION to LOC. */
 132 /* ??? This should be obsolete with the lineno_stmt productions
 133    in the grammar.  */
 134
 135 tree
 136 build_stmt (location_t loc, enum tree_code code, ...)
 137 {
 138   tree ret;
 139   int length, i;
 140   va_list p;
 141   bool side_effects;
 142
 143   /* This function cannot be used to construct variably-sized nodes.  */
 144   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
 145
 146   va_start (p, code);
 147
 148   ret = make_node (code);
 149   TREE_TYPE (ret) = void_type_node;
 150   length = TREE_CODE_LENGTH (code);
 151   SET_EXPR_LOCATION (ret, loc);
 152
 153   /* TREE_SIDE_EFFECTS will already be set for statements with
 154      implicit side effects.  Here we make sure it is set for other
 155      expressions by checking whether the parameters have side
 156      effects.  */
 157
 158   side_effects = false;
 159   for (i = 0; i < length; i++)
 160     {
 161       tree t = va_arg (p, tree);
 162       if (t && !TYPE_P (t))
 163         side_effects |= TREE_SIDE_EFFECTS (t);
 164       TREE_OPERAND (ret, i) = t;
 165     }
 166
 167   TREE_SIDE_EFFECTS (ret) |= side_effects;
 168
 169   va_end (p);
 170   return ret;
 171 }
 172
 173 /* Build a REALPART_EXPR or IMAGPART_EXPR, according to CODE, from ARG.  */
 174
 175 tree
 176 build_real_imag_expr (location_t location, enum tree_code code, tree arg)
 177 {
 178   tree ret;
 179   tree arg_type = TREE_TYPE (arg);
 180
 181   gcc_assert (code == REALPART_EXPR || code == IMAGPART_EXPR);
 182
 183   if (TREE_CODE (arg_type) == COMPLEX_TYPE)
 184     {
 185       ret = build1 (code, TREE_TYPE (TREE_TYPE (arg)), arg);
 186       SET_EXPR_LOCATION (ret, location);
 187     }
 188   else if (INTEGRAL_TYPE_P (arg_type) || SCALAR_FLOAT_TYPE_P (arg_type))
 189     {
 190       ret = (code == REALPART_EXPR
 191              ? arg
 192              : omit_one_operand_loc (location, arg_type,
 193                                      integer_zero_node, arg));
 194     }
 195   else
 196     {
 197       error_at (location, "wrong type argument to %s",
 198                 code == REALPART_EXPR ? "__real" : "__imag");
 199       ret = error_mark_node;
 200     }
 201
 202   return ret;
 203 }