CbC/CbC_gcc: gcc/ada/gcc-interface/utils.c comparison

comparison gcc/ada/gcc-interface/utils.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 *                                                                          *
 *                                U T I L S                                 *
 *                                                                          *
 *                          C Implementation File                           *
 *                                                                          *
-*          Copyright (C) 1992-2018, Free Software Foundation, Inc.         *
+*          Copyright (C) 1992-2019, Free Software Foundation, Inc.         *
 *                                                                          *
 * GNAT is free software;  you can  redistribute it  and/or modify it under *
 * terms of the  GNU General Public License as published  by the Free Soft- *
 * ware  Foundation;  either version 3,  or (at your option) any later ver- *
 * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
+static tree handle_stack_protect_attribute (tree *, tree, tree, int, bool *);
 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noicf_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noipa_attribute (tree *, tree, tree, int, bool *);
 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
 static tree handle_always_inline_attribute (tree *, tree, tree, int, bool *);
 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
+static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
+static tree handle_used_attribute (tree *, tree, tree, int, bool *);
+static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
+static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
+static tree handle_target_attribute (tree *, tree, tree, int, bool *);
+static tree handle_target_clones_attribute (tree *, tree, tree, int, bool *);
 static tree handle_vector_size_attribute (tree *, tree, tree, int, bool *);
 static tree handle_vector_type_attribute (tree *, tree, tree, int, bool *);
+static const struct attribute_spec::exclusions attr_cold_hot_exclusions[] =
+{
+{ "cold", true,  true,  true  },
+{ "hot" , true,  true,  true  },
+{ NULL  , false, false, false }
+};
 /* Fake handler for attributes we don't properly support, typically because
 they'd require dragging a lot of the common-c front-end circuitry.  */
 static tree fake_attribute_handler (tree *, tree, tree, int, bool *);
 handle_nonnull_attribute, NULL },
 { "sentinel",     0, 1,  false, true,  true,  false,
 handle_sentinel_attribute, NULL },
 { "noreturn",     0, 0,  true,  false, false, false,
 handle_noreturn_attribute, NULL },
+{ "stack_protect",0, 0, true,  false, false, false,
+handle_stack_protect_attribute, NULL },
 { "noinline",     0, 0,  true,  false, false, false,
 handle_noinline_attribute, NULL },
 { "noclone",      0, 0,  true,  false, false, false,
 handle_noclone_attribute, NULL },
+{ "no_icf",       0, 0,  true,  false, false, false,
+handle_noicf_attribute, NULL },
+{ "noipa",        0, 0,  true,  false, false, false,
+handle_noipa_attribute, NULL },
 { "leaf",         0, 0,  true,  false, false, false,
 handle_leaf_attribute, NULL },
 { "always_inline",0, 0,  true,  false, false, false,
 handle_always_inline_attribute, NULL },
 { "malloc",       0, 0,  true,  false, false, false,
 handle_malloc_attribute, NULL },
-{ "type generic", 0, 0,  false, true, true, false,
+{ "type generic", 0, 0,  false, true,  true,  false,
 handle_type_generic_attribute, NULL },
-{ "vector_size",  1, 1,  false, true, false,  false,
+{ "flatten",      0, 0,  true,  false, false, false,
+handle_flatten_attribute, NULL },
+{ "used",         0, 0,  true,  false, false, false,
+handle_used_attribute, NULL },
+{ "cold",         0, 0,  true,  false, false, false,
+handle_cold_attribute, attr_cold_hot_exclusions },
+{ "hot",          0, 0,  true,  false, false, false,
+handle_hot_attribute, attr_cold_hot_exclusions },
+{ "target",       1, -1, true,  false, false, false,
+handle_target_attribute, NULL },
+{ "target_clones",1, -1, true,  false, false, false,
+handle_target_clones_attribute, NULL },
+{ "vector_size",  1, 1,  false, true,  false, false,
 handle_vector_size_attribute, NULL },
-{ "vector_type",  0, 0,  false, true, false,  false,
+{ "vector_type",  0, 0,  false, true,  false, false,
 handle_vector_type_attribute, NULL },
-{ "may_alias",    0, 0, false, true, false, false, NULL, NULL },
+{ "may_alias",    0, 0,  false, true,  false, false,
+NULL, NULL },
 /* ??? format and format_arg are heavy and not supported, which actually
 prevents support for stdio builtins, which we however declare as part
 of the common builtins.def contents.  */
-{ "format",     3, 3,  false, true,  true,  false, fake_attribute_handler,
+{ "format",       3, 3,  false, true,  true,  false,
-NULL },
+fake_attribute_handler, NULL },
-{ "format_arg", 1, 1,  false, true,  true,  false, fake_attribute_handler,
+{ "format_arg",   1, 1,  false, true,  true,  false,
-NULL },
+fake_attribute_handler, NULL },
-{ NULL,         0, 0, false, false, false, false, NULL, NULL }
+{ NULL,           0, 0,  false, false, false, false,
+NULL, NULL }
 };
 /* Associates a GNAT tree node to a GCC tree node. It is used in
 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
 of `save_gnu_tree' for more info.  */
 static tree compute_related_constant (tree, tree);
 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.  */
 struct deferred_decl_context_node
 {
 create_type_decl (name, record_type, true, false, gnat_node);
 return record_type;
 }
+/* TYPE is an ARRAY_TYPE that is being used as the type of a field in a packed
+record.  See if we can rewrite it as a type that has non-BLKmode, which we
+can pack tighter in the packed record.  If so, return the new type; if not,
+return the original type.  */
+static tree
+make_packable_array_type (tree type)
+{
+const unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE (type));
+unsigned HOST_WIDE_INT new_size;
+unsigned int new_align;
+/* No point in doing anything if the size is either zero or too large for an
+integral mode, or if the type already has non-BLKmode.  */
+if (size == 0 || size > MAX_FIXED_MODE_SIZE || TYPE_MODE (type) != BLKmode)
+return type;
+/* Punt if the component type is an aggregate type for now.  */
+if (AGGREGATE_TYPE_P (TREE_TYPE (type)))
+return type;
+tree new_type = copy_type (type);
+new_size = ceil_pow2 (size);
+new_align = MIN (new_size, BIGGEST_ALIGNMENT);
+SET_TYPE_ALIGN (new_type, new_align);
+TYPE_SIZE (new_type) = bitsize_int (new_size);
+TYPE_SIZE_UNIT (new_type) = size_int (new_size / BITS_PER_UNIT);
+SET_TYPE_MODE (new_type, mode_for_size (new_size, MODE_INT, 1).else_blk ());
+return new_type;
+}
 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
-as the field type of a packed record if IN_RECORD is true, or as the
+as the type of a field in a packed record if IN_RECORD is true, or as
-component type of a packed array if IN_RECORD is false.  See if we can
+the component type of a packed array if IN_RECORD is false.  See if we
-rewrite it either as a type that has non-BLKmode, which we can pack
+can rewrite it either as a type that has non-BLKmode, which we can pack
 tighter in the packed record case, or as a smaller type with at most
 MAX_ALIGN alignment if the value is non-zero.  If so, return the new
 type; if not, return the original type.  */
 tree
 make_packable_type (tree type, bool in_record, unsigned int max_align)
 {
-unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE (type));
+const unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE (type));
+const unsigned int align = TYPE_ALIGN (type);
 unsigned HOST_WIDE_INT new_size;
-unsigned int align = TYPE_ALIGN (type);
 unsigned int new_align;
 /* No point in doing anything if the size is zero.  */
 if (size == 0)
 return type;
 /* Copy the name and flags from the old type to that of the new.
 Note that we rely on the pointer equality created here for
 TYPE_NAME to look through conversions in various places.  */
 TYPE_NAME (new_type) = TYPE_NAME (type);
