1 /* Convert language-specific tree expression to rtl instructions, 2 for GNU compiler. 3 Copyright (C) 1988-2020 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC 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 3, or (at your option) 10 any later version. 11 12 GCC 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 GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "cp-tree.h" 26 27 /* Expand C++-specific constants. Currently, this means PTRMEM_CST. */ 28 29 tree 30 cplus_expand_constant (tree cst) 31 { 32 switch (TREE_CODE (cst)) 33 { 34 case PTRMEM_CST: 35 { 36 tree type = TREE_TYPE (cst); 37 tree member; 38 39 /* Find the member. */ 40 member = PTRMEM_CST_MEMBER (cst); 41 42 /* We can't lower this until the class is complete. */ 43 if (!COMPLETE_TYPE_P (DECL_CONTEXT (member))) 44 return cst; 45 46 if (TREE_CODE (member) == FIELD_DECL) 47 { 48 /* Find the offset for the field. */ 49 cst = byte_position (member); 50 while (!same_type_p (DECL_CONTEXT (member), 51 TYPE_PTRMEM_CLASS_TYPE (type))) 52 { 53 /* The MEMBER must have been nestled within an 54 anonymous aggregate contained in TYPE. Find the 55 anonymous aggregate. */ 56 member = lookup_anon_field (TYPE_PTRMEM_CLASS_TYPE (type), 57 DECL_CONTEXT (member)); 58 cst = size_binop (PLUS_EXPR, cst, byte_position (member)); 59 } 60 cst = fold (build_nop (type, cst)); 61 } 62 else 63 { 64 tree delta; 65 tree pfn; 66 67 expand_ptrmemfunc_cst (cst, &delta, &pfn); 68 cst = build_ptrmemfunc1 (type, delta, pfn); 69 } 70 } 71 break; 72 73 case CONSTRUCTOR: 74 { 75 constructor_elt *elt; 76 unsigned HOST_WIDE_INT idx; 77 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (cst), idx, elt) 78 elt->value = cplus_expand_constant (elt->value); 79 } 80 81 default: 82 /* There's nothing to do. */ 83 break; 84 } 85 86 return cst; 87 } 88 89 /* We've seen an actual use of EXPR. Possibly replace an outer variable 90 reference inside with its constant value or a lambda capture. */ 91 92 tree 93 mark_use (tree expr, bool rvalue_p, bool read_p, 94 location_t loc /* = UNKNOWN_LOCATION */, 95 bool reject_builtin /* = true */) 96 { 97 #define RECUR(t) mark_use ((t), rvalue_p, read_p, loc, reject_builtin) 98 99 if (expr == NULL_TREE || error_operand_p (expr)) 100 return expr; 101 102 if (reject_builtin && reject_gcc_builtin (expr, loc)) 103 return error_mark_node; 104 105 if (read_p) 106 mark_exp_read (expr); 107 108 tree oexpr = expr; 109 bool recurse_op[3] = { false, false, false }; 110 switch (TREE_CODE (expr)) 111 { 112 case VAR_DECL: 113 case PARM_DECL: 114 if (rvalue_p && is_normal_capture_proxy (expr)) 115 { 116 /* Look through capture by copy. */ 117 tree cap = DECL_CAPTURED_VARIABLE (expr); 118 if (TREE_CODE (TREE_TYPE (cap)) == TREE_CODE (TREE_TYPE (expr)) 119 && decl_constant_var_p (cap)) 120 { 121 tree val = RECUR (cap); 122 if (!is_capture_proxy (val)) 123 { 124 tree l = current_lambda_expr (); 125 LAMBDA_EXPR_CAPTURE_OPTIMIZED (l) = true; 126 } 127 return val; 128 } 129 } 130 if (outer_automatic_var_p (expr) 131 && decl_constant_var_p (expr)) 132 { 133 if (rvalue_p) 134 { 135 tree t = maybe_constant_value (expr); 136 if (TREE_CONSTANT (t)) 137 { 138 expr = t; 139 break; 140 } 141 } 142 temp_override<location_t> l (input_location); 143 if (loc != UNKNOWN_LOCATION) 144 input_location = loc; 145 expr = process_outer_var_ref (expr, tf_warning_or_error, true); 146 if (!(TREE_TYPE (oexpr) 147 && TYPE_REF_P (TREE_TYPE (oexpr)))) 148 expr = convert_from_reference (expr); 149 } 150 break; 151 case COMPONENT_REF: 152 case NON_DEPENDENT_EXPR: 153 recurse_op[0] = true; 154 break; 155 case COMPOUND_EXPR: 156 recurse_op[1] = true; 157 break; 158 case COND_EXPR: 159 recurse_op[2] = true; 160 if (TREE_OPERAND (expr, 1)) 161 recurse_op[1] = true; 162 break; 163 case INDIRECT_REF: 164 if (REFERENCE_REF_P (expr)) 165 { 166 /* Try to look through the reference. */ 167 tree ref = TREE_OPERAND (expr, 0); 168 if (rvalue_p && is_normal_capture_proxy (ref)) 169 { 170 /* Look through capture by reference. */ 171 tree cap = DECL_CAPTURED_VARIABLE (ref); 172 if (!TYPE_REF_P (TREE_TYPE (cap)) 173 && decl_constant_var_p (cap)) 174 { 175 tree val = RECUR (cap); 176 if (!is_capture_proxy (val)) 177 { 178 tree l = current_lambda_expr (); 179 LAMBDA_EXPR_CAPTURE_OPTIMIZED (l) = true; 180 } 181 return val; 182 } 183 } 184 tree r = mark_rvalue_use (ref, loc, reject_builtin); 185 if (r != ref) 186 expr = convert_from_reference (r); 187 } 188 break; 189 190 case VIEW_CONVERT_EXPR: 191 if (location_wrapper_p (expr)) 192 { 193 loc = EXPR_LOCATION (expr); 194 tree op = TREE_OPERAND (expr, 0); 195 tree nop = RECUR (op); 196 if (nop == error_mark_node) 197 return error_mark_node; 198 else if (op == nop) 199 /* No change. */; 200 else if (DECL_P (nop) || CONSTANT_CLASS_P (nop)) 201 { 202 /* Reuse the location wrapper. */ 203 TREE_OPERAND (expr, 0) = nop; 204 /* If we're replacing a DECL with a constant, we also need to 205 change the TREE_CODE of the location wrapper. */ 206 if (rvalue_p) 207 TREE_SET_CODE (expr, NON_LVALUE_EXPR); 208 } 209 else 210 { 211 /* Drop the location wrapper. */ 212 expr = nop; 213 protected_set_expr_location (expr, loc); 214 } 215 return expr; 216 } 217 gcc_fallthrough(); 218 CASE_CONVERT: 219 recurse_op[0] = true; 220 break; 221 222 case MODIFY_EXPR: 223 { 224 tree lhs = TREE_OPERAND (expr, 0); 225 /* [expr.ass] "An assignment whose left operand is of 226 a volatile-qualified type is deprecated unless the assignment 227 is either a discarded-value expression or appears in an 228 unevaluated context." */ 229 if (!cp_unevaluated_operand 230 && (TREE_THIS_VOLATILE (lhs) 231 || CP_TYPE_VOLATILE_P (TREE_TYPE (lhs))) 232 && !TREE_THIS_VOLATILE (expr)) 233 { 234 if (warning_at (location_of (expr), OPT_Wvolatile, 235 "using value of assignment with " 236 "%<volatile%>-qualified left operand is " 237 "deprecated")) 238 /* Make sure not to warn about this assignment again. */ 239 TREE_THIS_VOLATILE (expr) = true; 240 } 241 break; 242 } 243 244 default: 245 break; 246 } 247 248 for (int i = 0; i < 3; ++i) 249 if (recurse_op[i]) 250 { 251 tree op = TREE_OPERAND (expr, i); 252 op = RECUR (op); 253 if (op == error_mark_node) 254 return error_mark_node; 255 TREE_OPERAND (expr, i) = op; 256 } 257 258 return expr; 259 #undef RECUR 260 } 261 262 /* Called whenever the expression EXPR is used in an rvalue context. 263 When REJECT_BUILTIN is true the expression is checked to make sure 264 it doesn't make it possible to obtain the address of a GCC built-in 265 function with no library fallback (or any of its bits, such as in 266 a conversion to bool). */ 267 268 tree 269 mark_rvalue_use (tree e, 270 location_t loc /* = UNKNOWN_LOCATION */, 271 bool reject_builtin /* = true */) 272 { 273 return mark_use (e, true, true, loc, reject_builtin); 274 } 275 276 /* Called whenever an expression is used in an lvalue context. */ 277 278 tree 279 mark_lvalue_use (tree expr) 280 { 281 return mark_use (expr, false, true, input_location, false); 282 } 283 284 /* As above, but don't consider this use a read. */ 285 286 tree 287 mark_lvalue_use_nonread (tree expr) 288 { 289 return mark_use (expr, false, false, input_location, false); 290 } 291 292 /* Called when expr appears as a discarded-value expression. */ 293 294 tree 295 mark_discarded_use (tree expr) 296 { 297 /* The lvalue-to-rvalue conversion (7.1) is applied if and only if the 298 expression is a glvalue of volatile-qualified type and it is one of the 299 following: 300 * ( expression ), where expression is one of these expressions, 301 * id-expression (8.1.4), 302 * subscripting (8.2.1), 303 * class member access (8.2.5), 304 * indirection (8.3.1), 305 * pointer-to-member operation (8.5), 306 * conditional expression (8.16) where both the second and the third 307 operands are one of these expressions, or 308 * comma expression (8.19) where the right operand is one of these 309 expressions. */ 310 if (expr == NULL_TREE) 311 return expr; 312 313 STRIP_ANY_LOCATION_WRAPPER (expr); 314 315 switch (TREE_CODE (expr)) 316 { 317 case COND_EXPR: 318 TREE_OPERAND (expr, 2) = mark_discarded_use (TREE_OPERAND (expr, 2)); 319 gcc_fallthrough (); 320 case COMPOUND_EXPR: 321 TREE_OPERAND (expr, 1) = mark_discarded_use (TREE_OPERAND (expr, 1)); 322 return expr; 323 324 case COMPONENT_REF: 325 case ARRAY_REF: 326 case INDIRECT_REF: 327 case MEMBER_REF: 328 break; 329 default: 330 if (DECL_P (expr)) 331 break; 332 else 333 return expr; 334 } 335 336 /* Like mark_rvalue_use, but don't reject built-ins. */ 337 return mark_use (expr, true, true, input_location, false); 338 } 339 340 /* Called whenever an expression is used in a type use context. */ 341 342 tree 343 mark_type_use (tree expr) 344 { 345 mark_exp_read (expr); 346 return expr; 347 } 348 349 /* Mark EXP as read, not just set, for set but not used -Wunused 350 warning purposes. */ 351 352 void 353 mark_exp_read (tree exp) 354 { 355 if (exp == NULL) 356 return; 357 358 switch (TREE_CODE (exp)) 359 { 360 case VAR_DECL: 361 if (DECL_DECOMPOSITION_P (exp)) 362 mark_exp_read (DECL_DECOMP_BASE (exp)); 363 gcc_fallthrough (); 364 case PARM_DECL: 365 DECL_READ_P (exp) = 1; 366 break; 367 case ARRAY_REF: 368 case COMPONENT_REF: 369 case MODIFY_EXPR: 370 case REALPART_EXPR: 371 case IMAGPART_EXPR: 372 CASE_CONVERT: 373 case ADDR_EXPR: 374 case INDIRECT_REF: 375 case FLOAT_EXPR: 376 case NON_DEPENDENT_EXPR: 377 case VIEW_CONVERT_EXPR: 378 mark_exp_read (TREE_OPERAND (exp, 0)); 379 break; 380 case COMPOUND_EXPR: 381 mark_exp_read (TREE_OPERAND (exp, 1)); 382 break; 383 case COND_EXPR: 384 if (TREE_OPERAND (exp, 1)) 385 mark_exp_read (TREE_OPERAND (exp, 1)); 386 if (TREE_OPERAND (exp, 2)) 387 mark_exp_read (TREE_OPERAND (exp, 2)); 388 break; 389 default: 390 break; 391 } 392 } 393 394 /* Fold X for consideration by one of the warning functions when checking 395 whether an expression has a constant value. */ 396 397 tree 398 fold_for_warn (tree x) 399 { 400 /* C++ implementation. */ 401 402 /* It's not generally safe to fully fold inside of a template, so 403 call fold_non_dependent_expr instead. */ 404 if (processing_template_decl) 405 { 406 tree f = fold_non_dependent_expr (x, tf_none); 407 if (f == error_mark_node) 408 return x; 409 else 410 return f; 411 } 412 else if (cxx_dialect >= cxx11) 413 x = maybe_constant_value (x, NULL_TREE, false, true); 414 415 return c_fully_fold (x, /*for_init*/false, /*maybe_constp*/NULL); 416 } 417