[thirdparty/gcc.git] / gcc / gimple-streamer-in.c

/* Routines for reading GIMPLE from a file stream.

   Copyright (C) 2011-2019 Free Software Foundation, Inc.
   Contributed by Diego Novillo <dnovillo@google.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "ssa.h"
#include "gimple-streamer.h"
#include "tree-eh.h"
#include "gimple-iterator.h"
#include "cgraph.h"
#include "value-prof.h"

/* Read a PHI function for basic block BB in function FN.  DATA_IN is
   the file being read.  IB is the input block to use for reading.  */

static gphi *
input_phi (class lto_input_block *ib, basic_block bb, class data_in *data_in,
	   struct function *fn)
{
  unsigned HOST_WIDE_INT ix;
  tree phi_result;
  int i, len;
  gphi *result;

  ix = streamer_read_uhwi (ib);
  phi_result = (*SSANAMES (fn))[ix];
  len = EDGE_COUNT (bb->preds);
  result = create_phi_node (phi_result, bb);

  /* We have to go through a lookup process here because the preds in the
     reconstructed graph are generally in a different order than they
     were in the original program.  */
  for (i = 0; i < len; i++)
    {
      tree def = stream_read_tree (ib, data_in);
      int src_index = streamer_read_uhwi (ib);
      bitpack_d bp = streamer_read_bitpack (ib);
      /* Do not cache a location - we do not have API to get pointer to the
	 location in PHI statement and we may trigger reallocation.  */
      location_t arg_loc = stream_input_location_now (&bp, data_in);
      basic_block sbb = BASIC_BLOCK_FOR_FN (fn, src_index);

      edge e = NULL;
      int j;

      for (j = 0; j < len; j++)
	if (EDGE_PRED (bb, j)->src == sbb)
	  {
	    e = EDGE_PRED (bb, j);
	    break;
	  }

      add_phi_arg (result, def, e, arg_loc);
    }

  return result;
}


/* Read a statement with tag TAG in function FN from block IB using
   descriptors in DATA_IN.  */

static gimple *
input_gimple_stmt (class lto_input_block *ib, class data_in *data_in,
		   enum LTO_tags tag)
{
  gimple *stmt;
  enum gimple_code code;
  unsigned HOST_WIDE_INT num_ops;
  size_t i;
  struct bitpack_d bp;
  bool has_hist;

  code = lto_tag_to_gimple_code (tag);

  /* Read the tuple header.  */
  bp = streamer_read_bitpack (ib);
  num_ops = bp_unpack_var_len_unsigned (&bp);
  stmt = gimple_alloc (code, num_ops);
  stmt->no_warning = bp_unpack_value (&bp, 1);
  if (is_gimple_assign (stmt))
    stmt->nontemporal_move = bp_unpack_value (&bp, 1);
  stmt->has_volatile_ops = bp_unpack_value (&bp, 1);
  has_hist = bp_unpack_value (&bp, 1);
  stmt->subcode = bp_unpack_var_len_unsigned (&bp);

  /* Read location information.  Caching here makes no sense until streamer
     cache can handle the following gimple_set_block.  */
  gimple_set_location (stmt, stream_input_location_now (&bp, data_in));

  /* Read lexical block reference.  */
  gimple_set_block (stmt, stream_read_tree (ib, data_in));

