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-2018 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 "function.h" 31 #include "basic-block.h" 32 #include "tree.h" 33 #include "gimple.h" 34 #include "cgraph.h" 35 #include "c-pretty-print.h" 36 #include "gimplify.h" 37 #include "langhooks.h" 38 #include "dumpfile.h" 39 #include "c-ubsan.h" 40 41 /* The gimplification pass converts the language-dependent trees 42 (ld-trees) emitted by the parser into language-independent trees 43 (li-trees) that are the target of SSA analysis and transformations. 44 45 Language-independent trees are based on the SIMPLE intermediate 46 representation used in the McCAT compiler framework: 47 48 "Designing the McCAT Compiler Based on a Family of Structured 49 Intermediate Representations," 50 L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan, 51 Proceedings of the 5th International Workshop on Languages and 52 Compilers for Parallel Computing, no. 757 in Lecture Notes in 53 Computer Science, New Haven, Connecticut, pp. 406-420, 54 Springer-Verlag, August 3-5, 1992. 55 56 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html 57 58 Basically, we walk down gimplifying the nodes that we encounter. As we 59 walk back up, we check that they fit our constraints, and copy them 60 into temporaries if not. */ 61 62 /* Callback for c_genericize. */ 63 64 static tree 65 ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data) 66 { 67 hash_set<tree> *pset = (hash_set<tree> *) data; 68 69 if (TREE_CODE (*tp) == BIND_EXPR) 70 { 71 /* Since walk_tree doesn't call the callback function on the decls 72 in BIND_EXPR_VARS, we have to walk them manually, so we can avoid 73 instrumenting DECL_INITIAL of TREE_STATIC vars. */ 74 *walk_subtrees = 0; 75 for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl)) 76 { 77 if (TREE_STATIC (decl)) 78 continue; 79 walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset, 80 pset); 81 walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset); 82 walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset, 83 pset); 84 } 85 walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset); 86 } 87 else if (TREE_CODE (*tp) == ADDR_EXPR 88 && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF) 89 { 90 ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true); 91 /* Make sure ubsan_maybe_instrument_array_ref is not called again 92 on the ARRAY_REF, the above call might not instrument anything 93 as the index might be constant or masked, so ensure it is not 94 walked again and walk its subtrees manually. */ 95 tree aref = TREE_OPERAND (*tp, 0); 96 pset->add (aref); 97 *walk_subtrees = 0; 98 walk_tree (&TREE_OPERAND (aref, 0), ubsan_walk_array_refs_r, pset, pset); 99 walk_tree (&TREE_OPERAND (aref, 1), ubsan_walk_array_refs_r, pset, pset); 100 walk_tree (&TREE_OPERAND (aref, 2), ubsan_walk_array_refs_r, pset, pset); 101 walk_tree (&TREE_OPERAND (aref, 3), ubsan_walk_array_refs_r, pset, pset); 102 } 103 else if (TREE_CODE (*tp) == ARRAY_REF) 104 ubsan_maybe_instrument_array_ref (tp, false); 105 return NULL_TREE; 106 } 107 108 /* Gimplification of statement trees. */ 109 110 /* Convert the tree representation of FNDECL from C frontend trees to 111 GENERIC. */ 112 113 void 114 c_genericize (tree fndecl) 115 { 116 FILE *dump_orig; 117 dump_flags_t local_dump_flags; 118 struct cgraph_node *cgn; 119 120 if (flag_sanitize & SANITIZE_BOUNDS) 121 { 122 hash_set<tree> pset; 123 walk_tree (&DECL_SAVED_TREE (fndecl), ubsan_walk_array_refs_r, &pset, 124 &pset); 125 } 126 127 if (warn_duplicated_branches) 128 walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl), 129 do_warn_duplicated_branches_r, NULL); 130 131 /* Dump the C-specific tree IR. */ 132 dump_orig = get_dump_info (TDI_original, &local_dump_flags); 133 if (dump_orig) 134 { 135 fprintf (dump_orig, "\n;; Function %s", 136 lang_hooks.decl_printable_name (fndecl, 2)); 137 fprintf (dump_orig, " (%s)\n", 138 (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null" 139 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)))); 140 fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); 141 fprintf (dump_orig, "\n"); 142 143 if (local_dump_flags & TDF_RAW) 144 dump_node (DECL_SAVED_TREE (fndecl), 145 TDF_SLIM | local_dump_flags, dump_orig); 146 else 147 print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); 148 fprintf (dump_orig, "\n"); 149 } 150 151 /* Dump all nested functions now. */ 152 cgn = cgraph_node::get_create (fndecl); 153 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) 154 c_genericize (cgn->decl); 155 } 156 157 static void 158 add_block_to_enclosing (tree block) 159 { 160 unsigned i; 161 tree enclosing; 162 gbind *bind; 163 vec<gbind *> stack = gimple_bind_expr_stack (); 164 165 FOR_EACH_VEC_ELT (stack, i, bind) 166 if (gimple_bind_block (bind)) 167 break; 168 169 enclosing = gimple_bind_block (bind); 170 BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block); 171 } 172 173 /* Genericize a scope by creating a new BIND_EXPR. 174 BLOCK is either a BLOCK representing the scope or a chain of _DECLs. 175 In the latter case, we need to create a new BLOCK and add it to the 176 BLOCK_SUBBLOCKS of the enclosing block. 177 BODY is a chain of C _STMT nodes for the contents of the scope, to be 178 genericized. */ 179 180 tree 181 c_build_bind_expr (location_t loc, tree block, tree body) 182 { 183 tree decls, bind; 184 185 if (block == NULL_TREE) 186 decls = NULL_TREE; 187 else if (TREE_CODE (block) == BLOCK) 188 decls = BLOCK_VARS (block); 189 else 190 { 191 decls = block; 192 if (DECL_ARTIFICIAL (decls)) 193 block = NULL_TREE; 194 else 195 { 196 block = make_node (BLOCK); 197 BLOCK_VARS (block) = decls; 198 add_block_to_enclosing (block); 199 } 200 } 201 202 if (!body) 203 body = build_empty_stmt (loc); 204 if (decls || block) 205 { 206 bind = build3 (BIND_EXPR, void_type_node, decls, body, block); 207 TREE_SIDE_EFFECTS (bind) = 1; 208 SET_EXPR_LOCATION (bind, loc); 209 } 210 else 211 bind = body; 212 213 return bind; 214 } 215 216 /* Gimplification of expression trees. */ 217 218 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in 219 gimplify_expr. */ 220 221 int 222 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, 223 gimple_seq *post_p ATTRIBUTE_UNUSED) 224 { 225 enum tree_code code = TREE_CODE (*expr_p); 226 227 switch (code) 228 { 229 case LSHIFT_EXPR: 230 case RSHIFT_EXPR: 231 case LROTATE_EXPR: 232 case RROTATE_EXPR: 233 { 234 /* We used to convert the right operand of a shift-expression 235 to an integer_type_node in the FEs. But it is unnecessary 236 and not desirable for diagnostics and sanitizers. We keep 237 this here to not pessimize the code, but we convert to an 238 unsigned type, because negative shift counts are undefined 239 anyway. 240 We should get rid of this conversion when we have a proper 241 type demotion/promotion pass. */ 242 tree *op1_p = &TREE_OPERAND (*expr_p, 1); 243 if (!VECTOR_TYPE_P (TREE_TYPE (*op1_p)) 244 && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)), 245 unsigned_type_node) 246 && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)), 247 integer_type_node)) 248 /* Make sure to unshare the result, tree sharing is invalid 249 during gimplification. */ 250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); 251 break; 252 } 253 254 case DECL_EXPR: 255 /* This is handled mostly by gimplify.c, but we have to deal with 256 not warning about int x = x; as it is a GCC extension to turn off 257 this warning but only if warn_init_self is zero. */ 258 if (VAR_P (DECL_EXPR_DECL (*expr_p)) 259 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) 260 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) 261 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) 262 && !warn_init_self) 263 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; 264 break; 265 266 case PREINCREMENT_EXPR: 267 case PREDECREMENT_EXPR: 268 case POSTINCREMENT_EXPR: 269 case POSTDECREMENT_EXPR: 270 { 271 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0)); 272 if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type)) 273 { 274 if (!TYPE_OVERFLOW_WRAPS (type)) 275 type = unsigned_type_for (type); 276 return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type); 277 } 278 break; 279 } 280 281 default:; 282 } 283 284 return GS_UNHANDLED; 285 } 286