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

static voidbuild_field (segment_info *h, tree union_type, record_layout_info rli){  tree field;  tree name;  HOST_WIDE_INT offset = h->offset;  unsigned HOST_WIDE_INT desired_align, known_align;  name = get_identifier (h->sym->name);  field = build_decl (FIELD_DECL, name, h->field);  gfc_set_decl_location (field, &h->sym->declared_at);  known_align = (offset & -offset) * BITS_PER_UNIT;  if (known_align == 0 || known_align > BIGGEST_ALIGNMENT)    known_align = BIGGEST_ALIGNMENT;  desired_align = update_alignment_for_field (rli, field, known_align);  if (desired_align > known_align)    DECL_PACKED (field) = 1;  DECL_FIELD_CONTEXT (field) = union_type;  DECL_FIELD_OFFSET (field) = size_int (offset);  DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;  SET_DECL_OFFSET_ALIGN (field, known_align);  rli->offset = size_binop (MAX_EXPR, rli->offset,                            size_binop (PLUS_EXPR,                                        DECL_FIELD_OFFSET (field),                                        DECL_SIZE_UNIT (field)));  h->field = field;}

void     field_DECL_FIELD_OFFSET(tree t){  if (DECL_FIELD_OFFSET(t)) {    //fprintf( code_outputfile,"DECL_BIT_FIELD %d/n",DECL_FIELD_OFFSET(t));    fprintf( code_outputfile,"DECL_BIT_FIELD/n"); // tree  }}

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 treecompute_object_offset (tree expr, tree var){  enum tree_code code = PLUS_EXPR;  tree base, off, t;  if (expr == var)    return size_zero_node;  switch (TREE_CODE (expr))    {    case COMPONENT_REF:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      t = TREE_OPERAND (expr, 1);      off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),			size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)				  / BITS_PER_UNIT));      break;    case REALPART_EXPR:    case NOP_EXPR:    case CONVERT_EXPR:    case VIEW_CONVERT_EXPR:    case NON_LVALUE_EXPR:      return compute_object_offset (TREE_OPERAND (expr, 0), var);    case IMAGPART_EXPR:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      off = TYPE_SIZE_UNIT (TREE_TYPE (expr));      break;    case ARRAY_REF:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      t = TREE_OPERAND (expr, 1);      if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)	{	  code = MINUS_EXPR;	  t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);	}      t = convert (sizetype, t);      off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);      break;    default:      return error_mark_node;    }  return size_binop (code, base, off);}

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 voidwrite_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,				   bool ref_p){  stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);  stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);  stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);  stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);  stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);}

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 voidwrite_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,				   bool ref_p){  stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);  stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);  stream_write_tree (ob, DECL_QUALIFIER (expr), ref_p);  stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);  stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);  streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);}

//.........这里部分代码省略.........	    TB_WF;	  break;	case TB_ABSTRACT_ORIGIN:	  if (head && DECL_P (head))	    TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));	  else if (head && TREE_CODE (head) == BLOCK)	    TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));	  else	    TB_WF;	  break;	case TB_ATTRIBUTES:	  if (head && DECL_P (head))	    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));

//.........这里部分代码省略.........        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);        }        print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);        if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))        {            print_node_brief (file, "attributes",                              DECL_ATTRIBUTES (node), indent + 4);            if (code != PARM_DECL)                print_node_brief (file, "initial", DECL_INITIAL (node),                                  indent + 4);        }        if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))        {            print_node_brief (file, "abstract_origin",                              DECL_ABSTRACT_ORIGIN (node), indent + 4);        }        if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))        {            print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);        }        lang_hooks.print_decl (file, node, indent);        if (DECL_RTL_SET_P (node))        {            indent_to (file, indent + 4);

//.........这里部分代码省略.........    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));      break;    case STRING_CST:      fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));      dump_int (di, "lngt", TREE_STRING_LENGTH (t));