  /* Read in all the operands.  */
  switch (code)
    {
    case GIMPLE_RESX:
      gimple_resx_set_region (as_a <gresx *> (stmt),
			      streamer_read_hwi (ib));
      break;

    case GIMPLE_EH_MUST_NOT_THROW:
      gimple_eh_must_not_throw_set_fndecl (
	as_a <geh_mnt *> (stmt),
	stream_read_tree (ib, data_in));
      break;

    case GIMPLE_EH_DISPATCH:
      gimple_eh_dispatch_set_region (as_a <geh_dispatch *> (stmt),
				     streamer_read_hwi (ib));
      break;

    case GIMPLE_ASM:
      {
	/* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
	gasm *asm_stmt = as_a <gasm *> (stmt);
	tree str;
	asm_stmt->ni = streamer_read_uhwi (ib);
	asm_stmt->no = streamer_read_uhwi (ib);
	asm_stmt->nc = streamer_read_uhwi (ib);
	asm_stmt->nl = streamer_read_uhwi (ib);
	str = streamer_read_string_cst (data_in, ib);
	asm_stmt->string = TREE_STRING_POINTER (str);
      }
      /* Fallthru  */

    case GIMPLE_ASSIGN:
    case GIMPLE_CALL:
    case GIMPLE_RETURN:
    case GIMPLE_SWITCH:
    case GIMPLE_LABEL:
    case GIMPLE_COND:
    case GIMPLE_GOTO:
    case GIMPLE_DEBUG:
      for (i = 0; i < num_ops; i++)
	{
	  tree *opp, op = stream_read_tree (ib, data_in);
	  gimple_set_op (stmt, i, op);
	  if (!op)
	    continue;

	  opp = gimple_op_ptr (stmt, i);
	  if (TREE_CODE (*opp) == ADDR_EXPR)
	    opp = &TREE_OPERAND (*opp, 0);
	  while (handled_component_p (*opp))
	    opp = &TREE_OPERAND (*opp, 0);
	  /* At LTO output time we wrap all global decls in MEM_REFs to
	     allow seamless replacement with prevailing decls.  Undo this
	     here if the prevailing decl allows for this.
	     ???  Maybe we should simply fold all stmts.  */
	  if (TREE_CODE (*opp) == MEM_REF
	      && TREE_CODE (TREE_OPERAND (*opp, 0)) == ADDR_EXPR
	      && integer_zerop (TREE_OPERAND (*opp, 1))
	      && (TREE_THIS_VOLATILE (*opp)
		  == TREE_THIS_VOLATILE
		       (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0)))
	      && !TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (*opp, 1)))
	      && (TREE_TYPE (*opp)
		  == TREE_TYPE (TREE_TYPE (TREE_OPERAND (*opp, 1))))
	      && (TREE_TYPE (*opp)
		  == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0))))
	    *opp = TREE_OPERAND (TREE_OPERAND (*opp, 0), 0);
	}
      if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
	{
	  if (gimple_call_internal_p (call_stmt))
	    gimple_call_set_internal_fn
	      (call_stmt, streamer_read_enum (ib, internal_fn, IFN_LAST));
	  else
	    gimple_call_set_fntype (call_stmt, stream_read_tree (ib, data_in));
	}
      break;

    case GIMPLE_NOP:
    case GIMPLE_PREDICT:
      break;

    case GIMPLE_TRANSACTION:
      gimple_transaction_set_label_norm (as_a <gtransaction *> (stmt),
				         stream_read_tree (ib, data_in));
      gimple_transaction_set_label_uninst (as_a <gtransaction *> (stmt),
				           stream_read_tree (ib, data_in));
      gimple_transaction_set_label_over (as_a <gtransaction *> (stmt),
				         stream_read_tree (ib, data_in));
      break;

    default:
      internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
		      lto_tag_name (tag));
    }

  /* Update the properties of symbols, SSA names and labels associated
     with STMT.  */
  if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
    {
      tree lhs = gimple_get_lhs (stmt);
      if (lhs && TREE_CODE (lhs) == SSA_NAME)
	SSA_NAME_DEF_STMT (lhs) = stmt;
    }
  else if (code == GIMPLE_ASM)
    {
      gasm *asm_stmt = as_a <gasm *> (stmt);
      unsigned i;

      for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++)
	{
	  tree op = TREE_VALUE (gimple_asm_output_op (asm_stmt, i));
	  if (TREE_CODE (op) == SSA_NAME)
	    SSA_NAME_DEF_STMT (op) = stmt;
	}
    }

  /* Reset alias information.  */
  if (code == GIMPLE_CALL)
    gimple_call_reset_alias_info (as_a <gcall *> (stmt));

  /* Mark the statement modified so its operand vectors can be filled in.  */
  gimple_set_modified (stmt, true);
  if (has_hist)
    stream_in_histogram_value (ib, stmt);

  return stmt;
}


