| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
These are not used anywhere, we have more efficient variable templates
for them instead. They're not documented as extensions, and are easy for
users to write if they need them.
libstdc++-v3/ChangeLog:
* include/bits/utility.h (__is_in_place_type): Remove.
* include/std/variant (__is_in_place_tag): Remove.
|
|
We don't need to include all of <stdint.h> when we only need uintptr_t
from it. By using GCC's internal macro we avoid unnecessarily declaring
everything in <stdint.h>. This helps users to avoid accidentally relying
on those names being declared without explicitly including the header.
libstdc++-v3/ChangeLog:
* include/bits/align.h (align, assume_aligned): Use
__UINTPTR_TYPE__ instead of uintptr_t. Do not include
<stdint.h>.
* include/bits/atomic_base.h (__atomic_ref): Likewise.
* include/bits/atomic_wait.h (__waiter_pool_base::_S_for):
Likewise.
* include/std/atomic: Include <cstdint>.
|
|
libstdc++-v3/ChangeLog:
* include/bits/atomic_base.h (__atomic_impl::compare_exchange_weak):
Remove unused parameter.
(__atomic_impl::compare_exchange_strong): Likewise.
|
|
As noted in the PR the compiler doesn't seem able to do this on its own,
so we get better code at all optimization levels by using memcmp.
libstdc++-v3/ChangeLog:
PR libstdc++/113807
* include/std/bitset (bitset::_M_is_equal()): Use memcmp to
optimize operator==.
|
|
This should have been done as part of r13-693-ge3b8b4f7814c54, but I
only added the preprocessor logic and didn't use ARGS in the code.
libstdc++-v3/ChangeLog:
* testsuite/26_numerics/random/discrete_distribution/operators/values.cc:
Use ARGS to limit number of iterations for simulators.
|
|
This is needed to avoid errors outside the immediate context when
evaluating is_default_constructible_v<basic_string<C, T, A>> when A is
not default constructible.
This change is not sufficient to solve the problem because there are a
large number of member functions which have a default argument that
constructs an allocator.
libstdc++-v3/ChangeLog:
PR libstdc++/113841
* include/bits/basic_string.h (basic_string::basic_string()):
Constrain so that it's only present if the allocator is default
constructible.
* include/bits/cow_string.h (basic_string::basic_string()):
Likewise.
* testsuite/21_strings/basic_string/cons/113841.cc: New test.
|
|
The C++17 non-const overload of data() allows modifying the string
contents directly, so for the COW string we must do a copy-on-write to
unshare it. That means allocating, which can throw, so it shouldn't be
noexcept.
libstdc++-v3/ChangeLog:
PR libstdc++/99942
* include/bits/cow_string.h (data()): Change to noexcept(false).
|
|
In PR116149 we choose a wrong vector length which causes wrong values in
a reduction. The problem happens in avlprop where we choose the
number of units in the instruction's mode as vector length. For the
non-scalar variants the respective operand has the correct non-widened
mode. For the scalar variants, however, the same operand has a scalar
mode which obviously only has one unit. This makes us choose VL = 1
leaving three elements undisturbed (so potentially -1). Those end up
in the reduction causing the wrong result.
This patch adjusts the mode_idx just for the scalar variants of the
affected instruction patterns.
gcc/ChangeLog:
PR target/116149
* config/riscv/vector.md: Fix mode_idx attribute of scalar
widen add/sub variants.
gcc/testsuite/ChangeLog:
* gcc.target/riscv/rvv/autovec/pr116149.c: New test.
|
|
A static analyzer found a pasto in gfc_get_array_descr_info.
The code does
t = base_decl;
if (!integer_zerop (dtype_off))
t = fold_build_pointer_plus (t, dtype_off);
dtype = TYPE_MAIN_VARIANT (get_dtype_type_node ());
field = gfc_advance_chain (TYPE_FIELDS (dtype), GFC_DTYPE_RANK);
rank_off = byte_position (field);
if (!integer_zerop (dtype_off))
t = fold_build_pointer_plus (t, rank_off);
i.e. uses the same !integer_zerop check between both, while it should
be checking rank_off in the latter case.
This actually doesn't change anything on the generated code, because
both the dtype_off and rank_off aren't zero,
typedef struct dtype_type
{
size_t elem_len;
int version;
signed char rank;
signed char type;
signed short attribute;
}
dtype_type;
struct {
type *base_addr;
size_t offset;
dtype_type dtype;
index_type span;
descriptor_dimension dim[];
};
dtype_off is 16 on 64-bit arches and 8 on 32-bit ones and rank_off is
12 on 64-bit arches and 8 on 32-bit arches, so this patch is just to
pacify those static analyzers or be prepared if the ABI changes in the
future. Because in the current ABI both of those are actually non-zero,
doing
if (!integer_zerop (something)) t = fold_build_pointer_plus (t, something);
actually isn't an optimization, it will consume more compile time. If
the ABI changes and we forget to readd it, nothing bad happens,
fold_build_pointer_plus handles 0 addends fine, just takes some compile
time to handle that.
I've kept this if (!integer_zerop (data_off)) guard earlier because
data_off is 0 in the current ABI, so it is an optimization there.
2024-08-01 Jakub Jelinek <jakub@redhat.com>
* trans-types.cc (gfc_get_array_descr_info): Don't test if
!integer_zerop (dtype_off), use fold_build_pointer_plus
unconditionally.
|
|
Also add a testcase for -mabi=lp64d where 'd' is required.
gcc/ChangeLog:
PR target/116111
* config/riscv/riscv.cc (riscv_option_override): Add error.
gcc/testsuite/ChangeLog:
* gcc.target/riscv/arch-41.c: New test.
* gcc.target/riscv/pr116111.c: New test.
Signed-off-by: Patrick O'Neill <patrick@rivosinc.com>
|
|
Remove useless test variable and use a more accurate dg-error pattern so
that only the ill-formed expression compilation error is considered.
libstdc++-v3/ChangeLog:
* testsuite/23_containers/map/operators/1_neg.cc (test01): Remove test variable
and use 'no match' dg-error patter.
* testsuite/23_containers/set/operators/1_neg.cc (test01): Likewise.
|
|
[PR116113]
The following testcase ICEs, because for structured binding error recovery
DECL_DECOMP_BASE is kept NULL and the newly added code to pick up saved
value from the base assumes that on structured binding bases the
TARGET_EXPR will be always there (that is the case if there are no errors).
The following patch fixes it by testing DECL_DECOMP_BASE before
dereferencing it, another option would be not to do that if
error_operand_p (cond).
2024-08-01 Jakub Jelinek <jakub@redhat.com>
PR c++/116113
* semantics.cc (maybe_convert_cond): Check DECL_DECOMP_BASE
is non-NULL before dereferencing it.
(finish_switch_cond): Likewise.
* g++.dg/cpp26/decomp11.C: New test.
|
|
This adds a cost model and core definition for Cortex-X925.
gcc/ChangeLog:
* config/aarch64/aarch64-cores.def (cortex-x925): New.
* config/aarch64/aarch64-tune.md: Regenerate.
* config/aarch64/tuning_models/cortexx925.h: New file.
* config/aarch64/aarch64.cc: Use it.
* doc/invoke.texi: Document it.
|
|
This updates the cost for Neoverse N2 to reflect the updated
Software Optimization Guide.
gcc/ChangeLog:
* config/aarch64/tuning_models/neoversen2.h: Update costs.
|
|
this updates the costs for gener-armv9-a based on the updated costs for
Neoverse V2 and Neoverse N2.
gcc/ChangeLog:
* config/aarch64/tuning_models/generic_armv9_a.h: Update costs.
|
|
This adds a cost model and core definition for Neoverse N3 and Cortex-A725.
It also makes Cortex-A725 use the Neoverse N3 cost model.
gcc/ChangeLog:
* config/aarch64/aarch64-cores.def (neoverse-n3, cortex-a725): New.
* config/aarch64/aarch64-tune.md: Regenerate.
* config/aarch64/tuning_models/neoversen3.h: New file.
* config/aarch64/aarch64.cc: Use it.
* doc/invoke.texi: Document it.
|
|
This adds a cost model and core definition for Neoverse V3AE.
gcc/ChangeLog:
* config/aarch64/aarch64-cores.def (neoverse-v3ae): New.
* config/aarch64/aarch64-tune.md: Regenerate.
* config/aarch64/tuning_models/neoversev3ae.h: New file.
* config/aarch64/aarch64.cc: Use it.
* doc/invoke.texi: Document it.
|
|
This adds a cost model and core definition for Neoverse V3.
It also makes Cortex-X4 use the Neoverse V3 cost model.
gcc/ChangeLog:
* config/aarch64/aarch64-cores.def (cortex-x4): Update.
(neoverse-v3): New.
* config/aarch64/aarch64-tune.md: Regenerate.
* config/aarch64/tuning_models/neoversev3.h: New file.
* config/aarch64/aarch64.cc: Use it.
* doc/invoke.texi: Document it.
|
|
This updates the cost for Neoverse V2 to reflect the updated
Software Optimization Guide.
It also makes Cortex-X3 use the Neoverse V2 cost model.
gcc/ChangeLog:
* config/aarch64/aarch64-cores.def (cortex-x3): Use Neoverse-V2 costs.
* config/aarch64/tuning_models/neoversev2.h: Update costs.
|
|
When this pattern was converted from being only dealing with 0/-1, we missed that if `e == f` is true
then the optimization is wrong and needs an extra check for that.
This changes the patterns to be:
/* (a ? x : y) != (b ? x : y) --> (a^b & (x != y)) ? TRUE : FALSE */
/* (a ? x : y) == (b ? x : y) --> (a^b & (x != y)) ? FALSE : TRUE */
/* (a ? x : y) != (b ? y : x) --> (a^b | (x == y)) ? FALSE : TRUE */
/* (a ? x : y) == (b ? y : x) --> (a^b | (x == y)) ? TRUE : FALSE */
Also this can't be done if the X can be a NaNs either. Since that changes the value there too.
This still produces better code than the original case and in many cases (x != y) will
still reduce to either false or true.
With this change we also need to make sure `a`, `b` and the resulting types are all
the same for the same reason as the previous patch.
I updated (well added) to the testcases to make sure there are the right amount of
comparisons left.
Changes since v1:
* v2: Fixed the testcase names and fixed dg-run to be `dg-do run`. Added a check for HONORS_NANS too.
Bootstrapped and tested on x86_64-linux-gnu with no regressions.
PR tree-optimization/116120
gcc/ChangeLog:
* match.pd (`(a ? x : y) eq/ne (b ? x : y)`): Add test for `x != y`
in result.
(`(a ? x : y) eq/ne (b ? y : x)`): Add test for `x == y` in result.
gcc/testsuite/ChangeLog:
* g++.dg/tree-ssa/pr111150.C: Add extra checks on the test.
* gcc.dg/tree-ssa/pr111150-1.c: Likewise.
* gcc.dg/tree-ssa/pr111150.c: Likewise.
* g++.dg/torture/pr116120-1.C: New test.
* g++.dg/torture/pr116120-2.C: New test.
Signed-off-by: Andrew Pinski <quic_apinski@quicinc.com>
|
|
The procedure Realloc_For_Chunk which is used to reallocate an unbounded
string when needed may lead in theory to an overflow, due to the use of
variable S_Length denoting the current allocated length instead of
Source.Last denoting the current string length. Now fixed.
This has no effect in practice since the only targets that use this
version of Ada.Strings.Unbounded do not have enough memory to make it
possible to have an overflow here.
gcc/ada/
* libgnat/a-strunb.adb (Realloc_For_Chunk): Fix computation of new
size.
|
|
The contracts of Ada.Strings.Bounded.To_String and
Ada.Strings.Fixed.Delete are updated to reflect the standard spec and to
allow proof of callers.
gcc/ada/
* libgnat/a-strbou.ads (To_String): Add a postcondition to state
the value of bounds of the returned string, which helps with proof
of callers.
* libgnat/a-strfix.adb (Delete): Fix implementation to produce
correct result in all cases. For example, returned string should
always have a lower bound of 1, which was not respected in one
case. This was not detected by proof, since this code was dead
according to the too strict precondition.
* libgnat/a-strfix.ads (Delete): State the correct precondition
from standard which allows a value of Through beyond the last
valid index, and also restricts values of From from below. Update
the Contract_Cases accordingly to allow new values of parameters.
|
|
For consistency, we now accept duplicate SPARK_Mode pragmas in
configuration files just like we accept other duplicate pragas there.
gcc/ada/
* sem_prag.adb (Analyze_Pragma): Don't check for duplicate
SPARK_Mode pragmas in configuration files.
|
|
The compiler fails to accept an access attribute where the prefix is the name
of an object of a user-defined reference type, and is not prepared to deal
with the possibility of overloaded prefixes other than subprogram cases.
Such a prefix can either represent the reference object directly, or it
can be interpreted as an implicit dereferencing of the object's reference
value, depending on the expected type. Special handling for this kind of
prefix is added alongside the normal handling for overloaded prefixes of
access attributes.
gcc/ada/
* sem_attr.adb (Resolve_Attribute, Attribute_*Access): Resolve
overloaded prefixes that denote objects of reference types,
determining whether to use the prefix object directly, or expand
it as an explicit dereference.
|
|
It is documented for N_Subprogram_Body_Stub instead of N_Subprogram_Body.
gcc/ada/
* sinfo.ads (N_Block_Statement): Move At_End_Proc to the end of
slot list and alphabetize flag list.
(N_Subprogram_Body): Add At_End_Proc.
(N_Package_Body): Move At_End_Proc to the end of slot list.
(N_Subprogram_Body_Stub): Remove At_End_Proc.
|
|
Apparently we can always safely set the type of a loop parameter from
its discrete subtype definition. It looks like the conditional setting
was only necessary when preconditions were expanded into dedicated
procedures, but we no longer use this expansion.
gcc/ada/
* sem_ch5.adb (Analyze_Loop_Parameter_Specification):
Unconditionally set the type of loop parameter.
|
|
The GNAT style guide specifies that there must not be blank lines after
'begin' keywords.
gcc/ada/
* backend_utils.adb (Scan_Common_Back_End_Switch): Remove blank
line.
* errout.adb (Output_JSON_Message): Likewise.
* erroutc.adb (Set_Msg_Char): Likewise.
* exp_aggr.adb (Two_Dim_Packed_Array_Handled): Likewise.
* exp_pakd.adb (Expand_Packed_Address_Reference): Likewise.
(Expand_Packed_Bit_Reference): Likewise.
(Expand_Packed_Boolean_Operator): Likewise.
(Expand_Packed_Element_Reference): Likewise.
(Expand_Packed_Eq): Likewise.
(Expand_Packed_Not): Likewise.
* exp_prag.adb (Build_Dim3_Declaration): Likewise.
* exp_strm.adb (Build_Elementary_Input_Call): Likewise.
* freeze.adb (Find_Aspect_No_Parts): Likewise.
(Get_Aspect_No_Parts_Value): Likewise.
* gen_il-gen.adb (Compile): Likewise.
* gnat1drv.adb (Adjust_Global_Switches): Likewise.
* gnat_cuda.adb (Expand_CUDA_Package): Likewise.
* gnatchop.adb (Read_File): Likewise.
* gnatls.adb (Get_Runtime_Path): Likewise.
* make.adb (Binding_Phase): Likewise.
* par-ch11.adb (P_Exception_Choice): Likewise.
* par-ch5.adb (P_Loop_Parameter_Specification): Likewise.
* par-ch6.adb (Is_Extended): Likewise.
* sem_attr.adb (Check_Dereference): Likewise.
* sem_ch12.adb (Build_Subprogram_Decl_Wrapper): Likewise.
* sem_ch3.adb (Build_Itype_Reference): Likewise.
* sem_prag.adb (Validate_Compile_Time_Warning_Errors): Likewise.
* sem_res.adb (Resolve_Declare_Expression): Likewise.
* sem_util.adb (Build_Default_Subtype): Likewise.
* sprint.adb (Sprint_Paren_Comma_List): Likewise.
|
|
gcc/ada/
* par-ch2.adb (P_Interpolated_String_Literal): remove support of
multi-line string literals.
* doc/gnat_rm/gnat_language_extensions.rst: Update documentation.
* gnat_rm.texi: Regenerate.
|
|
These messages are conditionally activated only when
-gnatwj (Warn_On_Obsolescent_Feature) is activated. They
should use the switch specific insertion character instead.
gcc/ada/
* sem_warn.adb (Output_Obsolescent_Entity_Warnings): use the ?j?
in warning messages.
|
|
Before this patch, the compiler failed to handle the case where the for loop
created by expansion of a quantified expression required cleanup handlers.
gcc/ada/
* sem_ch5.adb (Analyze_Loop_Parameter_Specification): Fix test for
expanded quantified expression context.
(Is_Expanded_Quantified_Expr): New function.
|
|
This patch fixes a failure of name resolution when
a range attribute reference appears in a Ghost_Predicate
and the ghost policy is Ignore.
gcc/ada/
* sem_ch13.adb (Add_Predicate): Remove the premature "return;".
Ghost code needs to be processed by later code in this procedure
even when ignored; otherwise the second pass of name resolution
fails much later. However, protect Set_SCO_Pragma_Enabled and
Add_Condition with "if not Is_Ignored_Ghost_Pragma"; these parts
should not happen if the ghost code is Ignored.
* libgnat/interfac__2020.ads (Unsigned_8): Minor reformatting.
* libgnat/interfac.ads (IEEE_Extended_Float): Minor comment
improvement.
|
|
...instead of defining it for all entities.
gcc/ada/
* einfo.ads (No_Return): Change description and adjust
accordingly.
* gen_il-gen-gen_entities.adb (Entity_Kind): Remove No_Return.
(Subprogram_Kind): Add No_Return.
(Generic_Subprogram_Kind): Likewise.
* sem_ch6.adb (Analyze_Return_Statement): Adjust No_Return test.
|
|
These semantics state that the compiler is permitted to enforce none of
the guarantees specified by the RM 7.6.1(14/1) and following subclauses,
and to instead just let the exception be propagated upward.
The guarantees impose a significant overhead in terms of complexity and
run-time performance compared to similar constructs in other languages,
and the goal is to reduce it significantly, if not eliminate it totally:
for example, untagged record types declared with the Finalizable aspect,
the relaxed finalization semantics and inline Initialize/Adjust/Finalize
primitives, and used with abort disabled:
pragma Restrictions (No_Abort_Statements);
pragma Restrictions (Max_Asynchronous_Select_Nesting => 0);
pragma Restrictions (No_Asynchronous_Control);
should behave like simple C++ classes.
The implementation morally boils down to undoing the changes made a few
months ago to the support of finalization for controlled objects, i.e.
to getting rid of the added linked list and the associated indirection
for controlled objects with relaxed finalization semantics.
But, in order to keep a unified processing for both kinds of controlled
objects and not to bring back the issues addressed by the aforementioned
changes, the work is split between the front-end and the code generator:
the front-end drops the linked list and the code generator is in charge
of eliminating the indirection with the help of the optimizer.
gcc/ada/
* doc/gnat_rm/gnat_language_extensions.rst (Generalized
Finalization): Update status.
* einfo.ads (Has_Relaxed_Finalization): Add more details.
* exp_ch4.adb (Process_Transients_In_Expression): Invoke
Make_Finalize_Call_For_Node instead of building the call.
* exp_ch5.adb (Expand_N_Assignment_Statement): Do not set up an
exception handler around the assignment for a controlled type with
relaxed finalization semantics. Streamline the code implementing
the protection against aborts and do not use an At_End handler for
a controlled type with relaxed finalization semantics.
* exp_ch7.ads (Make_Finalize_Call_For_Node): New function.
* exp_ch7.adb (Finalize_Address_For_Node): New function renaming.
(Set_Finalize_Address_For_Node): New procedure renaming.
(Attach_Object_To_Master_Node): Also attach the Finalize_Address
primitive to the Master_Node statically.
(Build_Finalizer): Add Has_Strict_Ctrl_Objs local variable. Insert
back the body of the finalizer at the end of the statement list in
the non-package case and restore the associated support code to
that effect. When all the controlled objects have the relaxed
finalization semantics, do not create a Finalization_Master and
finalize the objects directly instead.
(Processing_Actions): Add Strict parameter and use it to set the
Has_Strict_Ctrl_Objs variable.
(Process_Declarations): Make main loop more robust and adjust
calls to Processing_Actions.
(Make_Finalize_Address_Body): Mark the primitive as inlined if the
type has relaxed finalization semantics.
(Make_Finalize_Call_For_Node): New function.
* sem_ch6.adb (Check_Statement_Sequence): Skip subprogram bodies.
* libgnat/s-finpri.ads (Finalize_Object): Add Finalize_Address
parameter.
(Master_Node): Remove superfluous qualification.
* libgnat/s-finpri.adb (Attach_Object_To_Node): Likewise.
(Finalize_Master): Adjust calls to Finalize_Object.
(Finalize_Object): Add Finalize_Address parameter and assert that
it is equal to the component of the node. Use the Object_Address
component as guard.
(Suppress_Object_Finalize_At_End): Clear Object_Address component.
* gnat_rm.texi: Regenerate.
* gnat_ugn.texi: Regenerate.
|
|
gcc/ada/
* bindgen.adb (Gen_Main): Put back support for -G
* bindusg.adb (Display): Put back line for -G
* opt.ads (CCG_Mode): Update doc
* switch-b.adb (Scan_Binder_Switches): Put back support for -G
|
|
A previous commit disabled the removal of the Component_Size aspect from
GNAT's tree when in CodePeer_Mode. This effectively resulted in CodePeer
not ignoring Component_Size anymore. As a side effect, GNAT started
expanding packed operations on array types from their high-level
representations to operations operating on bits. It wasn't caught during
the original testing, but this actually confuses CodePeer. We thus need
to disable expansion of packed operations while in CodePeer_Mode.
gcc/ada/
* exp_pakd.adb (Expand_Bit_Packed_Element_Set): Disable expansion
in CodePeerMode.
(Expand_Packed_Address_Reference): Likewise.
(Expand_Packed_Bit_Reference): Likewise.
(Expand_Packed_Boolean_Operator): Likewise.
(Expand_Packed_Element_Reference): Likewise.
(Expand_Packed_Eq): Likewise.
(Expand_Packed_Not): Likewise.
|
|
Check expressions of aspects Default_Value and Default_Component_Value
for references to the annotated types just before resolving these
expressions.
This patch fixes both an asymmetry in processing of those aspects and
adds a missing check in GNATprove on aspect Default_Component_Value.
gcc/ada/
* sem_ch13.adb (Check_Aspect_Too_Late): Move routine to top-level.
(Resolve_Aspect_Expressions): Check aspects Default_Value and
Default_Component_Value before resolving their expressions.
|
|
This patch fixes an infinite loop in freezing that occurred when
expression of the Default_Value aspect includes a declare expression
with an object of the annotated type.
gcc/ada/
* sem_ch13.adb (Check_Aspect_Too_Late): Prevent freezing during
preanalysis.
|
|
This is a code cleanup and apparently has no impact on the behavior.
The Must_Not_Freeze is saved/set/restored by Preanalyze_Spec_Expression,
so it doesn't need to be set before calling that routine and apparently
doesn't need to be set after that calling that routine either.
gcc/ada/
* sem_ch13.adb (Resolve_Aspect_Expression): Don't set
Must_Not_Freeze before preanalyzing spec expressions.
|
|
There is no RM rule requiring an overriding indicator in the case where
this message is generated; such a rule was discussed many years ago in an
AI, but that AI was never approved. So generate a warning message instead
of an error message. And don't even do that if we are in an instance (warning
a user they should change the source of an instance seems unlikely to be
helpful, at least in this case).
gcc/ada/
* sem_disp.adb (Check_Dispatching_Operation): When calling
Error_Msg_NE to generate a "missing overriding indicator" message,
generate a warning message instead of an error message (and update
comment to describe this new behavior).
|
|
gcc/ada/
* sem_aggr.adb (Collect_Aggr_Bounds): Adjust previous patch to
store the bounds of inner null aggregates in the itype; required
generate the runtime check of ARM 4.3.3(30).
|
|
gcc/ada/
* osint-c.ads, osint-c.adb (Create_C_File, Close_C_File,
Delete_C_File): Put back, needed by LLVM based CCG.
* exp_unst.adb (Unnest_Subprogram): Complete previous change by
removing now dead code and corresponding ??? comment.
|
|
In the case of controlled components initialized by a container aggregate,
the compiler was suppressing the call to the needed Adjust operation,
because it was suppressed for all aggregates. But container aggregates
aren't built in place, so target adjustment should still be done in that
case.
gcc/ada/
* exp_ch3.adb (Build_Record_Init_Proc.Build_Assignment): Do the
component adjustment in the case of initialization by a container
aggregate.
|
|
This is a fallout of an earlier fix to Is_Build_In_Place_Aggregate_Return
that made it take into account intermediate conditional expressions, but
turned out to work only for a single nesting level of them.
The fix reuses the delayed expansion mechanism recently extended to deal
with conditional expressions in a straightforward way.
gcc/ada/
* exp_aggr.adb (Convert_To_Assignments): Set Expansion_Delayed on
intermediate conditional expressions for BIP aggregate returns
too.
* exp_ch4.adb (Expand_N_Case_Expression): Also deal with delayed
expansion in the return case.
(Expand_N_If_Expression): Likewise.
|
|
In some cases, an expanded name refering to a predefined operator (such as
Some_Package."+") occurring in a static expression function would be
incorrectly rejected with a message saying that the operator is not directly
visible (which, while True, does not make the reference illegal).
gcc/ada/
* sem_ch4.adb (Is_Effectively_Visible_Opertor): Return True if
Checking_Potentially_Static_Expression is True. The accompanying
comment says True is returned "if there is a reason it is ok for
Is_Visible_Operator to return False"; if
Checking_Potentially_Static_Expression is true, that is such a
reason.
|
|
This piece of code was introduced in 2011 in order to prevent spurious
false positives from appearing on specific code patterns making use of
Component_Size.
It seems that now this piece of code is causing small false positives
instead of preventing them, so let's remove it.
gcc/ada/
* sem_ch13.adb (Analyze_Attribute_Definition_Clause): Stop
ignoring Component_Size attribute in CodePeer_Mode.
|
|
This patches fixes a problem where cleanup statements would be
missing for some cases of loop parameter specifications that allocate
on the secondary stack.
gcc/ada/
* sem_ch5.adb (Prepare_Param_Spec_Loop): Fix criterion for
wrapping loop statements into blocks.
|
|
The support for generating C for Ada code is moved to GNAT LLVM.
Keep support for generating header files from Ada spec files which
is the remaining usage of -gnatceg.
gcc/ada/
* bindgen.adb, bindusg.adb, debug.adb, einfo.ads,
exp_aggr.adb, exp_attr.adb, exp_ch11.adb, exp_ch3.adb,
exp_ch4.adb, exp_ch6.adb, exp_ch7.adb, exp_ch8.adb, exp_dbug.adb,
exp_dbug.ads, exp_intr.adb, exp_unst.adb, exp_util.adb,
exp_util.ads, freeze.adb, gen_il-fields.ads,
gen_il-gen-gen_entities.adb, gnat1drv.adb, inline.adb, opt.ads,
osint-c.adb, osint-c.ads, sem_attr.adb, sem_ch12.adb, sem_ch3.adb,
sem_ch4.adb, sem_ch6.adb, sem_elab.adb, sem_res.adb, sinfo.ads,
snames.ads-tmpl, switch-b.adb, switch-c.adb: Major
clean up to remove C code generation for bodies.
|
|
This patch makes Exp_Aggr.Convert_To_Positional accepts appropriate
empty aggregates. The end goal is to remove violations of the
No_Elaboration_Code restriction in some cases of library-level array
objects.
gcc/ada/
* exp_aggr.adb (Flatten): Do not reject empty aggregates. Adjust
criterion for emitting warning about ineffective others clause.
* sem_aggr.adb (Array_Aggr_Subtype): Fix typo. Add handling of
aggregates that were converted to positional form.
(Resolve_Aggregate): Tweak criterion for transforming into a
string literal.
(Resolve_Array_Aggregate): Tweak criterion for reusing existing
bounds of aggregate.
(Retrieve_Aggregate_Bounds): New procedure.
* sem_util.adb (Has_Static_Empty_Array_Bounds): New function.
* sem_util.ads (Has_Static_Empty_Array_Bounds): Likewise.
|
|
This removes a parameter and a variable that are entirely determined by
another parameter and another variable respectively.
gcc/ada/
* exp_ch7.ads (Build_Finalizer): Remove Top_Decls parameter.
* exp_ch7.adb (Build_Finalizer): Likewise. Rename Counter_Val into
Count, replace Has_Ctrl_Objs local variable by expression
function, remove Spec_Decls local variable and do not reset
Finalizer_Decls.
(Expand_Cleanup_Actions): Adjust call to Build_Finalizer.
(Expand_N_Package_Body): Likewise.
(Expand_N_Package_Declaration): Likewise.
* inline.adb (Cleanup_Scopes): Likewise.
|
|
It is possible to call the "+" operator of System.Storage_Elements directly
as done for example in Expand_Interface_Thunk.
gcc/ada/
* exp_ch7.adb (Make_Address_For_Finalize): Generate a direct call
to the "+" operator of System.Storage_Elements.
(Make_Finalize_Address_Stmts): Likewise.
* rtsfind.ads (RE_Id): Remove RE_Add_Offset_To_Address.
(RE_Unit_Table): Remove entry for RE_Add_Offset_To_Address.
* libgnat/s-finpri.ads (Add_Offset_To_Address): Delete.
* libgnat/s-finpri.adb (Add_Offset_To_Address): Likewise.
|
