Aligne __EH_FRAME_BEGIN__ to pointer size since gcc/unwind-dw2-fde.h has

/* The first few fields of a CIE.  The CIE_id field is 0 for a CIE,
   to distinguish it from a valid FDE.  FDEs are aligned to an addressing
   unit boundary, but the fields within are unaligned.  */
struct dwarf_cie
{
  uword length;
  sword CIE_id;
  ubyte version;
  unsigned char augmentation[];
} __attribute__ ((packed, aligned (__alignof__ (void *))));

/* The first few fields of an FDE.  */
struct dwarf_fde
{
  uword length;
  sword CIE_delta;
  unsigned char pc_begin[];
} __attribute__ ((packed, aligned (__alignof__ (void *))));

which indicates that CIE/FDE should be aligned at the pointer size.

	PR libgcc/27576
	* crtstuff.c (__EH_FRAME_BEGIN__): Aligned to pointer size.

$ac_cv_prog_OBJDUMP contains the --host OBJDUMP that
libtool has inferred. Current config/gcc-plugin.m4 does
not respect the user's choice for OBJDUMP.

	PR plugins/95648
config/

	* gcc-plugin.m4: Use libtool's $ac_cv_prog_OBJDUMP.

gcc/

	* configure: Regenerate.

libcc1/

	* configure: Regenerate.

RTL DSE tracks redundant constant stores within a basic block.  When RTL
loop invariant motion hoists a constant initialization out of the loop
into a separate basic block, the constant store value becomes unknown
within the original basic block.  When recording store for RTL DSE, check
if the source register is set only once to a constant by a non-partial
unconditional load.  If yes, record the constant as the constant store
source.  It eliminates unrolled zero stores after memset 0 in a loop
where a vector register is used as the zero store source.

gcc/

	PR rtl-optimization/105638
	* df-core.cc (df_find_single_def_src): Moved and renamed from
	find_single_def_src in loop-iv.cc.  Change the argument to rtx
	and use rtx_equal_p.  Return null for partial or conditional
	defs.
	* df.h (df_find_single_def_src): New prototype.
	* dse.cc (record_store): Use the constant source if the source
	register is set only once.
	* loop-iv.cc (find_single_def_src): Moved to df-core.cc.
	(replace_single_def_regs): Replace find_single_def_src with
	df_find_single_def_src.

gcc/testsuite/

	PR rtl-optimization/105638
	* g++.target/i386/pr105638.C: New test.

In r12-3643 I improved our handling of type names after . or -> when
unqualified lookup doesn't find anything, but it needs to handle auto
specially.

	PR c++/105734

gcc/cp/ChangeLog:

	* parser.cc (cp_parser_postfix_dot_deref_expression): Use typeof
	if the expression has auto type.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/auto57.C: New test.

This testcase demonstrates that the issue in PR105623 is not limited to
templates, so we should do the marking in a less template-specific place.

	PR c++/105779

gcc/cp/ChangeLog:

	* call.cc (resolve_args): Call mark_single_function here.
	* pt.cc (unify_one_argument): Not here.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp1y/auto-fn63.C: New test.

Further cleanup option processing. Remove the duplication of global
variables for CPU and tune settings so that CPU option processing is
simplified even further. Move global variables that need save and
restore due to target option processing into aarch64.opt. This removes
the need for explicit saving/restoring and unnecessary reparsing of
options.

gcc/
	* config/aarch64/aarch64.opt (explicit_tune_core): Rename to
	selected_tune.
	(explicit_arch): Rename to selected_arch.
	(x_aarch64_override_tune_string): Remove.
	(aarch64_ra_sign_key): Add as TargetVariable so it gets saved/restored.
	(aarch64_override_tune_string): Add Save so it gets saved/restored.
	* config/aarch64/aarch64.h (aarch64_architecture_version): Remove.
	* config/aarch64/aarch64.cc (aarch64_architecture_version): Remove.
	(processor): Remove archtecture_version field.
	(selected_arch): Remove global.
	(selected_cpu): Remove global.
	(selected_tune): Remove global.
	(aarch64_ra_sign_key): Move global to aarch64.opt so it is saved.
	(aarch64_override_options_internal): Use aarch64_get_tune_cpu.
	(aarch64_override_options): Further simplify code to only set
	selected_arch and selected_tune globals.
	(aarch64_option_save): Remove now that target options are saved.
	(aarch64_option_restore): Remove redundant target option restores.
	* config/aarch64/aarch64-c.cc (aarch64_update_cpp_builtins): Use
	AARCH64_ISA_V9.
	* config/aarch64/aarch64-opts.h (aarch64_key_type): Add, moved from...
	* config/aarch64/aarch64-protos.h (aarch64_key_type): Remove.
	(aarch64_ra_sign_key): Remove.

A comparison with a constant is most likely always faster than
.MUL_OVERFLOW from which we only check whether it overflowed and not the
multiplication result, and even if not, it is simpler operation on GIMPLE
and even if a target exists where such multiplications with overflow checking
are cheaper than comparisons, because comparisons are so much more common
than overflow checking multiplications, it would be nice if it simply
arranged for comparisons to be emitted like those multiplications on its
own...

