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-2013 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 "tree.h" 31 #include "c-common.h" 32 #include "gimple.h" 33 #include "tree-inline.h" 34 #include "diagnostic-core.h" 35 #include "langhooks.h" 36 #include "langhooks-def.h" 37 #include "flags.h" 38 #include "dumpfile.h" 39 #include "c-pretty-print.h" 40 #include "cgraph.h" 41 42 43 /* The gimplification pass converts the language-dependent trees 44 (ld-trees) emitted by the parser into language-independent trees 45 (li-trees) that are the target of SSA analysis and transformations. 46 47 Language-independent trees are based on the SIMPLE intermediate 48 representation used in the McCAT compiler framework: 49 50 "Designing the McCAT Compiler Based on a Family of Structured 51 Intermediate Representations," 52 L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan, 53 Proceedings of the 5th International Workshop on Languages and 54 Compilers for Parallel Computing, no. 757 in Lecture Notes in 55 Computer Science, New Haven, Connecticut, pp. 406-420, 56 Springer-Verlag, August 3-5, 1992. 57 58 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html 59 60 Basically, we walk down gimplifying the nodes that we encounter. As we 61 walk back up, we check that they fit our constraints, and copy them 62 into temporaries if not. */ 63 64 /* Gimplification of statement trees. */ 65 66 /* Convert the tree representation of FNDECL from C frontend trees to 67 GENERIC. */ 68 69 void 70 c_genericize (tree fndecl) 71 { 72 FILE *dump_orig; 73 int local_dump_flags; 74 struct cgraph_node *cgn; 75 76 /* Dump the C-specific tree IR. */ 77 dump_orig = dump_begin (TDI_original, &local_dump_flags); 78 if (dump_orig) 79 { 80 fprintf (dump_orig, "\n;; Function %s", 81 lang_hooks.decl_printable_name (fndecl, 2)); 82 fprintf (dump_orig, " (%s)\n", 83 (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null" 84 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)))); 85 fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); 86 fprintf (dump_orig, "\n"); 87 88 if (local_dump_flags & TDF_RAW) 89 dump_node (DECL_SAVED_TREE (fndecl), 90 TDF_SLIM | local_dump_flags, dump_orig); 91 else 92 print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); 93 fprintf (dump_orig, "\n"); 94 95 dump_end (TDI_original, dump_orig); 96 } 97 98 /* Dump all nested functions now. */ 99 cgn = cgraph_get_create_node (fndecl); 100 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) 101 c_genericize (cgn->symbol.decl); 102 } 103 104 static void 105 add_block_to_enclosing (tree block) 106 { 107 unsigned i; 108 tree enclosing; 109 gimple bind; 110 vec<gimple> stack = gimple_bind_expr_stack (); 111 112 FOR_EACH_VEC_ELT (stack, i, bind) 113 if (gimple_bind_block (bind)) 114 break; 115 116 enclosing = gimple_bind_block (bind); 117 BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block); 118 } 119 120 /* Genericize a scope by creating a new BIND_EXPR. 121 BLOCK is either a BLOCK representing the scope or a chain of _DECLs. 122 In the latter case, we need to create a new BLOCK and add it to the 123 BLOCK_SUBBLOCKS of the enclosing block. 124 BODY is a chain of C _STMT nodes for the contents of the scope, to be 125 genericized. */ 126 127 tree 128 c_build_bind_expr (location_t loc, tree block, tree body) 129 { 130 tree decls, bind; 131 132 if (block == NULL_TREE) 133 decls = NULL_TREE; 134 else if (TREE_CODE (block) == BLOCK) 135 decls = BLOCK_VARS (block); 136 else 137 { 138 decls = block; 139 if (DECL_ARTIFICIAL (decls)) 140 block = NULL_TREE; 141 else 142 { 143 block = make_node (BLOCK); 144 BLOCK_VARS (block) = decls; 145 add_block_to_enclosing (block); 146 } 147 } 148 149 if (!body) 150 body = build_empty_stmt (loc); 151 if (decls || block) 152 { 153 bind = build3 (BIND_EXPR, void_type_node, decls, body, block); 154 TREE_SIDE_EFFECTS (bind) = 1; 155 SET_EXPR_LOCATION (bind, loc); 156 } 157 else 158 bind = body; 159 160 return bind; 161 } 162 163 /* Gimplification of expression trees. */ 164 165 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in 166 gimplify_expr. */ 167 168 int 169 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, 170 gimple_seq *post_p ATTRIBUTE_UNUSED) 171 { 172 enum tree_code code = TREE_CODE (*expr_p); 173 174 switch (code) 175 { 176 case DECL_EXPR: 177 /* This is handled mostly by gimplify.c, but we have to deal with 178 not warning about int x = x; as it is a GCC extension to turn off 179 this warning but only if warn_init_self is zero. */ 180 if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL 181 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) 182 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) 183 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) 184 && !warn_init_self) 185 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; 186 break; 187 188 case PREINCREMENT_EXPR: 189 case PREDECREMENT_EXPR: 190 case POSTINCREMENT_EXPR: 191 case POSTDECREMENT_EXPR: 192 { 193 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0)); 194 if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type)) 195 { 196 if (TYPE_OVERFLOW_UNDEFINED (type)) 197 type = unsigned_type_for (type); 198 return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type); 199 } 200 break; 201 } 202 203 default:; 204 } 205 206 return GS_UNHANDLED; 207 } 208