+TYPE_PACKED (new_type) = 1;
 TYPE_JUSTIFIED_MODULAR_P (new_type) = TYPE_JUSTIFIED_MODULAR_P (type);
 TYPE_CONTAINS_TEMPLATE_P (new_type) = TYPE_CONTAINS_TEMPLATE_P (type);
 TYPE_REVERSE_STORAGE_ORDER (new_type) = TYPE_REVERSE_STORAGE_ORDER (type);
 if (TREE_CODE (type) == RECORD_TYPE)
 TYPE_PADDING_P (new_type) = TYPE_PADDING_P (type);
 to change the layout by propagating the packedness downwards.  */
 tree new_field_list = NULL_TREE;
 for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 {
 tree new_field_type = TREE_TYPE (field);
-tree new_field, new_size;
+tree new_field, new_field_size;
-if (RECORD_OR_UNION_TYPE_P (new_field_type)
+if (AGGREGATE_TYPE_P (new_field_type)
-	  && !TYPE_FAT_POINTER_P (new_field_type)
 	  && tree_fits_uhwi_p (TYPE_SIZE (new_field_type)))
-	new_field_type = make_packable_type (new_field_type, true, max_align);
+	{
+	  if (RECORD_OR_UNION_TYPE_P (new_field_type)
+	      && !TYPE_FAT_POINTER_P (new_field_type))
+	    new_field_type
+	      = make_packable_type (new_field_type, true, max_align);
+	  else if (in_record
+		   && max_align > 0
+		   && max_align < BITS_PER_UNIT
+		   && TREE_CODE (new_field_type) == ARRAY_TYPE)
+	    new_field_type = make_packable_array_type (new_field_type);
+	}
 /* However, for the last field in a not already packed record type
 	 that is of an aggregate type, we need to use the RM size in the
 	 packable version of the record type, see finish_record_type.  */
 if (!DECL_CHAIN (field)
 	  && !TYPE_PACKED (type)
 	  && RECORD_OR_UNION_TYPE_P (new_field_type)
 	  && !TYPE_FAT_POINTER_P (new_field_type)
 	  && !TYPE_CONTAINS_TEMPLATE_P (new_field_type)
 	  && TYPE_ADA_SIZE (new_field_type))
-	new_size = TYPE_ADA_SIZE (new_field_type);
+	new_field_size = TYPE_ADA_SIZE (new_field_type);
 else
-	new_size = DECL_SIZE (field);
+	new_field_size = DECL_SIZE (field);
+/* This is a layout with full representation, alignment and size clauses
+	 so we simply pass 0 as PACKED like gnat_to_gnu_field in this case.  */
 new_field
 	= create_field_decl (DECL_NAME (field), new_field_type, new_type,
-			     new_size, bit_position (field),
+			     new_field_size, bit_position (field), 0,
-			     TYPE_PACKED (type),
 			     !DECL_NONADDRESSABLE_P (field));
 DECL_INTERNAL_P (new_field) = DECL_INTERNAL_P (field);
 SET_DECL_ORIGINAL_FIELD_TO_FIELD (new_field, field);
 if (TREE_CODE (new_type) == QUAL_UNION_TYPE)
 ??? This might not always be a win when done for a stand-alone object:
 since the nominal and the effective type of the object will now have
 different modes, a VIEW_CONVERT_EXPR will be required for converting
 between them and it might be hard to overcome afterwards, including
 at the RTL level when the stand-alone object is accessed as a whole.  */
-if (align != 0
+if (align > 0
 && RECORD_OR_UNION_TYPE_P (type)
 && TYPE_MODE (type) == BLKmode
 && !TYPE_BY_REFERENCE_P (type)
 && TREE_CODE (orig_size) == INTEGER_CST
 && !TREE_OVERFLOW (orig_size)
 && compare_tree_int (orig_size, MAX_FIXED_MODE_SIZE) <= 0
 && (!size
 	  || (TREE_CODE (size) == INTEGER_CST
 	      && compare_tree_int (size, MAX_FIXED_MODE_SIZE) <= 0)))
 {
-tree packable_type = make_packable_type (type, true);
+tree packable_type = make_packable_type (type, true, align);
 if (TYPE_MODE (packable_type) != BLKmode
 	  && align >= TYPE_ALIGN (packable_type))
 type = packable_type;
 }
 /* Generate message only for entities that come from source, since
 	 if we have an entity created by expansion, the message will be
 	 generated for some other corresponding source entity.  */
 if (Comes_From_Source (gnat_entity))
 	{
-	  if (Present (gnat_error_node))
+	  if (is_component_type)
+	    post_error_ne_tree ("component of& padded{ by ^ bits}?",
+				gnat_entity, gnat_entity,
+				size_diffop (size, orig_size));
+	  else if (Present (gnat_error_node))
 	    post_error_ne_tree ("{^ }bits of & unused?",
 				gnat_error_node, gnat_entity,
-				size_diffop (size, orig_size));
-	  else if (is_component_type)
-	    post_error_ne_tree ("component of& padded{ by ^ bits}?",
-				gnat_entity, gnat_entity,
 				size_diffop (size, orig_size));
 	}
 }
 return record;
 void
 finish_record_type (tree record_type, tree field_list, int rep_level,
 		    bool debug_info_p)
 {
-enum tree_code code = TREE_CODE (record_type);
+const enum tree_code orig_code = TREE_CODE (record_type);
+const bool had_size = TYPE_SIZE (record_type) != NULL_TREE;
+const bool had_size_unit = TYPE_SIZE_UNIT (record_type) != NULL_TREE;
+const bool had_align = TYPE_ALIGN (record_type) > 0;
+/* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
+out just like a UNION_TYPE, since the size will be fixed.  */
+const enum tree_code code
+= (orig_code == QUAL_UNION_TYPE && rep_level > 0 && had_size
+? UNION_TYPE : orig_code);
 tree name = TYPE_IDENTIFIER (record_type);
 tree ada_size = bitsize_zero_node;
 tree size = bitsize_zero_node;
-bool had_size = TYPE_SIZE (record_type) != 0;
-bool had_size_unit = TYPE_SIZE_UNIT (record_type) != 0;
-bool had_align = TYPE_ALIGN (record_type) != 0;
 tree field;
 TYPE_FIELDS (record_type) = field_list;
 /* Always attach the TYPE_STUB_DECL for a record type.  It is required to
 /* Globally initialize the record first.  If this is a rep'ed record,
 that just means some initializations; otherwise, layout the record.  */
 if (rep_level > 0)
 {
-SET_TYPE_ALIGN (record_type, MAX (BITS_PER_UNIT,
+if (TYPE_ALIGN (record_type) < BITS_PER_UNIT)
-					TYPE_ALIGN (record_type)));
+	SET_TYPE_ALIGN (record_type, BITS_PER_UNIT);
+if (!had_size)
+	TYPE_SIZE (record_type) = bitsize_zero_node;
 if (!had_size_unit)
 	TYPE_SIZE_UNIT (record_type) = size_zero_node;
-if (!had_size)
-	TYPE_SIZE (record_type) = bitsize_zero_node;
-/* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
-	 out just like a UNION_TYPE, since the size will be fixed.  */
-else if (code == QUAL_UNION_TYPE)
-	code = UNION_TYPE;
 }
 else
 {
 /* Ensure there isn't a size already set.  There can be in an error
 	 case where there is a rep clause but all fields have errors and
 	 no longer have a position.  */
-TYPE_SIZE (record_type) = 0;
+TYPE_SIZE (record_type) = NULL_TREE;
 /* Ensure we use the traditional GCC layout for bitfields when we need
 	 to pack the record type or have a representation clause.  The other
 	 possible layout (Microsoft C compiler), if available, would prevent
 	 efficient packing in almost all cases.  */
 	  && TYPE_ADA_SIZE (type))
 	this_ada_size = TYPE_ADA_SIZE (type);
 else
 	this_ada_size = this_size;
+const bool variant_part = (TREE_CODE (type) == QUAL_UNION_TYPE);
+const bool variant_part_at_zero = variant_part && integer_zerop (pos);
 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle.  */
 if (DECL_BIT_FIELD (field)
 	  && operand_equal_p (this_size, TYPE_SIZE (type), 0))
 	{
-	  unsigned int align = TYPE_ALIGN (type);
+	  const unsigned int align = TYPE_ALIGN (type);
 	  /* In the general case, type alignment is required.  */
 	  if (value_factor_p (pos, align))
 	    {
 	      /* The enclosing record type must be sufficiently aligned.
 	      && DECL_BIT_FIELD (field)
 	      && value_factor_p (pos, BITS_PER_UNIT))
 	    DECL_BIT_FIELD (field) = 0;
 	}
+/* Clear DECL_BIT_FIELD_TYPE for a variant part at offset 0, it's simply
+	 not supported by the DECL_BIT_FIELD_REPRESENTATIVE machinery because
+	 the variant part is always the last field in the list.  */
+if (variant_part_at_zero)
+	DECL_BIT_FIELD_TYPE (field) = NULL_TREE;
 /* If we still have DECL_BIT_FIELD set at this point, we know that the
 	 field is technically not addressable.  Except that it can actually
 	 be addressed if it is BLKmode and happens to be properly aligned.  */
 if (DECL_BIT_FIELD (field)
 	  && !(DECL_MODE (field) == BLKmode
 	  break;
 	case RECORD_TYPE:
 	  /* Since we know here that all fields are sorted in order of
 	     increasing bit position, the size of the record is one
-	     higher than the ending bit of the last field processed
+	     higher than the ending bit of the last field processed,
-	     unless we have a rep clause, since in that case we might
+	     unless we have a variant part at offset 0, since in this
-	     have a field outside a QUAL_UNION_TYPE that has a higher ending
+	     case we might have a field outside the variant part that
-	     position.  So use a MAX in that case.  Also, if this field is a
+	     has a higher ending position; so use a MAX in this case.
-	     QUAL_UNION_TYPE, we need to take into account the previous size in
+	     Also, if this field is a QUAL_UNION_TYPE, we need to take
-	     the case of empty variants.  */
+	     into account the previous size in the case of empty variants.  */
 	  ada_size
-	    = merge_sizes (ada_size, pos, this_ada_size,
+	    = merge_sizes (ada_size, pos, this_ada_size, variant_part,
-			   TREE_CODE (type) == QUAL_UNION_TYPE, rep_level > 0);
+			   variant_part_at_zero);
 	  size
-	    = merge_sizes (size, pos, this_size,
+	    = merge_sizes (size, pos, this_size, variant_part,
-			   TREE_CODE (type) == QUAL_UNION_TYPE, rep_level > 0);
+			   variant_part_at_zero);
 	  break;
 	default:
 	  gcc_unreachable ();
 	}
 tree new_record_type
 	= make_node (TREE_CODE (record_type) == QUAL_UNION_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
 				  ? "XVU" : "XVE");
 TYPE_NAME (new_record_type) = new_name;
 TYPE_SIZE_UNIT (new_record_type)
 	= size_int (TYPE_ALIGN (record_type) / BITS_PER_UNIT);
 /* 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);
 	  tree field_name = DECL_NAME (old_field);
 	  tree curpos = fold_bit_position (old_field);
 	  if (TREE_CODE (new_record_type) == UNION_TYPE)
 	    pos = bitsize_zero_node;
 	  else
 	    pos = compute_related_constant (curpos, last_pos);
-	  if (!pos
+	  if (pos)
-	      && TREE_CODE (curpos) == MULT_EXPR
+	    ;
-	      && tree_fits_uhwi_p (TREE_OPERAND (curpos, 1)))
+	  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));
 	      align = scale_by_factor_of (offset, align);
 	      last_pos = round_up (last_pos, align);
 	      pos = compute_related_constant (curpos, last_pos);
 	    }
-	  else if (!pos
+	  else if (TREE_CODE (curpos) == PLUS_EXPR
-		   && 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
 		      (TREE_OPERAND (TREE_OPERAND (curpos, 0), 1)))
 	    {
 	      align = scale_by_factor_of (offset, align);
 	      align = MIN (align, addend & -addend);
 	      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);
 	    }
-	  /* If we can't compute a position, set it to zero.
-	     ??? We really should abort here, but it's too much work
-	     to get this correct for all cases.  */
-	  if (!pos)
-	    pos = bitsize_zero_node;
 	  /* See if this type is variable-sized and make a pointer type
 	     and indicate the indirection if so.  Beware that the debug
 	     back-end may adjust the position computed above according
 	     to the alignment of the field type, i.e. the pointer 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);
+	      field_type = copy_type (build_pointer_type (field_type));
-	      if (align != 0 && TYPE_ALIGN (field_type) > align)
+	      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);
+		  align = DECL_ALIGN (old_field);
-		  SET_TYPE_ALIGN (field_type, align);
+		  last_pos = round_up (last_pos, align);
+		  pos = compute_related_constant (curpos, last_pos);
 		}
-	      var = true;
 	    }
+	  /* If we can't compute a position, set it to zero.
+	     ??? We really should abort here, but it's too much work
+	     to get this correct for all cases.  */
+	  if (!pos)
+	    pos = bitsize_zero_node;
 	  /* Make a new field name, if necessary.  */
 	  if (var || align != 0)
 	    {
 	      char suffix[16];
 	    }
 	  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;
 	  /* If old_field is a QUAL_UNION_TYPE, take its size as being
 	     zero.  The only time it's not the last field of the record
 	  last_pos = size_binop (PLUS_EXPR, curpos,
 				 (TREE_CODE (TREE_TYPE (old_field))
 				  == 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));
 add_parallel_type (record_type, new_record_type);
 }
 /* Utility function of above to merge LAST_SIZE, the previous size of a record
 with FIRST_BIT and SIZE that describe a field.  SPECIAL is true if this
 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
-replace a value of zero with the old size.  If HAS_REP is true, we take the
+replace a value of zero with the old size.  If MAX is true, we take the
 MAX of the end position of this field with LAST_SIZE.  In all other cases,
 we use FIRST_BIT plus SIZE.  Return an expression for the size.  */
 static tree
-merge_sizes (tree last_size, tree first_bit, tree size, bool special,
+merge_sizes (tree last_size, tree first_bit, tree size, bool special, bool max)
-	     bool has_rep)
 {
 tree type = TREE_TYPE (last_size);
 tree new_size;
 if (!special || TREE_CODE (size) != COND_EXPR)
 {
 new_size = size_binop (PLUS_EXPR, first_bit, size);
-if (has_rep)
+if (max)
 	new_size = size_binop (MAX_EXPR, last_size, new_size);
 }
 else
 new_size = fold_build3 (COND_EXPR, type, TREE_OPERAND (size, 0),
 			    integer_zerop (TREE_OPERAND (size, 1))
 			    ? last_size : merge_sizes (last_size, first_bit,
 						       TREE_OPERAND (size, 1),
-						       1, has_rep),
+						       1, max),
 			    integer_zerop (TREE_OPERAND (size, 2))
 			    ? last_size : merge_sizes (last_size, first_bit,
 						       TREE_OPERAND (size, 2),
-						       1, has_rep));
+						       1, max));
 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
-when fed through substitute_in_expr) into thinking that a constant
+when fed through SUBSTITUTE_IN_EXPR) into thinking that a constant
 size is not constant.  */
 while (TREE_CODE (new_size) == NON_LVALUE_EXPR)
 new_size = TREE_OPERAND (new_size, 0);
 return new_size;
 }
+/* Convert the size expression EXPR to TYPE and fold the result.  */
+static tree
+fold_convert_size (tree type, tree expr)
+{
+/* We assume that size expressions do not wrap around.  */
+if (TREE_CODE (expr) == MULT_EXPR || TREE_CODE (expr) == PLUS_EXPR)
+return size_binop (TREE_CODE (expr),
+		       fold_convert_size (type, TREE_OPERAND (expr, 0)),
+		       fold_convert_size (type, TREE_OPERAND (expr, 1)));
+return fold_convert (type, expr);
+}
 /* Return the bit position of FIELD, in bits from the start of the record,
 and fold it as much as possible.  This is a tree of type bitsizetype.  */
 static tree
 fold_bit_position (const_tree field)
 {
-tree offset = DECL_FIELD_OFFSET (field);
+tree offset = fold_convert_size (bitsizetype, DECL_FIELD_OFFSET (field));
-if (TREE_CODE (offset) == MULT_EXPR || TREE_CODE (offset) == PLUS_EXPR)
-offset = size_binop (TREE_CODE (offset),
-			 fold_convert (bitsizetype, TREE_OPERAND (offset, 0)),
-			 fold_convert (bitsizetype, TREE_OPERAND (offset, 1)));
-else
-offset = fold_convert (bitsizetype, offset);
 return size_binop (PLUS_EXPR, DECL_FIELD_BIT_OFFSET (field),
 		     size_binop (MULT_EXPR, offset, bitsize_unit_node));
 }
 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
 /* Then set the actual range.  */
 SET_TYPE_RM_MIN_VALUE (range_type, min);
 SET_TYPE_RM_MAX_VALUE (range_type, max);
 return range_type;
+}
+/* Return an extra subtype of TYPE with range MIN to MAX.  */
+tree
+create_extra_subtype (tree type, tree min, tree max)
+{
+const bool uns = TYPE_UNSIGNED (type);
+const unsigned prec = TYPE_PRECISION (type);
+tree subtype = uns ? make_unsigned_type (prec) : make_signed_type (prec);
+TREE_TYPE (subtype) = type;
+TYPE_EXTRA_SUBTYPE_P (subtype) = 1;
+SET_TYPE_RM_MIN_VALUE (subtype, min);
+SET_TYPE_RM_MAX_VALUE (subtype, max);
+return subtype;
 }
 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of TYPE.
 NAME gives the name of the type to be used in the declaration.  */
 && TREE_CODE (var_decl) == VAR_DECL
 && TREE_PUBLIC (var_decl)
 && !have_global_bss_p ())
 DECL_COMMON (var_decl) = 1;