2022-06-01  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/30314
	* match.pd (__builtin_mul_overflow_p (x, cst, (utype) 0) ->
	x > ~(utype)0 / cst): New simplification.

	* gcc.dg/tree-ssa/pr30314.c: New test.

The guard generation for a static var init was overly verbose.  We can
use a bit of RAII and avoid some rechecking.  Also in the !cxa_atexit
case, the only difference is whether can become whether to use
post-inc or pre-dec.

	gcc/cp/
	* decl2.cc (fix_temporary_vars_context_r): Use data argument
	for new context.
	(one_static_initialization_or_destruction): Adjust tree walk
	call.  Refactor guard generation.

The static init/fini generation is showing some bitrot.  This cleans
up several places to use C++, and also take advantage of already
having checked a variable for non-nullness.

	gcc/cp/
	* decl2.cc (ssdf_decl): Delete global.
	(start_static_storage_duration_function): Use some RAII.
	(do_static_initialization_or_destruction): Likewise.
	(c_parse_final_cleanups): Likewise.  Avoid rechecking 'vars'.

The end-of-compilation static init code generation functions are:

* Inconsistent in argument ordering (swapping 'is-init' and 'priority',
  wrt each other and other arguments).

* Inconsistent in naming. mostly calling the is-init argument 'initp',
  but sometimes calling it 'constructor_p' and in the worst case using
  a transcoded 'methody_type' character, and naming the priority
  argument 'initp'.

* Inconsistent in typing.  Sometimes the priority is unsigned,
  sometimes signed.  And the initp argument can of course be a bool.

* Several of the function comments have bit-rotted.

This addresses those oddities.  Name is-init 'initp', name priority
'priority'.  Place initp first, make priority unsigned.

	gcc/cp/
	* decl2.cc (start_objects): Replace 'method_type' parameter
	with 'initp' boolean, rename and retype 'priority' parameter.
	(finish_objects): Likewise.  Do not expand here.
	(one_static_initialization_or_destruction): Move 'initp'
	parameter first.
	(do_static_initialization_or_destruction): Likewise.
	(generate_ctor_or_dtor_function): Rename 'initp' parameter.
	Adjust start_objects/finish_obects calls and expand here.
	(generate_ctor_and_dtor_functions_for_priority): Adjust calls.
	(c_parse_final_cleanups): Likewise.
	(vtv_start_verification_constructor_init): Adjust.
	(vtv_finish_verification_constructor_init): Use finish_objects.

This avoids matching strlen to a pointer result, avoiding ICEing
because of an integer adjustment using PLUS_EXPR on pointers.

2022-06-01  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/105786
	* tree-loop-distribution.cc
	(loop_distribution::transform_reduction_loop): Only do strlen
	replacement for integer type reductions.

	* gcc.dg/torture/pr105786.c: New testcase.

The following testcase ICEs because we use different types in comparison,
idx has int type, while CASE_LOW has char type.

While I believe all CASE_{LOW,HIGH} in the same switch have to use the same
or compatible type, the index expression can have a promoted type as happens
in this testcase.  Other spots that handle switches do such foldings too.

2022-06-01  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/105770
	* tree-ssa-loop-unswitch.cc (find_unswitching_predicates_for_bb): Cast
	CASE_LOW and CASE_HIGH to TREE_TYPE (idx) before comparisons with idx.

	* gcc.dg/pr105770.c: New test.

Finally, the meat of the work.  Convert ranger and associated clients
to vrange.

Everything's relatively mechanical given the previous patches.  I did
include a minor cleanup in the edge code.  There's no need to check
that the type of the switch is an integer as non-integer switches are
invalid.  I verified this with an appropriately coded assert.

Tested on x86-64 & ppc64le Linux.

