Arthur Cohen [Wed, 26 Oct 2022 14:35:12 +0000 (16:35 +0200)]
gccrs: intrinsics: Cleanup error handling around atomic_store_*
gcc/rust/ChangeLog:
* backend/rust-compile-intrinsic.cc (check_for_basic_integer_type): New function.
(build_atomic_builtin_name): Use HIR Type instead of `tree`.
(atomic_store_handler_inner): Cleanup error handling.
(unchecked_op_inner): Likewise.
Arthur Cohen [Tue, 25 Oct 2022 09:24:10 +0000 (11:24 +0200)]
gccrs: intrinsics: Add early implementation for atomic_store_{seqcst, relaxed, release}
gcc/rust/ChangeLog:
* backend/rust-builtins.cc (BuiltinsContext::setup_atomic_fns): New function.
(BuiltinsContext::setup): Call `setup_atomic_fns`.
* backend/rust-builtins.h: Declare `setup_atomic_fns`.
* backend/rust-compile-intrinsic.cc (atomic_store_handler_inner): New function.
(atomic_store_handler): New handler.
(make_unsigned_long_tree): Add helper around making unsigned long trees.
(prefetch_data_handler): Use `make_unsigned_long_tree`.
(build_atomic_builtin_name): New function.
gcc/testsuite/ChangeLog:
* rust/compile/torture/intrinsics-4.rs: New test.
* rust/compile/torture/intrinsics-5.rs: New test.
* rust/execute/torture/atomic_store.rs: New test.
Philip Herron [Wed, 19 Oct 2022 17:02:36 +0000 (18:02 +0100)]
gccrs: Closure support at CallExpr
gcc/rust/ChangeLog:
* backend/rust-compile-context.h: Add new functions: `insert_closure_decl` and
`lookup_closure_decl`.
* backend/rust-compile-expr.cc (CompileExpr::visit): Start compiling Closures properly.
(CompileExpr::generate_closure_function): New function.
(CompileExpr::generate_closure_fntype): Likewise.
* backend/rust-compile-expr.h: Declare `generate_closure_function` and
`generate_closure_fntype`.
* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Visit closure types properly.
* backend/rust-mangle.cc (legacy_mangle_name): Add support for closures.
* backend/rust-tree.h (RS_CLOSURE_FLAG): Add new tree macro.
(RS_CLOSURE_TYPE_P): And checking for it on tree nodes.
* typecheck/rust-tyty.cc (ClosureType::is_equal): Add implementation.
Philip Herron [Wed, 19 Oct 2022 09:59:18 +0000 (10:59 +0100)]
gccrs: Refactor method call type checking
gcc/rust/ChangeLog:
* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Simplify method
call type checking by removing visitor and instead using one static cast. Use the
new interface.
* typecheck/rust-tyty-call.cc (TypeCheckMethodCallExpr::visit): Likewise.
(TypeCheckMethodCallExpr::go): Likewise.
(TypeCheckMethodCallExpr::check): Likewise.
* typecheck/rust-tyty-call.h (class TypeCheckMethodCallExpr): Likewise.
(class Argument): Likewise.
Philip Herron [Mon, 17 Oct 2022 10:35:26 +0000 (11:35 +0100)]
gccrs: Add check for recursive trait cycles
gcc/rust/ChangeLog:
* typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_trait): Check if a
trait query is currently in progress.
* typecheck/rust-hir-type-check.h (class TraitQueryGuard): Add helpers around
checking for trait queries and inserting them.
Philip Herron [Fri, 14 Oct 2022 13:00:16 +0000 (14:00 +0100)]
gccrs: Refactor TraitResolver to not require a visitor
gcc/rust/ChangeLog:
* typecheck/rust-hir-trait-resolve.cc (TraitResolver::TraitResolver): Do not nullptr init
`resolved_trait_reference` anymore.
(TraitResolver::resolve_path): Simplify function and rename to...
(TraitResolver::resolve_path_to_trait): ...this.
(TraitResolver::lookup_path): Use new interface.
* typecheck/rust-hir-trait-resolve.h (class TraitResolver): Do not inherit `HIRFullVisitor`
class anymore.
Philip Herron [Thu, 13 Oct 2022 09:10:37 +0000 (10:10 +0100)]
gccrs: Method resolution must support multiple candidates
This patch fixes bad method resolution in our operator_overload_9 case.
When we have a &mut reference to something and we deref we must resolve to
the mutable reference impl block. The interface we are using to resolve
methods is the can_eq interface which allows for permissive mutability
which means allowing for mutable reference being unified with an immutable
one. This meant we actual match against both the immutable and mutable
version leading to multiple candidate error.
The fix here adds a method resolution flag to the can_eq interface so that
we enforce mutability equality. The other hack is that we do not allow
can_eq of ParamTypes to generic Slices. I think there is some subtle thing
going on for that case. The Rustc method resolver actually filters the
impl blocks for reference types based looking up the relevant lang items
we need to do this as well but is a much larger refactor to our method
resolver which should be done seperately.
Fixes #1588
gcc/rust/ChangeLog:
* typecheck/rust-autoderef.cc: Add support for multiple resolution candidates.
* typecheck/rust-hir-dot-operator.cc (MethodResolver::MethodResolver): Edit
`try_result` field and change constructor.
(MethodResolver::Probe): Return set of candidates instead of singular candidate.
(MethodResolver::select): Add better implementation to account for multiple
candidates.
* typecheck/rust-hir-dot-operator.h (struct MethodCandidate): Overload comparison
operator in order to store them in `std::set`.
* typecheck/rust-hir-inherent-impl-overlap.h: Do not fail assertion on missing type.
* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Adapt code to use
multiple candidates.
* typecheck/rust-tyty.cc (set_cmp_autoderef_mode): Add code to handle automatic
derefs properly.
(reset_cmp_autoderef_mode): Add helper function to reset said mode.
* typecheck/rust-tyty.h (set_cmp_autoderef_mode): Declare function.
(reset_cmp_autoderef_mode): Likewise.
* typecheck/rust-tyty-cmp.h: Add handling of `autoderef_cmp_flag`
gcc/testsuite/ChangeLog:
* rust/compile/generics7.rs: Fix test with missing assertion.
* rust/execute/torture/operator_overload_9.rs: Fix test assertion.
Philip Herron [Thu, 6 Oct 2022 13:46:17 +0000 (14:46 +0100)]
gccrs: Support type resolution on super traits on dyn objects
When checking if specified bounds satisfy other bounds we must lookup the
super traits. To finish the support for super traits we need to redo the
computation of method addresses to support super traits.
Addresses #914
gcc/rust/ChangeLog:
* backend/rust-compile.cc: Add note about missing support for super
traits.
* typecheck/rust-tyty.cc (BaseType::satisfies_bound): New function.
(BaseType::bounds_compatible): New function.
(DynamicObjectType::get_object_items): New function.
* typecheck/rust-hir-trait-ref.h: Use new API to perform type resolution
on dyn objects.
Arthur Cohen [Tue, 11 Oct 2022 09:12:50 +0000 (11:12 +0200)]
gccrs: early-name-resolver: Add simple macro name resolution
This name resolver performs the same macro name resolution as what was
previously done by the AttrVisitor visitor and macro expander.
It also resolves macro expressions in builtin-macros properly, as well
as expanded AST nodes when necessary.
gcc/rust/ChangeLog:
* Make-lang.in: Compile early name resolver.
* expand/rust-attribute-visitor.cc (AttrVisitor::visit): Move macro
name resolution.
* expand/rust-macro-builtins.cc (try_expand_macro_expression): Run ENR
when recursively expanding macros.
* expand/rust-macro-expand.cc (MacroExpander::expand_invoc): No longer
perform name resolution in `expand_invoc`.
* expand/rust-macro-expand.h (struct MacroExpander): Keep ENR within
MacroExpander.
* rust-session-manager.cc (Session::expansion): Run ENR.
* resolve/rust-early-name-resolver.cc: New file.
* resolve/rust-early-name-resolver.h: New file.
* util/rust-hir-map.h: Add new mappings.
* util/rust-hir-map.cc (Mappings::insert_macro_invocation): Add insertion
function into mappings.
(Mappings::lookup_macro_invocation): Add lookup function for mappings.
Marc Poulhiès [Fri, 7 Oct 2022 16:48:36 +0000 (18:48 +0200)]
gccrs: fix ICE on missing closing paren
Fix crash (segfault) on a missing closing parenthesis when parsing the
expressions in a block. The returned `expr` was missing a check before being
used.
Add corresponding test.
Signed-off-by: Marc Poulhiès <dkm@kataplop.net>
gcc/rust/ChangeLog:
* parse/rust-parse-impl.h (Parser::parse_stmt_or_expr_without_block):
Check if `expr` is valid after parsing it.
gcc/testsuite/ChangeLog:
* rust/compile/missing_closing_paren.rs: New test.
Philip Herron [Wed, 5 Oct 2022 16:24:26 +0000 (17:24 +0100)]
gccrs: Ensure uniqueness on Path probe's
When we lookup names in paths such as Foo::bar, foo is a type we resolve
and then we lookup 'bar' based on what type Foo is which includes probing
relevant bounds of this type. We currently return a vector of possible
candidates and this patch changes it so that we return a set of unique
items based on DefId.
Addresses #1555
gcc/rust/ChangeLog:
* backend/rust-compile-expr.cc
(CompileExpr::resolve_method_address): Use auto and minor change
in candidate init.
* typecheck/rust-hir-type-check-path.cc
(TypeCheckExpr::resolve_segments): Likewise.
* typecheck/rust-hir-type-check-type.cc: Likewise.
* backend/rust-compile-resolve-path.cc
(HIRCompileBase::query_compile): Likewise. Removecall to
set_ty_ref.
* typecheck/rust-hir-path-probe.h (struct PathProbeCandidate): Add
locus initializer in ctor, implement get_defid.
(class PathProbeType::Probe): return a set instead of vector.
Adjust class impl.
(class ReportMultipleCandidateError): Do not inherit from
HIRImplVisitor anymore and remove corresponding impl. Adjust for
change in Probe. Simplify Report handling.
(class PathProbeImplTrait::Probe): Adjust return type.
Philip Herron [Fri, 30 Sep 2022 12:41:09 +0000 (13:41 +0100)]
gccrs: Add catch for recusive type queries
When we have a type query where by generic substitution occurs we can hit
the case where we need to Probe the bounds of the substited item to
determine whether the the bounds are compatible this can cause us to
end up querying the same type recursively.
Fixes #1550
gcc/rust/ChangeLog:
* typecheck/rust-hir-type-check-base.cc (TypeCheckBase::query_type):
Check for recursive queries.
* typecheck/rust-hir-type-check.h: New functions: `query_completed`,
`query_in_progress`, `insert_query`.
* typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): Use `query_type` API.
Philip Herron [Tue, 27 Sep 2022 08:50:06 +0000 (09:50 +0100)]
gccrs: Fix missing dead code analysis ICE on local enum definition
When resolving local enum's within a Block the name resolution info is
not at the top of the stack so this patch introduces a new mappings class
for miscellaneous name resolutions which can be used during path analaysis.
Fixes #1272
gcc/rust/ChangeLog:
* resolve/rust-name-resolver.h: Add miscellenaous item mappings.
* resolve/rust-name-resolver.cc (Resolver::insert_resolved_misc): Use
new mappings.
(Resolver::lookup_resolved_misc): Likewise.
* typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments):
Adapt function to insert into miscelleanous mappings.
* checks/lints/rust-lint-marklive.cc (MarkLive::find_ref_node_id):
Allow lookup in miscelleanous mappings in mark-live phase.
xtensa: Enforce return address saving when -Og is specified
Leaf function often omits saving its return address to the stack slot,
and this feature often makes debugging very confusing, especially for
stack dump analysis.
gcc/ChangeLog:
* config/xtensa/xtensa.cc (xtensa_call_save_reg): Change to return
true if register A0 (return address register) when -Og is specified.
Instructions that use high-part QImode registers can not be encoded
with REX prefix. To avoid REX prefix, operand constraints allow
only legacy QImode registers, immediates and constant memory operands.
The patch introduces matching predicate, so invalid operands are not
combined into instruction RTX only to be later fixed up by reload pass.
2023-02-20 Uroš Bizjak <ubizjak@gmail.com>
gcc/ChangeLog:
* config/i386/predicates.md
(general_x64constmem_operand): New predicate.
* config/i386/i386.md (*cmpqi_ext<mode>_1):
Use nonimm_x64constmem_operand.
(*cmpqi_ext<mode>_3): Use general_x64constmem_operand.
(*addqi_ext<mode>_1): Ditto.
(*testqi_ext<mode>_1): Ditto.
(*andqi_ext<mode>_1): Ditto.
(*andqi_ext<mode>_1_cc): Ditto.
(*<any_or:code>qi_ext<mode>_1): Ditto.
(*xorqi_ext<mode>_1_cc): Ditto.
Jakub Jelinek [Mon, 20 Feb 2023 21:07:57 +0000 (22:07 +0100)]
powerpc: Another umaddditi4 fix [PR108862]
The following testcase is miscompiled on powerpc64le-linux with
-O2 -mcpu=power9. The problem is that gen_umaddditi4 is called with
the same TImode register for both op0 and op3, and maddlddi4
overwrites the low half of op0 before the low half of op3 is read,
so when they are the same register it reads the result of maddlddi4.
The following patch fixes that by swapping maddlddi4 and
umadddi4_highpart{,_le} during expansion, as the latter writes into
a temporary pseudo and so can't change anything maddlddi4 depends on.
2023-02-20 Jakub Jelinek <jakub2redhat.com>
PR target/108862
* config/rs6000/rs6000.md (umaddditi4): Swap gen_maddlddi4 with
gen_umadddi4_highpart{,_le}.
* gcc.dg/pr108862.c: New test.
* gcc.target/powerpc/pr108862.c: New test.
Marek Polacek [Thu, 9 Feb 2023 00:13:18 +0000 (19:13 -0500)]
c++: ICE with -fno-elide-constructors and trivial fn [PR101073]
In constexpr-nsdmi3.C, with -fno-elide-constructors, we don't elide
the Y::Y(const Y&) call used to initialize o.c. So store_init_value
-> cxx_constant_init must constexpr-evaluate the call to Y::Y(const Y&)
in cxx_eval_call_expression. It's a trivial function, so we do the
"Shortcut trivial constructor/op=" code and rather than evaluating
the function, we just create an assignment
o.c = *(const struct Y &) (const struct Y *) &(&<PLACEHOLDER_EXPR struct X>)->b
which is a MODIFY_EXPR, so the preeval code in cxx_eval_store_expression
clears .ctor and .object, therefore we can't replace the PLACEHOLDER_EXPR
whereupon we crash at
/* A placeholder without a referent. We can get here when
checking whether NSDMIs are noexcept, or in massage_init_elt;
just say it's non-constant for now. */
gcc_assert (ctx->quiet);
The PLACEHOLDER_EXPR can also be on the LHS as in constexpr-nsdmi10.C.
I don't think we can do much here, but I noticed that the whole
trivial_fn_p (fun) block is only entered when -fno-elide-constructors.
This is true since GCC 9; it wasn't easy to bisect what changes made it
so, but r240845 is probably one of them. -fno-elide-constructors is an
option for experiments only so it's not clear to me why we'd still want
to shortcut trivial constructor/op=. I propose to remove the code and
add a checking assert to make sure we're not getting a trivial_fn_p
unless -fno-elide-constructors.
PR c++/101073
gcc/cp/ChangeLog:
* constexpr.cc (cxx_eval_call_expression): Replace shortcutting trivial
constructor/op= with a checking assert.
gcc/testsuite/ChangeLog:
* g++.dg/cpp0x/constexpr-nsdmi3.C: New test.
* g++.dg/cpp1y/constexpr-nsdmi10.C: New test.
Marek Polacek [Thu, 16 Feb 2023 22:41:24 +0000 (17:41 -0500)]
c++: ICE with redundant capture [PR108829]
Here we crash in is_capture_proxy:
/* Location wrappers should be stripped or otherwise handled by the
caller before using this predicate. */
gcc_checking_assert (!location_wrapper_p (decl));
We only crash with the redundant capture:
int abyPage = [=, abyPage] { ... }
because prune_lambda_captures is only called when there was a default
capture, and with [=] only abyPage won't be in LAMBDA_EXPR_CAPTURE_LIST.
The problem is that LAMBDA_CAPTURE_EXPLICIT_P wasn't propagated
correctly and so var_to_maybe_prune proceeded where it shouldn't.
Co-Authored by: Patrick Palka <ppalka@redhat.com>
PR c++/108829
gcc/cp/ChangeLog:
* pt.cc (prepend_one_capture): Set LAMBDA_CAPTURE_EXPLICIT_P.
(tsubst_lambda_expr): Pass LAMBDA_CAPTURE_EXPLICIT_P to
prepend_one_capture.
gcc/testsuite/ChangeLog:
* g++.dg/cpp0x/lambda/lambda-108829-2.C: New test.
* g++.dg/cpp0x/lambda/lambda-108829.C: New test.
The split of the versioning condition assumes the definition is
in the condition block which is ensured by the versioning code.
But that only works when we actually have to insert any statements
for the versioning condition. The following adjusts the guard
accordingly and asserts this condition.
'#include "tm_p.h"' in 'gcc/rust/backend/rust-tree.cc'
broke rust bootstrap on SPARC:
In file included from ./tm_p.h:4,
from /vol/gcc/src/hg/master/local/gcc/rust/backend/rust-tree.cc:38:
/vol/gcc/src/hg/master/local/gcc/config/sparc/sparc-protos.h:46:47: error: use of enum 'memmodel' without previous declaration
46 | extern void sparc_emit_membar_for_model (enum memmodel, int, int);
| ^~~~~~~~
Fixed by including memmodel.h. Tested on sparc-sun-solaris2.11 and
i386-pc-solaris2.11.
Richard Biener [Mon, 20 Feb 2023 08:54:37 +0000 (09:54 +0100)]
tree-optimization/108825 - checking ICE with unroll-and-jam
The issue is that unroll-and-jam applies RPO VN on the transformed body but
that leaves the IL in "indetermined" state (it returns a TODO to make it
valid again). But unroll-and-jam then continues to transform another loop and
in using the tree_unroll_loop helper runs into tree_transform_and_unroll_loop
performing IL checking on the whole function.
While the real fix is to elide all such checking I'm only making the
loop-local LC SSA verifier not perform function-wide SSA verification
at this point.
PR tree-optimization/108825
* tree-ssa-loop-manip.cc (verify_loop_closed_ssa): For
loop-local verfication only verify there's no pending SSA
update.
Gaius Mulley [Sun, 19 Feb 2023 22:08:31 +0000 (22:08 +0000)]
libgm2/libm2iso/RTco.cc (re-implementation) Bugfix for [PR108835]
This is a re-implementation of RTco.cc which fixes the race hazzard
seen occasionally when running testtransfer and coroutines from the
modula2 testsuite.
libgm2/ChangeLog:
PR testsuite/108835
* libm2iso/RTco.cc: Re-implementation using a single lock
mutex and inlined wait/signal implementation within
transfer.
Jason Merrill [Sat, 11 Feb 2023 00:16:45 +0000 (16:16 -0800)]
c++: static_assert (false) in template [DR2518]
For a long time, people have expected to be able to write
static_assert (false) in a template and only have it diagnosed if the
template is instantiated, but we (and other implementations) gave an error
about the uninstantiated template because the standard says that if no valid
instantiation of the template is possible, the program is ill-formed, no
diagnostic required, and we try to diagnose IFNDR things when feasible.
At the meeting last week we were looking at CWG2518, which wanted to specify
that an implementation must not accept a program containing a failing #error
or static_assert. We also looked at P2593, which proposed allowing
static_assert in an uninstantiated template. We ended up combining these
two in order to avoid requiring implementations to reject programs with
static_assert (false) in uninstantiated templates.
The committee accepted this as a DR, so I'm making the change to all
standard modes. This behavior was also conformant previously, since no
diagnostic was required in this case.
We continue to diagnose non-constant or otherwise ill-formed conditions, so
no changes to existing tests were needed.
projects / thirdparty / gcc.git / log
