自学教程：C++ stream_read_tree函数代码示例

static voidlto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,					 struct data_in *data_in, tree expr){  DECL_NAME (expr) = stream_read_tree (ib, data_in);  DECL_CONTEXT (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_complex_tree_pointers (struct lto_input_block *ib,				    struct data_in *data_in, tree expr){  TREE_REALPART (expr) = stream_read_tree (ib, data_in);  TREE_IMAGPART (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,					struct data_in *data_in, tree expr){  DECL_SIZE (expr) = stream_read_tree (ib, data_in);  DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);  DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);  /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information     for early inlining so drop it on the floor instead of ICEing in     dwarf2out.c.  */  if (TREE_CODE (expr) == PARM_DECL)    TREE_CHAIN (expr) = streamer_read_chain (ib, data_in);  if ((TREE_CODE (expr) == VAR_DECL       || TREE_CODE (expr) == PARM_DECL)      && DECL_HAS_VALUE_EXPR_P (expr))    SET_DECL_VALUE_EXPR (expr, stream_read_tree (ib, data_in));  if (TREE_CODE (expr) == VAR_DECL)    {      tree dexpr = stream_read_tree (ib, data_in);      if (dexpr)	SET_DECL_DEBUG_EXPR (expr, dexpr);    }}

static voidlto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,				  struct data_in *data_in, tree expr){  unsigned i;  tree t;  /* Note that the number of slots in EXPR was read in     streamer_alloc_tree when instantiating EXPR.  However, the     vector is empty so we cannot rely on vec::length to know how many     elements to read.  So, this list is emitted as a 0-terminated     list on the writer side.  */  do    {      t = stream_read_tree (ib, data_in);      if (t)	BINFO_BASE_BINFOS (expr)->quick_push (t);    }  while (t);  BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);  BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);  BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);  /* The vector of BINFO_BASE_ACCESSES is pre-allocated during     unpacking the bitfield section.  */  for (i = 0; i < vec_safe_length (BINFO_BASE_ACCESSES (expr)); i++)    {      tree a = stream_read_tree (ib, data_in);      (*BINFO_BASE_ACCESSES (expr))[i] = a;    }  /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX     and BINFO_VPTR_INDEX; these are used by C++ FE only.  */}

static voidlto_input_ts_list_tree_pointers (struct lto_input_block *ib,				 struct data_in *data_in, tree expr){  TREE_PURPOSE (expr) = stream_read_tree (ib, data_in);  TREE_VALUE (expr) = stream_read_tree (ib, data_in);  TREE_CHAIN (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,					    struct data_in *data_in, tree expr){  if (TREE_CODE (expr) == TYPE_DECL)    DECL_ORIGINAL_TYPE (expr) = stream_read_tree (ib, data_in);  DECL_VINDEX (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_omp_clause_tree_pointers (struct lto_input_block *ib,				       struct data_in *data_in, tree expr){  int i;  for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)    OMP_CLAUSE_OPERAND (expr, i) = stream_read_tree (ib, data_in);  OMP_CLAUSE_CHAIN (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,				       struct data_in *data_in, tree expr){  DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);  DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);  /* Do not stream DECL_QUALIFIER, it is useless after gimplification.  */  DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);  DECL_FCONTEXT (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,				       struct data_in *data_in, tree expr){  DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);  DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);  DECL_BIT_FIELD_REPRESENTATIVE (expr) = stream_read_tree (ib, data_in);  DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);  DECL_FCONTEXT (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_exp_tree_pointers (struct lto_input_block *ib,			        struct data_in *data_in, tree expr){  int i;  for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)    TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);  TREE_SET_BLOCK (expr, stream_read_tree (ib, data_in));}

static voidlto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,					    struct data_in *data_in, tree expr){  if (TREE_CODE (expr) == FUNCTION_DECL)    {      DECL_ARGUMENTS (expr) = streamer_read_chain (ib, data_in);      DECL_RESULT (expr) = stream_read_tree (ib, data_in);    }  else if (TREE_CODE (expr) == TYPE_DECL)    DECL_ORIGINAL_TYPE (expr) = stream_read_tree (ib, data_in);  DECL_VINDEX (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,				        struct data_in *data_in, tree expr){  unsigned i;  for (i = 0; i < CONSTRUCTOR_NELTS (expr); i++)    {      constructor_elt e;      e.index = stream_read_tree (ib, data_in);      e.value = stream_read_tree (ib, data_in);      (*CONSTRUCTOR_ELTS (expr))[i] = e;    }}

static voidlto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,					  struct data_in *data_in, tree expr){  /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,     maybe it should be handled here?  */  DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);  DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);  DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);  /* If the file contains a function with an EH personality set,     then it was compiled with -fexceptions.  In that case, initialize     the backend EH machinery.  */  if (DECL_FUNCTION_PERSONALITY (expr))    lto_init_eh ();}

