1 /* Tree lowering pass. This pass gimplifies the tree representation built 2 by the C-based front ends. The structure of gimplified, or 3 language-independent, trees is dictated by the grammar described in this 4 file. 5 Copyright (C) 2002-2015 Free Software Foundation, Inc. 6 Lowering of expressions contributed by Sebastian Pop <s.pop@laposte.net> 7 Re-written to support lowering of whole function trees, documentation 8 and miscellaneous cleanups by Diego Novillo <dnovillo@redhat.com> 9 10 This file is part of GCC. 11 12 GCC is free software; you can redistribute it and/or modify it under 13 the terms of the GNU General Public License as published by the Free 14 Software Foundation; either version 3, or (at your option) any later 15 version. 16 17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 18 WARRANTY; without even the implied warranty of MERCHANTABILITY or 19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 20 for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with GCC; see the file COPYING3. If not see 24 <http://www.gnu.org/licenses/>. */ 25 26 #include "config.h" 27 #include "system.h" 28 #include "coretypes.h" 29 #include "tm.h" 30 #include "hash-set.h" 31 #include "machmode.h" 32 #include "vec.h" 33 #include "double-int.h" 34 #include "input.h" 35 #include "alias.h" 36 #include "symtab.h" 37 #include "wide-int.h" 38 #include "inchash.h" 39 #include "tree.h" 40 #include "fold-const.h" 41 #include "c-common.h" 42 #include "predict.h" 43 #include "vec.h" 44 #include "hashtab.h" 45 #include "hash-set.h" 46 #include "machmode.h" 47 #include "hard-reg-set.h" 48 #include "input.h" 49 #include "function.h" 50 #include "basic-block.h" 51 #include "tree-ssa-alias.h" 52 #include "internal-fn.h" 53 #include "gimple-expr.h" 54 #include "is-a.h" 55 #include "gimple.h" 56 #include "gimplify.h" 57 #include "tree-inline.h" 58 #include "diagnostic-core.h" 59 #include "langhooks.h" 60 #include "langhooks-def.h" 61 #include "flags.h" 62 #include "dumpfile.h" 63 #include "c-pretty-print.h" 64 #include "hash-map.h" 65 #include "plugin-api.h" 66 #include "ipa-ref.h" 67 #include "cgraph.h" 68 #include "cilk.h" 69 #include "c-ubsan.h" 70 71 /* The gimplification pass converts the language-dependent trees 72 (ld-trees) emitted by the parser into language-independent trees 73 (li-trees) that are the target of SSA analysis and transformations. 74 75 Language-independent trees are based on the SIMPLE intermediate 76 representation used in the McCAT compiler framework: 77 78 "Designing the McCAT Compiler Based on a Family of Structured 79 Intermediate Representations," 80 L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan, 81 Proceedings of the 5th International Workshop on Languages and 82 Compilers for Parallel Computing, no. 757 in Lecture Notes in 83 Computer Science, New Haven, Connecticut, pp. 406-420, 84 Springer-Verlag, August 3-5, 1992. 85 86 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html 87 88 Basically, we walk down gimplifying the nodes that we encounter. As we 89 walk back up, we check that they fit our constraints, and copy them 90 into temporaries if not. */ 91 92 /* Callback for c_genericize. */ 93 94 static tree 95 ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data) 96 { 97 hash_set<tree> *pset = (hash_set<tree> *) data; 98 99 if (TREE_CODE (*tp) == BIND_EXPR) 100 { 101 /* Since walk_tree doesn't call the callback function on the decls 102 in BIND_EXPR_VARS, we have to walk them manually, so we can avoid 103 instrumenting DECL_INITIAL of TREE_STATIC vars. */ 104 *walk_subtrees = 0; 105 for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl)) 106 { 107 if (TREE_STATIC (decl)) 108 continue; 109 walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset, 110 pset); 111 walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset); 112 walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset, 113 pset); 114 } 115 walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset); 116 } 117 else if (TREE_CODE (*tp) == ADDR_EXPR 118 && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF) 119 { 120 ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true); 121 /* Make sure ubsan_maybe_instrument_array_ref is not called again 122 on the ARRAY_REF, the above call might not instrument anything 123 as the index might be constant or masked, so ensure it is not 124 walked again and walk its subtrees manually. */ 125 tree aref = TREE_OPERAND (*tp, 0); 126 pset->add (aref); 127 *walk_subtrees = 0; 128 walk_tree (&TREE_OPERAND (aref, 0), ubsan_walk_array_refs_r, pset, pset); 129 walk_tree (&TREE_OPERAND (aref, 1), ubsan_walk_array_refs_r, pset, pset); 130 walk_tree (&TREE_OPERAND (aref, 2), ubsan_walk_array_refs_r, pset, pset); 131 walk_tree (&TREE_OPERAND (aref, 3), ubsan_walk_array_refs_r, pset, pset); 132 } 133 else if (TREE_CODE (*tp) == ARRAY_REF) 134 ubsan_maybe_instrument_array_ref (tp, false); 135 return NULL_TREE; 136 } 137 138 /* Gimplification of statement trees. */ 139 140 /* Convert the tree representation of FNDECL from C frontend trees to 141 GENERIC. */ 142 143 void 144 c_genericize (tree fndecl) 145 { 146 FILE *dump_orig; 147 int local_dump_flags; 148 struct cgraph_node *cgn; 149 150 if (flag_sanitize & SANITIZE_BOUNDS) 151 { 152 hash_set<tree> pset; 153 walk_tree (&DECL_SAVED_TREE (fndecl), ubsan_walk_array_refs_r, &pset, 154 &pset); 155 } 156 157 /* Dump the C-specific tree IR. */ 158 dump_orig = get_dump_info (TDI_original, &local_dump_flags); 159 if (dump_orig) 160 { 161 fprintf (dump_orig, "\n;; Function %s", 162 lang_hooks.decl_printable_name (fndecl, 2)); 163 fprintf (dump_orig, " (%s)\n", 164 (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null" 165 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)))); 166 fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); 167 fprintf (dump_orig, "\n"); 168 169 if (local_dump_flags & TDF_RAW) 170 dump_node (DECL_SAVED_TREE (fndecl), 171 TDF_SLIM | local_dump_flags, dump_orig); 172 else 173 print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); 174 fprintf (dump_orig, "\n"); 175 } 176 177 /* Dump all nested functions now. */ 178 cgn = cgraph_node::get_create (fndecl); 179 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) 180 c_genericize (cgn->decl); 181 } 182 183 static void 184 add_block_to_enclosing (tree block) 185 { 186 unsigned i; 187 tree enclosing; 188 gbind *bind; 189 vec<gbind *> stack = gimple_bind_expr_stack (); 190 191 FOR_EACH_VEC_ELT (stack, i, bind) 192 if (gimple_bind_block (bind)) 193 break; 194 195 enclosing = gimple_bind_block (bind); 196 BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block); 197 } 198 199 /* Genericize a scope by creating a new BIND_EXPR. 200 BLOCK is either a BLOCK representing the scope or a chain of _DECLs. 201 In the latter case, we need to create a new BLOCK and add it to the 202 BLOCK_SUBBLOCKS of the enclosing block. 203 BODY is a chain of C _STMT nodes for the contents of the scope, to be 204 genericized. */ 205 206 tree 207 c_build_bind_expr (location_t loc, tree block, tree body) 208 { 209 tree decls, bind; 210 211 if (block == NULL_TREE) 212 decls = NULL_TREE; 213 else if (TREE_CODE (block) == BLOCK) 214 decls = BLOCK_VARS (block); 215 else 216 { 217 decls = block; 218 if (DECL_ARTIFICIAL (decls)) 219 block = NULL_TREE; 220 else 221 { 222 block = make_node (BLOCK); 223 BLOCK_VARS (block) = decls; 224 add_block_to_enclosing (block); 225 } 226 } 227 228 if (!body) 229 body = build_empty_stmt (loc); 230 if (decls || block) 231 { 232 bind = build3 (BIND_EXPR, void_type_node, decls, body, block); 233 TREE_SIDE_EFFECTS (bind) = 1; 234 SET_EXPR_LOCATION (bind, loc); 235 } 236 else 237 bind = body; 238 239 return bind; 240 } 241 242 /* Gimplification of expression trees. */ 243 244 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in 245 gimplify_expr. */ 246 247 int 248 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, 249 gimple_seq *post_p ATTRIBUTE_UNUSED) 250 { 251 enum tree_code code = TREE_CODE (*expr_p); 252 253 switch (code) 254 { 255 case LSHIFT_EXPR: 256 case RSHIFT_EXPR: 257 { 258 /* We used to convert the right operand of a shift-expression 259 to an integer_type_node in the FEs. But it is unnecessary 260 and not desirable for diagnostics and sanitizers. We keep 261 this here to not pessimize the code, but we convert to an 262 unsigned type, because negative shift counts are undefined 263 anyway. 264 We should get rid of this conversion when we have a proper 265 type demotion/promotion pass. */ 266 tree *op1_p = &TREE_OPERAND (*expr_p, 1); 267 if (TREE_CODE (TREE_TYPE (*op1_p)) != VECTOR_TYPE 268 && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)), 269 unsigned_type_node) 270 && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)), 271 integer_type_node)) 272 *op1_p = convert (unsigned_type_node, *op1_p); 273 break; 274 } 275 276 case DECL_EXPR: 277 /* This is handled mostly by gimplify.c, but we have to deal with 278 not warning about int x = x; as it is a GCC extension to turn off 279 this warning but only if warn_init_self is zero. */ 280 if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL 281 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) 282 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) 283 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) 284 && !warn_init_self) 285 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; 286 break; 287 288 case PREINCREMENT_EXPR: 289 case PREDECREMENT_EXPR: 290 case POSTINCREMENT_EXPR: 291 case POSTDECREMENT_EXPR: 292 { 293 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0)); 294 if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type)) 295 { 296 if (!TYPE_OVERFLOW_WRAPS (type)) 297 type = unsigned_type_for (type); 298 return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type); 299 } 300 break; 301 } 302 303 case CILK_SPAWN_STMT: 304 gcc_assert 305 (fn_contains_cilk_spawn_p (cfun) 306 && cilk_detect_spawn_and_unwrap (expr_p)); 307 308 /* If errors are seen, then just process it as a CALL_EXPR. */ 309 if (!seen_error ()) 310 return (enum gimplify_status) gimplify_cilk_spawn (expr_p); 311 312 case MODIFY_EXPR: 313 case INIT_EXPR: 314 case CALL_EXPR: 315 if (fn_contains_cilk_spawn_p (cfun) 316 && cilk_detect_spawn_and_unwrap (expr_p) 317 /* If an error is found, the spawn wrapper is removed and the 318 original expression (MODIFY/INIT/CALL_EXPR) is processes as 319 it is supposed to be. */ 320 && !seen_error ()) 321 return (enum gimplify_status) gimplify_cilk_spawn (expr_p); 322 323 default:; 324 } 325 326 return GS_UNHANDLED; 327 } 328