1 /* Routines for emitting GIMPLE to a file stream.
3 Copyright 2011 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
26 #include "tree-flow.h"
27 #include "data-streamer.h"
28 #include "gimple-streamer.h"
29 #include "lto-streamer.h"
31 /* Output PHI function PHI to the main stream in OB. */
34 output_phi (struct output_block *ob, gimple phi)
36 unsigned i, len = gimple_phi_num_args (phi);
38 output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
39 output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
41 for (i = 0; i < len; i++)
43 lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
44 output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
45 lto_output_location (ob, gimple_phi_arg_location (phi, i));
50 /* Emit statement STMT on the main stream of output block OB. */
53 output_gimple_stmt (struct output_block *ob, gimple stmt)
56 enum gimple_code code;
60 /* Emit identifying tag. */
61 code = gimple_code (stmt);
62 tag = lto_gimple_code_to_tag (code);
63 output_record_start (ob, tag);
65 /* Emit the tuple header. */
66 bp = bitpack_create (ob->main_stream);
67 bp_pack_var_len_unsigned (&bp, gimple_num_ops (stmt));
68 bp_pack_value (&bp, gimple_no_warning_p (stmt), 1);
69 if (is_gimple_assign (stmt))
70 bp_pack_value (&bp, gimple_assign_nontemporal_move_p (stmt), 1);
71 bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1);
72 bp_pack_var_len_unsigned (&bp, stmt->gsbase.subcode);
73 lto_output_bitpack (&bp);
75 /* Emit location information for the statement. */
76 lto_output_location (ob, gimple_location (stmt));
78 /* Emit the lexical block holding STMT. */
79 lto_output_tree (ob, gimple_block (stmt), true);
81 /* Emit the operands. */
82 switch (gimple_code (stmt))
85 output_sleb128 (ob, gimple_resx_region (stmt));
88 case GIMPLE_EH_MUST_NOT_THROW:
89 lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
92 case GIMPLE_EH_DISPATCH:
93 output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
97 lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
98 lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
99 lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
100 lto_output_uleb128_stream (ob->main_stream, gimple_asm_nlabels (stmt));
101 lto_output_string (ob, ob->main_stream, gimple_asm_string (stmt), true);
112 for (i = 0; i < gimple_num_ops (stmt); i++)
114 tree op = gimple_op (stmt, i);
115 /* Wrap all uses of non-automatic variables inside MEM_REFs
116 so that we do not have to deal with type mismatches on
117 merged symbols during IL read in. The first operand
118 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */
119 if (op && (i || !is_gimple_debug (stmt)))
122 while (handled_component_p (*basep))
123 basep = &TREE_OPERAND (*basep, 0);
124 if (TREE_CODE (*basep) == VAR_DECL
125 && !auto_var_in_fn_p (*basep, current_function_decl)
126 && !DECL_REGISTER (*basep))
128 bool volatilep = TREE_THIS_VOLATILE (*basep);
129 *basep = build2 (MEM_REF, TREE_TYPE (*basep),
130 build_fold_addr_expr (*basep),
131 build_int_cst (build_pointer_type
132 (TREE_TYPE (*basep)), 0));
133 TREE_THIS_VOLATILE (*basep) = volatilep;
136 lto_output_tree_ref (ob, op);
138 if (is_gimple_call (stmt))
140 if (gimple_call_internal_p (stmt))
141 lto_output_enum (ob->main_stream, internal_fn,
142 IFN_LAST, gimple_call_internal_fn (stmt));
144 lto_output_tree_ref (ob, gimple_call_fntype (stmt));
158 /* Output a basic block BB to the main stream in OB for this FN. */
161 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
163 gimple_stmt_iterator bsi = gsi_start_bb (bb);
165 output_record_start (ob,
166 (!gsi_end_p (bsi)) || phi_nodes (bb)
170 output_uleb128 (ob, bb->index);
171 output_sleb128 (ob, bb->count);
172 output_sleb128 (ob, bb->loop_depth);
173 output_sleb128 (ob, bb->frequency);
174 output_sleb128 (ob, bb->flags);
176 if (!gsi_end_p (bsi) || phi_nodes (bb))
178 /* Output the statements. The list of statements is terminated
180 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
183 gimple stmt = gsi_stmt (bsi);
185 output_gimple_stmt (ob, stmt);
187 /* Emit the EH region holding STMT. */
188 region = lookup_stmt_eh_lp_fn (fn, stmt);
191 output_record_start (ob, LTO_eh_region);
192 output_sleb128 (ob, region);
195 output_record_start (ob, LTO_null);
198 output_record_start (ob, LTO_null);
200 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
202 gimple phi = gsi_stmt (bsi);
204 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
205 will be filled in on reading when the SSA form is
207 if (is_gimple_reg (gimple_phi_result (phi)))
208 output_phi (ob, phi);
211 output_record_start (ob, LTO_null);