static voidlto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,				          struct data_in *data_in, tree expr){  tree id;  id = stream_read_tree (ib, data_in);  if (id)    {      gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);      SET_DECL_ASSEMBLER_NAME (expr, id);    }  DECL_SECTION_NAME (expr) = stream_read_tree (ib, data_in);  DECL_COMDAT_GROUP (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,				        struct data_in *data_in, tree expr){  unsigned i, len;  len = streamer_read_uhwi (ib);  for (i = 0; i < len; i++)    {      tree index, value;      index = stream_read_tree (ib, data_in);      value = stream_read_tree (ib, data_in);      CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);    }}

static voidlto_input_ts_common_tree_pointers (struct lto_input_block *ib,				   struct data_in *data_in, tree expr){  if (TREE_CODE (expr) != IDENTIFIER_NODE)    TREE_TYPE (expr) = stream_read_tree (ib, data_in);}

treestreamer_read_integer_cst (struct lto_input_block *ib, struct data_in *data_in){  tree type = stream_read_tree (ib, data_in);  unsigned HOST_WIDE_INT low = streamer_read_uhwi (ib);  HOST_WIDE_INT high = streamer_read_hwi (ib);  return build_int_cst_wide (type, low, high);}

static voidlto_input_ts_exp_tree_pointers (struct lto_input_block *ib,			        struct data_in *data_in, tree expr){  int i, length;  location_t loc;  length = streamer_read_hwi (ib);  gcc_assert (length == TREE_OPERAND_LENGTH (expr));  for (i = 0; i < length; i++)    TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);  loc = lto_input_location (ib, data_in);  SET_EXPR_LOCATION (expr, loc);  TREE_BLOCK (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_vector_tree_pointers (struct lto_input_block *ib,				   struct data_in *data_in, tree expr){  unsigned i;  for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)    VECTOR_CST_ELT (expr, i) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,					  struct data_in *data_in, tree expr){  DECL_VINDEX (expr) = stream_read_tree (ib, data_in);  /* DECL_STRUCT_FUNCTION is loaded on demand by cgraph_get_body.  */  DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);#ifndef ACCEL_COMPILER  DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);#endif  DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);  /* If the file contains a function with an EH personality set,     then it was compiled with -fexceptions.  In that case, initialize     the backend EH machinery.  */  if (DECL_FUNCTION_PERSONALITY (expr))    lto_init_eh ();}

static voidlto_input_ts_exp_tree_pointers (struct lto_input_block *ib,			        struct data_in *data_in, tree expr){  int i;  tree block;  for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)    TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);  block = stream_read_tree (ib, data_in);  /* TODO: Block is stored in the locus information.  It may make more sense to     to make it go via the location cache.  */  if (block)    {      data_in->location_cache.apply_location_cache ();      TREE_SET_BLOCK (expr, block);    }}

static voidlto_input_ts_vec_tree_pointers (struct lto_input_block *ib,				struct data_in *data_in, tree expr){  int i;  /* Note that TREE_VEC_LENGTH was read by streamer_alloc_tree to     instantiate EXPR.  */  for (i = 0; i < TREE_VEC_LENGTH (expr); i++)    TREE_VEC_ELT (expr, i) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_block_tree_pointers (struct lto_input_block *ib,				  struct data_in *data_in, tree expr){  /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information     for early inlining so drop it on the floor instead of ICEing in     dwarf2out.c.  */  BLOCK_VARS (expr) = streamer_read_chain (ib, data_in);  /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information     for early inlining so drop it on the floor instead of ICEing in     dwarf2out.c.  */  BLOCK_SUPERCONTEXT (expr) = stream_read_tree (ib, data_in);  /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information     for early inlining so drop it on the floor instead of ICEing in     dwarf2out.c.  */  BLOCK_FRAGMENT_ORIGIN (expr) = stream_read_tree (ib, data_in);  BLOCK_FRAGMENT_CHAIN (expr) = stream_read_tree (ib, data_in);  /* We re-compute BLOCK_SUBBLOCKS of our parent here instead     of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still     stream the child relationship explicitly.  */  if (BLOCK_SUPERCONTEXT (expr)      && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)    {      BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));      BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;    }  /* The global block is rooted at the TU decl.  Hook it here to     avoid the need to stream in this block during WPA time.  */  else if (BLOCK_SUPERCONTEXT (expr)	   && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)    DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;  /* The function-level block is connected at the time we read in     function bodies for the same reason.  */}