/* Read a basic block with tag TAG from DATA_IN using input block IB.
   FN is the function being processed.  */

void
input_bb (class lto_input_block *ib, enum LTO_tags tag,
	  class data_in *data_in, struct function *fn,
	  int count_materialization_scale)
{
  unsigned int index;
  basic_block bb;
  gimple_stmt_iterator bsi;

  /* This routine assumes that CFUN is set to FN, as it needs to call
     basic GIMPLE routines that use CFUN.  */
  gcc_assert (cfun == fn);

  index = streamer_read_uhwi (ib);
  bb = BASIC_BLOCK_FOR_FN (fn, index);

  bb->count = profile_count::stream_in (ib);
  if (count_materialization_scale != REG_BR_PROB_BASE
      && bb->count.ipa ().nonzero_p ())
    bb->count
      = bb->count.apply_scale (count_materialization_scale, REG_BR_PROB_BASE);
  bb->flags = streamer_read_hwi (ib);
  bb->discriminator = streamer_read_hwi (ib);

  /* LTO_bb1 has statements.  LTO_bb0 does not.  */
  if (tag == LTO_bb0)
    return;

  bsi = gsi_start_bb (bb);
  tag = streamer_read_record_start (ib);
  while (tag)
    {
      gimple *stmt = input_gimple_stmt (ib, data_in, tag);
      gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);

      /* After the statement, expect a 0 delimiter or the EH region
	 that the previous statement belongs to.  */
      tag = streamer_read_record_start (ib);
      lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);

      if (tag == LTO_eh_region)
	{
	  HOST_WIDE_INT region = streamer_read_hwi (ib);
	  gcc_assert (region == (int) region);
	  add_stmt_to_eh_lp (stmt, region);
	}

      tag = streamer_read_record_start (ib);
    }

  tag = streamer_read_record_start (ib);
  while (tag)
    {
      input_phi (ib, bb, data_in, fn);
      tag = streamer_read_record_start (ib);
    }
}
Commit	Line	Data
2541503d	1	/* Routines for reading GIMPLE from a file stream.
2541503d	2
fbd26352	3	Copyright (C) 2011-2019 Free Software Foundation, Inc.
2541503d	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"
9ef16211	25	#include "backend.h"
b20a8bb4	26	#include "tree.h"
9ef16211	27	#include "gimple.h"
9ef16211	28	#include "ssa.h"
7c29e30e	29	#include "gimple-streamer.h"
bc61cadb	30	#include "tree-eh.h"
dcf1a1ec	31	#include "gimple-iterator.h"
1140c305	32	#include "cgraph.h"
fc44a215	33	#include "value-prof.h"
2541503d	34
	35	/* Read a PHI function for basic block BB in function FN. DATA_IN is
	36	the file being read. IB is the input block to use for reading. */
	37
