gcc/c-family/c-semantics.c

   1 /* This file contains subroutine used by the C front-end to construct GENERIC.
   2    Copyright (C) 2000-2016 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 /* Finish the statement tree rooted at T.  */
  39
  40 tree
  41 pop_stmt_list (tree t)
  42 {
  43   tree u = NULL_TREE;
  44
  45   /* Pop statement lists until we reach the target level.  The extra
  46      nestings will be due to outstanding cleanups.  */
  47   while (1)
  48     {
  49       u = stmt_list_stack->pop ();
  50       if (!stmt_list_stack->is_empty ())
  51         {
  52           tree x = stmt_list_stack->last ();
  53           STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
  54         }
  55       if (t == u)
  56         break;
  57     }
  58
  59   gcc_assert (u != NULL_TREE);
  60
  61   /* If the statement list is completely empty, just return it.  This is
  62      just as good small as build_empty_stmt, with the advantage that
  63      statement lists are merged when they appended to one another.  So
  64      using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
  65      statements.  */
  66   if (TREE_SIDE_EFFECTS (t))
  67     {
  68       tree_stmt_iterator i = tsi_start (t);
  69
  70       /* If the statement list contained exactly one statement, then
  71          extract it immediately.  */
  72       if (tsi_one_before_end_p (i))
  73         {
  74           u = tsi_stmt (i);
  75           tsi_delink (&i);
  76           free_stmt_list (t);
  77           t = u;
  78         }
  79     }
  80
  81   return t;
  82 }
  83
  84 /* Build a generic statement based on the given type of node and
  85    arguments. Similar to `build_nt', except that we set
  86    EXPR_LOCATION to LOC. */
  87 /* ??? This should be obsolete with the lineno_stmt productions
  88    in the grammar.  */
  89
  90 tree
  91 build_stmt (location_t loc, enum tree_code code, ...)
  92 {
  93   tree ret;
  94   int length, i;
  95   va_list p;
  96   bool side_effects;
  97
  98   /* This function cannot be used to construct variably-sized nodes.  */
  99   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
 100
 101   va_start (p, code);
 102
 103   ret = make_node (code);
 104   TREE_TYPE (ret) = void_type_node;
 105   length = TREE_CODE_LENGTH (code);
 106   SET_EXPR_LOCATION (ret, loc);
 107
 108   /* TREE_SIDE_EFFECTS will already be set for statements with
 109      implicit side effects.  Here we make sure it is set for other
 110      expressions by checking whether the parameters have side
 111      effects.  */
 112
 113   side_effects = false;
 114   for (i = 0; i < length; i++)
 115     {
 116       tree t = va_arg (p, tree);
 117       if (t && !TYPE_P (t))
 118         side_effects |= TREE_SIDE_EFFECTS (t);
 119       TREE_OPERAND (ret, i) = t;
 120     }
 121
 122   TREE_SIDE_EFFECTS (ret) |= side_effects;
 123
 124   va_end (p);
 125   return ret;
 126 }
 127
 128 /* Build a REALPART_EXPR or IMAGPART_EXPR, according to CODE, from ARG.  */
 129
 130 tree
 131 build_real_imag_expr (location_t location, enum tree_code code, tree arg)
 132 {
 133   tree ret;
 134   tree arg_type = TREE_TYPE (arg);
 135
 136   gcc_assert (code == REALPART_EXPR || code == IMAGPART_EXPR);
 137
 138   if (TREE_CODE (arg_type) == COMPLEX_TYPE)
 139     {
 140       ret = build1 (code, TREE_TYPE (TREE_TYPE (arg)), arg);
 141       SET_EXPR_LOCATION (ret, location);
 142     }
 143   else if (INTEGRAL_TYPE_P (arg_type) || SCALAR_FLOAT_TYPE_P (arg_type))
 144     {
 145       ret = (code == REALPART_EXPR
 146              ? arg
 147              : omit_one_operand_loc (location, arg_type,
 148                                      integer_zero_node, arg));
 149     }
 150   else
 151     {
 152       error_at (location, "wrong type argument to %s",
 153                 code == REALPART_EXPR ? "__real" : "__imag");
 154       ret = error_mark_node;
 155     }
 156
 157   return ret;
 158 }