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

/* Output a declaration.  Used for function locals, and struct/union members. */void xml_generic_decl(tree decl, int indent, const char *tag, FILE *out){    fprintf(out, "%s<%s", spc(indent), tag);    xml_location(decl, out);    fprintf(out, ">/n");    indent += INDENT;    xml_decl_binding(decl, indent, "binding", out);    fprintf(out, "%s<type", spc(indent));    if (DECL_SIZE(decl))        fprintf(out, " size='%lu'", TREE_INT_CST_LOW(DECL_SIZE(decl)));    if (DECL_ALIGN(decl))        fprintf(out, " alignment='%d'", DECL_ALIGN(decl));    fprintf(out, ">/n");    /* Output the type. */    xml_type(TREE_TYPE(decl), decl, indent + INDENT, out);    fprintf(out, "%s</type>/n", spc(indent));    if (TREE_CODE(decl) == VAR_DECL && DECL_INITIAL(decl))    {        fprintf(out, "%s<initial>/n", spc(indent));        xml_expr(DECL_INITIAL(decl), indent + INDENT, out);        fprintf(out, "%s</initial>/n", spc(indent));    }    indent -= INDENT;    fprintf(out, "%s</%s>/n", spc(indent), tag);}

static voidwrite_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,				    bool ref_p){  stream_write_tree (ob, DECL_SIZE (expr), ref_p);  stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);  /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs     special handling in LTO, it must be handled by streamer hooks.  */  stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);  /* 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)    streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);  if ((TREE_CODE (expr) == VAR_DECL       || TREE_CODE (expr) == PARM_DECL)      && DECL_HAS_VALUE_EXPR_P (expr))    stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);  if (TREE_CODE (expr) == VAR_DECL)    stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);}

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);    }}

struct FieldInfo* createFieldInfo(const tree field_decl){  struct FieldInfo* fi = (struct FieldInfo*) xcalloc(1, sizeof(struct FieldInfo));  fi->isSpecial = DECL_ARTIFICIAL(field_decl);  fi->isBitField = DECL_BIT_FIELD(field_decl);  const char* fieldName;  if (fi->isSpecial)    fieldName = fieldNames[FIELD_BASE];  else if (DECL_NAME(field_decl))    fieldName = IDENTIFIER_POINTER(DECL_NAME(field_decl));  else    fieldName = fieldNames[FIELD_NONAME];  fi->name = xstrdup(fieldName);  fi->size = TREE_INT_CST_LOW(DECL_SIZE(field_decl));  // Offset calculation is a little bit wierd. According to GCC docs:  // "... DECL_FIELD_OFFSET is position, counting in bytes, of the  // DECL_OFFSET_ALIGN-bit sized word ..." and ".. DECL_FIELD_BIT_OFFSET is the  // bit offset of the first bit of the field within this word"  fi->offset = TREE_INT_CST_LOW(DECL_FIELD_OFFSET(field_decl)) * BITS_PER_UNIT +    TREE_INT_CST_LOW(DECL_FIELD_BIT_OFFSET(field_decl));  fi->align = DECL_ALIGN(field_decl);  return fi;}

static voidsdbout_field_types (tree type){  tree tail;  for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))    /* This condition should match the one for emitting the actual       members below.  */    if (TREE_CODE (tail) == FIELD_DECL	&& DECL_NAME (tail)	&& DECL_SIZE (tail)	&& host_integerp (DECL_SIZE (tail), 1)	&& host_integerp (bit_position (tail), 0))      {	if (POINTER_TYPE_P (TREE_TYPE (tail)))	  sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));	else	  sdbout_one_type (TREE_TYPE (tail));      }}

static treeubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data){  hash_set<tree> *pset = (hash_set<tree> *) data;  if (TREE_CODE (*tp) == BIND_EXPR)    {      /* Since walk_tree doesn't call the callback function on the decls	 in BIND_EXPR_VARS, we have to walk them manually, so we can avoid	 instrumenting DECL_INITIAL of TREE_STATIC vars.  */      *walk_subtrees = 0;      for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))	{	  if (TREE_STATIC (decl))	    continue;	  walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset,		     pset);	  walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset);	  walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset,		     pset);	}      walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset);    }  else if (TREE_CODE (*tp) == ADDR_EXPR	   && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF)    {      ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true);      /* Make sure ubsan_maybe_instrument_array_ref is not called again	 on the ARRAY_REF, the above call might not instrument anything	 as the index might be constant or masked, so ensure it is not	 walked again and walk its subtrees manually.  */      tree aref = TREE_OPERAND (*tp, 0);      pset->add (aref);      *walk_subtrees = 0;      walk_tree (&TREE_OPERAND (aref, 0), ubsan_walk_array_refs_r, pset, pset);      walk_tree (&TREE_OPERAND (aref, 1), ubsan_walk_array_refs_r, pset, pset);      walk_tree (&TREE_OPERAND (aref, 2), ubsan_walk_array_refs_r, pset, pset);      walk_tree (&TREE_OPERAND (aref, 3), ubsan_walk_array_refs_r, pset, pset);    }  else if (TREE_CODE (*tp) == ARRAY_REF)    ubsan_maybe_instrument_array_ref (tp, false);  return NULL_TREE;}

//.........这里部分代码省略.........      dump_child ("elts", TREE_TYPE (t));      dump_child ("domn", TYPE_DOMAIN (t));      break;    case RECORD_TYPE:    case UNION_TYPE:      if (TREE_CODE (t) == RECORD_TYPE)	dump_string_field (di, "tag", "struct");      else	dump_string_field (di, "tag", "union");      dump_child ("flds", TYPE_FIELDS (t));      dump_child ("fncs", TYPE_METHODS (t));      queue_and_dump_index (di, "binf", TYPE_BINFO (t),			    DUMP_BINFO);      break;    case CONST_DECL:      dump_child ("cnst", DECL_INITIAL (t));      break;    case DEBUG_EXPR_DECL:      dump_int (di, "-uid", DEBUG_TEMP_UID (t));      /* Fall through.  */    case VAR_DECL:    case PARM_DECL:    case FIELD_DECL:    case RESULT_DECL:      if (TREE_CODE (t) == PARM_DECL)	dump_child ("argt", DECL_ARG_TYPE (t));      else	dump_child ("init", DECL_INITIAL (t));      dump_child ("size", DECL_SIZE (t));      dump_int (di, "algn", DECL_ALIGN (t));      if (TREE_CODE (t) == FIELD_DECL)	{	  if (DECL_FIELD_OFFSET (t))	    dump_child ("bpos", bit_position (t));	}      else if (TREE_CODE (t) == VAR_DECL	       || TREE_CODE (t) == PARM_DECL)	{	  dump_int (di, "used", TREE_USED (t));	  if (DECL_REGISTER (t))	    dump_string_field (di, "spec", "register");	}      break;    case FUNCTION_DECL:      dump_child ("args", DECL_ARGUMENTS (t));      if (DECL_EXTERNAL (t))	dump_string_field (di, "body", "undefined");      if (TREE_PUBLIC (t))	dump_string_field (di, "link", "extern");      else	dump_string_field (di, "link", "static");      if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))	dump_child ("body", DECL_SAVED_TREE (t));      break;    case INTEGER_CST:      if (TREE_INT_CST_HIGH (t))	dump_int (di, "high", TREE_INT_CST_HIGH (t));      dump_int (di, "low", TREE_INT_CST_LOW (t));