gcc/ChangeLog:

	* gimple-range-cache.cc (ssa_block_ranges::dump): Convert to vrange.
	(sbr_vector::sbr_vector): Same.
	(sbr_vector::grow): Same.
	(sbr_vector::set_bb_range): Same.
	(sbr_vector::get_bb_range): Same.
	(sbr_sparse_bitmap::sbr_sparse_bitmap): Same.
	(sbr_sparse_bitmap::set_bb_range): Same.
	(sbr_sparse_bitmap::get_bb_range): Same.
	(block_range_cache::set_bb_range): Same.
	(block_range_cache::get_bb_range): Same.
	(block_range_cache::dump): Same.
	(ssa_global_cache::get_global_range): Same.
	(ssa_global_cache::set_global_range): Same.
	(ssa_global_cache::clear): Same.
	(ssa_global_cache::dump): Same.
	(ranger_cache::get_global_range): Same.
	(ranger_cache::set_global_range): Same.
	(ranger_cache::range_of_def): Same.
	(ranger_cache::entry_range): Same.
	(ranger_cache::exit_range): Same.
	(ranger_cache::edge_range): Same.
	(ranger_cache::range_of_expr): Same.
	(ranger_cache::range_on_edge): Same.
	(ranger_cache::block_range): Same.
	(ranger_cache::propagate_cache): Same.
	(ranger_cache::fill_block_cache): Same.
	(ranger_cache::range_from_dom): Same.
	* gimple-range-cache.h: Same.
	* gimple-range-edge.cc (gimple_outgoing_range::get_edge_range):
	Same.
	(gimple_outgoing_range::switch_edge_range): Same.
	(gimple_outgoing_range::edge_range_p): Same.
	* gimple-range-edge.h: Same.
	* gimple-range-fold.cc (fur_source::get_operand): Same.
	(fur_source::get_phi_operand): Same.
	(fur_edge::get_operand): Same.
	(fur_edge::get_phi_operand): Same.
	(fur_stmt::get_operand): Same.
	(fur_stmt::get_phi_operand): Same.
	(fur_list::fur_list): Same.
	(fur_list::get_operand): Same.
	(fur_list::get_phi_operand): Same.
	(fold_range): Same.
	(adjust_imagpart_expr): Same.
	(adjust_realpart_expr): Same.
	(gimple_range_adjustment): Same.
	(fold_using_range::fold_stmt): Same.
	(fold_using_range::range_of_range_op): Same.
	(fold_using_range::range_of_address): Same.
	(fold_using_range::range_of_phi): Same.
	(fold_using_range::range_of_call): Same.
	(fold_using_range::range_of_builtin_call): Same.
	(fold_using_range::range_of_builtin_int_call): Same.
	(fold_using_range::range_of_cond_expr): Same.
	(fur_source::register_outgoing_edges): Same.
	* gimple-range-fold.h (fold_range): Same.
	(gimple_range_type): Same.
	(gimple_range_ssa_p): Same.
	* gimple-range-gori.cc (gimple_range_calc_op1): Same.
	(gimple_range_calc_op2): Same.
	(gori_compute::compute_operand_range_switch): Same.
	(gori_compute::compute_operand_range): Same.
	(gori_compute::logical_combine): Same.
	(gori_compute::compute_logical_operands): Same.
	(gori_compute::compute_operand1_range): Same.
	(gori_compute::compute_operand2_range): Same.
	(gori_compute::compute_operand1_and_operand2_range): Same.
	(gori_compute::outgoing_edge_range_p): Same.
	(gori_compute::condexpr_adjust): Same.
	* gimple-range-gori.h (gimple_range_calc_op1): Same.
	(gimple_range_calc_op2): Same.
	* gimple-range-path.cc (path_range_query::get_cache): Same.
	(path_range_query::set_cache): Same.
	(path_range_query::range_on_path_entry): Same.
	(path_range_query::internal_range_of_expr): Same.
	(path_range_query::range_of_expr): Same.
	(path_range_query::ssa_range_in_phi): Same.
	(path_range_query::range_defined_in_block): Same.
	(path_range_query::compute_ranges_in_phis): Same.
	(path_range_query::compute_ranges_in_block): Same.
	(path_range_query::add_to_imports): Same.
	(path_range_query::range_of_stmt): Same.
	* gimple-range-path.h: Same.
	* gimple-range-infer.cc (gimple_infer_range::add_range): Same.
	(gimple_infer_range::~side_effect_manager): Same.
	(gimple_infer_range::get_nonzero): Same.
	(gimple_infer_range::maybe_adjust_range): Same.
	(gimple_infer_range::add_range): Same.
	* gimple-range-infer.h: Same.
	* gimple-range-tests.cc: Same.
	* gimple-range-trace.cc (range_tracer::trailer): Same.
	(debug_seed_ranger): Same.
	* gimple-range-trace.h: Same.
	* gimple-range.cc (gimple_ranger::range_of_expr): Same.
	(gimple_ranger::range_on_entry): Same.
	(gimple_ranger::range_on_exit): Same.
	(gimple_ranger::range_on_edge): Same.
	(gimple_ranger::fold_range_internal): Same.
	(gimple_ranger::range_of_stmt): Same.
	(gimple_ranger::prefill_name): Same.
	(gimple_ranger::prefill_stmt_dependencies): Same.
	(gimple_ranger::export_global_ranges): Same.
	(gimple_ranger::dump_bb): Same.
	* gimple-range.h: Same.
	* gimple-ssa-warn-access.cc (check_nul_terminated_array): Same.
	(memmodel_to_uhwi): Same.
	* tree-ssa-loop-niter.cc (refine_value_range_using_guard): Same.
	(determine_value_range): Same.
	(record_nonwrapping_iv): Same.
	(infer_loop_bounds_from_signedness): Same.
	(scev_var_range_cant_overflow): Same.
	* tree-ssa-threadedge.cc (hybrid_jt_simplifier::simplify): Same.
	* value-query.cc (range_query::range_on_edge): Same.
	(range_query::range_of_stmt): Same.
	(range_query::value_of_expr): Same.
	(range_query::value_on_edge): Same.
	(range_query::value_of_stmt): Same.
	(range_query::get_tree_range): Same.
	(update_global_range): Same.
	(get_range_global): Same.
	(gimple_range_global): Same.
	(global_range_query::range_of_expr): Same.
	(range_query::query_relation): Same.
	* value-query.h (gimple_range_global): Same.
	(update_global_range): Same.
	* vr-values.cc (vr_values::range_of_expr): Same.
	(bounds_of_var_in_loop): Same.
	(simplify_using_ranges::vrp_visit_cond_stmt): Same.
	* vr-values.h (class vr_values): Same.
	* tree-ssa-loop-unswitch.cc (unswitch_predicate): Same.