-/* Do not emit debug info for a CONST_DECL if optimization isn't enabled,
+/* Do not emit debug info if not requested, or for an external constant whose
-since we will create an associated variable.  Likewise for an external
+initializer is not absolute because this would require a global relocation
-constant whose initializer is not absolute, because this would mean a
+in a read-only section which runs afoul of the PE-COFF run-time relocation
-global relocation in a read-only section which runs afoul of the PE-COFF
+mechanism.  */
-run-time relocation mechanism.  */
 if (!debug_info_p
-|| (TREE_CODE (var_decl) == CONST_DECL && !optimize)
 || (extern_flag
 	  && constant_p
 	  && init
 	  && initializer_constant_valid_p (init, TREE_TYPE (init))
 	     != null_pointer_node))
 }
 return var_decl;
 }
-/* Return true if TYPE, an aggregate type, contains (or is) an array.  */
+/* Return true if TYPE, an aggregate type, contains (or is) an array.
+If SELF_REFERENTIAL is true, then an additional requirement on the
-static bool
+array is that it be self-referential.  */
-aggregate_type_contains_array_p (tree type)
+bool
+aggregate_type_contains_array_p (tree type, bool self_referential)
 {
 switch (TREE_CODE (type))
 {
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 {
 	tree field;
 	for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 	  if (AGGREGATE_TYPE_P (TREE_TYPE (field))
-	      && aggregate_type_contains_array_p (TREE_TYPE (field)))
+	      && aggregate_type_contains_array_p (TREE_TYPE (field),
+						  self_referential))
 	    return true;
 	return false;
 }
 case ARRAY_TYPE:
-return true;
+return self_referential ? type_contains_placeholder_p (type) : true;
 default:
 gcc_unreachable ();
 }
 }
 {
 tree field_decl = build_decl (input_location, FIELD_DECL, name, type);
 DECL_CONTEXT (field_decl) = record_type;
 TREE_READONLY (field_decl) = TYPE_READONLY (type);
+/* If a size is specified, use it.  Otherwise, if the record type is packed
+compute a size to use, which may differ from the object's natural size.
+We always set a size in this case to trigger the checks for bitfield
+creation below, which is typically required when no position has been
+specified.  */
+if (size)
+size = convert (bitsizetype, size);
+else if (packed == 1)
+{
+size = rm_size (type);
+if (TYPE_MODE (type) == BLKmode)
+	size = round_up (size, BITS_PER_UNIT);
+}
+/* If we may, according to ADDRESSABLE, then make a bitfield when the size
+is specified for two reasons: first, when it differs from the natural
+size; second, when the alignment is insufficient.
+We never make a bitfield if the type of the field has a nonconstant size,
+because no such entity requiring bitfield operations should reach here.
+We do *preventively* make a bitfield when there might be the need for it
+but we don't have all the necessary information to decide, as is the case
+of a field in a packed record.
+We also don't look at STRICT_ALIGNMENT here, and rely on later processing
+in layout_decl or finish_record_type to clear the bit_field indication if
+it is in fact not needed.  */
+if (addressable >= 0
+&& size
+&& TREE_CODE (size) == INTEGER_CST
+&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
+&& (packed
+	  || !tree_int_cst_equal (size, TYPE_SIZE (type))
+	  || (pos && !value_factor_p (pos, TYPE_ALIGN (type)))
+	  || (TYPE_ALIGN (record_type)
+	      && TYPE_ALIGN (record_type) < TYPE_ALIGN (type))))
+{
+DECL_BIT_FIELD (field_decl) = 1;
+DECL_SIZE (field_decl) = size;
+if (!packed && !pos)
+	{
+	  if (TYPE_ALIGN (record_type)
+	      && TYPE_ALIGN (record_type) < TYPE_ALIGN (type))
+	    SET_DECL_ALIGN (field_decl, TYPE_ALIGN (record_type));
+	  else
+	    SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type));
+	}
+}
+DECL_PACKED (field_decl) = pos ? DECL_BIT_FIELD (field_decl) : packed;
 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
 Likewise for an aggregate without specified position that contains an
 array, because in this case slices of variable length of this array
 must be handled by GCC and variable-sized objects need to be aligned
 to at least a byte boundary.  */
 if (packed && (TYPE_MODE (type) == BLKmode
 		 || (!pos
 		     && AGGREGATE_TYPE_P (type)
-		     && aggregate_type_contains_array_p (type))))
+		     && aggregate_type_contains_array_p (type, false))))
 SET_DECL_ALIGN (field_decl, BITS_PER_UNIT);