//.........这里部分代码省略.........	    TB_SET_HEAD (DECL_ATTRIBUTES (head));	  else if (head && TYPE_P (head))	    TB_SET_HEAD (TYPE_ATTRIBUTES (head));	  else	    TB_WF;	  break;	case TB_CONTEXT:	  if (head && DECL_P (head))	    TB_SET_HEAD (DECL_CONTEXT (head));	  else if (head && TYPE_P (head)		   && TYPE_CONTEXT (head))	    TB_SET_HEAD (TYPE_CONTEXT (head));	  else	    TB_WF;	  break;	case TB_OFFSET:	  if (head && TREE_CODE (head) == FIELD_DECL)	    TB_SET_HEAD (DECL_FIELD_OFFSET (head));	  else	    TB_WF;	  break;	case TB_BIT_OFFSET:	  if (head && TREE_CODE (head) == FIELD_DECL)	    TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));	  else	    TB_WF;          break;	case TB_UNIT_SIZE:	  if (head && DECL_P (head))	    TB_SET_HEAD (DECL_SIZE_UNIT (head));	  else if (head && TYPE_P (head))	    TB_SET_HEAD (TYPE_SIZE_UNIT (head));	  else	    TB_WF;	  break;	case TB_SIZE:	  if (head && DECL_P (head))	    TB_SET_HEAD (DECL_SIZE (head));	  else if (head && TYPE_P (head))	    TB_SET_HEAD (TYPE_SIZE (head));	  else	    TB_WF;	  break;	case TB_TYPE:	  if (head && TREE_TYPE (head))	    TB_SET_HEAD (TREE_TYPE (head));	  else	    TB_WF;	  break;	case TB_DECL_SAVED_TREE:	  if (head && TREE_CODE (head) == FUNCTION_DECL	      && DECL_SAVED_TREE (head))	    TB_SET_HEAD (DECL_SAVED_TREE (head));	  else	    TB_WF;	  break;	case TB_BODY:	  if (head && TREE_CODE (head) == BIND_EXPR)

