public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc/devel/rust/master] Refactor indirect_expression from the gcc-backend wrapper
@ 2022-08-06 12:09 Thomas Schwinge
0 siblings, 0 replies; only message in thread
From: Thomas Schwinge @ 2022-08-06 12:09 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:94e53f8e55e93da8db3d948c3f16d23b7c4ba7a6
commit 94e53f8e55e93da8db3d948c3f16d23b7c4ba7a6
Author: Philip Herron <philip.herron@embecosm.com>
Date: Wed Aug 3 11:54:54 2022 +0100
Refactor indirect_expression from the gcc-backend wrapper
This brings out the indirect expression out of our gcc wrapper, it also
just simplifies down to the normal build_indirect_expr_loc calls. Which
does not require specifiying the type since we can reuse TREE_TYPE. This
also simplifies the address_expression to just address_expr_with_loc and
grabs the type from TREE_TYPE as well.
Diff:
---
gcc/rust/backend/rust-compile-base.cc | 14 ++++-
gcc/rust/backend/rust-compile-base.h | 4 +-
gcc/rust/backend/rust-compile-expr.cc | 82 +++++----------------------
gcc/rust/backend/rust-compile-expr.h | 14 +----
gcc/rust/backend/rust-compile-extern.h | 9 +--
gcc/rust/backend/rust-compile-implitem.cc | 10 +---
gcc/rust/backend/rust-compile-item.cc | 9 +--
gcc/rust/backend/rust-compile-resolve-path.cc | 6 +-
gcc/rust/backend/rust-compile.cc | 27 ++-------
gcc/rust/rust-backend.h | 8 ---
gcc/rust/rust-gcc.cc | 24 --------
11 files changed, 44 insertions(+), 163 deletions(-)
diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc
index 28f39419bec..a640a48d7d8 100644
--- a/gcc/rust/backend/rust-compile-base.cc
+++ b/gcc/rust/backend/rust-compile-base.cc
@@ -411,7 +411,7 @@ HIRCompileBase::mark_addressable (tree exp, Location locus)
}
tree
-HIRCompileBase::address_expression (tree expr, tree ptrtype, Location location)
+HIRCompileBase::address_expression (tree expr, Location location)
{
if (expr == error_mark_node)
return error_mark_node;
@@ -419,8 +419,16 @@ HIRCompileBase::address_expression (tree expr, tree ptrtype, Location location)
if (!mark_addressable (expr, location))
return error_mark_node;
- return build_fold_addr_expr_with_type_loc (location.gcc_location (), expr,
- ptrtype);
+ return build_fold_addr_expr_loc (location.gcc_location (), expr);
+}
+
+tree
+HIRCompileBase::indirect_expression (tree expr, Location locus)
+{
+ if (expr == error_mark_node)
+ return error_mark_node;
+
+ return build_fold_indirect_ref_loc (locus.gcc_location (), expr);
}
std::vector<Bvariable *>
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index f993d06cb33..aad0da38535 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -101,7 +101,9 @@ protected:
static void setup_abi_options (tree fndecl, ABI abi);
- static tree address_expression (tree expr, tree ptrtype, Location locus);
+ static tree address_expression (tree expr, Location locus);
+
+ static tree indirect_expression (tree expr, Location locus);
static bool mark_addressable (tree, Location);
diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc
index 7aa691e2506..92c224c68c9 100644
--- a/gcc/rust/backend/rust-compile-expr.cc
+++ b/gcc/rust/backend/rust-compile-expr.cc
@@ -134,8 +134,7 @@ CompileExpr::visit (HIR::BorrowExpr &expr)
&tyty))
return;
- tree ptrtype = TyTyResolveCompile::compile (ctx, tyty);
- translated = address_expression (main_expr, ptrtype, expr.get_locus ());
+ translated = address_expression (main_expr, expr.get_locus ());
}
void
@@ -175,10 +174,7 @@ CompileExpr::visit (HIR::DereferenceExpr &expr)
return;
}
- bool known_valid = true;
- translated
- = ctx->get_backend ()->indirect_expression (expected_type, main_expr,
- known_valid, expr.get_locus ());
+ translated = indirect_expression (main_expr, expr.get_locus ());
}
// Helper for sort_tuple_patterns.
@@ -1111,15 +1107,7 @@ CompileExpr::get_fn_addr_from_dyn (const TyTy::DynamicObjectType *dyn,
// get any indirection sorted out
if (receiver->get_kind () == TyTy::TypeKind::REF)
{
- TyTy::ReferenceType *r = static_cast<TyTy::ReferenceType *> (receiver);
- auto indirect_ty = r->get_base ();
- tree indrect_compiled_tyty
- = TyTyResolveCompile::compile (ctx, indirect_ty);
-
- tree indirect
- = ctx->get_backend ()->indirect_expression (indrect_compiled_tyty,
- receiver_ref, true,
- expr_locus);
+ tree indirect = indirect_expression (receiver_ref, expr_locus);
receiver_ref = indirect;
}
@@ -1149,17 +1137,8 @@ CompileExpr::get_receiver_from_dyn (const TyTy::DynamicObjectType *dyn,
{
// get any indirection sorted out
if (receiver->get_kind () == TyTy::TypeKind::REF)
-
{
- TyTy::ReferenceType *r = static_cast<TyTy::ReferenceType *> (receiver);
- auto indirect_ty = r->get_base ();
- tree indrect_compiled_tyty
- = TyTyResolveCompile::compile (ctx, indirect_ty);
-
- tree indirect
- = ctx->get_backend ()->indirect_expression (indrect_compiled_tyty,
- receiver_ref, true,
- expr_locus);
+ tree indirect = indirect_expression (receiver_ref, expr_locus);
receiver_ref = indirect;
}
@@ -1179,8 +1158,7 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref,
tree fn = NULL_TREE;
if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
{
- return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
- expr_locus);
+ return address_expression (fn, expr_locus);
}
// Now we can try and resolve the address since this might be a forward
@@ -1440,8 +1418,7 @@ CompileExpr::compile_string_literal (const HIR::LiteralExpr &expr,
auto base = ctx->get_backend ()->string_constant_expression (
literal_value.as_string ());
- tree data = address_expression (base, build_pointer_type (TREE_TYPE (base)),
- expr.get_locus ());
+ tree data = address_expression (base, expr.get_locus ());
TyTy::BaseType *usize = nullptr;
bool ok = ctx->get_tyctx ()->lookup_builtin ("usize", &usize);
@@ -1487,8 +1464,7 @@ CompileExpr::compile_byte_string_literal (const HIR::LiteralExpr &expr,
vals,
expr.get_locus ());
- return address_expression (constructed, build_pointer_type (array_type),
- expr.get_locus ());
+ return address_expression (constructed, expr.get_locus ());
}
tree
@@ -1734,10 +1710,7 @@ HIRCompileBase::resolve_adjustements (
case Resolver::Adjustment::AdjustmentType::MUT_REF: {
if (!SLICE_TYPE_P (TREE_TYPE (e)))
{
- tree ptrtype
- = TyTyResolveCompile::compile (ctx,
- adjustment.get_expected ());
- e = address_expression (e, ptrtype, locus);
+ e = address_expression (e, locus);
}
}
break;
@@ -1785,10 +1758,7 @@ HIRCompileBase::resolve_deref_adjustment (Resolver::Adjustment &adjustment,
!= Resolver::Adjustment::AdjustmentType::ERROR;
if (needs_borrow)
{
- adjusted_argument
- = address_expression (expression,
- build_reference_type (TREE_TYPE (expression)),
- locus);
+ adjusted_argument = address_expression (expression, locus);
}
// make the call
@@ -1800,12 +1770,7 @@ tree
HIRCompileBase::resolve_indirection_adjustment (
Resolver::Adjustment &adjustment, tree expression, Location locus)
{
- tree expected_type
- = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
-
- return ctx->get_backend ()->indirect_expression (expected_type, expression,
- true, /* known_valid*/
- locus);
+ return indirect_expression (expression, locus);
}
tree
@@ -1824,9 +1789,7 @@ HIRCompileBase::resolve_unsized_adjustment (Resolver::Adjustment &adjustment,
= TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
// make a constructor for this
- tree data
- = address_expression (expression,
- build_reference_type (TREE_TYPE (expression)), locus);
+ tree data = address_expression (expression, locus);
// fetch the size from the domain
tree domain = TYPE_DOMAIN (expr_type);
@@ -1919,8 +1882,7 @@ CompileExpr::visit (HIR::IdentifierExpr &expr)
else if (ctx->lookup_function_decl (ref, &fn))
{
TREE_USED (fn) = 1;
- translated = address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
- expr.get_locus ());
+ translated = address_expression (fn, expr.get_locus ());
}
else if (ctx->lookup_var_decl (ref, &var))
{
@@ -2091,20 +2053,10 @@ CompileExpr::visit (HIR::ArrayIndexExpr &expr)
return;
}
- // lookup the expected type for this expression
- TyTy::BaseType *tyty = nullptr;
- bool ok
- = ctx->get_tyctx ()->lookup_type (expr.get_mappings ().get_hirid (),
- &tyty);
- rust_assert (ok);
- tree expected_type = TyTyResolveCompile::compile (ctx, tyty);
-
// rust deref always returns a reference from this overload then we can
// actually do the indirection
translated
- = ctx->get_backend ()->indirect_expression (expected_type,
- operator_overload_call,
- true, expr.get_locus ());
+ = indirect_expression (operator_overload_call, expr.get_locus ());
return;
}
@@ -2118,14 +2070,8 @@ CompileExpr::visit (HIR::ArrayIndexExpr &expr)
// do we need to add an indirect reference
if (array_expr_ty->get_kind () == TyTy::TypeKind::REF)
{
- TyTy::ReferenceType *r
- = static_cast<TyTy::ReferenceType *> (array_expr_ty);
- TyTy::BaseType *tuple_type = r->get_base ();
- tree array_tyty = TyTyResolveCompile::compile (ctx, tuple_type);
-
array_reference
- = ctx->get_backend ()->indirect_expression (array_tyty, array_reference,
- true, expr.get_locus ());
+ = indirect_expression (array_reference, expr.get_locus ());
}
translated
diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index 48a516ab419..bc1423991ac 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -53,14 +53,7 @@ public:
// do we need to add an indirect reference
if (tuple_expr_ty->get_kind () == TyTy::TypeKind::REF)
{
- TyTy::ReferenceType *r
- = static_cast<TyTy::ReferenceType *> (tuple_expr_ty);
- TyTy::BaseType *tuple_type = r->get_base ();
- tree tuple_tyty = TyTyResolveCompile::compile (ctx, tuple_type);
-
- tree indirect
- = ctx->get_backend ()->indirect_expression (tuple_tyty, receiver_ref,
- true, expr.get_locus ());
+ tree indirect = indirect_expression (receiver_ref, expr.get_locus ());
receiver_ref = indirect;
}
@@ -552,10 +545,7 @@ public:
&field_index);
rust_assert (ok);
- tree adt_tyty = TyTyResolveCompile::compile (ctx, adt);
- tree indirect
- = ctx->get_backend ()->indirect_expression (adt_tyty, receiver_ref,
- true, expr.get_locus ());
+ tree indirect = indirect_expression (receiver_ref, expr.get_locus ());
receiver_ref = indirect;
}
diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h
index 4355e4ad522..45a507e03be 100644
--- a/gcc/rust/backend/rust-compile-extern.h
+++ b/gcc/rust/backend/rust-compile-extern.h
@@ -110,10 +110,7 @@ public:
if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup,
fntype->get_id (), fntype))
{
- reference
- = address_expression (lookup, build_pointer_type (TREE_TYPE (lookup)),
- ref_locus);
-
+ reference = address_expression (lookup, ref_locus);
return;
}
@@ -155,9 +152,7 @@ public:
ctx->insert_function_decl (fntype, fndecl);
- reference
- = address_expression (fndecl, build_pointer_type (TREE_TYPE (fndecl)),
- ref_locus);
+ reference = address_expression (fndecl, ref_locus);
}
private:
diff --git a/gcc/rust/backend/rust-compile-implitem.cc b/gcc/rust/backend/rust-compile-implitem.cc
index 735dede93c6..d0f70a70228 100644
--- a/gcc/rust/backend/rust-compile-implitem.cc
+++ b/gcc/rust/backend/rust-compile-implitem.cc
@@ -67,10 +67,8 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
{
ctx->insert_function_decl (fntype, lookup);
}
- reference
- = address_expression (lookup,
- build_pointer_type (TREE_TYPE (lookup)),
- ref_locus);
+
+ reference = address_expression (lookup, ref_locus);
return;
}
}
@@ -96,9 +94,7 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
func.get_outer_attrs (), func.get_locus (),
func.get_block_expr ().get (), canonical_path, fntype,
function.has_return_type ());
- reference
- = address_expression (fndecl, build_pointer_type (TREE_TYPE (fndecl)),
- ref_locus);
+ reference = address_expression (fndecl, ref_locus);
}
} // namespace Compile
diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc
index 1f2e479e1f6..ceba51c2d27 100644
--- a/gcc/rust/backend/rust-compile-item.cc
+++ b/gcc/rust/backend/rust-compile-item.cc
@@ -144,10 +144,7 @@ CompileItem::visit (HIR::Function &function)
ctx->insert_function_decl (fntype, lookup);
}
- reference
- = address_expression (lookup,
- build_pointer_type (TREE_TYPE (lookup)),
- ref_locus);
+ reference = address_expression (lookup, ref_locus);
return;
}
}
@@ -171,9 +168,7 @@ CompileItem::visit (HIR::Function &function)
function.get_outer_attrs (), function.get_locus (),
function.get_definition ().get (), canonical_path,
fntype, function.has_function_return_type ());
- reference
- = address_expression (fndecl, build_pointer_type (TREE_TYPE (fndecl)),
- ref_locus);
+ reference = address_expression (fndecl, ref_locus);
}
void
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index b5bfa3c21bf..8c1b7ef1f2b 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -129,16 +129,14 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
{
TREE_USED (fn) = 1;
- return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
- expr_locus);
+ return address_expression (fn, expr_locus);
}
else if (fntype->get_abi () == ABI::INTRINSIC)
{
Intrinsics compile (ctx);
fn = compile.compile (fntype);
TREE_USED (fn) = 1;
- return address_expression (fn, build_pointer_type (TREE_TYPE (fn)),
- expr_locus);
+ return address_expression (fn, expr_locus);
}
}
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 9bcd01c814c..4f17fa6286e 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -225,20 +225,14 @@ HIRCompileBase::coercion_site (tree rvalue, const TyTy::BaseType *rval,
const TyTy::ReferenceType *act
= static_cast<const TyTy::ReferenceType *> (actual);
- tree expected_type = TyTyResolveCompile::compile (ctx, act->get_base ());
- tree deref_rvalue
- = ctx->get_backend ()->indirect_expression (expected_type, rvalue,
- false /*known_valid*/,
- rvalue_locus);
+ tree deref_rvalue = indirect_expression (rvalue, rvalue_locus);
tree coerced
= coercion_site (deref_rvalue, act->get_base (), exp->get_base (),
lvalue_locus, rvalue_locus);
if (exp->is_dyn_object () && SLICE_TYPE_P (TREE_TYPE (coerced)))
return coerced;
- return address_expression (coerced,
- build_reference_type (TREE_TYPE (coerced)),
- rvalue_locus);
+ return address_expression (coerced, rvalue_locus);
}
else if (expected->get_kind () == TyTy::TypeKind::POINTER)
{
@@ -258,14 +252,12 @@ HIRCompileBase::coercion_site (tree rvalue, const TyTy::BaseType *rval,
= static_cast<const TyTy::ReferenceType *> (expected);
TyTy::BaseType *actual_base = nullptr;
- tree expected_type = error_mark_node;
if (actual->get_kind () == TyTy::TypeKind::REF)
{
const TyTy::ReferenceType *act
= static_cast<const TyTy::ReferenceType *> (actual);
actual_base = act->get_base ();
- expected_type = TyTyResolveCompile::compile (ctx, act->get_base ());
}
else if (actual->get_kind () == TyTy::TypeKind::POINTER)
{
@@ -273,22 +265,16 @@ HIRCompileBase::coercion_site (tree rvalue, const TyTy::BaseType *rval,
= static_cast<const TyTy::PointerType *> (actual);
actual_base = act->get_base ();
- expected_type = TyTyResolveCompile::compile (ctx, act->get_base ());
}
rust_assert (actual_base != nullptr);
- tree deref_rvalue
- = ctx->get_backend ()->indirect_expression (expected_type, rvalue,
- false /*known_valid*/,
- rvalue_locus);
+ tree deref_rvalue = indirect_expression (rvalue, rvalue_locus);
tree coerced = coercion_site (deref_rvalue, actual_base, exp->get_base (),
lvalue_locus, rvalue_locus);
if (exp->is_dyn_object () && SLICE_TYPE_P (TREE_TYPE (coerced)))
return coerced;
- return address_expression (coerced,
- build_pointer_type (TREE_TYPE (coerced)),
- rvalue_locus);
+ return address_expression (coerced, rvalue_locus);
}
else if (expected->get_kind () == TyTy::TypeKind::ARRAY)
{
@@ -350,10 +336,7 @@ HIRCompileBase::coerce_to_dyn_object (tree compiled_ref,
tree address_of_compiled_ref = null_pointer_node;
if (!actual->is_unit ())
- address_of_compiled_ref
- = address_expression (compiled_ref,
- build_pointer_type (TREE_TYPE (compiled_ref)),
- locus);
+ address_of_compiled_ref = address_expression (compiled_ref, locus);
std::vector<tree> vtable_ctor_elems;
std::vector<unsigned long> vtable_ctor_idx;
diff --git a/gcc/rust/rust-backend.h b/gcc/rust/rust-backend.h
index 6d631a0365a..f7c0b083370 100644
--- a/gcc/rust/rust-backend.h
+++ b/gcc/rust/rust-backend.h
@@ -178,14 +178,6 @@ public:
// Create a reference to a variable.
virtual tree var_expression (Bvariable *var, Location) = 0;
- // Create an expression that indirects through the pointer expression EXPR
- // (i.e., return the expression for *EXPR). KNOWN_VALID is true if the pointer
- // is known to point to a valid memory location. BTYPE is the expected type
- // of the indirected EXPR.
- virtual tree indirect_expression (tree btype, tree expr, bool known_valid,
- Location)
- = 0;
-
// Return an expression for the multi-precision integer VAL in BTYPE.
virtual tree integer_constant_expression (tree btype, mpz_t val) = 0;
diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc
index 4fea6fbd7fc..27196e88593 100644
--- a/gcc/rust/rust-gcc.cc
+++ b/gcc/rust/rust-gcc.cc
@@ -201,8 +201,6 @@ public:
tree var_expression (Bvariable *var, Location);
- tree indirect_expression (tree, tree expr, bool known_valid, Location);
-
tree integer_constant_expression (tree type, mpz_t val);
tree float_constant_expression (tree type, mpfr_t val);
@@ -1053,28 +1051,6 @@ Gcc_backend::var_expression (Bvariable *var, Location location)
return var->get_tree (location);
}
-// An expression that indirectly references an expression.
-
-tree
-Gcc_backend::indirect_expression (tree type_tree, tree expr_tree,
- bool known_valid, Location location)
-{
- if (expr_tree == error_mark_node || type_tree == error_mark_node)
- return error_mark_node;
-
- // If the type of EXPR is a recursive pointer type, then we
- // need to insert a cast before indirecting.
- tree target_type_tree = TREE_TYPE (TREE_TYPE (expr_tree));
- if (VOID_TYPE_P (target_type_tree))
- expr_tree = fold_convert_loc (location.gcc_location (),
- build_pointer_type (type_tree), expr_tree);
-
- tree ret = build_fold_indirect_ref_loc (location.gcc_location (), expr_tree);
- if (known_valid)
- TREE_THIS_NOTRAP (ret) = 1;
- return ret;
-}
-
// Return a typed value as a constant integer.
tree
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-08-06 12:09 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-08-06 12:09 [gcc/devel/rust/master] Refactor indirect_expression from the gcc-backend wrapper Thomas Schwinge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).