From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 85807385841D; Sat, 6 Aug 2022 12:09:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 85807385841D Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Thomas Schwinge To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/rust/master] Refactor indirect_expression from the gcc-backend wrapper X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 2dc902baa1388841096e16e660082a8e79fce17e X-Git-Newrev: 94e53f8e55e93da8db3d948c3f16d23b7c4ba7a6 Message-Id: <20220806120940.85807385841D@sourceware.org> Date: Sat, 6 Aug 2022 12:09:40 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 06 Aug 2022 12:09:40 -0000 https://gcc.gnu.org/g:94e53f8e55e93da8db3d948c3f16d23b7c4ba7a6 commit 94e53f8e55e93da8db3d948c3f16d23b7c4ba7a6 Author: Philip Herron 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 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 (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 (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 (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 (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 (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 (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 (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 (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 vtable_ctor_elems; std::vector 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