-/* If a size is specified, use it.  Otherwise, if the record type is packed
-compute a size to use, which may differ from the object's natural size.
-We always set a size in this case to trigger the checks for bitfield
-creation below, which is typically required when no position has been
-specified.  */
-if (size)
-size = convert (bitsizetype, size);
-else if (packed == 1)
-{
-size = rm_size (type);
-if (TYPE_MODE (type) == BLKmode)
-	size = round_up (size, BITS_PER_UNIT);
-}
-/* If we may, according to ADDRESSABLE, make a bitfield if a size is
-specified for two reasons: first if the size differs from the natural
-size.  Second, if the alignment is insufficient.  There are a number of
-ways the latter can be true.
-We never make a bitfield if the type of the field has a nonconstant size,
-because no such entity requiring bitfield operations should reach here.
-We do *preventively* make a bitfield when there might be the need for it
-but we don't have all the necessary information to decide, as is the case
-of a field with no specified position in a packed record.
-We also don't look at STRICT_ALIGNMENT here, and rely on later processing
-in layout_decl or finish_record_type to clear the bit_field indication if
-it is in fact not needed.  */
-if (addressable >= 0
-&& size
-&& TREE_CODE (size) == INTEGER_CST
-&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-&& (!tree_int_cst_equal (size, TYPE_SIZE (type))
-	  || (pos && !value_factor_p (pos, TYPE_ALIGN (type)))
-	  || packed
-	  || (TYPE_ALIGN (record_type) != 0
-	      && TYPE_ALIGN (record_type) < TYPE_ALIGN (type))))
-{
-DECL_BIT_FIELD (field_decl) = 1;
-DECL_SIZE (field_decl) = size;
-if (!packed && !pos)
-	{
-	  if (TYPE_ALIGN (record_type) != 0
-	      && TYPE_ALIGN (record_type) < TYPE_ALIGN (type))
-	    SET_DECL_ALIGN (field_decl, TYPE_ALIGN (record_type));
-	  else
-	    SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type));
-	}
-}
-DECL_PACKED (field_decl) = pos ? DECL_BIT_FIELD (field_decl) : packed;
 /* Bump the alignment if need be, either for bitfield/packing purposes or
-to satisfy the type requirements if no such consideration applies.  When
+to satisfy the type requirements if no such considerations apply.  When
 we get the alignment from the type, indicate if this is from an explicit
 user request, which prevents stor-layout from lowering it later on.  */
