From 0ddb160c352ba2eacc375b94133813bb25704174 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 2 Oct 2023 18:41:33 +0100 Subject: [PATCH] gccrs: Remove backend dependancy on resolution rib information When making more desugaring for the HIR we can need to add new Let bindings which will require namesolution information but also rib information for which block the let binding is associated which was very unnessecary. This patch simply updates the BLOCK_CONTEXT of the current scope as we are compiling and encounter HIR::LetStmts instead of trying to do it all upfront which lots of wierd checks gcc/rust/ChangeLog: * backend/rust-compile-base.cc (HIRCompileBase::compile_locals_for_block): removed * backend/rust-compile-base.h: update header * backend/rust-compile-block.cc (CompileBlock::visit): remove old logic * backend/rust-compile-expr.cc (CompileExpr::generate_closure_function): likewise * backend/rust-compile-stmt.cc (CompileStmt::visit): likewise * backend/rust-compile-var-decl.h: ensure we setup tuple bindings correctly Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-base.cc | 51 +----------------- gcc/rust/backend/rust-compile-base.h | 3 -- gcc/rust/backend/rust-compile-block.cc | 13 +---- gcc/rust/backend/rust-compile-expr.cc | 5 +- gcc/rust/backend/rust-compile-stmt.cc | 16 ++++-- gcc/rust/backend/rust-compile-var-decl.h | 69 +++++++++++++++++++----- 6 files changed, 71 insertions(+), 86 deletions(-) diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc index 81ce0e919bd0..6939bffec5d6 100644 --- a/gcc/rust/backend/rust-compile-base.cc +++ b/gcc/rust/backend/rust-compile-base.cc @@ -564,35 +564,6 @@ HIRCompileBase::indirect_expression (tree expr, location_t locus) return build_fold_indirect_ref_loc (locus, expr); } -std::vector -HIRCompileBase::compile_locals_for_block (Context *ctx, Resolver::Rib &rib, - tree fndecl) -{ - std::vector locals; - for (auto it : rib.get_declarations ()) - { - NodeId node_id = it.first; - HirId ref = UNKNOWN_HIRID; - if (!ctx->get_mappings ()->lookup_node_to_hir (node_id, &ref)) - continue; - - // we only care about local patterns - HIR::Pattern *pattern = ctx->get_mappings ()->lookup_hir_pattern (ref); - if (pattern == nullptr) - continue; - - // lookup the type - TyTy::BaseType *tyty = nullptr; - if (!ctx->get_tyctx ()->lookup_type (ref, &tyty)) - continue; - - // compile the local - tree type = TyTyResolveCompile::compile (ctx, tyty); - CompileVarDecl::compile (fndecl, type, pattern, locals, ctx); - } - return locals; -} - void HIRCompileBase::compile_function_body (tree fndecl, HIR::BlockExpr &function_body, @@ -750,21 +721,11 @@ HIRCompileBase::compile_function ( if (!Backend::function_set_parameters (fndecl, param_vars)) return error_mark_node; - // lookup locals - auto body_mappings = function_body->get_mappings (); - Resolver::Rib *rib = nullptr; - bool ok - = ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (), &rib); - rust_assert (ok); - - std::vector locals - = compile_locals_for_block (ctx, *rib, fndecl); - tree enclosing_scope = NULL_TREE; location_t start_location = function_body->get_locus (); location_t end_location = function_body->get_end_locus (); - tree code_block = Backend::block (fndecl, enclosing_scope, locals, + tree code_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/, start_location, end_location); ctx->push_block (code_block); @@ -820,7 +781,6 @@ HIRCompileBase::compile_constant_item ( tree fndecl = Backend::function (compiled_fn_type, ident, "", 0, locus); TREE_READONLY (fndecl) = 1; - std::vector locals; tree enclosing_scope = NULL_TREE; location_t start_location = const_value_expr->get_locus (); location_t end_location = const_value_expr->get_locus (); @@ -830,16 +790,9 @@ HIRCompileBase::compile_constant_item ( = static_cast (const_value_expr); start_location = function_body->get_locus (); end_location = function_body->get_end_locus (); - - Resolver::Rib *rib = nullptr; - bool ok = ctx->get_resolver ()->find_name_rib ( - function_body->get_mappings ().get_nodeid (), &rib); - rust_assert (ok); - - locals = compile_locals_for_block (ctx, *rib, fndecl); } - tree code_block = Backend::block (fndecl, enclosing_scope, locals, + tree code_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/, start_location, end_location); ctx->push_block (code_block); diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h index cfe8c0e7b360..f19c80b3b24c 100644 --- a/gcc/rust/backend/rust-compile-base.h +++ b/gcc/rust/backend/rust-compile-base.h @@ -145,9 +145,6 @@ class HIRCompileBase static bool mark_addressable (tree, location_t); - static std::vector - compile_locals_for_block (Context *ctx, Resolver::Rib &rib, tree fndecl); - static tree named_constant_expression (tree type_tree, const std::string &name, tree const_val, location_t location); diff --git a/gcc/rust/backend/rust-compile-block.cc b/gcc/rust/backend/rust-compile-block.cc index a93e0bb2ae63..897639c920e7 100644 --- a/gcc/rust/backend/rust-compile-block.cc +++ b/gcc/rust/backend/rust-compile-block.cc @@ -42,20 +42,9 @@ CompileBlock::visit (HIR::BlockExpr &expr) tree fndecl = fnctx.fndecl; location_t start_location = expr.get_locus (); location_t end_location = expr.get_end_locus (); - auto body_mappings = expr.get_mappings (); - - Resolver::Rib *rib = nullptr; - if (!ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (), &rib)) - { - rust_fatal_error (expr.get_locus (), "failed to setup locals per block"); - return; - } - - std::vector locals - = compile_locals_for_block (ctx, *rib, fndecl); tree enclosing_scope = ctx->peek_enclosing_scope (); - tree new_block = Backend::block (fndecl, enclosing_scope, locals, + tree new_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/, start_location, end_location); ctx->push_block (new_block); diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index a5c853f17f50..c511cf1074f9 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -2310,7 +2310,6 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, bool is_block_expr = function_body->get_expression_type () == HIR::Expr::ExprType::Block; - std::vector locals = {}; if (is_block_expr) { auto body_mappings = function_body->get_mappings (); @@ -2319,8 +2318,6 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, = ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (), &rib); rust_assert (ok); - - locals = compile_locals_for_block (ctx, *rib, fndecl); } tree enclosing_scope = NULL_TREE; @@ -2333,7 +2330,7 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, end_location = body->get_end_locus (); } - tree code_block = Backend::block (fndecl, enclosing_scope, locals, + tree code_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/, start_location, end_location); ctx->push_block (code_block); diff --git a/gcc/rust/backend/rust-compile-stmt.cc b/gcc/rust/backend/rust-compile-stmt.cc index 839fa0cf5abf..73a63bb1c5a5 100644 --- a/gcc/rust/backend/rust-compile-stmt.cc +++ b/gcc/rust/backend/rust-compile-stmt.cc @@ -19,6 +19,8 @@ #include "rust-compile-pattern.h" #include "rust-compile-stmt.h" #include "rust-compile-expr.h" +#include "rust-compile-type.h" +#include "rust-compile-var-decl.h" namespace Rust { namespace Compile { @@ -44,10 +46,6 @@ CompileStmt::visit (HIR::ExprStmt &stmt) void CompileStmt::visit (HIR::LetStmt &stmt) { - // nothing to do - if (!stmt.has_init_expr ()) - return; - HIR::Pattern &stmt_pattern = *stmt.get_pattern (); HirId stmt_id = stmt_pattern.get_mappings ().get_hirid (); @@ -60,6 +58,16 @@ CompileStmt::visit (HIR::LetStmt &stmt) return; } + // setup var decl nodes + fncontext fnctx = ctx->peek_fn (); + tree fndecl = fnctx.fndecl; + tree translated_type = TyTyResolveCompile::compile (ctx, ty); + CompileVarDecl::compile (fndecl, translated_type, &stmt_pattern, ctx); + + // nothing to do + if (!stmt.has_init_expr ()) + return; + tree init = CompileExpr::Compile (stmt.get_init_expr ().get (), ctx); // FIXME use error_mark_node, check that CompileExpr returns error_mark_node // on failure and make this an assertion diff --git a/gcc/rust/backend/rust-compile-var-decl.h b/gcc/rust/backend/rust-compile-var-decl.h index eb7977b58fd6..709334f64e4e 100644 --- a/gcc/rust/backend/rust-compile-var-decl.h +++ b/gcc/rust/backend/rust-compile-var-decl.h @@ -30,11 +30,12 @@ class CompileVarDecl : public HIRCompileBase, public HIR::HIRPatternVisitor using HIR::HIRPatternVisitor::visit; public: - static void compile (tree fndecl, tree translated_type, HIR::Pattern *pattern, - std::vector &locals, Context *ctx) + static std::vector compile (tree fndecl, tree translated_type, + HIR::Pattern *pattern, Context *ctx) { - CompileVarDecl compiler (ctx, fndecl, translated_type, locals); + CompileVarDecl compiler (ctx, fndecl, translated_type); pattern->accept_vis (compiler); + return compiler.vars; } void visit (HIR::IdentifierPattern &pattern) override @@ -42,15 +43,58 @@ class CompileVarDecl : public HIRCompileBase, public HIR::HIRPatternVisitor if (!pattern.is_mut ()) translated_type = Backend::immutable_type (translated_type); - Bvariable *var - = Backend::local_variable (fndecl, pattern.get_identifier ().as_string (), - translated_type, NULL /*decl_var*/, - pattern.get_locus ()); + tree bind_tree = ctx->peek_enclosing_scope (); + std::string identifier = pattern.get_identifier ().as_string (); + tree decl + = build_decl (pattern.get_locus (), VAR_DECL, + Backend::get_identifier_node (identifier), translated_type); + DECL_CONTEXT (decl) = fndecl; + + gcc_assert (TREE_CODE (bind_tree) == BIND_EXPR); + tree block_tree = BIND_EXPR_BLOCK (bind_tree); + gcc_assert (TREE_CODE (block_tree) == BLOCK); + DECL_CHAIN (decl) = BLOCK_VARS (block_tree); + BLOCK_VARS (block_tree) = decl; + BIND_EXPR_VARS (bind_tree) = BLOCK_VARS (block_tree); + + rust_preserve_from_gc (decl); + Bvariable *var = new Bvariable (decl); HirId stmt_id = pattern.get_mappings ().get_hirid (); ctx->insert_var_decl (stmt_id, var); - locals.push_back (var); + vars.push_back (var); + } + + void visit (HIR::TuplePattern &pattern) override + { + switch (pattern.get_items ()->get_item_type ()) + { + case HIR::TuplePatternItems::ItemType::MULTIPLE: { + rust_assert (TREE_CODE (translated_type) == RECORD_TYPE); + auto &items = static_cast ( + *pattern.get_items ()); + + size_t offs = 0; + for (auto &sub : items.get_patterns ()) + { + tree sub_ty = error_mark_node; + tree field = TYPE_FIELDS (translated_type); + for (size_t i = 0; i < offs; i++) + { + field = DECL_CHAIN (field); + gcc_assert (field != NULL_TREE); + } + sub_ty = TREE_TYPE (field); + CompileVarDecl::compile (fndecl, sub_ty, sub.get (), ctx); + offs++; + } + } + break; + + default: + break; + } } // Empty visit for unused Pattern HIR nodes. @@ -62,21 +106,18 @@ class CompileVarDecl : public HIRCompileBase, public HIR::HIRPatternVisitor void visit (HIR::ReferencePattern &) override {} void visit (HIR::SlicePattern &) override {} void visit (HIR::StructPattern &) override {} - void visit (HIR::TuplePattern &) override {} void visit (HIR::TupleStructPattern &) override {} void visit (HIR::WildcardPattern &) override {} private: - CompileVarDecl (Context *ctx, tree fndecl, tree translated_type, - std::vector &locals) - : HIRCompileBase (ctx), fndecl (fndecl), translated_type (translated_type), - locals (locals) + CompileVarDecl (Context *ctx, tree fndecl, tree translated_type) + : HIRCompileBase (ctx), fndecl (fndecl), translated_type (translated_type) {} tree fndecl; tree translated_type; - std::vector &locals; + std::vector vars; }; } // namespace Compile