1 /* Convert language-specific tree expression to rtl instructions, 2 for GNU compiler. 3 Copyright (C) 1988-2018 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 || expr == error_mark_node) 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 && TREE_CODE (TREE_TYPE (oexpr)) == REFERENCE_TYPE)) 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 (TREE_CODE (TREE_TYPE (cap)) != REFERENCE_TYPE 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_CONVERT: 191 case VIEW_CONVERT_EXPR: 192 if (location_wrapper_p (expr)) 193 loc = EXPR_LOCATION (expr); 194 recurse_op[0] = true; 195 break; 196 197 default: 198 break; 199 } 200 201 for (int i = 0; i < 3; ++i) 202 if (recurse_op[i]) 203 { 204 tree op = TREE_OPERAND (expr, i); 205 op = RECUR (op); 206 if (op == error_mark_node) 207 return error_mark_node; 208 TREE_OPERAND (expr, i) = op; 209 } 210 211 return expr; 212 #undef RECUR 213 } 214 215 /* Called whenever the expression EXPR is used in an rvalue context. 216 When REJECT_BUILTIN is true the expression is checked to make sure 217 it doesn't make it possible to obtain the address of a GCC built-in 218 function with no library fallback (or any of its bits, such as in 219 a conversion to bool). */ 220 221 tree 222 mark_rvalue_use (tree e, 223 location_t loc /* = UNKNOWN_LOCATION */, 224 bool reject_builtin /* = true */) 225 { 226 return mark_use (e, true, true, loc, reject_builtin); 227 } 228 229 /* Called whenever an expression is used in an lvalue context. */ 230 231 tree 232 mark_lvalue_use (tree expr) 233 { 234 return mark_use (expr, false, true, input_location, false); 235 } 236 237 /* As above, but don't consider this use a read. */ 238 239 tree 240 mark_lvalue_use_nonread (tree expr) 241 { 242 return mark_use (expr, false, false, input_location, false); 243 } 244 245 /* Called when expr appears as a discarded-value expression. */ 246 247 tree 248 mark_discarded_use (tree expr) 249 { 250 /* The lvalue-to-rvalue conversion (7.1) is applied if and only if the 251 expression is a glvalue of volatile-qualified type and it is one of the 252 following: 253 * ( expression ), where expression is one of these expressions, 254 * id-expression (8.1.4), 255 * subscripting (8.2.1), 256 * class member access (8.2.5), 257 * indirection (8.3.1), 258 * pointer-to-member operation (8.5), 259 * conditional expression (8.16) where both the second and the third 260 operands are one of these expressions, or 261 * comma expression (8.19) where the right operand is one of these 262 expressions. */ 263 if (expr == NULL_TREE) 264 return expr; 265 266 switch (TREE_CODE (expr)) 267 { 268 case COND_EXPR: 269 TREE_OPERAND (expr, 2) = mark_discarded_use (TREE_OPERAND (expr, 2)); 270 gcc_fallthrough (); 271 case COMPOUND_EXPR: 272 TREE_OPERAND (expr, 1) = mark_discarded_use (TREE_OPERAND (expr, 1)); 273 return expr; 274 275 case COMPONENT_REF: 276 case ARRAY_REF: 277 case INDIRECT_REF: 278 case MEMBER_REF: 279 break; 280 default: 281 if (DECL_P (expr)) 282 break; 283 else 284 return expr; 285 } 286 287 /* Like mark_rvalue_use, but don't reject built-ins. */ 288 return mark_use (expr, true, true, input_location, false); 289 } 290 291 /* Called whenever an expression is used in a type use context. */ 292 293 tree 294 mark_type_use (tree expr) 295 { 296 mark_exp_read (expr); 297 return expr; 298 } 299 300 /* Mark EXP as read, not just set, for set but not used -Wunused 301 warning purposes. */ 302 303 void 304 mark_exp_read (tree exp) 305 { 306 if (exp == NULL) 307 return; 308 309 switch (TREE_CODE (exp)) 310 { 311 case VAR_DECL: 312 if (DECL_DECOMPOSITION_P (exp)) 313 mark_exp_read (DECL_DECOMP_BASE (exp)); 314 gcc_fallthrough (); 315 case PARM_DECL: 316 DECL_READ_P (exp) = 1; 317 break; 318 case ARRAY_REF: 319 case COMPONENT_REF: 320 case MODIFY_EXPR: 321 case REALPART_EXPR: 322 case IMAGPART_EXPR: 323 CASE_CONVERT: 324 case ADDR_EXPR: 325 case INDIRECT_REF: 326 case FLOAT_EXPR: 327 case NON_DEPENDENT_EXPR: 328 case VIEW_CONVERT_EXPR: 329 mark_exp_read (TREE_OPERAND (exp, 0)); 330 break; 331 case COMPOUND_EXPR: 332 mark_exp_read (TREE_OPERAND (exp, 1)); 333 break; 334 case COND_EXPR: 335 if (TREE_OPERAND (exp, 1)) 336 mark_exp_read (TREE_OPERAND (exp, 1)); 337 if (TREE_OPERAND (exp, 2)) 338 mark_exp_read (TREE_OPERAND (exp, 2)); 339 break; 340 default: 341 break; 342 } 343 } 344 345 /* Fold X for consideration by one of the warning functions when checking 346 whether an expression has a constant value. */ 347 348 tree 349 fold_for_warn (tree x) 350 { 351 /* C++ implementation. */ 352 353 /* It's not generally safe to fully fold inside of a template, so 354 call fold_non_dependent_expr instead. */ 355 if (processing_template_decl) 356 return fold_non_dependent_expr (x); 357 358 return c_fully_fold (x, /*for_init*/false, /*maybe_constp*/NULL); 359 } 360