-{
+else
-unsigned int bit_align
+{
-= (DECL_BIT_FIELD (field_decl) ? 1
+const unsigned int field_align
-	 : packed && TYPE_MODE (type) != BLKmode ? BITS_PER_UNIT : 0);
+	= DECL_BIT_FIELD (field_decl)
+	  ? 1
-if (bit_align > DECL_ALIGN (field_decl))
+	  : packed
-SET_DECL_ALIGN (field_decl, bit_align);
+	    ? BITS_PER_UNIT
-else if (!bit_align && TYPE_ALIGN (type) > DECL_ALIGN (field_decl))
+	    : 0;
-{
-	SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type));
+if (field_align > DECL_ALIGN (field_decl))
-	DECL_USER_ALIGN (field_decl) = TYPE_USER_ALIGN (type);
+	SET_DECL_ALIGN (field_decl, field_align);
-}
+else if (!field_align && TYPE_ALIGN (type) > DECL_ALIGN (field_decl))
-}
+	{
+	  SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type));
+	  DECL_USER_ALIGN (field_decl) = TYPE_USER_ALIGN (type);
+	}
+}
 if (pos)
 {
 /* We need to pass in the alignment the DECL is known to have.
 	 This is the lowest-order bit set in POS, but no more than
 	  && (known_align == 0 || known_align > TYPE_ALIGN (record_type)))
 	known_align = TYPE_ALIGN (record_type);
 layout_decl (field_decl, known_align);
 SET_DECL_OFFSET_ALIGN (field_decl,
-			     tree_fits_uhwi_p (pos) ? BIGGEST_ALIGNMENT
+			     tree_fits_uhwi_p (pos)
-			     : BITS_PER_UNIT);
+			     ? BIGGEST_ALIGNMENT : BITS_PER_UNIT);
 pos_from_bit (&DECL_FIELD_OFFSET (field_decl),
 		    &DECL_FIELD_BIT_OFFSET (field_decl),
 		    DECL_OFFSET_ALIGN (field_decl), pos);
 }
 value we have at this point is not accurate enough, so we don't account
 for this here and let finish_record_type decide.  */
 if (!addressable && !type_for_nonaliased_component_p (type))
 addressable = 1;
+/* Note that there is a trade-off in making a field nonaddressable because
+this will cause type-based alias analysis to use the same alias set for
+accesses to the field as for accesses to the whole record: while doing
+so will make it more likely to disambiguate accesses to other objects
+and accesses to the field, it will make it less likely to disambiguate
+accesses to the other fields of the record and accesses to the field.
+If the record is fully static, then the trade-off is irrelevant since
+the fields of the record can always be disambiguated by their offsets
+but, if the record is dynamic, then it can become problematic.  */
 DECL_NONADDRESSABLE_P (field_decl) = !addressable;
 return field_decl;
 }
 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
 a power of 2. */
 bool