This patch revamps the range allocator to handle generic vrange's.
I've cleaned it up somehow to make it obvious the various things you
can allocate with it.  I've also moved away from overloads into
distinct names when appropriate.

The various entry points are now:

  // Allocate a range of TYPE.
  vrange *alloc_vrange (tree type);
  // Allocate a memory block of BYTES.
  void *alloc (unsigned bytes);
  // Return a clone of SRC.
  template <typename T> T *clone (const T &src);

It is now possible to allocate a clone of an irange, or any future
range types:

      irange *i = allocator.clone <irange> (some_irange);
      frange *f = allocator.clone <frange> (some_frange);

You can actually do so without the <>, but I find it clearer to
specify the vrange type.

So with it you can allocate a specific range type, or vrange, or a
block of memory.

I have rewritten the C style casts to C++ casts, since casts tend to
be hints of problematic designs.  With the C++ casts you can at least
grep for them easier.  Speak of which, the next patch, which converts
ranger to vrange, will further clean this space by removing some
unnecessary casts.

Tested on x86-64 Linux and ppc64le Linux.

	* gimple-range-cache.cc (sbr_vector::sbr_vector): Adjust for
	vrange allocator.
	(sbr_vector::grow): Same.
	(sbr_vector::set_bb_range): Same.
	(sbr_sparse_bitmap::sbr_sparse_bitmap): Same.
	(sbr_sparse_bitmap::set_bb_range): Same.
	(block_range_cache::~block_range_cache): Same.
	(block_range_cache::set_bb_range): Same.
	(ssa_global_cache::ssa_global_cache): Same.
	(ssa_global_cache::~ssa_global_cache): Same.
	(ssa_global_cache::set_global_range): Same.
	* gimple-range-cache.h (block_range_cache): Same.
	(ssa_global_cache): Same.
	* gimple-range-edge.cc
	(gimple_outgoing_range::calc_switch_ranges): Same.
	* gimple-range-edge.h (gimple_outgoing_range): Same.
	* gimple-range-infer.cc (infer_range_manager::get_nonzero):
	Same.
	(infer_range_manager::add_range): Same.
	* gimple-range-infer.h (class infer_range_manager): Same.
	* value-range.h (class irange_allocator): Rename to...
	(class vrange_allocator): ...this.
	(irange_allocator::irange_allocator): New.
	(vrange_allocator::vrange_allocator): New.
	(irange_allocator::~irange_allocator): New.
	(vrange_allocator::~vrange_allocator): New.
	(irange_allocator::get_memory): Rename to...
	(vrange_allocator::alloc): ...this.
	(vrange_allocator::alloc_vrange): Rename from...
	(irange_allocator::allocate): ...this.
	(vrange_allocator::alloc_irange): New.

This patch provides the infrastructure to make range-ops type agnostic.

First, the range_op_handler function has been replaced with an object
of the same name.  It's coded in such a way to minimize changes to the
code base, and to encapsulate the dispatch code.

Instead of:

	range_operator *op = range_op_handler (code, type);
	if (op)
	  op->fold_range (...);

We now do:
	range_op_handler op (code, type);
	if (op)
	  op->fold_range (...);

I've folded gimple_range_handler into the range_op_handler class,
since it's also a query into the range operators.

Instead of:

	range_operator *handler = gimple_range_handler (stmt);

We now do:

	range_op_handler handler (stmt);

This all has the added benefit of moving all the dispatch code into an
independent class and avoid polluting range_operator (which we'll
further split later when frange and prange come live).

There's this annoying "using" keyword that's been added to each
operator due to hiding rules in C++.  The issue is that we will have
different virtual versions of fold_range() for each combination of
operands.  For example:

	// Traditional binary op on irange's.
	fold_range (irange &lhs, const irange &op1, const irange &op2);
	// For POINTER_DIFF_EXPR:
	fold_range (irange &lhs, const prange &op1, const prange &op2);
	// Cast from irange to prange.
	fold_range (prange &lhs, const irange &op1, const irange &op2);

Overloading virtuals when there are multiple same named methods causes
hidden virtuals warnings from -Woverloaded-virtual, thus the using
keyword.  An alternative would be to have different names:
fold_range_III, fold_range_IPP, fold_range_PII, but that's uglier
still.

Tested on x86-64 & ppc64le Linux.