/* Return 1 if check CI against BOUNDS always pass,   -1 if check CI against BOUNDS always fails and   0 if we cannot compute check result.  */static intchkp_get_check_result (struct check_info *ci, tree bounds){    gimple *bnd_def;    address_t bound_val;    int sign, res = 0;    if (dump_file && (dump_flags & TDF_DETAILS))    {        fprintf (dump_file, "Trying to compute result of the check/n");        fprintf (dump_file, "  check: ");        print_gimple_stmt (dump_file, ci->stmt, 0, 0);        fprintf (dump_file, "  address: ");        chkp_print_addr (ci->addr);        fprintf (dump_file, "/n  bounds: ");        print_generic_expr (dump_file, bounds, 0);        fprintf (dump_file, "/n");    }    if (TREE_CODE (bounds) != SSA_NAME)    {        if (dump_file && (dump_flags & TDF_DETAILS))            fprintf (dump_file, "  result: bounds tree code is not ssa_name/n");        return 0;    }    bnd_def = SSA_NAME_DEF_STMT (bounds);    /* Currently we handle cases when bounds are result of bndmk       or loaded static bounds var.  */    if (gimple_code (bnd_def) == GIMPLE_CALL            && gimple_call_fndecl (bnd_def) == chkp_bndmk_fndecl)    {        bound_val.pol.create (0);        chkp_collect_value (gimple_call_arg (bnd_def, 0), bound_val);        if (ci->type == CHECK_UPPER_BOUND)        {            address_t size_val;            size_val.pol.create (0);            chkp_collect_value (gimple_call_arg (bnd_def, 1), size_val);            chkp_add_addr_addr (bound_val, size_val);            size_val.pol.release ();            chkp_add_addr_item (bound_val, integer_minus_one_node, NULL);        }    }    else if (gimple_code (bnd_def) == GIMPLE_ASSIGN             && gimple_assign_rhs1 (bnd_def) == chkp_get_zero_bounds_var ())    {        if (dump_file && (dump_flags & TDF_DETAILS))            fprintf (dump_file, "  result: always pass with zero bounds/n");        return 1;    }    else if (gimple_code (bnd_def) == GIMPLE_ASSIGN             && gimple_assign_rhs1 (bnd_def) == chkp_get_none_bounds_var ())    {        if (dump_file && (dump_flags & TDF_DETAILS))            fprintf (dump_file, "  result: always fails with none bounds/n");        return -1;    }    else if (gimple_code (bnd_def) == GIMPLE_ASSIGN             && TREE_CODE (gimple_assign_rhs1 (bnd_def)) == VAR_DECL)    {        tree bnd_var = gimple_assign_rhs1 (bnd_def);        tree var;        tree size;        if (!DECL_INITIAL (bnd_var)                || DECL_INITIAL (bnd_var) == error_mark_node)        {            if (dump_file && (dump_flags & TDF_DETAILS))                fprintf (dump_file, "  result: cannot compute bounds/n");            return 0;        }        gcc_assert (TREE_CODE (DECL_INITIAL (bnd_var)) == ADDR_EXPR);        var = TREE_OPERAND (DECL_INITIAL (bnd_var), 0);        bound_val.pol.create (0);        chkp_collect_value (DECL_INITIAL (bnd_var), bound_val);        if (ci->type == CHECK_UPPER_BOUND)        {            if (TREE_CODE (var) == VAR_DECL)            {                if (DECL_SIZE (var)                        && !chkp_variable_size_type (TREE_TYPE (var)))                    size = DECL_SIZE_UNIT (var);                else                {                    if (dump_file && (dump_flags & TDF_DETAILS))                        fprintf (dump_file, "  result: cannot compute bounds/n");                    return 0;                }            }            else            {                gcc_assert (TREE_CODE (var) == STRING_CST);                size = build_int_cst (size_type_node,                                      TREE_STRING_LENGTH (var));//.........这里部分代码省略.........

static symtab_nodelto_symtab_resolve_symbols (symtab_node first){  symtab_node e;  symtab_node prevailing = NULL;  /* Always set e->node so that edges are updated to reflect decl merging. */  for (e = first; e; e = e->symbol.next_sharing_asm_name)    if (lto_symtab_symbol_p (e)	&& (e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY	    || e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY_EXP	    || e->symbol.resolution == LDPR_PREVAILING_DEF))      {	prevailing = e;	break;      }  /* If the chain is already resolved there is nothing else to do.  */  if (prevailing)    {      /* Assert it's the only one.  */      for (e = prevailing->symbol.next_sharing_asm_name; e; e = e->symbol.next_sharing_asm_name)	if (lto_symtab_symbol_p (e)	    && (e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY		|| e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY_EXP		|| e->symbol.resolution == LDPR_PREVAILING_DEF))	  fatal_error ("multiple prevailing defs for %qE",		       DECL_NAME (prevailing->symbol.decl));      return prevailing;    }  /* Find the single non-replaceable prevailing symbol and     diagnose ODR violations.  */  for (e = first; e; e = e->symbol.next_sharing_asm_name)    {      if (!lto_symtab_resolve_can_prevail_p (e))	continue;      /* If we have a non-replaceable definition it prevails.  */      if (!lto_symtab_resolve_replaceable_p (e))	{	  if (prevailing)	    {	      error_at (DECL_SOURCE_LOCATION (e->symbol.decl),			"%qD has already been defined", e->symbol.decl);	      inform (DECL_SOURCE_LOCATION (prevailing->symbol.decl),		      "previously defined here");	    }	  prevailing = e;	}    }  if (prevailing)    return prevailing;  /* Do a second round choosing one from the replaceable prevailing decls.  */  for (e = first; e; e = e->symbol.next_sharing_asm_name)    {      if (!lto_symtab_resolve_can_prevail_p (e))	continue;      /* Choose the first function that can prevail as prevailing.  */      if (TREE_CODE (e->symbol.decl) == FUNCTION_DECL)	{	  prevailing = e;	  break;	}      /* From variables that can prevail choose the largest one.  */      if (!prevailing	  || tree_int_cst_lt (DECL_SIZE (prevailing->symbol.decl),			      DECL_SIZE (e->symbol.decl))	  /* When variables are equivalent try to chose one that has useful	     DECL_INITIAL.  This makes sense for keyed vtables that are	     DECL_EXTERNAL but initialized.  In units that do not need them	     we replace the initializer by error_mark_node to conserve	     memory.	     We know that the vtable is keyed outside the LTO unit - otherwise	     the keyed instance would prevail.  We still can preserve useful	     info in the initializer.  */	  || (DECL_SIZE (prevailing->symbol.decl) == DECL_SIZE (e->symbol.decl)	      && (DECL_INITIAL (e->symbol.decl)		  && DECL_INITIAL (e->symbol.decl) != error_mark_node)	      && (!DECL_INITIAL (prevailing->symbol.decl)		  || DECL_INITIAL (prevailing->symbol.decl) == error_mark_node)))	prevailing = e;    }  return prevailing;}

//.........这里部分代码省略.........	      fn_ptr_tmp = TREE_TYPE (*anode);	      anode = &fn_ptr_tmp;	      flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;	    }	  else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)	    {	      /* Pass on this attribute to be tried again.  */	      returned_attrs = tree_cons (name, args, returned_attrs);	      continue;	    }	  if (TREE_CODE (*anode) != FUNCTION_TYPE	      && TREE_CODE (*anode) != METHOD_TYPE)	    {	      warning ("%qs attribute only applies to function types",		       IDENTIFIER_POINTER (name));	      continue;	    }	}      if (spec->handler != NULL)	returned_attrs = chainon ((*spec->handler) (anode, name, args,						    flags, &no_add_attrs),				  returned_attrs);      /* Layout the decl in case anything changed.  */      if (spec->type_required && DECL_P (*node)	  && (TREE_CODE (*node) == VAR_DECL	      || TREE_CODE (*node) == PARM_DECL	      || TREE_CODE (*node) == RESULT_DECL))	{	  /* Force a recalculation of mode and size.  */	  DECL_MODE (*node) = VOIDmode;	  DECL_SIZE (*node) = 0;	  layout_decl (*node, 0);	}      if (!no_add_attrs)	{	  tree old_attrs;	  tree a;	  if (DECL_P (*anode))	    old_attrs = DECL_ATTRIBUTES (*anode);	  else	    old_attrs = TYPE_ATTRIBUTES (*anode);	  for (a = lookup_attribute (spec->name, old_attrs);	       a != NULL_TREE;	       a = lookup_attribute (spec->name, TREE_CHAIN (a)))	    {	      if (simple_cst_equal (TREE_VALUE (a), args) == 1)		break;	    }	  if (a == NULL_TREE)	    {	      /* This attribute isn't already in the list.  */	      if (DECL_P (*anode))		DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);	      else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)		{		  TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);		  /* If this is the main variant, also push the attributes		     out to the other variants.  */

static boollto_symtab_merge (symtab_node *prevailing, symtab_node *entry){  tree prevailing_decl = prevailing->decl;  tree decl = entry->decl;  if (prevailing_decl == decl)    return true;  /* Merge decl state in both directions, we may still end up using     the new decl.  */  TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);  TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);  /* The linker may ask us to combine two incompatible symbols.     Detect this case and notify the caller of required diagnostics.  */  if (TREE_CODE (decl) == FUNCTION_DECL)    {      /* Merge decl state in both directions, we may still end up using	 the new decl.  */      DECL_POSSIBLY_INLINED (prevailing_decl) |= DECL_POSSIBLY_INLINED (decl);      DECL_POSSIBLY_INLINED (decl) |= DECL_POSSIBLY_INLINED (prevailing_decl);      if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl),			             TREE_TYPE (decl),				     DECL_COMMON (decl)				     || DECL_EXTERNAL (decl)))	return false;      return true;    }  if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl),				 TREE_TYPE (decl),				 DECL_COMMON (decl) || DECL_EXTERNAL (decl)))    return false;  /* There is no point in comparing too many details of the decls here.     The type compatibility checks or the completing of types has properly     dealt with most issues.  */  /* The following should all not invoke fatal errors as in non-LTO     mode the linker wouldn't complain either.  Just emit warnings.  */  /* Report a warning if user-specified alignments do not match.  */  if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))      && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))    return false;  if (DECL_SIZE (decl) && DECL_SIZE (prevailing_decl)      && !tree_int_cst_equal (DECL_SIZE (decl), DECL_SIZE (prevailing_decl))      /* As a special case do not warn about merging	 int a[];	 and	 int a[]={1,2,3};	 here the first declaration is COMMON	 and sizeof(a) == sizeof (int).  */      && ((!DECL_COMMON (decl) && !DECL_EXTERNAL (decl))	  || TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE	  || TYPE_SIZE (TREE_TYPE (decl))	     != TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl)))))    return false;  return true;}