-value_factor_p (tree value, HOST_WIDE_INT factor)
+value_factor_p (tree value, unsigned HOST_WIDE_INT factor)
 {
+gcc_checking_assert (pow2p_hwi (factor));
 if (tree_fits_uhwi_p (value))
-return tree_to_uhwi (value) % factor == 0;
+return (tree_to_uhwi (value) & (factor - 1)) == 0;
 if (TREE_CODE (value) == MULT_EXPR)
 return (value_factor_p (TREE_OPERAND (value, 0), factor)
 || value_factor_p (TREE_OPERAND (value, 1), factor));
 factor = 1;
 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.  */
 tree
 create_label_decl (tree name, Node_Id gnat_node)
 tree subprog_decl = build_decl (input_location, FUNCTION_DECL, name, type);
 DECL_ARGUMENTS (subprog_decl) = param_decl_list;
 DECL_ARTIFICIAL (subprog_decl) = artificial_p;
 DECL_EXTERNAL (subprog_decl) = extern_flag;
+DECL_FUNCTION_IS_DEF (subprog_decl) = definition;
+DECL_IGNORED_P (subprog_decl) = !debug_info_p;
 TREE_PUBLIC (subprog_decl) = public_flag;
-if (!debug_info_p)
-DECL_IGNORED_P (subprog_decl) = 1;
-if (definition)
-DECL_FUNCTION_IS_DEF (subprog_decl) = 1;
 switch (inline_status)
 {
 case is_suppressed:
 DECL_UNINLINABLE (subprog_decl) = 1;
 break;
-case is_disabled:
+case is_default:
 break;
 case is_required:
 if (Back_End_Inlining)
 	{
 	  TREE_PUBLIC (subprog_decl) = 0;
 	}
 /* ... fall through ... */
-case is_enabled:
+case is_prescribed:
+DECL_DISREGARD_INLINE_LIMITS (subprog_decl) = 1;
+/* ... fall through ... */
+case is_requested:
 DECL_DECLARED_INLINE_P (subprog_decl) = 1;
-DECL_NO_INLINE_WARNING_P (subprog_decl) = artificial_p;
+if (!Debug_Generated_Code)
+	DECL_NO_INLINE_WARNING_P (subprog_decl) = artificial_p;
 break;
 default:
 gcc_unreachable ();
 }
 gnat_pushlevel ();
 for (param_decl = DECL_ARGUMENTS (subprog_decl); param_decl;
 param_decl = DECL_CHAIN (param_decl))
 DECL_CONTEXT (param_decl) = subprog_decl;
-make_decl_rtl (subprog_decl);
 }
 /* Finish translating the current subprogram and set its BODY.  */
 void
 	 && TREE_ADDRESSABLE (t) == return_by_invisi_ref_p;
 }
 /* EXP is an expression for the size of an object.  If this size contains
 discriminant references, replace them with the maximum (if MAX_P) or
-minimum (if !MAX_P) possible value of the discriminant.  */
+minimum (if !MAX_P) possible value of the discriminant.
+Note that the expression may have already been gimplified,in which case
+COND_EXPRs have VOID_TYPE and no operands, and this must be handled.  */
 tree
 max_size (tree exp, bool max_p)
 {
 enum tree_code code = TREE_CODE (exp);
 case tcc_reference:
 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
 	 modify.  Otherwise, we treat it like a variable.  */
 if (CONTAINS_PLACEHOLDER_P (exp))
 	{
-	  tree val_type = TREE_TYPE (TREE_OPERAND (exp, 1));
+	  tree base_type = get_base_type (TREE_TYPE (TREE_OPERAND (exp, 1)));
-	  tree val = (max_p ? TYPE_MAX_VALUE (type) : TYPE_MIN_VALUE (type));
+	  tree val
-	  return
+	    = fold_convert (base_type,
-	    convert (type,
+			    max_p
-		     max_size (convert (get_base_type (val_type), val), true));
+			    ? TYPE_MAX_VALUE (type) : TYPE_MIN_VALUE (type));
+	  /* Walk down the extra subtypes to get more restrictive bounds.  */
+	  while (TYPE_IS_EXTRA_SUBTYPE_P (type))
+	    {
+	      type = TREE_TYPE (type);
+	      if (max_p)
+		val = fold_build2 (MIN_EXPR, base_type, val,
+				   fold_convert (base_type,
+						 TYPE_MAX_VALUE (type)));
+	      else
+		val = fold_build2 (MAX_EXPR, base_type, val,
+				   fold_convert (base_type,
+						 TYPE_MIN_VALUE (type)));
+	    }
+	  return fold_convert (type, max_size (val, max_p));
 	}
 return exp;
 case tcc_comparison:
 return build_int_cst (type, max_p ? 1 : 0);
 case tcc_unary:
+op0 = TREE_OPERAND (exp, 0);
 if (code == NON_LVALUE_EXPR)
-	return max_size (TREE_OPERAND (exp, 0), max_p);
+	return max_size (op0, max_p);
-op0 = max_size (TREE_OPERAND (exp, 0),
+if (VOID_TYPE_P (TREE_TYPE (op0)))
-		      code == NEGATE_EXPR ? !max_p : max_p);
+	return max_p ? TYPE_MAX_VALUE (type) : TYPE_MIN_VALUE (type);
+op0 = max_size (op0, code == NEGATE_EXPR ? !max_p : max_p);
 if (op0 == TREE_OPERAND (exp, 0))
 	return exp;
 return fold_build1 (code, type, op0);
 case tcc_binary:
-{
+op0 = TREE_OPERAND (exp, 0);
-	tree lhs = max_size (TREE_OPERAND (exp, 0), max_p);
+op1 = TREE_OPERAND (exp, 1);
-	tree rhs = max_size (TREE_OPERAND (exp, 1),
-			     code == MINUS_EXPR ? !max_p : max_p);
+/* If we have a multiply-add with a "negative" value in an unsigned
+	 type, do a multiply-subtract with the negated value, in order to
-	/* Special-case wanting the maximum value of a MIN_EXPR.
+	 avoid creating a spurious overflow below.  */
-	   In that case, if one side overflows, return the other.  */
+if (code == PLUS_EXPR
-	if (max_p && code == MIN_EXPR)
+	  && TREE_CODE (op0) == MULT_EXPR
-	  {
+	  && TYPE_UNSIGNED (type)
-	    if (TREE_CODE (rhs) == INTEGER_CST && TREE_OVERFLOW (rhs))
+	  && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST
-	      return lhs;
+	  && !TREE_OVERFLOW (TREE_OPERAND (op0, 1))
+	  && tree_int_cst_sign_bit (TREE_OPERAND (op0, 1)))
-	    if (TREE_CODE (lhs) == INTEGER_CST && TREE_OVERFLOW (lhs))
+	{
-	      return rhs;
+	  tree tmp = op1;
-	  }
+	  op1 = build2 (MULT_EXPR, type, TREE_OPERAND (op0, 0),
+			fold_build1 (NEGATE_EXPR, type,
-	/* Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
+				    TREE_OPERAND (op0, 1)));
-	   overflowing and the RHS a variable.  */
+	  op0 = tmp;
-	if ((code == MINUS_EXPR || code == PLUS_EXPR)
+	  code = MINUS_EXPR;
-	    && TREE_CODE (lhs) == INTEGER_CST
+	}
-	    && TREE_OVERFLOW (lhs)
-	    && TREE_CODE (rhs) != INTEGER_CST)
+op0 = max_size (op0, max_p);
-	  return lhs;
+op1 = max_size (op1, code == MINUS_EXPR ? !max_p : max_p);
-	/* If we are going to subtract a "negative" value in an unsigned type,
+if ((code == MINUS_EXPR || code == PLUS_EXPR))
-	   do the operation as an addition of the negated value, in order to
+	{
-	   avoid creating a spurious overflow below.  */
+	  /* If the op0 has overflowed and the op1 is a variable,
-	if (code == MINUS_EXPR
+	     propagate the overflow by returning the op0.  */
-	    && TYPE_UNSIGNED (type)
+	  if (TREE_CODE (op0) == INTEGER_CST
-	    && TREE_CODE (rhs) == INTEGER_CST
+	      && TREE_OVERFLOW (op0)
-	    && !TREE_OVERFLOW (rhs)
+	      && TREE_CODE (op1) != INTEGER_CST)
-	    && tree_int_cst_sign_bit (rhs) != 0)
+	    return op0;
-	  {
-	    rhs = fold_build1 (NEGATE_EXPR, type, rhs);
+	  /* If we have a "negative" value in an unsigned type, do the
-	    code = PLUS_EXPR;
+	     opposite operation on the negated value, in order to avoid
-	  }
+	     creating a spurious overflow below.  */
+	  if (TYPE_UNSIGNED (type)
-	if (lhs == TREE_OPERAND (exp, 0) && rhs == TREE_OPERAND (exp, 1))
+	      && TREE_CODE (op1) == INTEGER_CST
-	  return exp;
+	      && !TREE_OVERFLOW (op1)
+	      && tree_int_cst_sign_bit (op1))
-	/* We need to detect overflows so we call size_binop here.  */
+	    {
-	return size_binop (code, lhs, rhs);
+	      op1 = fold_build1 (NEGATE_EXPR, type, op1);
-}
+	      code = (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR);
+	    }
+	}
+if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
+	return exp;
+/* We need to detect overflows so we call size_binop here.  */
+return size_binop (code, op0, op1);
 case tcc_expression:
 switch (TREE_CODE_LENGTH (code))
 	{
 	case 1:
 	  return fold_build2 (code, type, op0, op1);
 	case 3:
 	  if (code == COND_EXPR)
 	    {
+	      op0 = TREE_OPERAND (exp, 0);
 	      op1 = TREE_OPERAND (exp, 1);
 	      op2 = TREE_OPERAND (exp, 2);
 	      if (!op1 || !op2)
 		return exp;
-	      return
+	      op1 = max_size (op1, max_p);
-		fold_build2 (max_p ? MAX_EXPR : MIN_EXPR, type,
+	      op2 = max_size (op2, max_p);
-			     max_size (op1, max_p), max_size (op2, max_p));
+	      /* If we have the MAX of a "negative" value in an unsigned type
+		 and zero for a length expression, just return zero.  */
+	      if (max_p
+		  && TREE_CODE (op0) == LE_EXPR
+		  && TYPE_UNSIGNED (type)
+		  && TREE_CODE (op1) == INTEGER_CST
+		  && !TREE_OVERFLOW (op1)
+		  && tree_int_cst_sign_bit (op1)
+		  && integer_zerop (op2))
+		return op2;
+	      return fold_build2 (max_p ? MAX_EXPR : MIN_EXPR, type, op1, op2);
 	    }
 	  break;
 	default:
 	  break;
 if (TREE_CODE (array_type) == ARRAY_TYPE
 || (TREE_CODE (array_type) == INTEGER_TYPE
 	  && TYPE_HAS_ACTUAL_BOUNDS_P (array_type)))
 bound_list = TYPE_ACTUAL_BOUNDS (array_type);
-/* First make the list for a CONSTRUCTOR for the template.  Go down the
+/* First make the list for a CONSTRUCTOR for the template.  Go down
-field list of the template instead of the type chain because this
+the field list of the template instead of the type chain because
-array might be an Ada array of arrays and we can't tell where the
+this array might be an Ada array of array and we can't tell where
-nested arrays stop being the underlying object.  */
+the nested array stop being the underlying object.  */
+for (field = TYPE_FIELDS (template_type);
-for (field = TYPE_FIELDS (template_type); field;
+field;
-(bound_list
-	? (bound_list = TREE_CHAIN (bound_list))
-	: (array_type = TREE_TYPE (array_type))),
 field = DECL_CHAIN (DECL_CHAIN (field)))
 {
 tree bounds, min, max;
 /* If we have a bound list, get the bounds from there.  Likewise
 	 for an ARRAY_TYPE.  Otherwise, if expr is a PARM_DECL with
-	 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
+	 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the
-	 This will give us a maximum range.  */
+	 template, but this will only give us a maximum range.  */
 if (bound_list)
-	bounds = TREE_VALUE (bound_list);
+	{
+	  bounds = TREE_VALUE (bound_list);
+	  bound_list = TREE_CHAIN (bound_list);
+	}
 else if (TREE_CODE (array_type) == ARRAY_TYPE)
-	bounds = TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type));
+	{
+	  bounds = TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type));
+	  array_type = TREE_TYPE (array_type);
+	}
 else if (expr && TREE_CODE (expr) == PARM_DECL
 	       && DECL_BY_COMPONENT_PTR_P (expr))
 	bounds = TREE_TYPE (field);
 else
 	gcc_unreachable ();
 		     == TYPE_NAME (TREE_TYPE (TYPE_FIELDS (type))))))
 	return convert (type, TREE_OPERAND (expr, 0));
 /* If the inner type is of self-referential size and the expression type
 	 is a record, do this as an unchecked conversion unless both types are
-	 essentially the same.  But first pad the expression if possible to
+	 essentially the same.  */
-	 have the same size on both sides.  */
 if (ecode == RECORD_TYPE
 	  && CONTAINS_PLACEHOLDER_P (DECL_SIZE (TYPE_FIELDS (type)))
 	  && TYPE_MAIN_VARIANT (etype)
 	     != TYPE_MAIN_VARIANT (TREE_TYPE (TYPE_FIELDS (type))))
