1 /* Routines for reading GIMPLE from a file stream. 2 3 Copyright (C) 2011-2015 Free Software Foundation, Inc. 4 Contributed by Diego Novillo <dnovillo@google.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "diagnostic.h" 26 #include "hash-set.h" 27 #include "machmode.h" 28 #include "vec.h" 29 #include "double-int.h" 30 #include "input.h" 31 #include "alias.h" 32 #include "symtab.h" 33 #include "options.h" 34 #include "wide-int.h" 35 #include "inchash.h" 36 #include "tree.h" 37 #include "fold-const.h" 38 #include "predict.h" 39 #include "tm.h" 40 #include "hard-reg-set.h" 41 #include "input.h" 42 #include "function.h" 43 #include "dominance.h" 44 #include "cfg.h" 45 #include "basic-block.h" 46 #include "tree-ssa-alias.h" 47 #include "internal-fn.h" 48 #include "tree-eh.h" 49 #include "gimple-expr.h" 50 #include "is-a.h" 51 #include "gimple.h" 52 #include "gimple-iterator.h" 53 #include "gimple-ssa.h" 54 #include "tree-phinodes.h" 55 #include "stringpool.h" 56 #include "tree-ssanames.h" 57 #include "plugin-api.h" 58 #include "ipa-ref.h" 59 #include "cgraph.h" 60 #include "data-streamer.h" 61 #include "tree-streamer.h" 62 #include "gimple-streamer.h" 63 #include "value-prof.h" 64 65 /* Read a PHI function for basic block BB in function FN. DATA_IN is 66 the file being read. IB is the input block to use for reading. */ 67 68 static gphi * 69 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in, 70 struct function *fn) 71 { 72 unsigned HOST_WIDE_INT ix; 73 tree phi_result; 74 int i, len; 75 gphi *result; 76 77 ix = streamer_read_uhwi (ib); 78 phi_result = (*SSANAMES (fn))[ix]; 79 len = EDGE_COUNT (bb->preds); 80 result = create_phi_node (phi_result, bb); 81 82 /* We have to go through a lookup process here because the preds in the 83 reconstructed graph are generally in a different order than they 84 were in the original program. */ 85 for (i = 0; i < len; i++) 86 { 87 tree def = stream_read_tree (ib, data_in); 88 int src_index = streamer_read_uhwi (ib); 89 bitpack_d bp = streamer_read_bitpack (ib); 90 /* Do not cache a location - we do not have API to get pointer to the 91 location in PHI statement and we may trigger reallocation. */ 92 location_t arg_loc = stream_input_location_now (&bp, data_in); 93 basic_block sbb = BASIC_BLOCK_FOR_FN (fn, src_index); 94 95 edge e = NULL; 96 int j; 97 98 for (j = 0; j < len; j++) 99 if (EDGE_PRED (bb, j)->src == sbb) 100 { 101 e = EDGE_PRED (bb, j); 102 break; 103 } 104 105 add_phi_arg (result, def, e, arg_loc); 106 } 107 108 return result; 109 } 110 111 112 /* Read a statement with tag TAG in function FN from block IB using 113 descriptors in DATA_IN. */ 114 115 static gimple 116 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in, 117 enum LTO_tags tag) 118 { 119 gimple stmt; 120 enum gimple_code code; 121 unsigned HOST_WIDE_INT num_ops; 122 size_t i; 123 struct bitpack_d bp; 124 bool has_hist; 125 126 code = lto_tag_to_gimple_code (tag); 127 128 /* Read the tuple header. */ 129 bp = streamer_read_bitpack (ib); 130 num_ops = bp_unpack_var_len_unsigned (&bp); 131 stmt = gimple_alloc (code, num_ops); 132 stmt->no_warning = bp_unpack_value (&bp, 1); 133 if (is_gimple_assign (stmt)) 134 stmt->nontemporal_move = bp_unpack_value (&bp, 1); 135 stmt->has_volatile_ops = bp_unpack_value (&bp, 1); 136 has_hist = bp_unpack_value (&bp, 1); 137 stmt->subcode = bp_unpack_var_len_unsigned (&bp); 138 139 /* Read location information. Caching here makes no sense until streamer 140 cache can handle the following gimple_set_block. */ 141 gimple_set_location (stmt, stream_input_location_now (&bp, data_in)); 142 143 /* Read lexical block reference. */ 144 gimple_set_block (stmt, stream_read_tree (ib, data_in)); 145 146 /* Read in all the operands. */ 147 switch (code) 148 { 149 case GIMPLE_RESX: 150 gimple_resx_set_region (as_a <gresx *> (stmt), 151 streamer_read_hwi (ib)); 152 break; 153 154 case GIMPLE_EH_MUST_NOT_THROW: 155 gimple_eh_must_not_throw_set_fndecl ( 156 as_a <geh_mnt *> (stmt), 157 stream_read_tree (ib, data_in)); 158 break; 159 160 case GIMPLE_EH_DISPATCH: 161 gimple_eh_dispatch_set_region (as_a <geh_dispatch *> (stmt), 162 streamer_read_hwi (ib)); 163 break; 164 165 case GIMPLE_ASM: 166 { 167 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */ 168 gasm *asm_stmt = as_a <gasm *> (stmt); 169 tree str; 170 asm_stmt->ni = streamer_read_uhwi (ib); 171 asm_stmt->no = streamer_read_uhwi (ib); 172 asm_stmt->nc = streamer_read_uhwi (ib); 173 asm_stmt->nl = streamer_read_uhwi (ib); 174 str = streamer_read_string_cst (data_in, ib); 175 asm_stmt->string = TREE_STRING_POINTER (str); 176 } 177 /* Fallthru */ 178 179 case GIMPLE_ASSIGN: 180 case GIMPLE_CALL: 181 case GIMPLE_RETURN: 182 case GIMPLE_SWITCH: 183 case GIMPLE_LABEL: 184 case GIMPLE_COND: 185 case GIMPLE_GOTO: 186 case GIMPLE_DEBUG: 187 for (i = 0; i < num_ops; i++) 188 { 189 tree *opp, op = stream_read_tree (ib, data_in); 190 gimple_set_op (stmt, i, op); 191 if (!op) 192 continue; 193 194 opp = gimple_op_ptr (stmt, i); 195 if (TREE_CODE (*opp) == ADDR_EXPR) 196 opp = &TREE_OPERAND (*opp, 0); 197 while (handled_component_p (*opp)) 198 opp = &TREE_OPERAND (*opp, 0); 199 /* At LTO output time we wrap all global decls in MEM_REFs to 200 allow seamless replacement with prevailing decls. Undo this 201 here if the prevailing decl allows for this. 202 ??? Maybe we should simply fold all stmts. */ 203 if (TREE_CODE (*opp) == MEM_REF 204 && TREE_CODE (TREE_OPERAND (*opp, 0)) == ADDR_EXPR 205 && integer_zerop (TREE_OPERAND (*opp, 1)) 206 && (TREE_THIS_VOLATILE (*opp) 207 == TREE_THIS_VOLATILE 208 (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0))) 209 && !TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (*opp, 1))) 210 && (TREE_TYPE (*opp) 211 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (*opp, 1)))) 212 && (TREE_TYPE (*opp) 213 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0)))) 214 *opp = TREE_OPERAND (TREE_OPERAND (*opp, 0), 0); 215 } 216 if (gcall *call_stmt = dyn_cast <gcall *> (stmt)) 217 { 218 if (gimple_call_internal_p (call_stmt)) 219 gimple_call_set_internal_fn 220 (call_stmt, streamer_read_enum (ib, internal_fn, IFN_LAST)); 221 else 222 gimple_call_set_fntype (call_stmt, stream_read_tree (ib, data_in)); 223 } 224 break; 225 226 case GIMPLE_NOP: 227 case GIMPLE_PREDICT: 228 break; 229 230 case GIMPLE_TRANSACTION: 231 gimple_transaction_set_label (as_a <gtransaction *> (stmt), 232 stream_read_tree (ib, data_in)); 233 break; 234 235 default: 236 internal_error ("bytecode stream: unknown GIMPLE statement tag %s", 237 lto_tag_name (tag)); 238 } 239 240 /* Update the properties of symbols, SSA names and labels associated 241 with STMT. */ 242 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL) 243 { 244 tree lhs = gimple_get_lhs (stmt); 245 if (lhs && TREE_CODE (lhs) == SSA_NAME) 246 SSA_NAME_DEF_STMT (lhs) = stmt; 247 } 248 else if (code == GIMPLE_ASM) 249 { 250 gasm *asm_stmt = as_a <gasm *> (stmt); 251 unsigned i; 252 253 for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) 254 { 255 tree op = TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); 256 if (TREE_CODE (op) == SSA_NAME) 257 SSA_NAME_DEF_STMT (op) = stmt; 258 } 259 } 260 261 /* Reset alias information. */ 262 if (code == GIMPLE_CALL) 263 gimple_call_reset_alias_info (as_a <gcall *> (stmt)); 264 265 /* Mark the statement modified so its operand vectors can be filled in. */ 266 gimple_set_modified (stmt, true); 267 if (has_hist) 268 stream_in_histogram_value (ib, stmt); 269 270 return stmt; 271 } 272 273 274 /* Read a basic block with tag TAG from DATA_IN using input block IB. 275 FN is the function being processed. */ 276 277 void 278 input_bb (struct lto_input_block *ib, enum LTO_tags tag, 279 struct data_in *data_in, struct function *fn, 280 int count_materialization_scale) 281 { 282 unsigned int index; 283 basic_block bb; 284 gimple_stmt_iterator bsi; 285 286 /* This routine assumes that CFUN is set to FN, as it needs to call 287 basic GIMPLE routines that use CFUN. */ 288 gcc_assert (cfun == fn); 289 290 index = streamer_read_uhwi (ib); 291 bb = BASIC_BLOCK_FOR_FN (fn, index); 292 293 bb->count = apply_scale (streamer_read_gcov_count (ib), 294 count_materialization_scale); 295 bb->frequency = streamer_read_hwi (ib); 296 bb->flags = streamer_read_hwi (ib); 297 298 /* LTO_bb1 has statements. LTO_bb0 does not. */ 299 if (tag == LTO_bb0) 300 return; 301 302 bsi = gsi_start_bb (bb); 303 tag = streamer_read_record_start (ib); 304 while (tag) 305 { 306 gimple stmt = input_gimple_stmt (ib, data_in, tag); 307 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT); 308 309 /* After the statement, expect a 0 delimiter or the EH region 310 that the previous statement belongs to. */ 311 tag = streamer_read_record_start (ib); 312 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null); 313 314 if (tag == LTO_eh_region) 315 { 316 HOST_WIDE_INT region = streamer_read_hwi (ib); 317 gcc_assert (region == (int) region); 318 add_stmt_to_eh_lp (stmt, region); 319 } 320 321 tag = streamer_read_record_start (ib); 322 } 323 324 tag = streamer_read_record_start (ib); 325 while (tag) 326 { 327 input_phi (ib, bb, data_in, fn); 328 tag = streamer_read_record_start (ib); 329 } 330 } 331