gcc/ChangeLog:

	* gimple-range-edge.cc (gimple_outgoing_range_stmt_p): Adjust for
	vrange and convert range_op_handler function calls to use the
	identically named object.
	* gimple-range-fold.cc (gimple_range_operand1): Same.
	(gimple_range_operand2): Same.
	(fold_using_range::fold_stmt): Same.
	(fold_using_range::range_of_range_op): Same.
	(fold_using_range::range_of_builtin_ubsan_call): Same.
	(fold_using_range::relation_fold_and_or): Same.
	(fur_source::register_outgoing_edges): Same.
	* gimple-range-fold.h (gimple_range_handler): Remove.
	* gimple-range-gori.cc (gimple_range_calc_op1): Adjust for vrange.
	(gimple_range_calc_op2): Same.
	(range_def_chain::get_def_chain): Same.
	(gori_compute::compute_operand_range): Same.
	(gori_compute::condexpr_adjust): Same.
	* gimple-range.cc (gimple_ranger::prefill_name): Same.
	(gimple_ranger::prefill_stmt_dependencies): Same.
	* range-op.cc (get_bool_state): Same.
	(class operator_equal): Add using clause.
	(class operator_not_equal): Same.
	(class operator_lt): Same.
	(class operator_le): Same.
	(class operator_gt): Same.
	(class operator_ge): Same.
	(class operator_plus): Same.
	(class operator_minus): Same.
	(class operator_mult): Same.
	(class operator_exact_divide): Same.
	(class operator_lshift): Same.
	(class operator_rshift): Same.
	(class operator_cast): Same.
	(class operator_logical_and): Same.
	(class operator_bitwise_and): Same.
	(class operator_logical_or): Same.
	(class operator_bitwise_or): Same.
	(class operator_bitwise_xor): Same.
	(class operator_trunc_mod): Same.
	(class operator_logical_not): Same.
	(class operator_bitwise_not): Same.
	(class operator_cst): Same.
	(class operator_identity): Same.
	(class operator_unknown): Same.
	(class operator_abs): Same.
	(class operator_negate): Same.
	(class operator_addr_expr): Same.
	(class pointer_or_operator): Same.
	(operator_plus::op1_range): Adjust for vrange.
	(operator_minus::op1_range): Same.
	(operator_mult::op1_range): Same.
	(operator_cast::op1_range): Same.
	(operator_bitwise_not::fold_range): Same.
	(operator_negate::fold_range): Same.
	(range_op_handler): Rename to...
	(get_handler): ...this.
	(range_op_handler::range_op_handler): New.
	(range_op_handler::fold_range): New.
	(range_op_handler::op1_range): New.
	(range_op_handler::op2_range): New.
	(range_op_handler::lhs_op1_relation): New.
	(range_op_handler::lhs_op2_relation): New.
	(range_op_handler::op1_op2_relation): New.
	(range_cast): Adjust for vrange.
	* range-op.h (range_op_handler): Remove function.
	(range_cast): Adjust for vrange.
	(class range_op_handler): New.
	(get_bool_state): Adjust for vrange.
	(empty_range_varying): Same.
	(relop_early_resolve): Same.
	* tree-data-ref.cc (compute_distributive_range): Same.
	* tree-vrp.cc (get_range_op_handler): Remove.
	(range_fold_binary_symbolics_p): Use range_op_handler class
	instead of get_range_op_handler.
	(range_fold_unary_symbolics_p): Same.
	(range_fold_binary_expr): Same.
	(range_fold_unary_expr): Same.
	* value-query.cc (range_query::get_tree_range): Adjust for vrange.

Now that we have generic ranges, we need a way to define generic local
temporaries on the stack for intermediate calculations in the ranger
and elsewhere.  We need temporaries analogous to int_range_max, but
for any of the supported types (currently just integers, but soon
integers, pointers, and floats).

The Value_Range object is such a temporary.  It is designed to be
transparently used as a vrange.  It shares vrange's abstract API, and
implicitly casts itself to a vrange when passed around.

The ultimate name will be value_range, but we need to remove legacy
first for that to happen.  Until then, Value_Range will do.

Sample usage is as follows.  Instead of:

	extern void foo (vrange &);

	int_range_max t;
	t.set_nonzero (type);
	foo (t);

one does:

	Value_Range t (type);
	t.set_nonzero (type);
	foo (t);

You can also delay initialization, for use in loops for example:

	Value_Range t;
	...
	t.set_type (type);
	t.set_varying (type);

Creating an supported range type, will result in an unsupported_range
object being created, which will trap if anything but set_undefined()
and undefined_p() are called on it.  There's no size penalty for the
unsupported_range, since its immutable and can be shared across
instances.

Since supports_type_p() is called at construction time for each
temporary, I've removed the non-zero check from this function, which
was mostly unneeded.  I fixed the handful of callers that were
passing null types, and in the process sped things up a bit.

As more range types come about, the Value_Range class will be augmented
to support them by adding the relevant bits in the initialization
code, etc.

Tested on x86-64 & ppc64le Linux.

gcc/ChangeLog:

	* gimple-range-fold.h (gimple_range_type): Check type before
	calling supports_type_p.
	* gimple-range-path.cc (path_range_query::range_of_stmt): Same.
	* value-query.cc (range_query::get_tree_range): Same.
	* value-range.cc (Value_Range::lower_bound): New.
	(Value_Range::upper_bound): New.
	(Value_Range::dump): New.
	* value-range.h (class Value_Range): New.
	(irange::supports_type_p): Do not check if type is non-zero.

This is a series of patches making ranger type agnostic in preparation
for contributing support for other types of ranges (pointers and
floats initially).

