| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
GNATprove relies on the comment for Get_Enum_Lit_From_Pos, which
promises to raise Constraint_Error when its Pos parameter is not among
the representation values for enumeration literal. However, this promise
was only respected in builds with range checks enabled.
The root problem was that a similar comment for conversion from Uint to
Char_Code was likewise only respected in builds with range checks
enabled.
Now both routines respect promises in their comments. The behaviour of
GNAT itself is not affected. The fix is needed to filter garbage
counterexamples generated by provers for characters objects in SPARK.
gcc/ada/
* uintp.adb (UI_To_CC): Guard against illegal inputs; reuse
UI_To_Int.
|
|
Replace "Char_Code (UI_To_Int (...))" with "UI_To_CC (...).
Cleanup related to handling characters in GNATprove counterexamples;
semantics is unaffected.
gcc/ada/
* par-prag.adb (Prag): Simplify conversion of character codes.
* sem_case.adb (Choice_Image): Likewise.
(Lit_Of): Likewise.
|
|
This patch corrects issues in the compiler whereby finalization of a
heap- allocated class-wide type may cause an invalid memory read at
runtime when the type in question contains a component whose type has a
large alignment.
gcc/ada/
* exp_attr.adb (Expand_N_Attribute_Reference) <Attribute_Tag>:
Deal specifically wth class-wide equivalent types without a
parent.
* exp_util.adb (Build_Allocate_Deallocate_Proc): Extract
allocator node for calculation of alignment actual and modify
alignment for allocators of class-wide types with associated
expressions.
(Make_CW_Equivalent_Type): Handle interface types differently
when generating the equivalent record.
* sem_aux.adb (First_Tag_Component): Accept class-wide
equivalent types too.
|
|
The current termination condition of the recursion is wrong. When in
JSON mode, names should be fully qualified. This requires to stop not at
the first encountered compilation unit but to recurse up to Standard.
gcc/ada/
* repinfo.adb (List_Name): Rework termination condition.
|
|
Style cleanups. Violation initially spotted while reading the code for
UI_Expon; other occurrences found with grep (and examined manually,
because sometimes the extra space is needed for a code layout).
gcc/ada/
* bindgen.adb, errout.adb, exp_unst.adb, gnatchop.adb,
libgnat/a-ngcefu.adb, libgnat/a-strunb.adb,
libgnat/a-stwiun.adb, libgnat/a-stzunb.adb,
libgnat/a-wtedit.adb, libgnat/g-debpoo.adb, osint.adb,
sigtramp-vxworks.c, uintp.adb: Remove extra whitespace around +,
-, *, / and **.
|
|
Pragma Loop_Variant is now expanded into a null statement in CodePeer
mode. Remove annotation related to false positives in runtime units.
gcc/ada/
* libgnat/s-expmod.adb: Remove CodePeer annotation for pragma
Loop_Variant.
|
|
In GNATprove we don't want inlining-for-proof to expand subprogram
bodies into actions attached to nodes. These actions are attached either
to expressions or to statements.
For expressions, we prevented inlining by Is_Potentially_Unevaluated.
For statements, we prevented inlining by In_While_Loop_Condition, but
forgot about actions attached to ELSIF condition.
There are no other expression or statements nodes where actions could be
attached, so this fix is exhaustive.
gcc/ada/
* sem_util.ads (In_Statement_Condition_With_Actions): Renamed
from In_While_Loop_Condition; move to fit the alphabetic order.
* sem_util.adb (In_Statement_Condition_With_Actions): Detect
Elsif condition; stop search on other statements; prevent search
from going too far; move to fit the alphabetic order.
* sem_res.adb (Resolve_Call): Adapt caller.
|
|
Routine Has_Excluded_Declaration iterates over declarations with
First/Present/Next, which is safe when declarations are No_List.
Cleanup related to excessive inlining-for-proof by GNATprove.
gcc/ada/
* inline.adb (Build_Body_To_Inline): Remove redundant guards.
* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Likewise.
|
|
The compiler was failing to give an error on the result of a call to the
Input attribute passed as actual for an In/Out parameter.
gcc/ada/
* sem_util.adb (Is_OK_Variable_For_Out_Formal): Remove test on
Comes_From_Source in the condition dealing with the expression
of an N_Unchecked_Type_Conversion node.
|
|
The "Start of processing for ..." labels should be aligned with the
BEGIN that follows. Violations found with:
$ grep -Pzo "( *) \-\- Start of processing for \w+\n\n\1begin" *.adb
and corrected manually, because some of them had to be entirely removed.
Also, remove trailing semicolons found while guessing the grep pattern.
gcc/ada/
* exp_aggr.adb, exp_ch3.adb, exp_util.adb, freeze.adb,
gnatfind.adb, gnatlink.adb, gnatxref.adb, gprep.adb,
libgnat/a-cfhama.adb, libgnat/g-alleve.adb, sem_ch12.adb,
sem_ch13.adb, xr_tabls.adb: Fix style labels.
|
|
This patch improves error messages in the compiler so that missing
'with' error messages show the complete package name instead of a
limited number of selectors.
gcc/ada/
* err_vars.ads: Add new error message names and nodes.
* erroutc.adb (Set_Msg_Insertion_Name,
Set_Msg_Insertion_Name_Literal): Likewise.
* errout.adb (Set_Msg_Insertion_Node): Likewise.
* errout.ads: Likewise.
* exp_disp.adb (Check_Premature_Freezing): Modify setting of
Error_Msg_Node_2 to occur directly before Error_Msg call where
applicable.
* sem_ch8.adb (Error_Missing_With_Of_Known_Unit): Added to
handle the printing of full package names of known units.
(Undefined, Find_Expanded_Name): Replace error printing with
call to Error_Missing_With_Of_Known_Unit.
|
|
Calls to Error_Msg procedures with a message using the < or <<
insertions need to set appropriately Error_Msg_Warn. This was not done
in one call, which would lead to spurious errors when changing the
implementation of a runtime unit. This fixes it so that changes can be
applied.
gcc/ada/
* exp_ch4.adb (Expand_Allocator_Expression): Set Error_Msg_Warn
correctly.
|
|
In some cases, the compiler would incorrectly reject unprefixed uses of
component names in an aspect specification for the composite type.
Correct this error.
gcc/ada/
* sem_ch13.adb (Replace_Type_Ref): In the case of an identifier
that names a component of the type, simplify the test to decide
whether to build a prefix for it (the prefix denotes the current
instance of the enclosing type): if the identifier doesn't
already have a prefix, then give it one. This isn't quite right
in the corner case of a quantified expression or some other such
expression that declares an object with the same name as a
component, but it is still an improvement.
|
|
The problem comes from the construction of Stream operations, which
happens at the point a tagged type is frozen. Streams need to see the
full view of types, so that for example the Read attribute for an array
can be expanded into a loop over the Read attribute for the component
type. Now if during that expansion we have a private type we may need
to retrieve the full view of the type to find its structure. And the
corresponding tree must be compiled in the context of the package that
defines the type, which might not be the current package. The problem
arises when both array and component types are private, then the
described mechanism is invoked twice.
gcc/ada/
* exp_attr.adb (Compile_Stream_Body_In_Scope): Do not install
package if array type and element type come from the same
package, and the original array type is private.
|
|
When the parent type has a variant part and the derived type is also
discriminated but statically selects a variant, the initialization
routine of the derived type may attempt to access components of other
variants that are no longer present.
gcc/ada/
* exp_ch4.adb (Handle_Changed_Representation): Simplify and fix
thinko in the loop building the constraints for discriminants.
* exp_ch5.adb (Make_Component_List_Assign): Try also to extract
discriminant values for a derived type.
|
|
The first implementation just created a scope for the analysis of the
declarations and the expression, so that visibility would just work as
it does for all other constructs. However this led to an annoying bug
when one of the declarations or the expression itself creates a
transient scope: there may be a confusion on scope exit between those
two scopes. As a result visibility is handled by explicit traversal of
the expression and replacement of occurrences of the local variables,
see Replace_Local_Ref in Resolve_Declare_Expression (sem_res.adb). The
current code does not take into account that there may be references to
a local object in a subsequent declaration (not just in the expression).
gcc/ada/
* sem_res.adb (Resolve_Declare_Expression): Traverse the
expression to replace references to local variables that occur
within declarations of the declare_expression; fix typos in
comments.
|
|
Recall that Has_Possible_Literal_Aspects only comes in if a given node
does not have any visible interpretation. If one operand is a literal we
assume that there may be a user-defined literal defined for some type to
be determined during the downward pass of resolution, but that depends
on the existence of some user-defined function or operator that can take
that literal as an actual. If analysis did not find such, the call is
illegal. I think that the following must be added to Operator_Check to
recover the proper error.
Note that this breaks current partial implementation of user-defined
literals.
gcc/ada/
* sem_ch4.adb (Operator_Check): Fix condition.
|
|
A number of SPARK pragmas controlled by an optional Boolean expression
require those expressions to be static. This is now clarified in the
GNAT RM.
gcc/ada/
* doc/gnat_rm/implementation_defined_pragmas.rst
(Abstract_State, Async_Readers, Async_Writers,
Constant_After_Elaboration, Effective_Reads, Effective_Writes,
Extensions_Visible, Ghost, No_Caching, Volatile_Function): Only
static Boolean expressions are allowed.
* gnat_rm.texi: Regenerate.
|
|
In SPARK loop and subprogram variants we now allow expressions of any
discrete type and of Ada.Numerics.Big_Numbers.Big_Integers.Big_Integer
type.
gcc/ada/
* exp_prag.adb (Expand_Pragma_Loop_Variant,
Expand_Pragma_Subprogram_Variant): Adapt call via
Process_Variant to Make_Variant_Comparison.
* exp_util.adb (Make_Variant_Comparison): Compare Big_Integer
expressions with a function call and not an operator.
* exp_util.ads (Make_Variant_Comparison): Add type parameter,
which is needed because the Curr_Val and Old_Val expressions
might not be yet decorated.
* rtsfind.ads: (RTU_Id): Add support for Big_Integers and
Big_Integers_Ghost.
(RE_Id): Add support for Big_Integer and its ghost variant.
(RE_Unit_Table): Add mapping from Big_Integer to Big_Integers;
same for the ghost variants.
* rtsfind.adb (Get_Unit_Name): Add support for Big_Numbers.
* sem_prag.adb (Analyze_Pragma): Allow Big_Integer in pragma
Loop_Variant.
(Analyze_Variant): Allow Big_Integer in pragma
Subprogram_Variant.
|
|
In SPARK loop and subprogram variants we now allow expressions of any
discrete type or of Ada.Numerics.Big_Numbers.Big_Integers.Big_Integer
type. This requires a variant of Preanalyze_Assert_Expression that
doesn't force the expression to be of a particular type, similar to the
existing variant of Analyze_And_Resolve.
gcc/ada/
* sem_ch3.ads, sem_ch3.adb (Preanalyze_Assert_Expression): Add a
variant that doesn't force preanalysis to yield a specific type.
|
|
The main goal was to make it symmetrical, but this also moves error handling
entirely to the second phase of type resolution.
gcc/ada/
* einfo.ads (Access Kinds): Reorder and beef up.
* sem.adb (Analyze): Call Analyze_Comparison_Equality_Op for all
comparison and equality operators.
* sem_ch4.ads (Analyze_Comparison_Op): Delete.
(Analyze_Equality_Op): Likewise.
(Analyze_Comparison_Equality_Op): Declare.
(Ambiguous_Operands): Likewise.
* sem_ch4.adb (Ambiguous_Operands): Remove declaration.
(Defined_In_Scope): Delete.
(Find_Comparison_Types): Merge into...
(Find_Equality_Types): Merge into...
(Find_Comparison_Equality_Types): ...this. Make fully symmetrical.
(Analyze_Arithmetic_Op): Minor consistency tweaks.
(Analyze_Comparison_Op): Merge into...
(Analyze_Equality_Op): Merge into...
(Analyze_Comparison_Equality_Op): ...this. Make fully symmetrical.
(Analyze_Logical_Op): Minor consistency tweaks.
(Analyze_Membership_Op): Make fully symmetrical.
(Analyze_One_Call): Minor comment tweak.
(Analyze_Operator_Call): Call Find_Comparison_Equality_Types.
(Analyze_User_Defined_Binary_Op): Make fully symmetrical.
(Check_Arithmetic_Pair.Specific_Type): Delete.
(Diagnose_Call): Add special handling for "+" operator.
(Operator_Check): Call Analyze_Comparison_Equality_Op.
* sem_ch8.adb (Has_Implicit_Operator): Add Is_Type guard for boolean
operators, use Valid_Comparison_Arg and Valid_Equality_Arg for resp.
comparison and equality operators.
* sem_res.adb (Check_For_Visible_Operator): Call Is_Visible_Operator
(Make_Call_Into_Operator): Use Preserve_Comes_From_Source.
(Resolve_Actuals): Deal specifically with Any_Type actuals for user-
defined comparison and equality operators.
(Resolve_Call): Minor tweaks.
(Resolve_Comparison_Op): Tidy up and give error for ambiguity.
(Resolve_Equality_Op): Likewise, as well as other errors.
(Rewrite_Renamed_Operator): Simplify.
* sem_type.ads (Is_Invisible_Operator): Delete.
(Is_Visible_Operator): Declare.
(Has_Compatible_Type): Remove For_Comparison parameter.
(Specific_Type): Declare.
(Valid_Equality_Arg): Likewise.
* sem_type.adb (Specific_Type): Remove declaration.
(Add_One_Interp): Call Is_Visible_Operator for the visibility test.
(Remove_Conversions): Rename into...
(Remove_Conversions_And_Abstract_Operations): ...this. Do not apply
numeric-type treatment to Any_Type. Expand the special handling for
abstract interpretations to second operand. Remove obsolete code.
(Disambiguate): Adjust to above renaming. Tweak to hidden case and
call Remove_Conversions_And_Abstract_Operations for operators too.
(Entity_Matches_Spec): Minor tweak.
(Find_Unique_Type): Simplify and deal with user-defined literals.
(Has_Compatible_Type): Remove For_Comparison parameter and adjust.
Call the Is_User_Defined_Literal predicate and remove call to
the Is_Invisible_Operator predicate.
(Is_Invisible_Operator): Delete.
(Is_Visible_Operator): New function.
(Operator_Matches_Spec): Use Valid_Equality_Arg predicate.
(Specific_Type): Tidy up, make fully symmetrical and deal with
private views the same way as Covers.
(Valid_Comparison_Arg): Return true for Any_Composite/Any_String.
(Valid_Equality_Arg): New function.
* sem_util.ads (Is_User_Defined_Literal): Declare.
* sem_util.adb (Is_User_Defined_Literal): New function.
|
|
For warnings related to the Unreferenced, Unmodified, and Unused
aspects, refer to the "aspect", not the "pragma". Note that the aspect
can be set by an aspect_specification or a pragma, so the term "aspect"
is correct even in the pragma case. However, messages in sem_prag.adb
use Fix_Error, so they refer to "aspect" or "pragma". It's not clear
that we really ought to refer to "pragma", now that those are obsolete,
but de call Fix_Error for uniformity. We do not attempt to make
Fix_Error available outside sem_prag.adb -- too much trouble for
something that perhaps ought to be removed.
gcc/ada/
* lib-xref.adb, sem_util.adb: Change wording of warning messages
to use "aspect".
* sem_prag.adb: Use Fix_Error to change wording of warnings.
* doc/gnat_rm/implementation_defined_pragmas.rst: Minor: fix
cut&paste error.
* gnat_rm.texi: Regenerate.
|
|
On VxWorks >= 7.2 and 653, signal processing code is expected to clear
the TCB exception count field when returning control back to user code.
This change arranges to do so. It is believed that this is only an
issue in Kernel mode, and not RTP because there is no exception count
field in RTP mode and no failures have been observed.
gcc/ada/
* init.c [vxworks] (CLEAR_EXCEPTION_COUNT): New macro.
(__gnat_clear_exception_count): Remove.
(__gnat_map_signal): Call CLEAR_EXCEPTION_COUNT().
|
|
gcc/ada/
* doc/gnat_ugn/gnat_utility_programs.rst: Remove gnattest
section.
|
|
At the beginning of Analyze_Attribute routine we analyze the attribute
prefix. There is no need to repeat this analysis in branches for
individual attributes.
Code cleanup related to various Analyze/Resolve routines.
gcc/ada/
* sem_attr.adb (Analyze_Attribute): Remove calls to Analyze for
attributes Identity, Priority, Ref, Restriction_Set, To_Address
and for tasking-related attributes Callable, Terminated and
Storage_Size.
|
|
Node created by a call to New_Occurrence_Of (RTE (...), ...) has its
Etype set. There is no need to follow it with a call to Set_Etype.
Cleanup of various Analyze/Resolve routines.
gcc/ada/
* sem_attr.adb (Analyze_Attribute): Don't call Set_Etype for
Bit_Order attribute.
|
|
Replace "not Is_Non_Empty_List (...)" with "Is_Empty_List (...)".
Code cleanup; semantics is unaffected.
gcc/ada/
* exp_ch5.adb (Update_Choice_Index): Simplify condition.
* sem_ch8.adb (Attribute_Renaming): Likewise.
|
|
Remove close parameter from __gnat_kill because it is not used in
implementation.
gcc/ada/
* adaint.c (__gnat_kill): Remove close parameter.
(__gnat_killprocesstree): Do not provide close parameter on call
to __gnat_kill.
* libgnat/g-expect.adb (Kill): Remove Close parameter.
(Close): Do not provide Close parameter on call to Kill.
(Send_Signal): Do not provide Close parameter on call to Kill.
* libgnat/s-os_lib.adb (Kill): Do not provide close parameter on
call to __gnat_kill.
|
|
Call Kill before close input handler in Close routine. Otherwise close
input handler can terminate process before Kill and exit code became
unpredictable.
gcc/ada/
* libgnat/g-expect.adb (Close): Call Kill before Close_Input.
|
|
I noticed that, while the C/C++ frontends invoke the GENERIC match.pd
simplifications to do early folding, the debug output from
generic-match.cc does not appear in the -fdump-tree-original output,
even with -fdump-tree-original-folding or -fdump-tree-original-all. This
patch fixes that.
For example, before the patch, for the following code:
int a[2];
void bar ();
void f()
{
if ((unsigned long)(a + 1) == 0)
bar ();
}
on AArch64 at -O0, -fdump-tree-original-all would give:
;; Function f (null)
;; enabled by -tree-original
{
if (0)
{
bar ();
}
}
After the patch, we get:
Applying pattern match.pd:3774, generic-match.cc:24535
Matching expression match.pd:146, generic-match.cc:23
Applying pattern match.pd:5638, generic-match.cc:13388
;; Function f (null)
;; enabled by -tree-original
{
if (0)
{
bar ();
}
}
The reason we don't get the match.pd output as it stands, is that the
original dump is treated specially in c-opts.cc: it gets its own state
which is independent from that used by other dump files in the compiler.
Like most of the compiler, the generated generic-match.cc has code of
the form:
if (dump_file && (dump_flags & TDF_FOLDING))
fprintf (dump_file, ...);
But, as it stands, -fdump-tree-original has its own FILE * and flags in
c-opts.cc (original_dump_{file,flags}) and never touches the global
dump_{file,flags} (managed by dumpfile.{h,cc}). This patch adjusts the
code in c-opts.cc to use the main dump infrastructure used by the rest
of the compiler, instead of treating the original dump specially.
We take the opportunity to make a small refactor: the code in
c-gimplify.cc:c_genericize can, with this change, use the global dump
infrastructure to get the original dump file and flags instead of using
the bespoke get_dump_info function implemented in c-opts.cc. With this
change, we remove the only use of get_dump_info, so this can be removed.
Note that we also fix a leak of the original dump file in
c_common_parse_file. I originally thought it might be possible to
achieve this with only one static call to dump_finish () (by simply
moving it earlier in the loop), but unfortunately the dump file is
required to be open while c_parse_final_cleanups runs, as we (e.g.)
perform some template instantiations here for C++, which need to appear
in the original dump file.
We adjust cgraph_node::get_create to avoid introducing noise in the
original dump file: without this, these "Introduced new external node"
lines start appearing in the original dump files, which breaks tests
that do a scan-tree-dump-times on the original dump looking for a
certain function name.
gcc/c-family/ChangeLog:
* c-common.h (get_dump_info): Delete.
* c-gimplify.cc (c_genericize): Get TDI_original dump file info
from the global dump_manager instead of the (now obsolete)
get_dump_info.
* c-opts.cc (original_dump_file): Delete.
(original_dump_flags): Delete.
(c_common_parse_file): Switch to using global dump_manager to
manage the original dump file; fix leak of dump file.
(get_dump_info): Delete.
gcc/ChangeLog:
* cgraph.cc (cgraph_node::get_create): Don't dump if the current
symtab state is PARSING.
|
|
gcc/c/ChangeLog:
* c-parser.cc (c_parser_conditional_expression): Use {,UN}LIKELY
macros.
(c_parser_binary_expression): Likewise.
gcc/cp/ChangeLog:
* cp-gimplify.cc (cp_genericize_r): Use {,UN}LIKELY
macros.
* parser.cc (cp_finalize_omp_declare_simd): Likewise.
(cp_finalize_oacc_routine): Likewise.
gcc/ChangeLog:
* system.h (LIKELY): Define.
(UNLIKELY): Likewise.
* domwalk.cc (sort_bbs_postorder): Use {,UN}LIKELY
macros.
* dse.cc (set_position_unneeded): Likewise.
(set_all_positions_unneeded): Likewise.
(any_positions_needed_p): Likewise.
(all_positions_needed_p): Likewise.
* expmed.cc (flip_storage_order): Likewise.
* genmatch.cc (dt_simplify::gen_1): Likewise.
* ggc-common.cc (gt_pch_save): Likewise.
* print-rtl.cc: Likewise.
* rtl-iter.h (T>::array_type::~array_type): Likewise.
(T>::next): Likewise.
* rtl-ssa/internals.inl: Likewise.
* rtl-ssa/member-fns.inl: Likewise.
* rtlanal.cc (T>::add_subrtxes_to_queue): Likewise.
(rtx_properties::try_to_add_dest): Likewise.
* rtlanal.h (growing_rtx_properties::repeat): Likewise.
(vec_rtx_properties_base::~vec_rtx_properties_base): Likewise.
* simplify-rtx.cc (simplify_replace_fn_rtx): Likewise.
* sort.cc (likely): Likewise.
(mergesort): Likewise.
* wide-int.h (wi::eq_p): Likewise.
(wi::ltu_p): Likewise.
(wi::cmpu): Likewise.
(wi::bit_and): Likewise.
(wi::bit_and_not): Likewise.
(wi::bit_or): Likewise.
(wi::bit_or_not): Likewise.
(wi::bit_xor): Likewise.
(wi::add): Likewise.
(wi::sub): Likewise.
|
|
rv64gcv should exapnd into:
rv64imafdcv_zicsr_zifencei_zve32f_zve32x_zve64d_zve64f_zve64x_zvl128b_zvl32b_zvl64b
but we exapnd fd twice for now:
rv64imafdfdcv_zicsr_zifencei_zve32f_zve32x_zve64d_zve64f_zve64x_zvl128b_zvl32b_zvl64b
gcc/ChangeLog:
* config/riscv/arch-canonicalize: Handle g correctly.
|
|
|
|
|
|
Attribute format takes three arguments: archetype, string-index, and
first-to-check. The last two specify the position in the function
parameter list. r63030 clarified that "Since non-static C++ methods have
an implicit this argument, the arguments of such methods should be counted
from two, not one, when giving values for string-index and first-to-check."
Therefore one has to write
struct D {
D(const char *, ...) __attribute__((format(printf, 2, 3)));
};
However -- and this is the problem in this PR -- ctors with virtual
bases also get two additional parameters: the in-charge parameter and
the VTT parameter (added in maybe_retrofit_in_chrg). In fact we'll end up
with two clones of the ctor: an in-charge and a not-in-charge version (see
build_cdtor_clones). That means that the argument position the user
specified in the attribute argument will refer to different arguments,
depending on which constructor we're currently dealing with. This can
cause a range of problems: wrong errors, confusing warnings, or crashes.
This patch corrects that; for C we don't have to do anything, and in C++
we can use num_artificial_parms_for. It would be wrong to rewrite the
attributes the user supplied, so I've changed POS to be passed by
reference so that we don't have to change all the call sites of
positional_argument and we still get the default_conversion adjustment.
Attribute format_arg is not affected, because it requires that the
function returns "const char *" which will never be the case for cdtors.
PR c++/101833
PR c++/47634
gcc/c-family/ChangeLog:
* c-attribs.cc (positional_argument): Pass POS by reference. Deal
with FN being either a function declaration or function type. Use
maybe_adjust_arg_pos_for_attribute.
* c-common.cc (check_function_arguments): Maybe pass FNDECL down to
check_function_format.
* c-common.h (maybe_adjust_arg_pos_for_attribute): Declare.
(positional_argument): Adjust.
* c-format.cc (get_constant): Rename to ...
(validate_constant): ... this. Take EXPR by reference. Return bool
instead of tree.
(handle_format_arg_attribute): Don't overwrite FORMAT_NUM_EXPR by the
return value of validate_constant.
(decode_format_attr): Don't overwrite FORMAT_NUM_EXPR and
FIRST_ARG_NUM_EXPR by the return value of validate_constant.
(check_function_format): Adjust a parameter name.
(handle_format_attribute): Maybe pass FNDECL down to decode_format_attr.
gcc/c/ChangeLog:
* c-objc-common.cc (maybe_adjust_arg_pos_for_attribute): New.
gcc/cp/ChangeLog:
* tree.cc (maybe_adjust_arg_pos_for_attribute): New.
gcc/ChangeLog:
* tree-core.h (struct attribute_spec): Update comment for HANDLER.
gcc/testsuite/ChangeLog:
* g++.dg/ext/attr-format-arg1.C: New test.
* g++.dg/ext/attr-format1.C: New test.
* g++.dg/ext/attr-format2.C: New test.
* g++.dg/ext/attr-format3.C: New test.
|
|
|
|
As of CL 77510 it is never true.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/394695
|
|
In reading C++ diagnostics, it's often hard to find the name of the function
in the middle of the template header, return type, parameters, and template
arguments. So let's colorize it, and maybe the template argument bindings
while we're at it.
I've somewhat arbitrarily chosen bold green for the function name, and
non-bold magenta for the template arguments.
A side-effect of this is that when this happens in a quote (i.e. %qD), the
rest of the quote after the function name is no longer bold. I think that's
acceptable; returning to the bold would require maintaining a colorize stack
instead of the on/off controls we have now.
gcc/cp/ChangeLog:
* error.cc (decl_to_string): Add show_color parameter.
(subst_to_string): Likewise.
(cp_printer): Pass it.
(type_to_string): Set pp_show_color.
(dump_function_name): Use "fnname" color.
(dump_template_bindings): Use "targs" color.
(struct colorize_guard): New.
(reinit_cxx_pp): Clear pp_show_color.
gcc/ChangeLog:
* diagnostic-color.cc: Add fnname and targs color entries.
* doc/invoke.texi: Document them.
gcc/testsuite/ChangeLog:
* g++.dg/diagnostic/function-color1.C: New test.
|
|
The comment for this overload, which copies the value out of the vector,
was mostly describing the other overload, which stores a pointer into the
vector.
gcc/ChangeLog:
* vec.h (vec::iterate): Fix comment.
|
|
While looking at PR105245 in stage 4, I wanted to reorganize the code a bit,
but it seemed prudent to defer that to stage 1.
PR c++/105245
PR c++/100111
gcc/cp/ChangeLog:
* constexpr.cc (cxx_eval_store_expression): Reorganize empty base
handling.
|
|
For golang/go#35945
Fixes golang/go#28104
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/403954
|
|
The -mpower8-fusion and -mpower10-fusion options do not modify which
instructions we can generate, so ignore them when deciding whether we
can inline callee into caller.
2022-05-06 Michael Meissner <meissner@linux.ibm.com>
gcc/
PR target/102059
* config/rs6000/rs6000.cc (rs6000_can_inline_p): Ignore -mpower8-fusion
and -mpower10-fusion options for inlining purposes.
gcc/testsuite/
PR target/102059
* gcc.target/powerpc/pr102059-4.c: New test.
|
|
This iterator is not used anymore and is a leftover from previous
cleanup (r10-5890-gabbe1ed2735517).
2022-04-28 Christophe Lyon <christophe.lyon@arm.com>
gcc/
* config/aarch64/iterators.md (GPF_TF_F16): Delete.
|
|
gcc/ChangeLog:
* omp-low.cc (omp_runtime_api_call): Added target_is_accessible to
omp_runtime_apis array.
libgomp/ChangeLog:
* libgomp.map: Added omp_target_is_accessible.
* libgomp.texi: Tagged omp_target_is_accessible as supported.
* omp.h.in: Added omp_target_is_accessible.
* omp_lib.f90.in: Added interface for omp_target_is_accessible.
* omp_lib.h.in: Likewise.
* target.c (omp_target_is_accessible): Added implementation of
omp_target_is_accessible.
* testsuite/libgomp.c-c++-common/target-is-accessible-1.c: New test.
* testsuite/libgomp.fortran/target-is-accessible-1.f90: New test.
|
|
An allocate clause in target region must specify an allocator
unless the compilation unit has requires construct with
dynamic_allocators clause. Current implementation of the allocate
clause did not check for this restriction. This patch fills that
gap.
gcc/ChangeLog:
* omp-low.cc (omp_maybe_offloaded_ctx): New prototype.
(scan_sharing_clauses): Check a restriction on allocate clause.
gcc/testsuite/ChangeLog:
* c-c++-common/gomp/allocate-2.c: Add tests.
* c-c++-common/gomp/allocate-8.c: New test.
* gfortran.dg/gomp/allocate-3.f90: Add tests.
* gcc.dg/gomp/pr104517.c: Update.
|
|
|
|
This patch fixes the second half of 64679. Here we issue a wrong
"redefinition of 'int x'" for the following:
struct Bar {
Bar(int, int, int);
};
int x = 1;
Bar bar(int(x), int(x), int{x}); // #1
cp_parser_parameter_declaration_list does pushdecl every time it sees
a named parameter, so the second "int(x)" causes the error. That's
premature, since this turns out to be a constructor call after the
third argument!
If the first parameter is parenthesized, we can't push until we've
established we're looking at a function declaration. Therefore this
could be fixed by some kind of lookahead. I thought about introducing a
lightweight variant of cp_parser_parameter_declaration_list that would
not have any side effects and would return as soon as it figures out
whether it's looking at a declaration or expression. Since that would
require fairly nontrivial changes, I wanted something simpler.
Something like delaying the pushdecl until we've reached the ')'
following the parameter-declaration-clause. But we must push the
parameters before processing a default argument, as in:
Bar bar(int(a), int(b), int c = sizeof(a)); // valid
Moreover, this code should still be accepted
Bar f(int(i), decltype(i) j = 42);
so this patch stashes parameters into a vector when parsing tentatively
only when pushdecl-ing a parameter would result in a clash and an error
about redefinition/redeclaration. The stashed parameters are pushed at
the end of a parameter-declaration-clause if it's followed by a ')', so
that we still diagnose redefining a parameter.
PR c++/64679
gcc/cp/ChangeLog:
* parser.cc (cp_parser_parameter_declaration_clause): Maintain
a vector of parameters that haven't been pushed yet. Push them at the
end of a valid parameter-declaration-clause.
(cp_parser_parameter_declaration_list): Take a new auto_vec parameter.
Do not pushdecl while parsing tentatively when pushdecl-ing a parameter
would result in a hard error.
(cp_parser_cache_defarg): Adjust the call to
cp_parser_parameter_declaration_list.
gcc/testsuite/ChangeLog:
* g++.dg/parse/ambig11.C: New test.
* g++.dg/parse/ambig12.C: New test.
* g++.dg/parse/ambig13.C: New test.
* g++.dg/parse/ambig14.C: New test.
|
|
Use conditional compilation for ia32 target istead.
2022-05-05 Uroš Bizjak <ubizjak@gmail.com>
gcc/testsuite/ChangeLog:
* gcc.target/i386/pr103611-2.c (dg-do): Compile for target ia32.
(dg-options): Remove -m32.
* gcc.target/i386/pr105032.c (dg-do): Compile for taget ia32.
(dg-additional-options): Remove.
* gcc.target/i386/pr104732.c (dg-options): Remove -m32.
* gcc.target/i386/pr99753.c (dg-options): Ditto.
|
|
This patch adds support for OMP 5.1 "canonical loop nest form" to the
Fortran front end, marks non-rectangular loops for processing
by the middle end, and implements missing checks in the gimplifier
for additional prohibitions on non-rectangular loops.
Note that the OMP spec also prohibits non-rectangular loops with the TILE
construct; that construct hasn't been implemented yet, so that error will
need to be filled in later.
gcc/fortran/
* gfortran.h (struct gfc_omp_clauses): Add non_rectangular bit.
* openmp.cc (is_outer_iteration_variable): New function.
(expr_is_invariant): New function.
(bound_expr_is_canonical): New function.
(resolve_omp_do): Replace existing non-rectangularity error with
check for canonical form and setting non_rectangular bit.
* trans-openmp.cc (gfc_trans_omp_do): Transfer non_rectangular
flag to generated tree structure.
gcc/
* gimplify.cc (gimplify_omp_for): Update messages for SCHEDULED
and ORDERED clause conflict errors. Add check for GRAINSIZE and
NUM_TASKS on TASKLOOP.
gcc/testsuite/
* c-c++-common/gomp/loop-6.c (f3): New function to test TASKLOOP
diagnostics.
* gfortran.dg/gomp/collapse1.f90: Update expected messages.
* gfortran.dg/gomp/pr85313.f90: Remove dg-error on non-rectangular
loops that are now accepted.
* gfortran.dg/gomp/non-rectangular-loop.f90: New file.
* gfortran.dg/gomp/canonical-loop-1.f90: New file.
* gfortran.dg/gomp/canonical-loop-2.f90: New file.
|
|
* gcc.pot: Regenerate.
|
