utils.c (potential_alignment_gap): Delete.

	* gcc-interface/utils.c (potential_alignment_gap): Delete.
	(rest_of_record_type_compilation): Do not call above function.  Use
	the alignment of the field instead of that of its type, if need be.
	When the original field has variable size, always lower the alignment
	of the pointer type.  Reset the bit-field status of the new field if
	it does not encode a bit-field.

From-SVN: r278930

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index f8b9f18c8c1ebad8ebafdb19ca62438c80a984af..e454613bd289bfa6cb05bf2d80d85a54adea8844 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,12 @@
+2019-12-03  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/utils.c (potential_alignment_gap): Delete.
+       (rest_of_record_type_compilation): Do not call above function.  Use
+       the alignment of the field instead of that of its type, if need be.
+       When the original field has variable size, always lower the alignment
+       of the pointer type.  Reset the bit-field status of the new field if
+       it does not encode a bit-field.
+
 2019-12-03  Eric Botcazou  <ebotcazou@adacore.com>
 
        * gcc-interface/utils.c (fold_convert_size): New function.

diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
index 80c0716299f5c65f4f6326bcae969c1a69593613..7217eeaf350814c2f55c9cb5c8b129e1e0033d44 100644 (file)
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -288,7 +288,6 @@ static tree split_plus (tree, tree *);
 static tree float_type_for_precision (int, machine_mode);
 static tree convert_to_fat_pointer (tree, tree);
 static unsigned int scale_by_factor_of (tree, unsigned int);
-static bool potential_alignment_gap (tree, tree, tree);
 
 /* Linked list used as a queue to defer the initialization of the DECL_CONTEXT
    of ..._DECL nodes and of the TYPE_CONTEXT of ..._TYPE nodes.  */
@@ -2171,7 +2170,6 @@ rest_of_record_type_compilation (tree record_type)
                     ? UNION_TYPE : TREE_CODE (record_type));
       tree orig_name = TYPE_IDENTIFIER (record_type), new_name;
       tree last_pos = bitsize_zero_node;
-      tree old_field, prev_old_field = NULL_TREE;
 
       new_name
        = concat_name (orig_name, TREE_CODE (record_type) == QUAL_UNION_TYPE
@@ -2189,7 +2187,8 @@ rest_of_record_type_compilation (tree record_type)
 
       /* Now scan all the fields, replacing each field with a new field
         corresponding to the new encoding.  */
-      for (old_field = TYPE_FIELDS (record_type); old_field;
+      for (tree old_field = TYPE_FIELDS (record_type);
+          old_field;
           old_field = DECL_CHAIN (old_field))
        {
          tree field_type = TREE_TYPE (old_field);
@@ -2213,9 +2212,10 @@ rest_of_record_type_compilation (tree record_type)
          else
            pos = compute_related_constant (curpos, last_pos);
 
-         if (!pos
-             && TREE_CODE (curpos) == MULT_EXPR
-             && tree_fits_uhwi_p (TREE_OPERAND (curpos, 1)))
+         if (pos)
+           ;
+         else if (TREE_CODE (curpos) == MULT_EXPR
+                  && tree_fits_uhwi_p (TREE_OPERAND (curpos, 1)))
            {
              tree offset = TREE_OPERAND (curpos, 0);
              align = tree_to_uhwi (TREE_OPERAND (curpos, 1));
@@ -2223,8 +2223,7 @@ rest_of_record_type_compilation (tree record_type)
              last_pos = round_up (last_pos, align);
              pos = compute_related_constant (curpos, last_pos);
            }
-         else if (!pos
-                  && TREE_CODE (curpos) == PLUS_EXPR
+         else if (TREE_CODE (curpos) == PLUS_EXPR
                   && tree_fits_uhwi_p (TREE_OPERAND (curpos, 1))
                   && TREE_CODE (TREE_OPERAND (curpos, 0)) == MULT_EXPR
                   && tree_fits_uhwi_p
@@ -2240,9 +2239,9 @@ rest_of_record_type_compilation (tree record_type)
              last_pos = round_up (last_pos, align);
              pos = compute_related_constant (curpos, last_pos);
            }
-         else if (potential_alignment_gap (prev_old_field, old_field, pos))
+         else
            {
-             align = TYPE_ALIGN (field_type);
+             align = DECL_ALIGN (old_field);
              last_pos = round_up (last_pos, align);
              pos = compute_related_constant (curpos, last_pos);
            }
@@ -2261,13 +2260,17 @@ rest_of_record_type_compilation (tree record_type)
             in this case, if we don't preventively counter that.  */
          if (TREE_CODE (DECL_SIZE (old_field)) != INTEGER_CST)
            {
-             field_type = build_pointer_type (field_type);
-             if (align != 0 && TYPE_ALIGN (field_type) > align)
+             field_type = copy_type (build_pointer_type (field_type));
+             SET_TYPE_ALIGN (field_type, BITS_PER_UNIT);
+             var = true;
+
+             /* ??? Kludge to work around a bug in Workbench's debugger.  */
+             if (align == 0)
                {
-                 field_type = copy_type (field_type);
-                 SET_TYPE_ALIGN (field_type, align);
+                 align = DECL_ALIGN (old_field);
+                 last_pos = round_up (last_pos, align);
+                 pos = compute_related_constant (curpos, last_pos);
                }
-             var = true;
            }
 
          /* Make a new field name, if necessary.  */
@@ -2287,6 +2290,16 @@ rest_of_record_type_compilation (tree record_type)
          new_field
            = create_field_decl (field_name, field_type, new_record_type,
                                 DECL_SIZE (old_field), pos, 0, 0);
+         /* The specified position is not the actual position of the field
+            but the gap with the previous field, so the computation of the
+            bit-field status may be incorrect.  We adjust it manually to
+            avoid generating useless attributes for the field in DWARF.  */
+         if (DECL_SIZE (old_field) == TYPE_SIZE (field_type)
+             && value_factor_p (pos, BITS_PER_UNIT))
+           {
+             DECL_BIT_FIELD (new_field) = 0;
+             DECL_BIT_FIELD_TYPE (new_field) = NULL_TREE;
+           }
          DECL_CHAIN (new_field) = TYPE_FIELDS (new_record_type);
          TYPE_FIELDS (new_record_type) = new_field;
 
@@ -2300,7 +2313,6 @@ rest_of_record_type_compilation (tree record_type)
                                  == QUAL_UNION_TYPE)
                                 ? bitsize_zero_node
                                 : DECL_SIZE (old_field));
-         prev_old_field = old_field;
        }
 
       TYPE_FIELDS (new_record_type) = nreverse (TYPE_FIELDS (new_record_type));
@@ -3260,52 +3272,6 @@ scale_by_factor_of (tree expr, unsigned int value)
   return factor * value;
 }
 
