1/* Routines for emitting GIMPLE to a file stream. 2 3 Copyright (C) 2011-2015 Free Software Foundation, Inc. 4 Contributed by Diego Novillo <dnovillo@google.com> 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 3, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along 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 "hash-set.h" 26#include "machmode.h" 27#include "vec.h" 28#include "double-int.h" 29#include "input.h" 30#include "alias.h" 31#include "symtab.h" 32#include "options.h" 33#include "wide-int.h" 34#include "inchash.h" 35#include "tree.h" 36#include "fold-const.h" 37#include "predict.h" 38#include "tm.h" 39#include "hard-reg-set.h" 40#include "input.h" 41#include "function.h" 42#include "basic-block.h" 43#include "tree-ssa-alias.h" 44#include "internal-fn.h" 45#include "tree-eh.h" 46#include "gimple-expr.h" 47#include "is-a.h" 48#include "gimple.h" 49#include "gimple-iterator.h" 50#include "gimple-ssa.h" 51#include "plugin-api.h" 52#include "ipa-ref.h" 53#include "cgraph.h" 54#include "data-streamer.h" 55#include "gimple-streamer.h" 56#include "lto-streamer.h" 57#include "tree-streamer.h" 58#include "value-prof.h" 59 60/* Output PHI function PHI to the main stream in OB. */ 61 62static void 63output_phi (struct output_block *ob, gphi *phi) 64{ 65 unsigned i, len = gimple_phi_num_args (phi); 66 67 streamer_write_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI)); 68 streamer_write_uhwi (ob, SSA_NAME_VERSION (PHI_RESULT (phi))); 69 70 for (i = 0; i < len; i++) 71 { 72 stream_write_tree (ob, gimple_phi_arg_def (phi, i), true); 73 streamer_write_uhwi (ob, gimple_phi_arg_edge (phi, i)->src->index); 74 bitpack_d bp = bitpack_create (ob->main_stream); 75 stream_output_location (ob, &bp, gimple_phi_arg_location (phi, i)); 76 streamer_write_bitpack (&bp); 77 } 78} 79 80 81/* Emit statement STMT on the main stream of output block OB. */ 82 83static void 84output_gimple_stmt (struct output_block *ob, gimple stmt) 85{ 86 unsigned i; 87 enum gimple_code code; 88 enum LTO_tags tag; 89 struct bitpack_d bp; 90 histogram_value hist; 91 92 /* Emit identifying tag. */ 93 code = gimple_code (stmt); 94 tag = lto_gimple_code_to_tag (code); 95 streamer_write_record_start (ob, tag); 96 97 /* Emit the tuple header. */ 98 bp = bitpack_create (ob->main_stream); 99 bp_pack_var_len_unsigned (&bp, gimple_num_ops (stmt)); 100 bp_pack_value (&bp, gimple_no_warning_p (stmt), 1); 101 if (is_gimple_assign (stmt)) 102 bp_pack_value (&bp, 103 gimple_assign_nontemporal_move_p ( 104 as_a <gassign *> (stmt)), 105 1); 106 bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1); 107 hist = gimple_histogram_value (cfun, stmt); 108 bp_pack_value (&bp, hist != NULL, 1); 109 bp_pack_var_len_unsigned (&bp, stmt->subcode); 110 111 /* Emit location information for the statement. */ 112 stream_output_location (ob, &bp, LOCATION_LOCUS (gimple_location (stmt))); 113 streamer_write_bitpack (&bp); 114 115 /* Emit the lexical block holding STMT. */ 116 stream_write_tree (ob, gimple_block (stmt), true); 117 118 /* Emit the operands. */ 119 switch (gimple_code (stmt)) 120 { 121 case GIMPLE_RESX: 122 streamer_write_hwi (ob, gimple_resx_region (as_a <gresx *> (stmt))); 123 break; 124 125 case GIMPLE_EH_MUST_NOT_THROW: 126 stream_write_tree (ob, 127 gimple_eh_must_not_throw_fndecl ( 128 as_a <geh_mnt *> (stmt)), 129 true); 130 break; 131 132 case GIMPLE_EH_DISPATCH: 133 streamer_write_hwi (ob, 134 gimple_eh_dispatch_region ( 135 as_a <geh_dispatch *> (stmt))); 136 break; 137 138 case GIMPLE_ASM: 139 { 140 gasm *asm_stmt = as_a <gasm *> (stmt); 141 streamer_write_uhwi (ob, gimple_asm_ninputs (asm_stmt)); 142 streamer_write_uhwi (ob, gimple_asm_noutputs (asm_stmt)); 143 streamer_write_uhwi (ob, gimple_asm_nclobbers (asm_stmt)); 144 streamer_write_uhwi (ob, gimple_asm_nlabels (asm_stmt)); 145 streamer_write_string (ob, ob->main_stream, 146 gimple_asm_string (asm_stmt), true); 147 } 148 /* Fallthru */ 149 150 case GIMPLE_ASSIGN: 151 case GIMPLE_CALL: 152 case GIMPLE_RETURN: 153 case GIMPLE_SWITCH: 154 case GIMPLE_LABEL: 155 case GIMPLE_COND: 156 case GIMPLE_GOTO: 157 case GIMPLE_DEBUG: 158 for (i = 0; i < gimple_num_ops (stmt); i++) 159 { 160 tree op = gimple_op (stmt, i); 161 tree *basep = NULL; 162 /* Wrap all uses of non-automatic variables inside MEM_REFs 163 so that we do not have to deal with type mismatches on 164 merged symbols during IL read in. The first operand 165 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */ 166 if (op && (i || !is_gimple_debug (stmt))) 167 { 168 basep = &op; 169 if (TREE_CODE (*basep) == ADDR_EXPR) 170 basep = &TREE_OPERAND (*basep, 0); 171 while (handled_component_p (*basep)) 172 basep = &TREE_OPERAND (*basep, 0); 173 if (TREE_CODE (*basep) == VAR_DECL 174 && !auto_var_in_fn_p (*basep, current_function_decl) 175 && !DECL_REGISTER (*basep)) 176 { 177 bool volatilep = TREE_THIS_VOLATILE (*basep); 178 tree ptrtype = build_pointer_type (TREE_TYPE (*basep)); 179 *basep = build2 (MEM_REF, TREE_TYPE (*basep), 180 build1 (ADDR_EXPR, ptrtype, *basep), 181 build_int_cst (ptrtype, 0)); 182 TREE_THIS_VOLATILE (*basep) = volatilep; 183 } 184 else 185 basep = NULL; 186 } 187 stream_write_tree (ob, op, true); 188 /* Restore the original base if we wrapped it inside a MEM_REF. */ 189 if (basep) 190 *basep = TREE_OPERAND (TREE_OPERAND (*basep, 0), 0); 191 } 192 if (is_gimple_call (stmt)) 193 { 194 if (gimple_call_internal_p (stmt)) 195 streamer_write_enum (ob->main_stream, internal_fn, 196 IFN_LAST, gimple_call_internal_fn (stmt)); 197 else 198 stream_write_tree (ob, gimple_call_fntype (stmt), true); 199 } 200 break; 201 202 case GIMPLE_NOP: 203 case GIMPLE_PREDICT: 204 break; 205 206 case GIMPLE_TRANSACTION: 207 { 208 gtransaction *trans_stmt = as_a <gtransaction *> (stmt); 209 gcc_assert (gimple_transaction_body (trans_stmt) == NULL); 210 stream_write_tree (ob, gimple_transaction_label (trans_stmt), true); 211 } 212 break; 213 214 default: 215 gcc_unreachable (); 216 } 217 if (hist) 218 stream_out_histogram_value (ob, hist); 219} 220 221 222/* Output a basic block BB to the main stream in OB for this FN. */ 223 224void 225output_bb (struct output_block *ob, basic_block bb, struct function *fn) 226{ 227 gimple_stmt_iterator bsi = gsi_start_bb (bb); 228 229 streamer_write_record_start (ob, 230 (!gsi_end_p (bsi)) || phi_nodes (bb) 231 ? LTO_bb1 232 : LTO_bb0); 233 234 streamer_write_uhwi (ob, bb->index); 235 streamer_write_gcov_count (ob, bb->count); 236 streamer_write_hwi (ob, bb->frequency); 237 streamer_write_hwi (ob, bb->flags); 238 239 if (!gsi_end_p (bsi) || phi_nodes (bb)) 240 { 241 /* Output the statements. The list of statements is terminated 242 with a zero. */ 243 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 244 { 245 int region; 246 gimple stmt = gsi_stmt (bsi); 247 248 output_gimple_stmt (ob, stmt); 249 250 /* Emit the EH region holding STMT. */ 251 region = lookup_stmt_eh_lp_fn (fn, stmt); 252 if (region != 0) 253 { 254 streamer_write_record_start (ob, LTO_eh_region); 255 streamer_write_hwi (ob, region); 256 } 257 else 258 streamer_write_record_start (ob, LTO_null); 259 } 260 261 streamer_write_record_start (ob, LTO_null); 262 263 for (gphi_iterator psi = gsi_start_phis (bb); 264 !gsi_end_p (psi); 265 gsi_next (&psi)) 266 { 267 gphi *phi = psi.phi (); 268 269 /* Only emit PHIs for gimple registers. PHI nodes for .MEM 270 will be filled in on reading when the SSA form is 271 updated. */ 272 if (!virtual_operand_p (gimple_phi_result (phi))) 273 output_phi (ob, phi); 274 } 275 276 streamer_write_record_start (ob, LTO_null); 277 } 278} 279