static voidlto_input_ts_type_common_tree_pointers (struct lto_input_block *ib,					struct data_in *data_in, tree expr){  TYPE_SIZE (expr) = stream_read_tree (ib, data_in);  TYPE_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);  TYPE_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);  TYPE_NAME (expr) = stream_read_tree (ib, data_in);  /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be     reconstructed during fixup.  */  /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists     during fixup.  */  TYPE_MAIN_VARIANT (expr) = stream_read_tree (ib, data_in);  TYPE_CONTEXT (expr) = stream_read_tree (ib, data_in);  /* TYPE_CANONICAL gets re-computed during type merging.  */  TYPE_CANONICAL (expr) = NULL_TREE;  TYPE_STUB_DECL (expr) = stream_read_tree (ib, data_in);}

static voidlto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,				  struct data_in *data_in, tree expr){  unsigned i, len;  tree t;  /* Note that the number of slots in EXPR was read in     streamer_alloc_tree when instantiating EXPR.  However, the     vector is empty so we cannot rely on VEC_length to know how many     elements to read.  So, this list is emitted as a 0-terminated     list on the writer side.  */  do    {      t = stream_read_tree (ib, data_in);      if (t)	VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);    }  while (t);  BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);  BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);  BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);  len = streamer_read_uhwi (ib);  if (len > 0)    {      VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);      for (i = 0; i < len; i++)	{	  tree a = stream_read_tree (ib, data_in);	  VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);	}    }  BINFO_INHERITANCE_CHAIN (expr) = stream_read_tree (ib, data_in);  BINFO_SUBVTT_INDEX (expr) = stream_read_tree (ib, data_in);  BINFO_VPTR_INDEX (expr) = stream_read_tree (ib, data_in);}

treestreamer_read_chain (struct lto_input_block *ib, struct data_in *data_in){  tree first, prev, curr;  /* The chain is written as NULL terminated list of trees.  */  first = prev = NULL_TREE;  do    {      curr = stream_read_tree (ib, data_in);      if (prev)	TREE_CHAIN (prev) = curr;      else	first = curr;      prev = curr;    }  while (curr);  return first;}

static gimpleinput_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,	   struct function *fn){  unsigned HOST_WIDE_INT ix;  tree phi_result;  int i, len;  gimple result;  ix = streamer_read_uhwi (ib);  phi_result = VEC_index (tree, SSANAMES (fn), ix);  len = EDGE_COUNT (bb->preds);  result = create_phi_node (phi_result, bb);  SSA_NAME_DEF_STMT (phi_result) = result;  /* 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);      location_t arg_loc = lto_input_location (ib, data_in);      basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (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;}

treestreamer_read_chain (struct lto_input_block *ib, struct data_in *data_in){  int i, count;  tree first, prev, curr;  first = prev = NULL_TREE;  count = streamer_read_hwi (ib);  for (i = 0; i < count; i++)    {      curr = stream_read_tree (ib, data_in);      if (prev)	TREE_CHAIN (prev) = curr;      else	first = curr;      TREE_CHAIN (curr) = NULL_TREE;      prev = curr;    }  return first;}

treestreamer_read_integer_cst (struct lto_input_block *ib, struct data_in *data_in){  tree result, type;  HOST_WIDE_INT low, high;  bool overflow_p;  type = stream_read_tree (ib, data_in);  overflow_p = (streamer_read_uchar (ib) != 0);  low = streamer_read_uhwi (ib);  high = streamer_read_uhwi (ib);  result = build_int_cst_wide (type, low, high);  /* If the original constant had overflown, build a replica of RESULT to     avoid modifying the shared constant returned by build_int_cst_wide.  */  if (overflow_p)    {      result = copy_node (result);      TREE_OVERFLOW (result) = 1;    }  return result;}