1a91d914	38	static gphi *
2e966e2a	39	input_phi (class lto_input_block ib, basic_block bb, class data_in data_in,
2541503d	40	struct function *fn)
	41	{
	42	unsigned HOST_WIDE_INT ix;
	43	tree phi_result;
	44	int i, len;
1a91d914	45	gphi *result;
2541503d	46
7f385784	47	ix = streamer_read_uhwi (ib);
f1f41a6c	48	phi_result = (*SSANAMES (fn))[ix];
2541503d	49	len = EDGE_COUNT (bb->preds);
2541503d	50	result = create_phi_node (phi_result, bb);
2541503d	51
	52	/* We have to go through a lookup process here because the preds in the
	53	reconstructed graph are generally in a different order than they
	54	were in the original program. */
	55	for (i = 0; i < len; i++)
	56	{
515cf651	57	tree def = stream_read_tree (ib, data_in);
7f385784	58	int src_index = streamer_read_uhwi (ib);
ec180527	59	bitpack_d bp = streamer_read_bitpack (ib);
da6f3259	60	/* Do not cache a location - we do not have API to get pointer to the
	61	location in PHI statement and we may trigger reallocation. */
	62	location_t arg_loc = stream_input_location_now (&bp, data_in);
98e6ab47	63	basic_block sbb = BASIC_BLOCK_FOR_FN (fn, src_index);
2541503d	64
	65	edge e = NULL;
	66	int j;
	67
	68	for (j = 0; j < len; j++)
	69	if (EDGE_PRED (bb, j)->src == sbb)
	70	{
	71	e = EDGE_PRED (bb, j);
	72	break;
	73	}
	74
60d535d2	75	add_phi_arg (result, def, e, arg_loc);
2541503d	76	}
	77
	78	return result;
	79	}
	80
	81
	82	/* Read a statement with tag TAG in function FN from block IB using
	83	descriptors in DATA_IN. */
	84
42acab1c	85	static gimple *
2e966e2a	86	input_gimple_stmt (class lto_input_block ib, class data_in data_in,
b73e2dd6	87	enum LTO_tags tag)
2541503d	88	{
42acab1c	89	gimple *stmt;
2541503d	90	enum gimple_code code;
	91	unsigned HOST_WIDE_INT num_ops;
	92	size_t i;
	93	struct bitpack_d bp;
fc44a215	94	bool has_hist;
2541503d	95
	96	code = lto_tag_to_gimple_code (tag);
	97
	98	/* Read the tuple header. */
7f385784	99	bp = streamer_read_bitpack (ib);
2541503d	100	num_ops = bp_unpack_var_len_unsigned (&bp);
2541503d	101	stmt = gimple_alloc (code, num_ops);
de6bd75e	102	stmt->no_warning = bp_unpack_value (&bp, 1);
2541503d	103	if (is_gimple_assign (stmt))
de6bd75e	104	stmt->nontemporal_move = bp_unpack_value (&bp, 1);
de6bd75e	105	stmt->has_volatile_ops = bp_unpack_value (&bp, 1);
fc44a215	106	has_hist = bp_unpack_value (&bp, 1);
de6bd75e	107	stmt->subcode = bp_unpack_var_len_unsigned (&bp);
2541503d	108
da6f3259	109	/* Read location information. Caching here makes no sense until streamer
	110	cache can handle the following gimple_set_block. */
	111	gimple_set_location (stmt, stream_input_location_now (&bp, data_in));
2541503d	112
2541503d	113	/* Read lexical block reference. */
515cf651	114	gimple_set_block (stmt, stream_read_tree (ib, data_in));
2541503d	115
	116	/* Read in all the operands. */
	117	switch (code)
	118	{
	119	case GIMPLE_RESX:
1a91d914	120	gimple_resx_set_region (as_a <gresx *> (stmt),
1a91d914	121	streamer_read_hwi (ib));
2541503d	122	break;
	123
	124	case GIMPLE_EH_MUST_NOT_THROW:
1a91d914	125	gimple_eh_must_not_throw_set_fndecl (
	126	as_a <geh_mnt *> (stmt),
	127	stream_read_tree (ib, data_in));
2541503d	128	break;
	129
	130	case GIMPLE_EH_DISPATCH:
1a91d914	131	gimple_eh_dispatch_set_region (as_a <geh_dispatch *> (stmt),
1a91d914	132	streamer_read_hwi (ib));
2541503d	133	break;
	134
	135	case GIMPLE_ASM:
	136	{
	137	/* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1a91d914	138	gasm asm_stmt = as_a <gasm > (stmt);
2541503d	139	tree str;
de6bd75e	140	asm_stmt->ni = streamer_read_uhwi (ib);
	141	asm_stmt->no = streamer_read_uhwi (ib);
	142	asm_stmt->nc = streamer_read_uhwi (ib);
	143	asm_stmt->nl = streamer_read_uhwi (ib);
7f385784	144	str = streamer_read_string_cst (data_in, ib);
de6bd75e	145	asm_stmt->string = TREE_STRING_POINTER (str);
2541503d	146	}
	147	/* Fallthru */
	148
	149	case GIMPLE_ASSIGN:
	150	case GIMPLE_CALL:
	151	case GIMPLE_RETURN:
	152	case GIMPLE_SWITCH:
	153	case GIMPLE_LABEL:
	154	case GIMPLE_COND:
	155	case GIMPLE_GOTO:
	156	case GIMPLE_DEBUG:
	157	for (i = 0; i < num_ops; i++)
	158	{
972031ce	159	tree *opp, op = stream_read_tree (ib, data_in);
2541503d	160	gimple_set_op (stmt, i, op);
	161	if (!op)
	162	continue;
	163
972031ce	164	opp = gimple_op_ptr (stmt, i);
	165	if (TREE_CODE (*opp) == ADDR_EXPR)
	166	opp = &TREE_OPERAND (*opp, 0);
	167	while (handled_component_p (*opp))
ce016e27	168	opp = &TREE_OPERAND (*opp, 0);
972031ce	169	/* At LTO output time we wrap all global decls in MEM_REFs to
	170	allow seamless replacement with prevailing decls. Undo this
	171	here if the prevailing decl allows for this.
	172	??? Maybe we should simply fold all stmts. */
	173	if (TREE_CODE (*opp) == MEM_REF
	174	&& TREE_CODE (TREE_OPERAND (*opp, 0)) == ADDR_EXPR
	175	&& integer_zerop (TREE_OPERAND (*opp, 1))
	176	&& (TREE_THIS_VOLATILE (*opp)
	177	== TREE_THIS_VOLATILE
	178	(TREE_OPERAND (TREE_OPERAND (*opp, 0), 0)))
	179	&& !TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (*opp, 1)))
	180	&& (TREE_TYPE (*opp)
	181	== TREE_TYPE (TREE_TYPE (TREE_OPERAND (*opp, 1))))
	182	&& (TREE_TYPE (*opp)
	183	== TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*opp, 0), 0))))
	184	opp = TREE_OPERAND (TREE_OPERAND (opp, 0), 0);