The first step in this process is to implement vrange, an abstract
class that will be exclusively used by ranger, and from which all
ranges will inherit.  Vrange provides the minimum operations for
ranger to work.  The current virtual methods are what we've used to
implement frange (floats) and prange (pointers), but we may restrict
the virtual methods further as other ranges come about
(i.e. set_nonnegative() has no meaning for a future string range).

This patchset also provides a mechanism for declaring local type
agnostic ranges that can transparently hold an irange, frange,
prange's, etc, and a dispatch mechanism for range-ops to work with
various range types.  More details in the relevant patches.

FUTURE PLAN
===========

The plan after this is to contribute a bare bones implementation for
floats (frange) that will provide relationals, followed by a
separation of integers and pointers (irange and prange).  Once this is
in place, we can further enhance both floats and pointers.  For
example, pointer tracking, pointer plus optimizations, and keeping
track of NaN's, etc.

Once frange and prange come live, all ranger clients will immediately
benefit from these enhancements.  For instance, in our local branch,
the threader is already float aware with regards to relationals.

We expect to wait a few weeks before starting to contribute further
enhancements to give the tree a time to stabilize, and Andrew time to
rebase his upcoming patches  :-P.

NOTES
=====

In discussions with Andrew, it has become clear that with vrange
coming about, supports_type_p() is somewhat ambiguous.  Prior to
vrange it has been used to (a) determine if a type is supported by
ranger, (b) as a short-cut for checking if a type is pointer or integer,
as well as (c) to see if a given range can hold a type.  These things
have had the same meaning in irange, but are slightly different with
vrange.  I will address this in a follow-up patch.

Speaking of supported types, we now provide an unsupported_range
for passing around ranges for unsupported types. We've been silently
doing this for a while, in both vr-values by creating VARYING for
unsupported types with error_mark_node end points, and in ranger when
we pass an unsupported range before we realize in range_of_expr that
it's unsupported.  This class just formalizes what we've already been
doing in an irange, but making it explicit that you can't do anything
with these ranges except pass them.  Any other operation traps.

There is no GTY support for vrange yet, as we don't store it long
term.  When we contribute support for global ranges (think
SSA_NAME_RANGE_INFO but for generic ranges), we will include it.  There
was just no need to pollute this patchset with it.

TESTING
=======

The patchset has been tested on x86-64 Linux as well as ppc64 Linux.
I have also verified that we fold the same number of conditionals in
evrp as well as thread the same number of paths.  There should be no
user visible changes.

We have also benchmarked the work, with the final numbers being an
*improvement* of 1.92% for evrp, and 0.82% for VRP.  Overall
compilation has a miniscule improvement.  This is despite the extra
indirection level.

The improvements are mostly because of small cleanups required for the
generalization of ranges.  As a sanity check, I stuck kcachegrind on a
few sample .ii files to see where the time was being gained.  Most of
the gain came from gimple_range_global() being 19% faster.  This
function is called a lot, and it was constructing a legacy
value_range, then returning it by value, which the caller then had to
convert to an irange.  This is in line with other pending work:
anytime we get rid of legacy, we gain time.

I will wait a few days before committing to welcome any comments.

gcc/ChangeLog:

	* value-range-equiv.cc (value_range_equiv::set): New.
	* value-range-equiv.h (class value_range_equiv): Make set method
	virtual.
	Remove default bitmap argument from set method.
	* value-range.cc (vrange::contains_p): New.
	(vrange::singleton_p): New.
	(vrange::operator=): New.
	(vrange::operator==): New.
	(irange::fits_p): Move to .cc file.
	(irange::set_nonnegative): New.
	(unsupported_range::unsupported_range): New.
	(unsupported_range::set): New.
	(unsupported_range::type): New.
	(unsupported_range::set_undefined): New.
	(unsupported_range::set_varying): New.
	(unsupported_range::dump): New.
	(unsupported_range::union_): New.
	(unsupported_range::intersect): New.
	(unsupported_range::zero_p): New.
	(unsupported_range::nonzero_p): New.
	(unsupported_range::set_nonzero): New.
	(unsupported_range::set_zero): New.
	(unsupported_range::set_nonnegative): New.
	(unsupported_range::fits_p): New.
	(irange::set): Call irange::set_undefined.
	(irange::verify_range): Check discriminator field.
	(irange::dump): Dump [irange] marker.
	(irange::debug): Move to...
	(vrange::debug): ...here.
	(dump_value_range): Accept vrange.
	(debug): Same.
	* value-range.h (enum value_range_discriminator): New.
	(class vrange): New.
	(class unsupported_range): New.
	(struct vrange_traits): New.
	(is_a): New.
	(as_a): New.
	(class irange): Inherit from vrange.
	(dump_value_range): Adjust for vrange.
	(irange::kind): Rename to...
	(vrange::kind): ...this.
	(irange::varying_p): Rename to...
	(vrange::varying_p): ...this.
	(irange::undefined_p): Rename to...
	(vrange::undefined_p): ...this.
	(irange::irange): Set discriminator.
	(irange::union_): Convert to irange before passing to irange
	method.
	(irange::intersect): Same.
	(vrange::supports_type_p): New.
	* vr-values.cc (vr_values::extract_range_from_binary_expr): Pass
	NULL bitmap argument to value_range_equiv::set.
	(vr_values::extract_range_basic): Same.