static voidlto_symtab_resolve_symbols (void **slot){  lto_symtab_entry_t e;  lto_symtab_entry_t prevailing = NULL;  /* Always set e->node so that edges are updated to reflect decl merging. */  for (e = (lto_symtab_entry_t) *slot; e; e = e->next)    {      if (TREE_CODE (e->decl) == FUNCTION_DECL)	e->node = cgraph_get_node (e->decl);      else if (TREE_CODE (e->decl) == VAR_DECL)	e->vnode = varpool_get_node (e->decl);      if (e->resolution == LDPR_PREVAILING_DEF_IRONLY	  || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP	  || e->resolution == LDPR_PREVAILING_DEF)	prevailing = e;    }  /* If the chain is already resolved there is nothing else to do.  */  if (prevailing)    return;  /* Find the single non-replaceable prevailing symbol and     diagnose ODR violations.  */  for (e = (lto_symtab_entry_t) *slot; e; e = e->next)    {      if (!lto_symtab_resolve_can_prevail_p (e))	{	  e->resolution = LDPR_RESOLVED_IR;          e->guessed = true;	  continue;	}      /* Set a default resolution - the final prevailing one will get         adjusted later.  */      e->resolution = LDPR_PREEMPTED_IR;      e->guessed = true;      if (!lto_symtab_resolve_replaceable_p (e))	{	  if (prevailing)	    {	      error_at (DECL_SOURCE_LOCATION (e->decl),			"%qD has already been defined", e->decl);	      inform (DECL_SOURCE_LOCATION (prevailing->decl),		      "previously defined here");	    }	  prevailing = e;	}    }  if (prevailing)    goto found;  /* Do a second round choosing one from the replaceable prevailing decls.  */  for (e = (lto_symtab_entry_t) *slot; e; e = e->next)    {      if (e->resolution != LDPR_PREEMPTED_IR)	continue;      /* Choose the first function that can prevail as prevailing.  */      if (TREE_CODE (e->decl) == FUNCTION_DECL)	{	  prevailing = e;	  break;	}      /* From variables that can prevail choose the largest one.  */      if (!prevailing	  || tree_int_cst_lt (DECL_SIZE (prevailing->decl),			      DECL_SIZE (e->decl)))	prevailing = e;    }  if (!prevailing)    return;found:  /* If current lto files represent the whole program,    it is correct to use LDPR_PREVALING_DEF_IRONLY.    If current lto files are part of whole program, internal    resolver doesn't know if it is LDPR_PREVAILING_DEF    or LDPR_PREVAILING_DEF_IRONLY.  Use IRONLY conforms to    using -fwhole-program.  Otherwise, it doesn't    matter using either LDPR_PREVAILING_DEF or    LDPR_PREVAILING_DEF_IRONLY        FIXME: above workaround due to gold plugin makes some    variables IRONLY, which are indeed PREVAILING_DEF in    resolution file.  These variables still need manual    externally_visible attribute.  */    prevailing->resolution = LDPR_PREVAILING_DEF_IRONLY;    prevailing->guessed = true;}