2541503d	185	}
1a91d914	186	if (gcall call_stmt = dyn_cast <gcall > (stmt))
2541503d	187	{
1a91d914	188	if (gimple_call_internal_p (call_stmt))
2541503d	189	gimple_call_set_internal_fn
1a91d914	190	(call_stmt, streamer_read_enum (ib, internal_fn, IFN_LAST));
2541503d	191	else
1a91d914	192	gimple_call_set_fntype (call_stmt, stream_read_tree (ib, data_in));
2541503d	193	}
	194	break;
	195
	196	case GIMPLE_NOP:
	197	case GIMPLE_PREDICT:
	198	break;
	199
ea0e88d1	200	case GIMPLE_TRANSACTION:
a08574d7	201	gimple_transaction_set_label_norm (as_a <gtransaction *> (stmt),
	202	stream_read_tree (ib, data_in));
	203	gimple_transaction_set_label_uninst (as_a <gtransaction *> (stmt),
	204	stream_read_tree (ib, data_in));
	205	gimple_transaction_set_label_over (as_a <gtransaction *> (stmt),
	206	stream_read_tree (ib, data_in));
ea0e88d1	207	break;
ea0e88d1	208
2541503d	209	default:
	210	internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
	211	lto_tag_name (tag));
	212	}
	213
	214	/* Update the properties of symbols, SSA names and labels associated
	215	with STMT. */
	216	if (code == GIMPLE_ASSIGN \|\| code == GIMPLE_CALL)
	217	{
	218	tree lhs = gimple_get_lhs (stmt);
	219	if (lhs && TREE_CODE (lhs) == SSA_NAME)
	220	SSA_NAME_DEF_STMT (lhs) = stmt;
	221	}