Volatile variables marked with the No_Caching aspect can now have
confirming aspects for other volatile properties, with a value of
False.

gcc/ada/

	* contracts.adb (Check_Type_Or_Object_External_Properties): Check
	the validity of combinations only when No_Caching is not used.
	* sem_prag.adb (Analyze_External_Property_In_Decl_Part): Check
	valid combinations with No_Caching.

Systemitize Word_Size and Memory_Size declarations rather than hard code
with numerical values or OS specific Long_Integer size.

gcc/ada/

	* libgnat/system-vxworks7-aarch64.ads (Word_Size): Compute
	based on Standard'Word_Size. (Memory_Size): Compute based
	on Word_Size.
	* libgnat/system-vxworks7-arm.ads: Likewise.
	* libgnat/system-vxworks7-e500-kernel.ads: Likewise.
	* libgnat/system-vxworks7-ppc-kernel.ads: Likewise.
	* libgnat/system-vxworks7-ppc64-kernel.ads: Likewise.
	* libgnat/system-vxworks7-x86-kernel.ads: Likewise.
	* libgnat/system-vxworks7-x86_64-kernel.ads: Likewise.

Systemitize Word_Size and Memory_Size declarations rather than hard code
with numerical values or OS specific Long_Integer size.

gcc/ada/

	* libgnat/system-qnx-arm.ads (Memory_Size): Compute based on
	Word_Size.

On illegal code like:

   type T is new Positive in range 1..5;

the compiler was emitting message:

  error: extra "in"ignored
                  ^^

which lacked a space character.

A tiny diagnostic improvement; spotted while mistakenly typing an
illegal test.

gcc/ada/

	* par-util.adb (Ignore): Add missing space to message string.

This pragma was wrongly not recognized as an assertion pragma.  Now
fixed.

gcc/ada/

	* sem_prag.ads (Assertion_Expression_Pragmas): Fix value for
	pragma Subprogram_Variant.

The Returns_On_Secondary_Stack predicate is a misnomer because it must be
invoked on a type and types do not return; as a matter of fact, the other
Returns_XXX predicates apply to functions.

gcc/ada/

	* exp_ch6.adb (Caller_Known_Size): Invoke Needs_Secondary_Stack in
	lieu of Returns_On_Secondary_Stack.
	(Expand_Call_Helper): Likewise.
	(Expand_Simple_Function_Return): Likewise.
	(Needs_BIP_Alloc_Form): Likewise.
	* exp_ch7.adb (Wrap_Transient_Declaration): Likewise.
	* sem_res.adb (Resolve_Call): Likewise.
	(Resolve_Entry_Call): Likewise.
	* sem_util.ads (Returns_On_Secondary_Stack): Rename into...
	(Needs_Secondary_Stack): ...this.
	* sem_util.adb (Returns_On_Secondary_Stack): Rename into...
	(Needs_Secondary_Stack): ...this.
	* fe.h (Returns_On_Secondary_Stack): Delete.
	(Needs_Secondary_Stack): New function.
	* gcc-interface/decl.cc (gnat_to_gnu_subprog_type): Replace call
	to Returns_On_Secondary_Stack with Needs_Secondary_Stack.

This fixes a small oddity whereby a subprogram body declared without a spec
would be frozen before its entity is fully processed as an overloaded name.
Now the latter step computes useful information, for example whether the
body is a (late) primitive of a tagged type, which can be required during
the freezing process.  The change also adjusts Check_Dispatching_Operation
accordingly.  No functional changes.

gcc/ada/

	* sem_ch6.adb (Analyze_Subprogram_Body_Helper): For the case where
	there is no previous declaration, freeze the body entity only after
	it has been processed as a new overloaded name.
	Use Was_Expression_Function to recognize expression functions.
	* sem_disp.adb (Check_Dispatching_Operation): Do not require a body
	which is the last primitive to be frozen here.

Correction of a typo regarding indexes.

gcc/ada/

	* libgnat/a-cfdlli.adb ("="): Make the function properly loop
	over the right list.

When subtype predicate checks are added for object declarations, it
could lead to a compiler crash or to an incorrect check.

When the subtype for the object being declared is built later by
Analyze_Object_Declaration, the predicate check can't be applied on the
object instead of a copy as the call will be incorrect after the subtype
has been built.

When subtypes for LHS and RHS do not statically match, only checking the
predicate on the object after it has been initialized may miss a failing
predicate on the RHS.

In both cases, skip the optimization and check the predicate on a copy.

Rename Should_Build_Subtype into Build_Default_Subtype_OK and move it
out of sem_ch3 to make it available to other part of the compiler (in
particular to checks.adb).

gcc/ada/

	* checks.adb (Apply_Predicate_Check): Refine condition for
	applying optimization.
	* sem_ch3.adb (Analyze_Component_Declaration): Adjust calls to
	Should_Build_Subtype.
	(Analyze_Object_Declaration): Likewise.
	(Should_Build_Subtype): Rename/move to ...
	* sem_util.ads (Build_Default_Subtype_OK): ... this.
	* sem_util.adb (Build_Default_Subtype_OK): Moved from
	sem_ch3.adb.