//.........这里部分代码省略.........            if (DECL_LANG_FLAG_1 (node))                fputs (" decl_1", file);            if (DECL_LANG_FLAG_2 (node))                fputs (" decl_2", file);            if (DECL_LANG_FLAG_3 (node))                fputs (" decl_3", file);            if (DECL_LANG_FLAG_4 (node))                fputs (" decl_4", file);            if (DECL_LANG_FLAG_5 (node))                fputs (" decl_5", file);            if (DECL_LANG_FLAG_6 (node))                fputs (" decl_6", file);            if (DECL_LANG_FLAG_7 (node))                fputs (" decl_7", file);            mode = DECL_MODE (node);            fprintf (file, " %s", GET_MODE_NAME (mode));        }        if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)                && DECL_BY_REFERENCE (node))            fputs (" passed-by-reference", file);        if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)  && DECL_DEFER_OUTPUT (node))            fputs (" defer-output", file);        xloc = expand_location (DECL_SOURCE_LOCATION (node));        fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,                 xloc.column);        if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))        {            print_node (file, "size", DECL_SIZE (node), indent + 4);            print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);            if (code != FUNCTION_DECL || DECL_BUILT_IN (node))                indent_to (file, indent + 3);            if (DECL_USER_ALIGN (node))                fprintf (file, " user");            fprintf (file, " align %d", DECL_ALIGN (node));            if (code == FIELD_DECL)                fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,                         DECL_OFFSET_ALIGN (node));            if (code == FUNCTION_DECL && DECL_BUILT_IN (node))            {                if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)                    fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));                else                    fprintf (file, " built-in %s:%s",                             built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],                             built_in_names[(int) DECL_FUNCTION_CODE (node)]);            }        }        if (code == FIELD_DECL)        {            print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);            print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),                        indent + 4);            if (DECL_BIT_FIELD_TYPE (node))                print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),                            indent + 4);        }

