gcc/cp/class.c

84      vcall offset initializers.  */
89   /* The vtable index of the next vcall or vbase offset.  */
97   /* True when adding vcall offset entries to the vtable.  False when
244   tree offset;
289   offset = BINFO_OFFSET (binfo);
293   /* Do we need to look in the vtable for the real offset?  */
304       if (!virtual_access && integer_zerop (offset))
348       /* Going via virtual base V_BINFO.  We need the static offset
349 	 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
350 	 V_BINFO.  That offset is an entry in D_BINFO's vtable.  */
378       offset = convert_to_integer (ptrdiff_type_node,
379 				   size_diffop (offset,
382       if (!integer_zerop (offset))
383 	v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
389 	offset = build3 (COND_EXPR, ptrdiff_type_node,
396 	offset = v_offset;
407   if (!integer_zerop (offset))
408     expr = build2 (code, ptr_target_type, expr, offset);
1973 /* Return the index of the vcall offset for FN when TYPE is used as a
2065 	   overriding function. We will want the vbase offset from
2107 	      tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2112 		     offset to be from there.  */
2113 		  offset = size_diffop
2114 		    (offset, convert
2118 		/* There was an existing fixed offset, this must be
2121 		fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2123 		fixed_offset = offset;
2142      use the vcall offset located there to finish the conversion.  */
2193      (or one of its primary bases, which are at the same offset).  */
2202        if we happen to get our primary back.  In that case, the offset
2651    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
3109 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3117   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3120 			   (splay_tree_key) offset,
3134 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3143   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3155    F for every subobject, passing it the type, offset, and table of
3159    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3168 			tree offset,
3178   if (max_offset && INT_CST_LT (max_offset, offset))
3202       r = (*f) (type, offset, offsets);
3224 				       offset,
3234 					 offset,
3266 							offset,
3286 		       (vbase, f, offset,
3309 						    offset,
3339 				      offset,
3345 	  offset = size_binop (PLUS_EXPR, offset,
3350 	  if (max_offset && INT_CST_LT (max_offset, offset))
3365 			  tree offset,
3374      either at offset zero (if empty, in which case they cannot
3379      all offsets, as either the empty class is at offset zero (where
3388   walk_subobject_offsets (type, record_subobject_offset, offset,
3398 		   tree offset,
3404   /* Get the node in OFFSETS that indicates the maximum offset where
3412   return walk_subobject_offsets (type, check_subobject_offset, offset,
3429   tree offset = NULL_TREE;
3457       offset = byte_position (decl);
3460 	 something of the same type at the offset we're about to use.
3467 	 Here, we put S at offset zero in U.  Then, we can't put T at
3468 	 offset zero -- its S component would be at the same address
3475 	 offset zero.  */
3482       if (layout_conflict_p (field_p ? type : binfo, offset,
3511 			     size_diffop (convert (ssizetype, offset),
3520 				tree offset,
3523   return is_empty_class (type) && !integer_zerop (offset);
3550 		 "offset of empty base %qT may not be ABI-compliant and may"
3555   /* This is an empty base class.  We first try to put it at offset
3644 	 not morally virtual, and at an offset other than zero."  */
3650 	     an empty class placed at offset zero might itself have an
3651 	     empty base at a nonzero offset.  */
4311    OFFSET, which is a type offset, is number of bytes.  */
4314 propagate_binfo_offsets (tree binfo, tree offset)
4320   /* Update BINFO's offset.  */
4325 			   offset));
4331     propagate_binfo_offsets (primary_binfo, offset);
4344       propagate_binfo_offsets (base_binfo, offset);
4373       rli->offset = TYPE_SIZE_UNIT (t);
4417 		     "offset of virtual base %qT is not ABI-compliant and "
4426 /* Returns the offset of the byte just past the end of the base class
4445 /* Returns the offset of the byte just past the end of the base class
4446    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4456   tree offset;
4468       offset = end_of_base (base_binfo);
4469       if (INT_CST_LT_UNSIGNED (result, offset))
4470 	result = offset;
4478 	offset = end_of_base (base_binfo);
4479 	if (INT_CST_LT_UNSIGNED (result, offset))
4480 	  result = offset;
4553      offset.  However, now we need to make sure that RLI is big enough
4596      types that appear at that offset.  */
4702 		   of the bit-field; all fields start at offset zero.  */
4747 		     "the offset of %qD may not be ABI-compliant and may "
4775 	warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
4779 	 offset of the field.  */
6831       /* Record the offset in the VTT where this sub-VTT can be found.  */
7069      initialize each vtable we can figure out at what offset the
7242   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7252   /* Add the vcall and vbase offset entries.  */
7334 	  /* Pull the offset for `this', and the function to call, out of
7392   /* The negative offset initializers are also in reverse order.  */
7419 /* Returns the initializers for the vbase offset entries in the vtable
7422    where the next vbase offset will go.  */
7440      it is the offset of that which we need to use.  */
7477       /* If we've already got an offset for this virtual base, we
7483       /* Figure out where we can find this vbase offset.  */
7492 	/* The vbase offset had better be the same.  */
7495       /* The next vbase will come at a more negative offset.  */
7514 /* Adds the initializers for the vcall offset entries in the vtable
7526       /* We need a vcall offset for each of the virtual functions in this
7538 	 knowing what (or even whether) this offset will be when we define B2,
7539 	 so we store this "vcall offset" in the A sub-vtable and look it up in
7669 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7679      signature as FN, then we do not need a second vcall offset.
7685 	  /* We only use one vcall offset for virtual destructors,
7694      offset.  */
7704   /* The next vcall offset will be found at a more negative
7705      offset.  */
7751   tree offset;
7759      primary base, and then add the offset in the vtbl to that value.  */
7771   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7785   /* Add the offset-to-top entry.  It comes earlier in the vtable than
7786      the typeinfo entry.  Convert the offset to look like a
7788   init = build_nop (vfunc_ptr_type_node, offset);