Bump the pc +3 total for Thumb mode, the same calculation that as is
done for arm-linux.

gcc/ada/

	* init.c (__gnat_adjust_context_for_raise) [QNX][__thumb2__]: Bump
	the pc an extra byte.

This commit makes GNAT use absolute paths in -fdiagnostics-format=json's
output when -gnatef is present on the command line. This makes life
easier for tools that ingest GNAT's output.

gcc/ada/

	* doc/gnat_ugn/building_executable_programs_with_gnat.rst:
	Document new behavior.
	* errout.adb (Write_JSON_Location): Output absolute paths when
	needed.
	* switch-c.adb (Scan_Front_End_Switches): Update -gnatef
	comment.
	* usage.adb (Usage): Update description of -gnatef.
	* gnat_ugn.texi: Regenerate.

The combination of pragma/aspect Inline_Always and -gnateV -gnata runs
afoul of the handling of inlining across units by gigi, which does not
inline a subprogram that calls nested subprograms if these subprograms
are not themselves inlined.

This condition does not apply to internally generated subprograms but
the special _postconditions procedure has Debug_Info_Needed set so it
is not considered as such and, as a consequence, triggers an error if
the enclosing subprogram requires inlining by means of Inline_Always.

The _postconditions procedure is already marked inlined when generating
C code so it makes sense to mark it inlined in the general case as well.

gcc/ada/

	* contracts.adb (Build_Postconditions_Procedure): Set Is_Inlined
	unconditionnally on the procedure entity.

When analyzing an array or record type declaration whose component has a
constrained access type, e.g.:

   type Buffer_Acc is not null access all String;

   type Buffer_Rec is record
      Data : Buffer_Acc (1 .. 10);
   end record;

   type Buffer_Arr is array (Boolean) of Buffer_Acc (1 .. 10);

we propagated various properties of the unconstrained access type (e.g.
the designated type, access-to-constant flag), but forgot to propagate
the null-exclusion.

For GNAT it didn't make a big difference, because the (anonymous)
component type was never subject to legality checks. The "value
tracking" optimisation machinery, which also deals with null values,
only works for entire objects and doesn't care about components.
However, GNATprove uses this flag when an access-to-component object is
dereferenced.

gcc/ada/

	* sem_ch3.adb (Constrain_Access): Propagate null-exclusion flag
	from parent type.

gcc/ada/

	* sem_ch5.adb (Analyze_Loop_Statement): Add a comment about
	a finalization issue.

The initial work didn't change anything for limited types because they use
a specific return mechanism for functions called build-in-place where there
is no anonymous return object, so the secondary stack was used only for the
sake of consistency with the nonlimited case.

This change aligns the limited case with the nonlimited case, i.e. either
they both use the primary stack or they both use the secondary stack.

gcc/ada/

	* exp_ch6.adb (Caller_Known_Size): Call Returns_On_Secondary_Stack
	instead of Requires_Transient_Scope and tidy up.
	(Needs_BIP_Alloc_Form): Likewise.
	* exp_util.adb (Initialized_By_Aliased_BIP_Func_Call): Also return
	true if the build-in-place function call has no BIPalloc parameter.
	(Is_Finalizable_Transient): Remove redundant test.

Some features haven't got customer feedback or made upstream yet.

gcc/ada/

	* doc/gnat_rm/security_hardening_features.rst: Note that hardening
	features are experimental.
	* gnat_rm.texi: Regenerate.

Avoid improperly suppressing checks for the wrapper subprogram that is
built when a null type extension inherits (and does not override) a
function with a controlling result. This is a follow-up to other changes
already made on this ticket.

gcc/ada/

	* exp_ch3.adb (Make_Controlling_Function_Wrappers): Set the
	Corresponding_Spec field of a wrapper subprogram body before
	analyzing the subprogram body; the field will be set (again)
	during analysis, but we need it to be set earlier.
	* exp_ch13.adb (Expand_N_Freeze_Entity): Add wrapper subprogram
	bodies to the list of declarations for which we do not want to
	suppress checks.

This is needed after the creation of Returns_On_Secondary_Stack from the
original Requires_Transient_Scope.

gcc/ada/

	* sem_util.adb (Indirect_Temp_Needed): Adjust reference in comment.

Shared libraries now fully supported on arm-qnx.

gcc/ada/

	* Makefile.rtl (GNATLIB_SHARED): Revert disablement for arm-qnx.

Having components that need to be returned on the secondary stack would
not always force a record type to be returned on the secondary stack
itself.

gcc/ada/

	* sem_util.adb
	(Returns_On_Secondary_Stack.Caller_Known_Size_Record): Directly
	check the dependence on discriminants for the variant part, if
	any, instead of calling the Is_Definite_Subtype predicate.

gcc/ada/

	* sem_warn.adb (Warn_On_Unreferenced_Entity): Fix warning tag.

This makes tagging more accurate.

gcc/ada/

	* sem_warn.adb (Check_References): Adjust conditions under which
	warning messages should be emitted and their tags as well.