-/* Given two consecutive field decls PREV_FIELD and CURR_FIELD, return true
-   unless we can prove these 2 fields are laid out in such a way that no gap
-   exist between the end of PREV_FIELD and the beginning of CURR_FIELD.  OFFSET
-   is the distance in bits between the end of PREV_FIELD and the starting
-   position of CURR_FIELD. It is ignored if null. */
-
-static bool
-potential_alignment_gap (tree prev_field, tree curr_field, tree offset)
-{
-  /* If this is the first field of the record, there cannot be any gap */
-  if (!prev_field)
-    return false;
-
-  /* If the previous field is a union type, then return false: The only
-     time when such a field is not the last field of the record is when
-     there are other components at fixed positions after it (meaning there
-     was a rep clause for every field), in which case we don't want the
-     alignment constraint to override them. */
-  if (TREE_CODE (TREE_TYPE (prev_field)) == QUAL_UNION_TYPE)
-    return false;
-
-  /* If the distance between the end of prev_field and the beginning of
-     curr_field is constant, then there is a gap if the value of this
-     constant is not null. */
-  if (offset && tree_fits_uhwi_p (offset))
-    return !integer_zerop (offset);
-
-  /* If the size and position of the previous field are constant,
-     then check the sum of this size and position. There will be a gap
-     iff it is not multiple of the current field alignment. */
-  if (tree_fits_uhwi_p (DECL_SIZE (prev_field))
-      && tree_fits_uhwi_p (bit_position (prev_field)))
-    return ((tree_to_uhwi (bit_position (prev_field))
-            + tree_to_uhwi (DECL_SIZE (prev_field)))
-           % DECL_ALIGN (curr_field) != 0);
-
-  /* If both the position and size of the previous field are multiples
-     of the current field alignment, there cannot be any gap. */
-  if (value_factor_p (bit_position (prev_field), DECL_ALIGN (curr_field))
-      && value_factor_p (DECL_SIZE (prev_field), DECL_ALIGN (curr_field)))
-    return false;
-
-  /* Fallback, return that there may be a potential gap */
-  return true;
-}
-
 /* Return a LABEL_DECL with NAME.  GNAT_NODE is used for the position of
    the decl.  */