2541503d	222	else if (code == GIMPLE_ASM)
2541503d	223	{
1a91d914	224	gasm asm_stmt = as_a <gasm > (stmt);
2541503d	225	unsigned i;
2541503d	226
1a91d914	227	for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++)
2541503d	228	{
1a91d914	229	tree op = TREE_VALUE (gimple_asm_output_op (asm_stmt, i));
2541503d	230	if (TREE_CODE (op) == SSA_NAME)
	231	SSA_NAME_DEF_STMT (op) = stmt;
	232	}
	233	}
	234
	235	/* Reset alias information. */
	236	if (code == GIMPLE_CALL)
1a91d914	237	gimple_call_reset_alias_info (as_a <gcall *> (stmt));
2541503d	238
	239	/* Mark the statement modified so its operand vectors can be filled in. */
	240	gimple_set_modified (stmt, true);
fc44a215	241	if (has_hist)
fc44a215	242	stream_in_histogram_value (ib, stmt);
2541503d	243
	244	return stmt;
	245	}
	246
	247
	248	/* Read a basic block with tag TAG from DATA_IN using input block IB.
	249	FN is the function being processed. */
	250
	251	void
2e966e2a	252	input_bb (class lto_input_block *ib, enum LTO_tags tag,
2e966e2a	253	class data_in data_in, struct function fn,
2541503d	254	int count_materialization_scale)
	255	{
	256	unsigned int index;
	257	basic_block bb;
	258	gimple_stmt_iterator bsi;
	259
	260	/* This routine assumes that CFUN is set to FN, as it needs to call
	261	basic GIMPLE routines that use CFUN. */
	262	gcc_assert (cfun == fn);
	263
7f385784	264	index = streamer_read_uhwi (ib);
98e6ab47	265	bb = BASIC_BLOCK_FOR_FN (fn, index);
2541503d	266
151b9ff5	267	bb->count = profile_count::stream_in (ib);
	268	if (count_materialization_scale != REG_BR_PROB_BASE
	269	&& bb->count.ipa ().nonzero_p ())
	270	bb->count
	271	= bb->count.apply_scale (count_materialization_scale, REG_BR_PROB_BASE);
7f385784	272	bb->flags = streamer_read_hwi (ib);
f89ca6e1	273	bb->discriminator = streamer_read_hwi (ib);
2541503d	274
	275	/* LTO_bb1 has statements. LTO_bb0 does not. */
	276	if (tag == LTO_bb0)
	277	return;
	278
	279	bsi = gsi_start_bb (bb);
7f385784	280	tag = streamer_read_record_start (ib);
2541503d	281	while (tag)
2541503d	282	{
42acab1c	283	gimple *stmt = input_gimple_stmt (ib, data_in, tag);
2541503d	284	gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
	285
	286	/* After the statement, expect a 0 delimiter or the EH region
	287	that the previous statement belongs to. */
7f385784	288	tag = streamer_read_record_start (ib);
2541503d	289	lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
	290
	291	if (tag == LTO_eh_region)
	292	{
7f385784	293	HOST_WIDE_INT region = streamer_read_hwi (ib);
2541503d	294	gcc_assert (region == (int) region);
	295	add_stmt_to_eh_lp (stmt, region);
	296	}
	297
7f385784	298	tag = streamer_read_record_start (ib);
2541503d	299	}
2541503d	300
7f385784	301	tag = streamer_read_record_start (ib);
2541503d	302	while (tag)
2541503d	303	{
b03e5397	304	input_phi (ib, bb, data_in, fn);
7f385784	305	tag = streamer_read_record_start (ib);
2541503d	306	}
2541503d	307	}