gcc/cp/expr.c

   1 /* Convert language-specific tree expression to rtl instructions,
   2    for GNU compiler.
   3    Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 #include "config.h"
  23 #include "rtl.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "expr.h"
  27 #include "cp-tree.h"
  28
  29 #undef NULL
  30 #define NULL 0
  31
  32 /* Hook used by expand_expr to expand language-specific tree codes.  */
  33
  34 rtx
  35 cplus_expand_expr (exp, target, tmode, modifier)
  36      tree exp;
  37      rtx target;
  38      enum machine_mode tmode;
  39      enum expand_modifier modifier;
  40 {
  41   tree type = TREE_TYPE (exp);
  42   register enum machine_mode mode = TYPE_MODE (type);
  43   register enum tree_code code = TREE_CODE (exp);
  44   rtx original_target = target;
  45   int ignore = target == const0_rtx;
  46
  47   if (ignore)
  48     target = 0, original_target = 0;
  49
  50   /* No sense saving up arithmetic to be done
  51      if it's all in the wrong mode to form part of an address.
  52      And force_operand won't know whether to sign-extend or zero-extend.  */
  53
  54   if (mode != Pmode && modifier == EXPAND_SUM)
  55     modifier = EXPAND_NORMAL;
  56
  57   switch (code)
  58     {
  59     case NEW_EXPR:
  60       {
  61         /* Something needs to be initialized, but we didn't know
  62            where that thing was when building the tree.  For example,
  63            it could be the return value of a function, or a parameter
  64            to a function which lays down in the stack, or a temporary
  65            variable which must be passed by reference.
  66
  67            Cleanups are handled in a language-specific way: they
  68            might be run by the called function (true in GNU C++
  69            for parameters with cleanups), or they might be
  70            run by the caller, after the call (true in GNU C++
  71            for other cleanup needs).  */
  72
  73         tree func = TREE_OPERAND (exp, 0);
  74         tree args = TREE_OPERAND (exp, 1);
  75         tree type = TREE_TYPE (exp), slot;
  76         tree fn_type = TREE_TYPE (TREE_TYPE (func));
  77         tree return_type = TREE_TYPE (fn_type);
  78         tree call_exp;
  79         rtx call_target, return_target;
  80         int pcc_struct_return = 0;
  81
  82         /* The expression `init' wants to initialize what
  83            `target' represents.  SLOT holds the slot for TARGET.  */
  84         slot = TREE_OPERAND (exp, 2);
  85
  86         if (target == 0)
  87           {
  88             /* Should always be called with a target in BLKmode case.  */
  89             my_friendly_assert (mode != BLKmode, 205);
  90             my_friendly_assert (DECL_RTL (slot) != 0, 206);
  91
  92             target = gen_reg_rtx (mode);
  93           }
  94
  95         /* The target the initializer will initialize (CALL_TARGET)
  96            must now be directed to initialize the target we are
  97            supposed to initialize (TARGET).  The semantics for
  98            choosing what CALL_TARGET is is language-specific,
  99            as is building the call which will perform the
 100            initialization.  It is left here to show the choices that
 101            exist for C++.  */
 102
 103         if (TREE_CODE (func) == ADDR_EXPR
 104             && TREE_CODE (TREE_OPERAND (func, 0)) == FUNCTION_DECL
 105             && DECL_CONSTRUCTOR_P (TREE_OPERAND (func, 0)))
 106           {
 107             type = TYPE_POINTER_TO (type);
 108             /* Don't clobber a value that might be part of a default
 109                parameter value.  */
 110             if (TREE_PERMANENT (args))
 111               args = tree_cons (0, build1 (ADDR_EXPR, type, slot),
 112                                 TREE_CHAIN (args));
 113             else
 114               TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot);
 115             call_target = 0;
 116           }
 117         else if (TREE_CODE (return_type) == REFERENCE_TYPE)
 118           {
 119             type = return_type;
 120             call_target = 0;
 121           }
 122         else
 123           {
 124 #ifdef PCC_STATIC_STRUCT_RETURN
 125             pcc_struct_return = 1;
 126             call_target = 0;
 127 #else
 128             call_target = target;
 129 #endif
 130           }
 131         if (call_target)
 132           {
 133             preserve_temp_slots (call_target);
 134
 135             /* Make this a valid memory address now.  The code below assumes
 136                that it can compare rtx and make assumptions based on the
 137                result.  The assumptions are true only if the address was
 138                valid to begin with.  */
 139             call_target = validize_mem (call_target);
 140           }
 141
 142         preserve_temp_slots (DECL_RTL (slot));
 143         call_exp = build (CALL_EXPR, type, func, args, 0);
 144         TREE_SIDE_EFFECTS (call_exp) = 1;
 145         return_target = expand_expr (call_exp, call_target, mode, 0);
 146         free_temp_slots ();
 147         if (call_target == 0)
 148           {
 149             if (pcc_struct_return)
 150               {
 151                 tree init = build (RTL_EXPR, type, 0, return_target);
 152                 TREE_ADDRESSABLE (init) = 1;
 153                 expand_aggr_init (slot, init, 0);
 154                 if (TYPE_NEEDS_DESTRUCTOR (type))
 155                   {
 156                     init = build (RTL_EXPR, build_reference_type (type), 0,
 157                                   XEXP (return_target, 0));
 158                     init = maybe_build_cleanup (convert_from_reference (init));
 159                     if (init != NULL_TREE)
 160                       expand_expr (init, 0, 0, 0);
 161                   }
 162                 call_target = return_target = DECL_RTL (slot);
 163               }
 164             else
 165               call_target = return_target;
 166           }
 167
 168         if (call_target != return_target)
 169           {
 170             my_friendly_assert (! TYPE_NEEDS_CONSTRUCTING (type), 317);
 171             if (GET_MODE (return_target) == BLKmode)
 172               emit_block_move (call_target, return_target, expr_size (exp),
 173                                TYPE_ALIGN (type) / BITS_PER_UNIT);
 174             else
 175               emit_move_insn (call_target, return_target);
 176           }
 177
 178         if (TREE_CODE (return_type) == REFERENCE_TYPE)
 179           {
 180             tree init;
 181
 182             if (GET_CODE (call_target) == REG
 183                 && REGNO (call_target) < FIRST_PSEUDO_REGISTER)
 184               my_friendly_abort (39);
 185
 186             type = TREE_TYPE (exp);
 187
 188             init = build (RTL_EXPR, return_type, 0, call_target);
 189             /* We got back a reference to the type we want.  Now initialize
 190                target with that.  */
 191             expand_aggr_init (slot, init, 0);
 192           }
 193
 194         if (DECL_RTL (slot) != target)
 195           emit_move_insn (DECL_RTL (slot), target);
 196         return DECL_RTL (slot);
 197       }
 198
 199     case OFFSET_REF:
 200       {
 201 #if 1
 202         return expand_expr (default_conversion (resolve_offset_ref (exp)),
 203                             target, tmode, EXPAND_NORMAL);
 204 #else
 205         /* This is old crusty code, and does not handle all that the
 206            resolve_offset_ref function does.  (mrs) */
 207         tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0);
 208         tree offset = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
 209         return expand_expr (build (PLUS_EXPR, TREE_TYPE (exp), base, offset),
 210                             target, tmode, EXPAND_NORMAL);
 211 #endif
 212       }
 213
 214     case THUNK_DECL:
 215       return DECL_RTL (exp);
 216
 217     case THROW_EXPR:
 218       expand_throw (TREE_OPERAND (exp, 0));
 219       return NULL;
 220
 221     default:
 222       break;
 223     }
 224   my_friendly_abort (40);
 225   /* NOTREACHED */
 226   return NULL;
 227 }
 228
 229 void
 230 init_cplus_expand ()
 231 {
 232   lang_expand_expr = cplus_expand_expr;
 233 }
 234
 235 /* If DECL had its rtl moved from where callers expect it
 236    to be, fix it up.  RESULT is the nominal rtl for the RESULT_DECL,
 237    which may be a pseudo instead of a hard register.  */
 238
 239 void
 240 fixup_result_decl (decl, result)
 241      tree decl;
 242      rtx result;
 243 {
 244   if (REG_P (result))
 245     {
 246       if (REGNO (result) >= FIRST_PSEUDO_REGISTER)
 247         {
 248           rtx real_decl_result;
 249
 250 #ifdef FUNCTION_OUTGOING_VALUE
 251           real_decl_result
 252             = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl), current_function_decl);
 253 #else
 254           real_decl_result
 255             = FUNCTION_VALUE (TREE_TYPE (decl), current_function_decl);
 256 #endif
 257           REG_FUNCTION_VALUE_P (real_decl_result) = 1;
 258           result = real_decl_result;
 259         }
 260       emit_move_insn (result, DECL_RTL (decl));
 261       emit_insn (gen_rtx (USE, VOIDmode, result));
 262     }
 263 }
 264
 265 /* Return nonzero iff DECL is memory-based.  The DECL_RTL of
 266    certain const variables might be a CONST_INT, or a REG
 267    in some cases.  We cannot use `memory_operand' as a test
 268    here because on most RISC machines, a variable's address
 269    is not, by itself, a legitimate address.  */
 270 int
 271 decl_in_memory_p (decl)
 272      tree decl;
 273 {
 274   return DECL_RTL (decl) != 0 && GET_CODE (DECL_RTL (decl)) == MEM;
 275 }