-	{
+	return unchecked_convert (type, expr, false);
-	  if (TREE_CODE (TYPE_SIZE (etype)) == INTEGER_CST)
-	    expr = convert (maybe_pad_type (etype, TYPE_SIZE (type), 0, Empty,
-					    false, false, false, true),
-			    expr);
-	  return unchecked_convert (type, expr, false);
-	}
 /* If we are converting between array types with variable size, do the
 	 final conversion as an unchecked conversion, again to avoid the need
 	 for some variable-sized temporaries.  If valid, this conversion is
 	 very likely purely technical and without real effects.  */
 				       fold_convert (TREE_TYPE (etype), expr),
 				       convert (TREE_TYPE (etype),
 						TYPE_MIN_VALUE (etype))));
 /* If the input is a justified modular type, we need to extract the actual
-object before converting it to any other type with the exceptions of an
+object before converting it to an other type with the exceptions of an
-unconstrained array or of a mere type variant.  It is useful to avoid the
+[unconstrained] array or a mere type variant.  It is useful to avoid
-extraction and conversion in the type variant case because it could end
+the extraction and conversion in these cases because it could end up
-up replacing a VAR_DECL expr by a constructor and we might be about the
+replacing a VAR_DECL by a constructor and we might be about the take
-take the address of the result.  */
+the address of the result.  */
 if (ecode == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (etype)
+&& code != ARRAY_TYPE
 && code != UNCONSTRAINED_ARRAY_TYPE
 && TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (etype))
 return
 convert (type, build_component_ref (expr, TYPE_FIELDS (etype), false));
 return expr;
 case STRING_CST:
 /* If we are converting a STRING_CST to another constrained array type,
 	 just make a new one in the proper type.  */
