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