intgfc_interpret_derived (unsigned char *buffer, size_t buffer_size, gfc_expr *result){  gfc_component *cmp;  gfc_constructor *head = NULL, *tail = NULL;  int ptr;  tree type;  /* The attributes of the derived type need to be bolted to the floor.  */  result->expr_type = EXPR_STRUCTURE;  type = gfc_typenode_for_spec (&result->ts);  cmp = result->ts.u.derived->components;  /* Run through the derived type components.  */  for (;cmp; cmp = cmp->next)    {      if (head == NULL)	head = tail = gfc_get_constructor ();      else	{	  tail->next = gfc_get_constructor ();	  tail = tail->next;	}      /* The constructor points to the component.  */      tail->n.component = cmp;      tail->expr = gfc_constant_result (cmp->ts.type, cmp->ts.kind,					&result->where);      tail->expr->ts = cmp->ts;      /* Copy shape, if needed.  */      if (cmp->as && cmp->as->rank)	{	  int n;	  tail->expr->expr_type = EXPR_ARRAY;	  tail->expr->rank = cmp->as->rank;	  tail->expr->shape = gfc_get_shape (tail->expr->rank);	  for (n = 0; n < tail->expr->rank; n++)	     {	       mpz_init_set_ui (tail->expr->shape[n], 1);	       mpz_add (tail->expr->shape[n], tail->expr->shape[n],			cmp->as->upper[n]->value.integer);	       mpz_sub (tail->expr->shape[n], tail->expr->shape[n],			cmp->as->lower[n]->value.integer);	     }	}      /* Calculate the offset, which consists of the the FIELD_OFFSET in	 bytes, which appears in multiples of DECL_OFFSET_ALIGN-bit-sized,	 and additional bits of FIELD_BIT_OFFSET. The code assumes that all	 sizes of the components are multiples of BITS_PER_UNIT,	 i.e. there are, e.g., no bit fields.  */      ptr = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (cmp->backend_decl));      gcc_assert (ptr % 8 == 0);      ptr = ptr/8 + TREE_INT_CST_LOW (DECL_FIELD_OFFSET (cmp->backend_decl));      gfc_target_interpret_expr (&buffer[ptr], buffer_size - ptr,				 tail->expr);      result->value.constructor = head;    }      return int_size_in_bytes (type);}

voidexpand_builtin_cilk_detach (tree exp){  rtx_insn *insn;  tree fptr = get_frame_arg (exp);  if (fptr == NULL_TREE)    return;  tree parent = cilk_dot (fptr, CILK_TI_FRAME_PARENT, 0);  tree worker = cilk_dot (fptr, CILK_TI_FRAME_WORKER, 0);  tree tail = cilk_arrow (worker, CILK_TI_WORKER_TAIL, 1);  rtx wreg = expand_expr (worker, NULL_RTX, Pmode, EXPAND_NORMAL);  if (GET_CODE (wreg) != REG)    wreg = copy_to_reg (wreg);  rtx preg = expand_expr (parent, NULL_RTX, Pmode, EXPAND_NORMAL);  /* TMP <- WORKER.TAIL    *TMP <- PARENT     TMP <- TMP + 1     WORKER.TAIL <- TMP   */  HOST_WIDE_INT worker_tail_offset =    tree_to_shwi (DECL_FIELD_OFFSET (cilk_trees[CILK_TI_WORKER_TAIL])) +    tree_to_shwi (DECL_FIELD_BIT_OFFSET (cilk_trees[CILK_TI_WORKER_TAIL])) /    BITS_PER_UNIT;  rtx tmem0 = gen_rtx_MEM (Pmode,			   plus_constant (Pmode, wreg, worker_tail_offset));  set_mem_attributes (tmem0, tail, 0);  MEM_NOTRAP_P (tmem0) = 1;  gcc_assert (MEM_VOLATILE_P (tmem0));  rtx treg = copy_to_mode_reg (Pmode, tmem0);  rtx tmem1 = gen_rtx_MEM (Pmode, treg);  set_mem_attributes (tmem1, TREE_TYPE (TREE_TYPE (tail)), 0);  MEM_NOTRAP_P (tmem1) = 1;  emit_move_insn (tmem1, preg);  emit_move_insn (treg, plus_constant (Pmode, treg, GET_MODE_SIZE (Pmode)));  /* There is a release barrier (st8.rel, membar #StoreStore,     sfence, lwsync, etc.) between the two stores.  On x86     normal volatile stores have proper semantics; the sfence     would only be needed for nontemporal stores (which we     could generate using the storent optab, for no benefit     in this case).     The predicate may return false even for a REG if this is     the limited release operation that only stores 0.  */  enum insn_code icode = direct_optab_handler (sync_lock_release_optab, Pmode);   if (icode != CODE_FOR_nothing      && insn_data[icode].operand[1].predicate (treg, Pmode)      && (insn = GEN_FCN (icode) (tmem0, treg)) != NULL_RTX)    emit_insn (insn);  else    emit_move_insn (tmem0, treg);  /* The memory barrier inserted above should not prevent     the load of flags from being moved before the stores,     but in practice it does because it is implemented with     unspec_volatile.  In-order RISC machines should     explicitly load flags earlier.  */  tree flags = cilk_dot (fptr, CILK_TI_FRAME_FLAGS, 0);  expand_expr (build2 (MODIFY_EXPR, void_type_node, flags,		       build2 (BIT_IOR_EXPR, TREE_TYPE (flags), flags,			       build_int_cst (TREE_TYPE (flags),					      CILK_FRAME_DETACHED))),	       const0_rtx, VOIDmode, EXPAND_NORMAL);}