-if (code == ecode && AGGREGATE_TYPE_P (etype)
+if (code == ecode
-	  && !(TREE_CODE (TYPE_SIZE (etype)) == INTEGER_CST
+	  && !(TREE_CONSTANT (TYPE_SIZE (etype))
-	       && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
+	       && !TREE_CONSTANT (TYPE_SIZE (type))))
 	{
 	  expr = copy_node (expr);
 	  TREE_TYPE (expr) = type;
 	  return expr;
 	}
 enum tree_code code = TREE_CODE (expr);
 tree type = TREE_TYPE (expr);
 /* If the type is unsigned, overflow is allowed so we cannot be sure that
 EXPR doesn't overflow.  Keep it simple if optimization is disabled.  */
-if (TYPE_UNSIGNED (type) || !optimize)
+if (TYPE_UNSIGNED (type) || !optimize || optimize_debug)
 return convert (sizetype, expr);
 switch (code)
 {
 case VAR_DECL:
 /* If the expression is already of the right type, we are done.  */
 if (etype == type)
 return expr;
-/* If both types are integral just do a normal conversion.
+/* If both types are integral or regular pointer, then just do a normal
-Likewise for a conversion to an unconstrained array.  */
+conversion.  Likewise for a conversion to an unconstrained array.  */
 if (((INTEGRAL_TYPE_P (type)
 	|| (POINTER_TYPE_P (type) && !TYPE_IS_THIN_POINTER_P (type))
 	|| (code == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (type)))
 && (INTEGRAL_TYPE_P (etype)
 	   || (POINTER_TYPE_P (etype) && !TYPE_IS_THIN_POINTER_P (etype))
 /* If we are converting from a scalar type to a type with a different size,
 we need to pad to have the same size on both sides.
 ??? We cannot do it unconditionally because unchecked conversions are
-used liberally by the front-end to implement polymorphism, e.g. in:
+used liberally by the front-end to implement interface thunks:
+type ada__tags__addr_ptr is access system.address;
 S191s : constant ada__tags__addr_ptr := ada__tags__addr_ptr!(S190s);
 return p___size__4 (p__object!(S191s.all));
-so we skip all expressions that are references.  */
+so we need to skip dereferences.  */
-else if (!REFERENCE_CLASS_P (expr)
+else if (!INDIRECT_REF_P (expr)
 	   && !AGGREGATE_TYPE_P (etype)
-	   && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
+	   && ecode != UNCONSTRAINED_ARRAY_TYPE
+	   && TREE_CONSTANT (TYPE_SIZE (type))
 	   && (c = tree_int_cst_compare (TYPE_SIZE (etype), TYPE_SIZE (type))))
 {
 if (c < 0)
 	{
 	  expr = convert (maybe_pad_type (etype, TYPE_SIZE (type), 0, Empty,
 	  expr = unchecked_convert (rec_type, expr, notrunc_p);
 	  expr = build_component_ref (expr, TYPE_FIELDS (rec_type), false);
 	}
 }
+/* Likewise if we are converting from a scalar type to a type with self-
+referential size.  We use the max size to do the padding in this case.  */
+else if (!INDIRECT_REF_P (expr)
+	   && !AGGREGATE_TYPE_P (etype)
+	   && ecode != UNCONSTRAINED_ARRAY_TYPE
+	   && CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type)))
+{
+tree new_size = max_size (TYPE_SIZE (type), true);
+c = tree_int_cst_compare (TYPE_SIZE (etype), new_size);
+if (c < 0)
+	{
+	  expr = convert (maybe_pad_type (etype, new_size, 0, Empty,
+					  false, false, false, true),
+			  expr);
+	  expr = unchecked_convert (type, expr, notrunc_p);
+	}
+else
+	{
+	  tree rec_type = maybe_pad_type (type, TYPE_SIZE (etype), 0, Empty,
+					  false, false, false, true);
+	  expr = unchecked_convert (rec_type, expr, notrunc_p);
+	  expr = build_component_ref (expr, TYPE_FIELDS (rec_type), false);
+	}
+}
 /* We have a special case when we are converting between two unconstrained
 array types.  In that case, take the address, convert the fat pointer
 types, and dereference.  */
 else if (ecode == code && code == UNCONSTRAINED_ARRAY_TYPE)
 expr = build_unary_op (INDIRECT_REF, NULL_TREE,
 {
 expr = convert (tem, expr);
 return unchecked_convert (type, expr, notrunc_p);
 }
-/* If we are converting a CONSTRUCTOR to a more aligned RECORD_TYPE, bump
+/* If we are converting a CONSTRUCTOR to a more aligned aggregate type, bump
-the alignment of the CONSTRUCTOR to speed up the copy operation.  */
+the alignment of the CONSTRUCTOR to speed up the copy operation.  But do
+not do it for a conversion between original and packable version to avoid
+an infinite recursion.  */
 else if (TREE_CODE (expr) == CONSTRUCTOR
-	   && code == RECORD_TYPE
+	   && AGGREGATE_TYPE_P (type)
+	   && TYPE_NAME (type) != TYPE_NAME (etype)
 	   && TYPE_ALIGN (etype) < TYPE_ALIGN (type))
 {
 expr = convert (maybe_pad_type (etype, NULL_TREE, TYPE_ALIGN (type),
+				      Empty, false, false, false, true),
+		      expr);
+return unchecked_convert (type, expr, notrunc_p);
+}
+/* If we are converting a CONSTRUCTOR to a larger aggregate type, bump the
+size of the CONSTRUCTOR to make sure there are enough allocated bytes.
+But do not do it for a conversion between original and packable version
+to avoid an infinite recursion.  */
+else if (TREE_CODE (expr) == CONSTRUCTOR
+	   && AGGREGATE_TYPE_P (type)
+	   && TYPE_NAME (type) != TYPE_NAME (etype)
+	   && TREE_CONSTANT (TYPE_SIZE (type))
+	   && (!TREE_CONSTANT (TYPE_SIZE (etype))
+	       || tree_int_cst_lt (TYPE_SIZE (etype), TYPE_SIZE (type))))
+{
+expr = convert (maybe_pad_type (etype, TYPE_SIZE (type), 0,
 				      Empty, false, false, false, true),
 		      expr);
 return unchecked_convert (type, expr, notrunc_p);
 }
 if (TREE_CODE (iter) == FUNCTION_DECL
 	&& DECL_EXTERNAL (iter)
 	&& DECL_INITIAL (iter) == NULL
 	&& !DECL_IGNORED_P (iter)
 	&& DECL_FUNCTION_IS_DEF (iter))
+debug_hooks->early_global_decl (iter);
+/* Output global constants.  */
+FOR_EACH_VEC_SAFE_ELT (global_decls, i, iter)
+if (TREE_CODE (iter) == CONST_DECL && !DECL_IGNORED_P (iter))
 debug_hooks->early_global_decl (iter);
 /* Then output the global variables.  We need to do that after the debug
 information for global types is emitted so that they are finalized.  Skip
 external global variables, unless we need to emit debug info for them:
 				ARG6) NAME,
 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 				ARG6, ARG7) NAME,
 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
 #include "builtin-types.def"
+#include "ada-builtin-types.def"
 #undef DEF_PRIMITIVE_TYPE
 #undef DEF_FUNCTION_TYPE_0
 #undef DEF_FUNCTION_TYPE_1
 #undef DEF_FUNCTION_TYPE_2
 #undef DEF_FUNCTION_TYPE_3
 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
 #define DEF_POINTER_TYPE(ENUM, TYPE) \
 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
 #include "builtin-types.def"
+#include "ada-builtin-types.def"
 #undef DEF_PRIMITIVE_TYPE
 #undef DEF_FUNCTION_TYPE_0
 #undef DEF_FUNCTION_TYPE_1
 #undef DEF_FUNCTION_TYPE_2
 {
 if (!prototype_p (type)
 	  && (!TYPE_ATTRIBUTES (type)
 	      || !lookup_attribute ("type generic", TYPE_ATTRIBUTES (type))))
 	{
-	  error ("nonnull attribute without arguments on a non-prototype");
+	  error ("%qs attribute without arguments on a non-prototype",
+		 "nonnull");
 	  *no_add_attrs = true;
 	}
 return NULL_TREE;
 }
 {
 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
 	{
-	  error ("nonnull argument has invalid operand number (argument %lu)",
+	  error ("%qs argument has invalid operand number (argument %lu)",
-		 (unsigned long) attr_arg_num);
+		 "nonnull", (unsigned long) attr_arg_num);
 	  *no_add_attrs = true;
 	  return NULL_TREE;
 	}
 if (prototype_p (type))
 	    }
 	  if (!argument
 	      || TREE_CODE (argument) == VOID_TYPE)
 	    {
-	      error ("nonnull argument with out-of-range operand number "
+	      error ("%qs argument with out-of-range operand number "
-		     "(argument %lu, operand %lu)",
+		     "(argument %lu, operand %lu)", "nonnull",
 		     (unsigned long) attr_arg_num, (unsigned long) arg_num);
 	      *no_add_attrs = true;
 	      return NULL_TREE;
 	    }
 	  if (TREE_CODE (argument) != POINTER_TYPE)
 	    {
-	      error ("nonnull argument references non-pointer operand "
+	      error ("%qs argument references non-pointer operand "
-		     "(argument %lu, operand %lu)",
+		     "(argument %lu, operand %lu)", "nonnull",
 		   (unsigned long) attr_arg_num, (unsigned long) arg_num);
 	      *no_add_attrs = true;
 	      return NULL_TREE;
 	    }
 	}
 }
 return NULL_TREE;
 }
+/* Handle a "stack_protect" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_stack_protect_attribute (tree *node, tree name, tree, int,
+				bool *no_add_attrs)
+{
+if (TREE_CODE (*node) != FUNCTION_DECL)
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
 /* Handle a "noinline" attribute; arguments as in
 struct attribute_spec.handler.  */
 static tree
 handle_noinline_attribute (tree *node, tree name,
 }
 return NULL_TREE;
 }
+/* Handle a "no_icf" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_noicf_attribute (tree *node, tree name,
+			tree ARG_UNUSED (args),
+			int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+if (TREE_CODE (*node) != FUNCTION_DECL)
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
+/* Handle a "noipa" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_noipa_attribute (tree *node, tree name, tree, int, bool *no_add_attrs)
+{
+if (TREE_CODE (*node) != FUNCTION_DECL)
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
 /* Handle a "leaf" attribute; arguments as in
 struct attribute_spec.handler.  */
 static tree
 handle_leaf_attribute (tree *node, tree name, tree ARG_UNUSED (args),
 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
 /* Ensure we have a variadic function.  */
 gcc_assert (!prototype_p (*node) || stdarg_p (*node));
+return NULL_TREE;
+}
+/* Handle a "flatten" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_flatten_attribute (tree *node, tree name,
+			  tree args ATTRIBUTE_UNUSED,
+			  int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
+{
+if (TREE_CODE (*node) == FUNCTION_DECL)
+/* Do nothing else, just set the attribute.  We'll get at
+it later with lookup_attribute.  */
+;
+else
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
+/* Handle a "used" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
+		       int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+tree node = *pnode;
+if (TREE_CODE (node) == FUNCTION_DECL
+|| (VAR_P (node) && TREE_STATIC (node))
+|| (TREE_CODE (node) == TYPE_DECL))
+{
+TREE_USED (node) = 1;
+DECL_PRESERVE_P (node) = 1;
+if (VAR_P (node))
+	DECL_READ_P (node) = 1;
+}
+else
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
+/* Handle a "cold" and attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+		       int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+if (TREE_CODE (*node) == FUNCTION_DECL
+|| TREE_CODE (*node) == LABEL_DECL)
+{
+/* Attribute cold processing is done later with lookup_attribute.  */
+}
+else
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
+/* Handle a "hot" and attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+		      int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+if (TREE_CODE (*node) == FUNCTION_DECL
+|| TREE_CODE (*node) == LABEL_DECL)
+{
+/* Attribute hot processing is done later with lookup_attribute.  */
+}
+else
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+return NULL_TREE;
+}
+/* Handle a "target" attribute.  */
+static tree
+handle_target_attribute (tree *node, tree name, tree args, int flags,
+			 bool *no_add_attrs)
+{
+/* Ensure we have a function type.  */
+if (TREE_CODE (*node) != FUNCTION_DECL)
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
+else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (*node)))
+{
+warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
+		   "with %qs attribute", name, "target_clones");
+*no_add_attrs = true;
+}
+else if (!targetm.target_option.valid_attribute_p (*node, name, args, flags))
+*no_add_attrs = true;
+/* Check that there's no empty string in values of the attribute.  */
+for (tree t = args; t != NULL_TREE; t = TREE_CHAIN (t))
+{
+tree value = TREE_VALUE (t);
+if (TREE_CODE (value) == STRING_CST
+	  && TREE_STRING_LENGTH (value) == 1
+	  && TREE_STRING_POINTER (value)[0] == '\0')
+	{
+	  warning (OPT_Wattributes, "empty string in attribute %<target%>");
+	  *no_add_attrs = true;
+	}
+}
+return NULL_TREE;
+}
+/* Handle a "target_clones" attribute.  */
+static tree
+handle_target_clones_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+			  int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+/* Ensure we have a function type.  */
+if (TREE_CODE (*node) == FUNCTION_DECL)
+{
+if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (*node)))
+	{
+	  warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
+		   "with %qs attribute", name, "always_inline");
+	  *no_add_attrs = true;
+	}
+else if (lookup_attribute ("target", DECL_ATTRIBUTES (*node)))
+	{
+	  warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
+		   "with %qs attribute", name, "target");
+	  *no_add_attrs = true;
+	}
+else
+	/* Do not inline functions with multiple clone targets.  */
+	DECL_UNINLINABLE (*node) = 1;
+}
+else
+{
+warning (OPT_Wattributes, "%qE attribute ignored", name);
+*no_add_attrs = true;
+}
 return NULL_TREE;
 }
 /* Handle a "vector_size" attribute; arguments as in
 struct attribute_spec.handler.  */
 }
 static int flag_isoc94 = 0;
 static int flag_isoc99 = 0;
 static int flag_isoc11 = 0;
+static int flag_isoc2x = 0;
-/* Install what the common builtins.def offers.  */
+/* Install what the common builtins.def offers plus our local additions.
+Note that ada-builtins.def is included first so that locally redefined
+built-in functions take precedence over the commonly defined ones.  */
 static void
 install_builtin_functions (void)
 {
 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
 def_builtin_1 (ENUM, NAME, CLASS,                                   \
 builtin_types[(int) TYPE],                           \
 builtin_types[(int) LIBTYPE],                        \
 BOTH_P, FALLBACK_P, NONANSI_P,                       \
 built_in_attributes[(int) ATTRS], IMPLICIT);
+#define DEF_ADA_BUILTIN(ENUM, NAME, TYPE, ATTRS)		\
+DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_FRONTEND, TYPE, BT_LAST, \
+	       false, false, false, ATTRS, true, true)
+#include "ada-builtins.def"
 #include "builtins.def"
 }
 /* ----------------------------------------------------------------------- *
 *                              BUILTIN FUNCTIONS                          *

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ada/gcc-interface/utils.c @ 145:1830386684a0