static treebuild_common_decl (gfc_common_head *com, tree union_type, bool is_init){  gfc_symbol *common_sym;  tree decl;  /* Create a namespace to store symbols for common blocks.  */  if (gfc_common_ns == NULL)    gfc_common_ns = gfc_get_namespace (NULL, 0);  gfc_get_symbol (com->name, gfc_common_ns, &common_sym);  decl = common_sym->backend_decl;  /* Update the size of this common block as needed.  */  if (decl != NULL_TREE)    {      tree size = TYPE_SIZE_UNIT (union_type);      /* Named common blocks of the same name shall be of the same size	 in all scoping units of a program in which they appear, but	 blank common blocks may be of different sizes.  */      if (!tree_int_cst_equal (DECL_SIZE_UNIT (decl), size)	  && strcmp (com->name, BLANK_COMMON_NAME))	gfc_warning ("Named COMMON block '%s' at %L shall be of the "		     "same size as elsewhere (%lu vs %lu bytes)", com->name,		     &com->where,		     (unsigned long) TREE_INT_CST_LOW (size),		     (unsigned long) TREE_INT_CST_LOW (DECL_SIZE_UNIT (decl)));      if (tree_int_cst_lt (DECL_SIZE_UNIT (decl), size))	{	  DECL_SIZE (decl) = TYPE_SIZE (union_type);	  DECL_SIZE_UNIT (decl) = size;	  DECL_MODE (decl) = TYPE_MODE (union_type);	  TREE_TYPE (decl) = union_type;	  layout_decl (decl, 0);	}     }  /* If this common block has been declared in a previous program unit,     and either it is already initialized or there is no new initialization     for it, just return.  */  if ((decl != NULL_TREE) && (!is_init || DECL_INITIAL (decl)))    return decl;  /* If there is no backend_decl for the common block, build it.  */  if (decl == NULL_TREE)    {      decl = build_decl (input_location,			 VAR_DECL, get_identifier (com->name), union_type);      gfc_set_decl_assembler_name (decl, gfc_sym_mangled_common_id (com));      TREE_PUBLIC (decl) = 1;      TREE_STATIC (decl) = 1;      DECL_IGNORED_P (decl) = 1;      if (!com->is_bind_c)	DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;      else        {	  /* Do not set the alignment for bind(c) common blocks to	     BIGGEST_ALIGNMENT because that won't match what C does.  Also,	     for common blocks with one element, the alignment must be	     that of the field within the common block in order to match	     what C will do.  */	  tree field = NULL_TREE;	  field = TYPE_FIELDS (TREE_TYPE (decl));	  if (DECL_CHAIN (field) == NULL_TREE)	    DECL_ALIGN (decl) = TYPE_ALIGN (TREE_TYPE (field));	}      DECL_USER_ALIGN (decl) = 0;      GFC_DECL_COMMON_OR_EQUIV (decl) = 1;      gfc_set_decl_location (decl, &com->where);      if (com->threadprivate)	DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);      /* Place the back end declaration for this common block in         GLOBAL_BINDING_LEVEL.  */      common_sym->backend_decl = pushdecl_top_level (decl);    }  /* Has no initial values.  */  if (!is_init)    {      DECL_INITIAL (decl) = NULL_TREE;      DECL_COMMON (decl) = 1;      DECL_DEFER_OUTPUT (decl) = 1;    }  else    {      DECL_INITIAL (decl) = error_mark_node;      DECL_COMMON (decl) = 0;      DECL_DEFER_OUTPUT (decl) = 0;    }  return decl;}