static treeget_init_field (segment_info *head, tree union_type, tree *field_init,		record_layout_info rli){  segment_info *s;  HOST_WIDE_INT length = 0;  HOST_WIDE_INT offset = 0;  unsigned HOST_WIDE_INT known_align, desired_align;  bool overlap = false;  tree tmp, field;  tree init;  unsigned char *data, *chk;  VEC(constructor_elt,gc) *v = NULL;  tree type = unsigned_char_type_node;  int i;  /* Obtain the size of the union and check if there are any overlapping     initializers.  */  for (s = head; s; s = s->next)    {      HOST_WIDE_INT slen = s->offset + s->length;      if (s->sym->value)	{	  if (s->offset < offset)            overlap = true;	  offset = slen;	}      length = length < slen ? slen : length;    }  if (!overlap)    return NULL_TREE;  /* Now absorb all the initializer data into a single vector,     whilst checking for overlapping, unequal values.  */  data = XCNEWVEC (unsigned char, (size_t)length);  chk = XCNEWVEC (unsigned char, (size_t)length);  /* TODO - change this when default initialization is implemented.  */  memset (data, '/0', (size_t)length);  memset (chk, '/0', (size_t)length);  for (s = head; s; s = s->next)    if (s->sym->value)      gfc_merge_initializers (s->sym->ts, s->sym->value,			      &data[s->offset],			      &chk[s->offset],			     (size_t)s->length);    for (i = 0; i < length; i++)    CONSTRUCTOR_APPEND_ELT (v, NULL, build_int_cst (type, data[i]));  free (data);  free (chk);  /* Build a char[length] array to hold the initializers.  Much of what     follows is borrowed from build_field, above.  */  tmp = build_int_cst (gfc_array_index_type, length - 1);  tmp = build_range_type (gfc_array_index_type,			  gfc_index_zero_node, tmp);  tmp = build_array_type (type, tmp);  field = build_decl (gfc_current_locus.lb->location,		      FIELD_DECL, NULL_TREE, tmp);  known_align = BIGGEST_ALIGNMENT;  desired_align = update_alignment_for_field (rli, field, known_align);  if (desired_align > known_align)    DECL_PACKED (field) = 1;  DECL_FIELD_CONTEXT (field) = union_type;  DECL_FIELD_OFFSET (field) = size_int (0);  DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;  SET_DECL_OFFSET_ALIGN (field, known_align);  rli->offset = size_binop (MAX_EXPR, rli->offset,                            size_binop (PLUS_EXPR,                                        DECL_FIELD_OFFSET (field),                                        DECL_SIZE_UNIT (field)));  init = build_constructor (TREE_TYPE (field), v);  TREE_CONSTANT (init) = 1;  *field_init = init;  for (s = head; s; s = s->next)    {      if (s->sym->value == NULL)	continue;      gfc_free_expr (s->sym->value);      s->sym->value = NULL;    }  return field;}

static treecompute_object_offset (const_tree expr, const_tree var){  enum tree_code code = PLUS_EXPR;  tree base, off, t;  if (expr == var)    return size_zero_node;  switch (TREE_CODE (expr))    {    case COMPONENT_REF:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      t = TREE_OPERAND (expr, 1);      off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),			size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t))				  / BITS_PER_UNIT));      break;    case REALPART_EXPR:    CASE_CONVERT:    case VIEW_CONVERT_EXPR:    case NON_LVALUE_EXPR:      return compute_object_offset (TREE_OPERAND (expr, 0), var);    case IMAGPART_EXPR:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      off = TYPE_SIZE_UNIT (TREE_TYPE (expr));      break;    case ARRAY_REF:      base = compute_object_offset (TREE_OPERAND (expr, 0), var);      if (base == error_mark_node)	return base;      t = TREE_OPERAND (expr, 1);      tree low_bound, unit_size;      low_bound = array_ref_low_bound (CONST_CAST_TREE (expr));      unit_size = array_ref_element_size (CONST_CAST_TREE (expr));      if (! integer_zerop (low_bound))	t = fold_build2 (MINUS_EXPR, TREE_TYPE (t), t, low_bound);      if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)	{	  code = MINUS_EXPR;	  t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);	}      t = fold_convert (sizetype, t);      off = size_binop (MULT_EXPR, unit_size, t);      break;    case MEM_REF:      gcc_assert (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR);      return wide_int_to_tree (sizetype, mem_ref_offset (expr));    default:      return error_mark_node;    }  return size_binop (code, base, off);}