expr.c revision 52284
1/* Convert language-specific tree expression to rtl instructions, 2 for GNU compiler. 3 Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc. 4 5This file is part of GNU CC. 6 7GNU CC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22 23#include "config.h" 24#include "system.h" 25#include "rtl.h" 26#include "tree.h" 27#include "flags.h" 28#include "expr.h" 29#include "cp-tree.h" 30#include "toplev.h" 31 32#if 0 33static tree extract_aggr_init PROTO((tree, tree)); 34static tree extract_scalar_init PROTO((tree, tree)); 35#endif 36static rtx cplus_expand_expr PROTO((tree, rtx, enum machine_mode, 37 enum expand_modifier)); 38 39/* Hook used by output_constant to expand language-specific 40 constants. */ 41 42static tree 43cplus_expand_constant (cst) 44 tree cst; 45{ 46 switch (TREE_CODE (cst)) 47 { 48 case PTRMEM_CST: 49 { 50 tree type = TREE_TYPE (cst); 51 tree member; 52 tree offset; 53 54 /* Find the member. */ 55 member = PTRMEM_CST_MEMBER (cst); 56 57 if (TREE_CODE (member) == FIELD_DECL) 58 { 59 /* Find the offset for the field. */ 60 offset = convert (sizetype, 61 size_binop (EASY_DIV_EXPR, 62 DECL_FIELD_BITPOS (member), 63 size_int (BITS_PER_UNIT))); 64 65 /* We offset all pointer to data members by 1 so that we 66 can distinguish between a null pointer to data member 67 and the first data member of a structure. */ 68 offset = size_binop (PLUS_EXPR, offset, size_int (1)); 69 70 cst = cp_convert (type, offset); 71 } 72 else 73 { 74 tree delta; 75 tree idx; 76 tree pfn; 77 tree delta2; 78 79 expand_ptrmemfunc_cst (cst, &delta, &idx, &pfn, &delta2); 80 81 cst = build_ptrmemfunc1 (type, delta, idx, 82 pfn, delta2); 83 } 84 } 85 break; 86 87 default: 88 /* There's nothing to do. */ 89 break; 90 } 91 92 return cst; 93} 94 95/* Hook used by expand_expr to expand language-specific tree codes. */ 96 97static rtx 98cplus_expand_expr (exp, target, tmode, modifier) 99 tree exp; 100 rtx target; 101 enum machine_mode tmode; 102 enum expand_modifier modifier; 103{ 104 tree type = TREE_TYPE (exp); 105 register enum machine_mode mode = TYPE_MODE (type); 106 register enum tree_code code = TREE_CODE (exp); 107 int ignore = target == const0_rtx; 108 109 if (ignore) 110 target = 0; 111 112 /* No sense saving up arithmetic to be done 113 if it's all in the wrong mode to form part of an address. 114 And force_operand won't know whether to sign-extend or zero-extend. */ 115 116 if (mode != Pmode && modifier == EXPAND_SUM) 117 modifier = EXPAND_NORMAL; 118 119 switch (code) 120 { 121 case AGGR_INIT_EXPR: 122 { 123 /* Something needs to be initialized, but we didn't know 124 where that thing was when building the tree. For example, 125 it could be the return value of a function, or a parameter 126 to a function which lays down in the stack, or a temporary 127 variable which must be passed by reference. 128 129 Cleanups are handled in a language-specific way: they 130 might be run by the called function (true in GNU C++ 131 for parameters with cleanups), or they might be 132 run by the caller, after the call (true in GNU C++ 133 for other cleanup needs). */ 134 135 tree func = TREE_OPERAND (exp, 0); 136 tree args = TREE_OPERAND (exp, 1); 137 tree type = TREE_TYPE (exp), slot; 138 tree call_exp; 139 rtx call_target, return_target; 140 int pcc_struct_return = 0; 141 142 /* The expression `init' wants to initialize what 143 `target' represents. SLOT holds the slot for TARGET. */ 144 slot = TREE_OPERAND (exp, 2); 145 146 /* Should always be called with a target. */ 147 my_friendly_assert (target != NULL_RTX, 205); 148 149 /* The target the initializer will initialize (CALL_TARGET) 150 must now be directed to initialize the target we are 151 supposed to initialize (TARGET). The semantics for 152 choosing what CALL_TARGET is is language-specific, 153 as is building the call which will perform the 154 initialization. It is left here to show the choices that 155 exist for C++. */ 156 157 if (TREE_CODE (func) == ADDR_EXPR 158 && TREE_CODE (TREE_OPERAND (func, 0)) == FUNCTION_DECL 159 && DECL_CONSTRUCTOR_P (TREE_OPERAND (func, 0))) 160 { 161 type = build_pointer_type (type); 162 /* Don't clobber a value that might be part of a default 163 parameter value. */ 164 mark_addressable (slot); 165 if (TREE_PERMANENT (args)) 166 args = expr_tree_cons (0, build1 (ADDR_EXPR, type, slot), 167 TREE_CHAIN (args)); 168 else 169 TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot); 170 call_target = 0; 171 } 172 else 173 { 174 call_target = target; 175#ifdef PCC_STATIC_STRUCT_RETURN 176 if (aggregate_value_p (type)) 177 { 178 pcc_struct_return = 1; 179 call_target = 0; 180 } 181#endif 182 } 183 184 call_exp = build (CALL_EXPR, type, func, args, NULL_TREE); 185 TREE_SIDE_EFFECTS (call_exp) = 1; 186 return_target = expand_call (call_exp, call_target, ignore); 187 188 if (call_target) 189 /* Trust that the right thing has been done; it's too hard to 190 verify. */ 191 return return_target; 192 193 /* If we're suffering under the ancient PCC_STATIC_STRUCT_RETURN 194 calling convention, we need to copy the return value out of 195 the static return buffer into slot. */ 196 if (pcc_struct_return) 197 { 198 extern int flag_access_control; 199 int old_ac = flag_access_control; 200 201 tree init = build_decl (VAR_DECL, NULL_TREE, 202 build_reference_type (type)); 203 DECL_RTL (init) = XEXP (return_target, 0); 204 init = convert_from_reference (init); 205 206 flag_access_control = 0; 207 expand_aggr_init (slot, init, LOOKUP_ONLYCONVERTING); 208 flag_access_control = old_ac; 209 210 if (TYPE_NEEDS_DESTRUCTOR (type)) 211 { 212 init = maybe_build_cleanup (init); 213 if (init != NULL_TREE) 214 expand_expr (init, const0_rtx, VOIDmode, 0); 215 } 216 } 217 218 return DECL_RTL (slot); 219 } 220 221 case PTRMEM_CST: 222 return expand_expr (cplus_expand_constant (exp), 223 target, tmode, modifier); 224 225 case OFFSET_REF: 226 { 227 return expand_expr (default_conversion (resolve_offset_ref (exp)), 228 target, tmode, EXPAND_NORMAL); 229 } 230 231 case THUNK_DECL: 232 return DECL_RTL (exp); 233 234 case THROW_EXPR: 235 expand_throw (TREE_OPERAND (exp, 0)); 236 return NULL; 237 238 case VEC_INIT_EXPR: 239 return expand_expr 240 (expand_vec_init 241 (NULL_TREE, TREE_OPERAND (exp, 0), 242 build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2), 243 integer_one_node), 244 TREE_OPERAND (exp, 1), 0), target, tmode, modifier); 245 246 case NEW_EXPR: 247 return expand_expr (build_new_1 (exp), target, tmode, modifier); 248 249 default: 250 break; 251 } 252 my_friendly_abort (40); 253 /* NOTREACHED */ 254 return NULL; 255} 256 257void 258init_cplus_expand () 259{ 260 lang_expand_expr = cplus_expand_expr; 261 lang_expand_constant = cplus_expand_constant; 262} 263 264/* If DECL had its rtl moved from where callers expect it 265 to be, fix it up. RESULT is the nominal rtl for the RESULT_DECL, 266 which may be a pseudo instead of a hard register. */ 267 268void 269fixup_result_decl (decl, result) 270 tree decl; 271 rtx result; 272{ 273 if (REG_P (result)) 274 { 275 if (REGNO (result) >= FIRST_PSEUDO_REGISTER) 276 { 277 rtx real_decl_result; 278 279#ifdef FUNCTION_OUTGOING_VALUE 280 real_decl_result 281 = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl), current_function_decl); 282#else 283 real_decl_result 284 = FUNCTION_VALUE (TREE_TYPE (decl), current_function_decl); 285#endif 286 REG_FUNCTION_VALUE_P (real_decl_result) = 1; 287 result = real_decl_result; 288 } 289 store_expr (decl, result, 0); 290 emit_insn (gen_rtx (USE, VOIDmode, result)); 291 } 292} 293 294#if 0 295/* Expand this initialization inline and see if it's simple enough that 296 it can be done at compile-time. */ 297 298static tree 299extract_aggr_init (decl, init) 300 tree decl, init; 301{ 302 return 0; 303} 304 305static tree 306extract_scalar_init (decl, init) 307 tree decl, init; 308{ 309 rtx value, insns, insn; 310 extern struct obstack temporary_obstack; 311 tree t = NULL_TREE; 312 313 push_obstacks (&temporary_obstack, &temporary_obstack); 314 start_sequence (); 315 value = expand_expr (init, NULL_RTX, VOIDmode, 0); 316 insns = get_insns (); 317 end_sequence (); 318 reg_scan (insns, max_reg_num (), 0); 319 jump_optimize (insns, 0, 0, 1); 320 pop_obstacks (); 321 322 for (insn = insns; insn; insn = NEXT_INSN (insn)) 323 { 324 rtx r, to; 325 326 if (GET_CODE (insn) == NOTE) 327 continue; 328 else if (GET_CODE (insn) != INSN) 329 return 0; 330 331 r = PATTERN (insn); 332 if (GET_CODE (r) != SET) 333 return 0; 334 335 to = XEXP (r, 0); 336 337 if (! (to == value 338 || (GET_CODE (to) == SUBREG && XEXP (to, 0) == value))) 339 return 0; 340 341 r = XEXP (r, 1); 342 343 switch (GET_CODE (r)) 344 { 345 case CONST_INT: 346 t = build_int_2 (XEXP (r, 0), 0); 347 break; 348 default: 349 return 0; 350 } 351 } 352 353 return t; 354} 355#endif 356 357int 358extract_init (decl, init) 359 tree decl ATTRIBUTE_UNUSED, init ATTRIBUTE_UNUSED; 360{ 361 return 0; 362 363#if 0 364 if (IS_AGGR_TYPE (TREE_TYPE (decl)) 365 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 366 init = extract_aggr_init (decl, init); 367 else 368 init = extract_scalar_init (decl, init); 369 370 if (init == NULL_TREE) 371 return 0; 372 373 DECL_INITIAL (decl) = init; 374 return 1; 375#endif 376} 377 378void 379do_case (start, end) 380 tree start, end; 381{ 382 tree value1 = NULL_TREE, value2 = NULL_TREE, label; 383 384 if (start != NULL_TREE && TREE_TYPE (start) != NULL_TREE 385 && POINTER_TYPE_P (TREE_TYPE (start))) 386 error ("pointers are not permitted as case values"); 387 388 if (end && pedantic) 389 pedwarn ("ANSI C++ forbids range expressions in switch statement"); 390 391 if (processing_template_decl) 392 { 393 add_tree (build_min_nt (CASE_LABEL, start, end)); 394 return; 395 } 396 397 if (start) 398 value1 = check_cp_case_value (start); 399 if (end) 400 value2 = check_cp_case_value (end); 401 402 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 403 404 if (value1 != error_mark_node 405 && value2 != error_mark_node) 406 { 407 tree duplicate; 408 int success; 409 410 if (end) 411 success = pushcase_range (value1, value2, convert_and_check, 412 label, &duplicate); 413 else if (start) 414 success = pushcase (value1, convert_and_check, label, &duplicate); 415 else 416 success = pushcase (NULL_TREE, 0, label, &duplicate); 417 418 if (success == 1) 419 { 420 if (end) 421 error ("case label not within a switch statement"); 422 else if (start) 423 cp_error ("case label `%E' not within a switch statement", start); 424 else 425 error ("default label not within a switch statement"); 426 } 427 else if (success == 2) 428 { 429 if (end) 430 { 431 error ("duplicate (or overlapping) case value"); 432 cp_error_at ("this is the first entry overlapping that value", 433 duplicate); 434 } 435 else if (start) 436 { 437 cp_error ("duplicate case value `%E'", start); 438 cp_error_at ("previously used here", duplicate); 439 } 440 else 441 { 442 error ("multiple default labels in one switch"); 443 cp_error_at ("this is the first default label", duplicate); 444 } 445 } 446 else if (success == 3) 447 warning ("case value out of range"); 448 else if (success == 4) 449 warning ("empty range specified"); 450 else if (success == 5) 451 { 452 if (end) 453 error ("case label within scope of cleanup or variable array"); 454 else if (! start) 455 error ("`default' label within scope of cleanup or variable array"); 456 else 457 cp_error ("case label `%E' within scope of cleanup or variable array", start); 458 } 459 } 460 define_case_label (); 461} 462