Remove extra whitespace in examples of pragmas and aspects.
Spotted while adding description of pragma Ada_2022.
gcc/ada/
* doc/gnat_rm/implementation_defined_aspects.rst,
doc/gnat_rm/implementation_defined_pragmas.rst: Remove extra
whitespace.
* gnat_rm.texi: Regenerate.
Fix formatting of description lists, i.e. continuation lines are now
indented like their preceding lines.
Spotted while adding description of pragma Ada_2022.
gcc/ada/
* doc/gnat_rm/implementation_defined_characteristics.rst: Remove
extra indent in continuation lines; indent both descriptions of
Max_Picture_Length.
* gnat_rm.texi: Regenerate.
An entity flag Reachable now only applies to E_Label entities. We had an
appropriate guard for setting this flag, but not for clearing.
Cleanup related to detection of uninitialized scalars with GOTO
statements.
gcc/ada/
* sem_ch5.adb (Analyze_Statements): Only clear Reachable flag on
proper label entities.
Pragma Ada_2022 is similar to existing pragma Ada_2012 and similarly
deserves to be documented.
gcc/ada/
* doc/gnat_rm/implementation_defined_pragmas.rst (Pragma
Ada_2022): Copy description from pragma Ada 2012 and adapt.
* doc/gnat_ugn/the_gnat_compilation_model.rst (Configuration
Pragmas): List pragma Ada 2022.
* gnat_rm.texi, gnat_ugn.texi: Regenerate.
In the case of an object declaration with an indefinite nominal subtype
(roughly speaking, that's an object that takes its bounds,
discriminants, and/or tag from its explicit initial value), GNAT does
not support address specifications unless the size of the object is
known at compile time. In some cases, such unsupported address
specifications were not properly rejected. This could lead to either an
internal error during compilation or (in the class-wide case) to a
warning accompanied by raising Program_Error at run time.
gcc/ada/
* sem_ch13.adb (Analyze_Attribute_Definition_Clause): Replace
the existing check for an address specification for an object of
a class-wide type with a more general check which rejects either
the class-wide case or the case where the FE would (if the
address specification were accepted) build a malformed
tree (specifically, an object renaming declaration with a
specified address). In the case where the check fails, reject
the construct at compile time instead of generating an
unconditional raise of Program_Error.
* doc/gnat_rm/representation_clauses_and_pragmas.rst: Update
documentation to reflect these changes.
* gnat_rm.texi: Regenerate.
An entity flag Reachable is described as "defined in labels". It is only
read and written for entities of kind E_Label (the code has necessary
guards for that). There no need for this flag to be specified for all
entities in the generated AST.
Cleanup related to detection of uninitialized scalars with GOTO
statements.
gcc/ada/
* gen_il-gen-gen_entities.adb (Reachable): Move from
Root_Entity_Type to E_Label.
Library-level variables with initializers could have Is_Known_Valid
set when analyzing their definition, and the flag would only be
cleared when analyzing a statement that assigned to them. Procedures
and functions analyzed before the flag got cleared could skip validity
checking for the corresponding variable. This patch fixes this
problem: we no longer set Is_Known_Valid when analyzing initializers
of library-level variables,and use the same Safe_To_Capture_Value
predicate that prevents assignments from recording known-valid states.
This causes any variable with an initialization value, that would have
had its initializer value used as its known constant value if the use
is analyzed before any assignment to the variable, to no longer be
regarded as holding a constant value. Some might turn out to have a
constant value, after all, but we don't know that yet: we can only
tell after analyzing every subprogram that could possibly assign to
it. At the points where Safe_To_Capture_Value calls are introduced,
Never_Set_In_Source does not yet hold its final value.
gcc/ada/
* exp_ch3.adb (Expand_N_Object_Declaration): Guard
Set_Is_Known_Valid with Safe_To_Capture_Value.
If the -gnatR -gnatc are both given, then the compiler crashes. This
patch fixes that, and avoids printing the uncomputed sizes and
alignments that were causing the crash. (Previous versions of the
compiler printed incorrect values in such cases.)
gcc/ada/
* repinfo.adb (List_Object_Info): Do not try to print values
that have not been computed (and so are No_Uint).
(Rep_Not_Constant): Reverse sense and change name to
Compile_Time_Known_Rep. This makes the code at call sites a
little more readable. Simplify code to a single return
statement.
The following makes sure to disable var-tracking if only
dwarf2-line debuginfo is present.
2022-05-11 Richard Biener <rguenther@suse.de>
PR bootstrap/105551
* opts.cc (finish_options): Also disable var-tracking if
!DWARF2_DEBUGGING_INFO.
Currently we hardcode ALTIVEC_REGS for register constraint v and
RS6000_CONSTRAINT_v looks confusing, this is to fix it with
rs6000_constraints[RS6000_CONSTRAINT_v] to align with some other
existing register constraints with RS6000_CONSTRAINT_*.
gcc/ChangeLog:
* config/rs6000/constraints.md (register constraint v): Use
rs6000_constraints[RS6000_CONSTRAINT_v] instead of ALTIVEC_REGS.
Do not allow strange option format:
-msmall-data-limit= 11.
For -output-pch we need to use Separate syntax as lang spec
rules automatically append a space.
PR target/105355
gcc/ChangeLog:
* config/riscv/riscv.opt: Remove Separate from
-msmall-data-limit=.
* optc-gen.awk: Report error for the described situation.
* gcc.cc: Use Separate syntax.
* opts.cc (gen_command_line_string): Change option name.
gcc/c-family/ChangeLog:
* c-opts.cc (c_common_handle_option): Change option name.
* c.opt: Remove Joined and use Separate option.
gcc/cp/ChangeLog:
* lang-specs.h: Use Separate syntax.
gcc/objc/ChangeLog:
* lang-specs.h: Use Separate syntax.
gcc/objcp/ChangeLog:
* lang-specs.h: Use Separate syntax.
gcc/
PR target/105414
* match.pd (minmax): Skip constant folding for fmin/fmax when both
arguments are sNaN or one is sNaN and another is NaN.
gcc/testsuite/
PR target/105414
* gcc.dg/pr105414.c: New.
TEAM arguments to coarray intrinsics must be scalar expressions of type
TEAM_TYPE of intrinsic module ISO_FORTRAN_ENV.
gcc/fortran/ChangeLog:
PR fortran/105526
* resolve.cc (check_team): New.
(gfc_resolve_code): Add checks for arguments to coarray intrinsics
FORM TEAM, CHANGE TEAM, and SYNC TEAM.
gcc/testsuite/ChangeLog:
PR fortran/105526
* gfortran.dg/coarray_50.f90: New test.
Add .note.GNU-stack section only for Linux since it may not be supported
on non-Linux OSes. __ELF__ isn't checked since these tests can only run
on Linux/x86 ELF systems.
PR target/105472
* gcc.target/i386/iamcu/asm-support.S: Add .note.GNU-stack section
only for Linux.
* gcc.target/x86_64/abi/asm-support.S: Likewise.
* gcc.target/x86_64/abi/avx/asm-support.S: Likewise.
* gcc.target/x86_64/abi/avx512f/asm-support.S: Likewise.
* gcc.target/x86_64/abi/avx512fp16/asm-support.S: Likewise.
* gcc.target/x86_64/abi/avx512fp16/m256h/asm-support.S: Likewise.
* gcc.target/x86_64/abi/avx512fp16/m512h/asm-support.S: Likewise.
* gcc.target/x86_64/abi/ms-sysv/do-test.S: Likewise.
The following testcase ICEs (and only without -g), because we don't replace
one VEC_COND_EXPR with .VCOND* call.
We don't do that because gimple_expand_vec_set_expr adds some stmts before
*gsi and then uses gsi_remove to remove it. gsi_remove moves the iterator
to the next stmt and in the caller we then do gsi_next before looking at
another stmt, which means we can skip processing of one stmt, which in this
case happened to be a VEC_COND_EXPR but with -g is some debug stmt in
between. As we always emit some stmts before it, it is easy to update the
iterator to the last stmt emitted there, so that caller continues really
with the next stmt.
2022-05-10 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/105528
* gimple-isel.cc (gimple_expand_vec_set_expr): After gsi_remove
set *gsi to gsi_for_stmt (ass_stmt). Fix up function comment.
* gcc.dg/pr105528.c: New test.
The example missed the mode condition in the replacement text.
2022-05-10 Segher Boessenkool <segher@kernel.crashing.org>
* doc/md.texi (Defining Mode Iterators): Correct example replacement
text.
Unlike in C, in C++ the conditional operator yields an lvalue if both
branches are lvalues, so these setter macros are unnecessary; we can
just assign to PACK_EXPANSION_PATTERN and ARGUMENT_PACK_ARGS directly.
gcc/cp/ChangeLog:
* coroutines.cc (instantiate_coro_traits): Adjust accordingly.
* cp-tree.def: Remove mention of SET_PACK_EXPANSION_PATTERN.
* cp-tree.h (SET_PACK_EXPANSION_PATTERN): Remove.
(SET_ARGUMENT_PACK_ARGS): Remove.
* module.cc (trees_in::tree_node): Adjust accordingly.
* parser.cc (make_char_string_pack): Likewise.
(make_string_pack): Likewise.
* pt.cc (make_pack_expansion): Likewise.
(template_parm_to_arg): Likewise.
(coerce_template_parameter_pack): Likewise.
(extract_fnparm_pack): Likewise.
(extract_locals_r): Likewise.
(make_argument_pack): Likewise.
(tsubst_argument_pack): Likewise.
(lookup_init_capture_pack): Likewise.
(type_unification_real): Likewise.
(unify_pack_expansion): Likewise.
(tsubst_initializer_list): Likewise.
This makes the accessor macros for TYPE_/EXPR_PACK_EXPANSION
and TYPE_/NONTYPE_ARGUMENT_PACK check the tree code of the argument.
gcc/cp/ChangeLog:
* cp-tree.h (PACK_EXPANSION_CHECK): Define.
(PACK_EXPANSION_PATTERN): Use PACK_EXPANSION_CHECK.
(SET_PACK_EXPANSION_PATTERN): Likewise.
(PACK_EXPANSION_PARAMETER_PACKS): Likewise.
(PACK_EXPANSION_EXTRA_ARGS): Likewise.
(PACK_EXPANSION_LOCAL_P): Likewise.
(PACK_EXPANSION_SIZEOF_P): Likewise.
(PACK_EXPANSION_AUTO_P): Likewise.
(PACK_EXPANSION_FORCE_EXTRA_ARGS_P): Likewise.
(ARGUMENT_PACK_CHECK): Define.
(ARGUMENT_PACK_ARGS): Use ARGUMENT_PACK_CHECK.
(SET_ARGUMENT_PACK_ARGS): Likewise.
* parser.cc (cp_parser_sizeof_pack): Check for error_mark_node
before setting PACK_EXPANSION_SIZEOF_P.
The allocation function alloc_f is called for nsize
items where each is of type void *.
libiberty/ChangeLog:
* hashtab.c (htab_empty): Use void * type instead of void **.
(htab_expand): Likewise.
Co-Authored-By: Alan Modra <amodra@gmail.com>
As at r2.2 of the RISC-V ISA specification[1] (equivalent to version 2.0
of the "F" and "D" standard architecture extensions for single-precision
and double-precision floating-point respectively) the FMIN and FMAX
machine instructions fully match our requirement for the `fminM3' and
`fmaxM3' standard RTL patterns:
"For FMIN and FMAX, if at least one input is a signaling NaN, or if both
inputs are quiet NaNs, the result is the canonical NaN. If one operand
is a quiet NaN and the other is not a NaN, the result is the non-NaN
operand."
suitably for the IEEE 754-2008 `minNum' and `maxNum' operations.
However we only define `sminM3' and `smaxM3' standard RTL patterns to
produce the FMIN and FMAX machine instructions, which in turn causes the
`__builtin_fmin' and `__builtin_fmax' family of intrinsics to emit the
corresponding libcalls rather than the relevant machine instructions.
This is according to earlier revisions of the RISC-V ISA specification,
which we however do not support anymore, as from commit 4b81528241
("RISC-V: Support version controling for ISA standard extensions").
As from r20190608 of the RISC-V ISA specification (equivalent to version
2.2 of the "F" and "D" standard ISA extensions for single-precision and
double-precision floating-point respectively) the definition of the FMIN
and FMAX machine instructions has been updated[2]:
"Defined the signed-zero behavior of FMIN.fmt and FMAX.fmt, and changed
their behavior on signaling-NaN inputs to conform to the minimumNumber
and maximumNumber operations in the proposed IEEE 754-201x
specification."
and specifically[3]:
"Floating-point minimum-number and maximum-number instructions FMIN.S
and FMAX.S write, respectively, the smaller or larger of rs1 and rs2 to
rd. For the purposes of these instructions only, the value -0.0 is
considered to be less than the value +0.0. If both inputs are NaNs, the
result is the canonical NaN. If only one operand is a NaN, the result
is the non-NaN operand. Signaling NaN inputs set the invalid operation
exception flag, even when the result is not NaN."
Consequently for forwards compatibility with r20190608+ hardware we
cannot use the FMIN and FMAX machine instructions unconditionally even
where the ISA level of r2.2 has been specified with the `-misa-spec=2.2'
option where operation would be different between ISA revisions, that
is the handling of signaling NaN inputs.
Therefore provide new `fmin<mode>3' and `fmax<mode>3' patterns removing
the need to emit libcalls with the `__builtin_fmin' and `__builtin_fmax'
family of intrinsics, however limit them to where `-fno-signaling-nans'
is in effect, deferring to other code generation strategies otherwise as
applicable. Use newly-defined UNSPECs as the operation codes so that
the patterns are only ever used if referred to by their names, as there
is no RTL expression defined for the IEEE 754-2008 `minNum' and `maxNum'
operations.
References:
[1] "The RISC-V Instruction Set Manual, Volume I: User-Level ISA",
Document Version 2.2, May 7, 2017, Section 8.3 "NaN Generation and
Propagation", p. 48
[1] "The RISC-V Instruction Set Manual, Volume I: Unprivileged ISA",
Document Version 20190608-Base-Ratified, June 8, 2019, "Preface",
p. ii
[2] same, Section 11.6 "Single-Precision Floating-Point Computational
Instructions", p. 66
gcc/
* config/riscv/riscv.md (UNSPEC_FMIN, UNSPEC_FMAX): New
constants.
(fmin<mode>3, fmax<mode>3): New insns.
gcc/testsuite/
* gcc.target/riscv/fmax-snan.c: New test.
* gcc.target/riscv/fmax.c: New test.
* gcc.target/riscv/fmaxf-snan.c: New test.
* gcc.target/riscv/fmaxf.c: New test.
* gcc.target/riscv/fmin-snan.c: New test.
* gcc.target/riscv/fmin.c: New test.
* gcc.target/riscv/fminf-snan.c: New test.
* gcc.target/riscv/fminf.c: New test.
* gcc.target/riscv/smax-ieee.c: New test.
* gcc.target/riscv/smax.c: New test.
* gcc.target/riscv/smaxf-ieee.c: New test.
* gcc.target/riscv/smaxf.c: New test.
* gcc.target/riscv/smin-ieee.c: New test.
* gcc.target/riscv/smin.c: New test.
* gcc.target/riscv/sminf-ieee.c: New test.
* gcc.target/riscv/sminf.c: New test.
The following cleans up if-conversions fold_build_cond_expr to
use gimple-match folding instead of GENERIC folding.
2022-05-10 Richard Biener <rguenther@suse.de>
* tree-if-conv.cc (fold_build_cond_expr): Use
match-and-simplify to simplify the condition.
(ifcvt_follow_ssa_use_edges): Remove.
(predicate_scalar_phi): Use follow_all_ssa_edges.
Fix-up for commit c14ea6a72f
"Catch 'GIMPLE_DEBUG' misbehavior in OpenACC 'kernels' decomposition
[PR100400, PR103836, PR104061]".
For C++ compilation of 'c-c++-common/goacc/kernels-decompose-pr100400-1-2.c',
we first emit a 'sorry' diagnostic, and then a 'gcc_unreachable' (or
'internal_error', see below) diagnostic, but for example, for
'--enable-checking=release' (thus, '!CHECKING_P'), the second one may actually
be turned into a 'confused by earlier errors, bailing out' diagnostic. (See
'gcc/diagnostic.cc:diagnostic_report_diagnostic': "When not checking, ICEs are
converted to fatal errors when an error has already occurred.") Thus, make
'c-c++-common/goacc/kernels-decompose-pr100400-1-2.c' behave consistently via
'-Wfatal-errors', and thus only matching the 'sorry' diagnostic.
For example, for '--enable-checking=no' (thus, '!ENABLE_ASSERT_CHECKING'), a
call to 'gcc_unreachable' cannot be assumed emit an 'internal_error'-like
diagnostic, so explicitly call 'internal_error' in
'gcc/omp-oacc-kernels-decompose.cc:visit_loops_in_gang_single_region', in the
'GIMPLE_OMP_FOR' case, to avoid regressing
'c-c++-common/goacc/kernels-decompose-pr100400-1-3.c', and
'c-c++-common/goacc/kernels-decompose-pr100400-1-4.c'.
PR middle-end/100400
gcc/
* omp-oacc-kernels-decompose.cc
(visit_loops_in_gang_single_region) <GIMPLE_OMP_FOR>: Explicitly
call 'internal_error'.
gcc/testsuite/
* c-c++-common/goacc/kernels-decompose-pr100400-1-2.c: Specify
'-Wfatal-errors'.
Fix-up for recent commit r13-116-g3f8c389fe90bf565a6221a46bb7fb745dd4c1510
"OpenMP: Fix use_device_{addr,ptr} with in-data-sharing arg", where we
currently get:
libgomp: use_device_ptr pointer wasn't mapped
FAIL: libgomp.fortran/use_device_addr-5.f90 -O execution test
libgomp/
* testsuite/libgomp.fortran/use_device_addr-5.f90: Fix up
multi-device testing.
In modules, 'attached to global module' nearly always means 'not in
module purview'. Also the implementation treats, 'in global module &&
in module purview' as meaning 'header unit'. The ModuleKind flags
reflected that. The 'nearly always' means there are cases that the
first condition is not invariant, and that of course invalidates the
second equivalence.
This disambiguates the ModuleKind flags to allow that 'not quite', and
separate out header-unitness from the GMF & purview flags combination.
1) Separate out named-module vs header-unit from the MODULE/GLOBAL flags.
2) Replace the MODULE/GLOBAL flags with PURVIEW & ATTACH flags.
3) Adjust the parser state handling.
Lays ground-work for language-declaration changes.
gcc/cp/
* cp-tree.h (enum module_kind_bits): Disambiguate purview,
attach, named module vs header-unit.
(global_purview_p, not_module_p): Delete.
(named_module_p): New.
(header_module_p, module_purview_p): Adjust.
(module_attach_p, named_module_purview_p): New.
* decl.cc (duplicate_decls): Adjust.
* module.cc (declare_module, preprocessed_module): Adjust.
* name-lookup.cc (init_global_partition): Adjust.
(get_fixed_binding_slot, pushdecl): Adjust.
* parser.cc (cp_parser_module_declaration): Adjust.
(cp_parser_import_declaration, cp_parser_declaration): Adjust.
The following makes sure to have a consistent state of
flag_var_tracking_assignments with the distributed handling
in process_options and finish_options by moving everything to
finish_options which also restores diagnostics for
-g0 -fvar-tracking which was lost with previous changes.
2022-05-10 Richard Biener <rguenther@suse.de>
PR middle-end/105537
* toplev.cc (process_options): Move flag_var_tracking
handling ...
* opts.cc (finish_options): ... here.
* gcc.dg/torture/pr105537.c: New testcase.
gcov_info::n_functions type is initialized by generated
code in build_info_type:
/* n_functions */
field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
get_gcov_unsigned_t ());
It uses gcov_unsigned_t, but the struct definition in libgcov.h uses
unsigned type. That brings troubled on 16-bit targets.
PR gcov-profile/105535
libgcc/ChangeLog:
* libgcov.h (struct gcov_info): Use gcov_unsigned_t for
n_functions.
Co-Authored-By: Hans-Peter Helfert <peter-helfert@t-online.de>
When code was moved from process_options to finish_options it
was not properly adjusted to look at and alter the opts set
passed to the function but continued to modify the global options
set. The following rectifies this and makes sure the same
mistake isn't repeated by poisoning global_options{,_set}.
2022-05-10 Richard Biener <rguenther@suse.de>
* flags.h (dwarf_debuginfo_p): Add opts argument, guard
API with !GENERATOR_FILE.
* opts.cc (global_options): Poison.
(global_options_set): Likewise.
(finish_options): Refer to options via opts.
The simple test case below has the unfortunate property that on x86_64,
it is larger when compiled with -Os than when compiled with -O2.
int foo(char x)
{
return (x & 123) != 0;
}
The issue is x86's complex instruction encoding, where andb $XX,%dil
requires more bytes than andl $XX,%edi. This patch adds logic to
i386.md's *testqi_1_maybe_si and *andqi_2_maybe_si define_insn patterns
to prefer the shorter SImode alternative when optimizing for size.
2022-05-10 Uroš Bizjak <ubizjak@gmail.com>
Roger Sayle <roger@nextmovesoftware.com>
gcc/ChangeLog
* config/i386/i386.md (*testqi_1_maybe_si): Prefer shorter SImode
alternative when optimizing for size and the immediate operand is
const_0_to_127_operand.
(*andqi_2_maybe_si): Likewise.
* config/i386/predicates.md (const_0_to_127_operand): New predicate.
gcc/testsuite/ChangeLog
* gcc.target/i386/and-1.c: New test case.
This patch adds a small (follow-up) optimization to chrec_apply for
linear chrecs to clean-up the final value expressions sometimes generated
by GCC's scalar evolution pass. The transformation of A+(X-1)*A into
A*X is usually unsafe with respect to overflow (see PR92712), and so
can't be performed by match.pd (or fold-const). However, during scalar
evolution's evaluation of recurrences it's known that X-1 can't be negative
(in fact X-1 is unsigned even when A is signed), hence this optimization
can be applied. Interestingly, this expression does get simplified in
later passes once the range of X-1 is bounded by VRP, but that occurs
long after the decision of whether to perform final value replacement,
which is based on the complexity of this expression.
The motivating test case is the optimization of the loop (from comment
int square(int x) {
int result = 0;
for (int i = 0; i < x; ++i)
result += x;
return result;
}
which is currently optimized, with final value replacement to:
final value replacement:
with expr: (int) ((unsigned int) x_3(D) + 4294967295) * x_3(D) + x_3(D)
but with this patch it first gets simplified further:
final value replacement:
with expr: x_3(D) * x_3(D)
2022-05-10 Roger Sayle <roger@nextmovesoftware.com>
gcc/ChangeLog
* tree-chrec.cc (chrec_apply): Attempt to fold the linear chrec
"{a, +, a} (x-1)" as "a*x", as the number of loop iterations, x-1,
can't be negative.
gcc/testsuite/ChangeLog
* gcc.dg/tree-ssa/pr65855-2.c: New test case.
Validity checking of enumerations with nonstandard representation
starts by checking the value range, then calling _rep_to_pos to verify
that the value itself is valid. The value range check is thus
redundant and inefficient: the _rep_to_pos call is normally inlined
when optimizing for speed and the range check slows down the fast
path; it is unnecesary and undesirable when optimizing for size, and
just unnecessary when not optimizing. This patch thus drops the range
check for nonstandard boolean types.
gcc/ada/
* exp_attr.adb (Expand_N_Attribute_Reference) <Attribute_Valid>:
Drop redundant range check for nonstandard booleans.
This patch improves the generated code for nonstandard boolean types.
One of the improvements extends the code that avoids converting back
to the nonstandard boolean type an expression computed as standard
boolean, when it will be converted to a(nother) nonstandard boolean
type.
The other improvement involves using the literal representation
constants in an If_Expression instead of dereferencing the T'Val array
when converting to a (nonstandard) boolean type. Avoiding the array
dereference enables the compiler middle-end to propagate the constants
and perform optimizations based on them, to the point of obviating the
improvement above.
Unfortunately, the code generated with this alternate expansion tends
to be slightly larger if it turns out to not enable any further
optimization, though it's most certainly faster, especially on targets
with conditional moves, more so if "store flag" is slow, as on x86.
Still, the array dereference is more straightforward and shorter, so
I've arranged for this alternate expansion to be used only when
optimizing for speed.
gcc/ada/
* exp_util.adb (Adjust_Result_Type): Leave result in
Standard.Boolean if it's going to be converted to another
boolean type.
* exp_ch4.adb (Expand_N_Type_Conversion): When optimizing,
convert to nonstandard booleans with an if_expression with
boolean literals.
We failed to call Adjust_Condition for the condition expression of an
if_expression, so non-standard booleans were expanded like standard
booleans, disregarding representation clauses. Fixed.
gcc/ada/
* exp_ch4.adb (Expand_N_If_Expression): Call Adjust_Condition to
handle non-standard booleans.
This patch fixes an issue in the compiler whereby a use_type_clause
incorrectly gets flagged as ineffective when the use of it comes after a
generic package instantiation where the installation of private use
clauses are required and one such clause references the same type.
gcc/ada/
* sem_ch8.adb (Use_One_Type): Remove code in charge of setting
Current_Use_Clause when Id is known to be redundant, and modify
the printing of errors associated with redundant use type
clauses so that line number gets included in more cases.
We have two variants of Earlier_In_Extended_Unit that take either
Node_Id or Source_Ptr values. The caller can simply use another variant
and not explicitly convert parameters.
Code cleanup; semantics is unaffected.
gcc/ada/
* sem_warn.adb (Check_Unset_Reference): Use variant of
Earlier_In_Extended_Unit that calls Sloc internally.
Both Source_Ptr and Int are integer types (and even happen to have equal
ranges). Their values can be calculated without converting
back-and-forth, e.g.:
Int (Loc1) - Int (Loc2)
can be written simply as:
Int (Loc1 - Loc2)
Code cleanup related to handling of references to unset objects.
Offending occurrences found with various invocations of grep.
gcc/ada/
* par-ch10.adb, scng.adb, sem_res.adb, sinfo-utils.adb,
treepr.adb: Simplify calculations with Source_Ptr and Loc
values.