//.........这里部分代码省略.........	    int i;	    tree binfo, child;	    for (binfo = TYPE_BINFO (type), i = 0;		 BINFO_BASE_ITERATE (binfo, i, child); i++)	      {		tree child_type = BINFO_TYPE (child);		tree child_type_name;		if (TYPE_NAME (child_type) == 0)		  continue;		if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)		  child_type_name = TYPE_NAME (child_type);		else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)		  {		    child_type_name = DECL_NAME (TYPE_NAME (child_type));		    if (child_type_name && template_name_p (child_type_name))		      child_type_name			= DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));		  }		else		  continue;		PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));		PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));		PUT_SDB_SCL (member_scl);		sdbout_type (BINFO_TYPE (child));		PUT_SDB_ENDEF;	      }	  }	/* Output the individual fields.  */	if (TREE_CODE (type) == ENUMERAL_TYPE)	  {	    for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))	      {	        tree value = TREE_VALUE (tem);	        if (TREE_CODE (value) == CONST_DECL)	          value = DECL_INITIAL (value);	        if (host_integerp (value, 0))		  {		    PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));		    PUT_SDB_INT_VAL (tree_low_cst (value, 0));		    PUT_SDB_SCL (C_MOE);		    PUT_SDB_TYPE (T_MOE);		    PUT_SDB_ENDEF;		  }	      }	  }	else			/* record or union type */	  for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))	    /* Output the name, type, position (in bits), size (in bits)	       of each field.  */	    /* Omit here the nameless fields that are used to skip bits.	       Also omit fields with variable size or position.	       Also omit non FIELD_DECL nodes that GNU C++ may put here.  */	    if (TREE_CODE (tem) == FIELD_DECL		&& DECL_NAME (tem)		&& DECL_SIZE (tem)		&& host_integerp (DECL_SIZE (tem), 1)		&& host_integerp (bit_position (tem), 0))	      {		const char *name;		name = IDENTIFIER_POINTER (DECL_NAME (tem));		PUT_SDB_DEF (name);		if (DECL_BIT_FIELD_TYPE (tem))		  {		    PUT_SDB_INT_VAL (int_bit_position (tem));		    PUT_SDB_SCL (C_FIELD);		    sdbout_type (DECL_BIT_FIELD_TYPE (tem));		    PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));		  }		else		  {		    PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);		    PUT_SDB_SCL (member_scl);		    sdbout_type (TREE_TYPE (tem));		  }		PUT_SDB_ENDEF;	      }	/* Output end of a structure,union, or enumeral definition.  */	PUT_SDB_PLAIN_DEF ("eos");	PUT_SDB_INT_VAL (size);	PUT_SDB_SCL (C_EOS);	PUT_SDB_TAG (KNOWN_TYPE_TAG (type));	PUT_SDB_SIZE (size);	PUT_SDB_ENDEF;	break;      }    default:      break;    }}