From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 0352C39960C2; Wed, 8 Jun 2022 11:51:55 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0352C39960C2 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] Replace Bfunction with GCC tree X-Act-Checkin: gcc X-Git-Author: David Faust X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 553e88f1dd4b4794334ee6d1861c185b92361a0b X-Git-Newrev: 95048daaffa5e16df4d663702fe80294eac7b85e Message-Id: <20220608115155.0352C39960C2@sourceware.org> Date: Wed, 8 Jun 2022 11:51:55 +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: Wed, 08 Jun 2022 11:51:55 -0000 https://gcc.gnu.org/g:95048daaffa5e16df4d663702fe80294eac7b85e commit 95048daaffa5e16df4d663702fe80294eac7b85e Author: David Faust Date: Mon Nov 15 09:49:38 2021 -0800 Replace Bfunction with GCC tree Diff: --- gcc/rust/backend/rust-compile-base.h | 4 +- gcc/rust/backend/rust-compile-context.h | 23 ++-- gcc/rust/backend/rust-compile-expr.cc | 2 +- gcc/rust/backend/rust-compile-expr.h | 2 +- gcc/rust/backend/rust-compile-extern.h | 8 +- gcc/rust/backend/rust-compile-fnparam.h | 12 +- gcc/rust/backend/rust-compile-implitem.h | 12 +- gcc/rust/backend/rust-compile-intrinsic.cc | 4 +- gcc/rust/backend/rust-compile-intrinsic.h | 2 +- gcc/rust/backend/rust-compile-item.h | 6 +- gcc/rust/backend/rust-compile-resolve-path.cc | 2 +- gcc/rust/backend/rust-compile-var-decl.h | 7 +- gcc/rust/backend/rust-compile.cc | 12 +- gcc/rust/rust-backend.h | 65 ++++----- gcc/rust/rust-gcc.cc | 189 +++++++++++--------------- 15 files changed, 156 insertions(+), 194 deletions(-) diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h index 56504515b5c..af0ea408ccd 100644 --- a/gcc/rust/backend/rust-compile-base.h +++ b/gcc/rust/backend/rust-compile-base.h @@ -193,11 +193,11 @@ protected: Context *get_context () { return ctx; } - void compile_function_body (Bfunction *fndecl, + void compile_function_body (tree fndecl, std::unique_ptr &function_body, bool has_return_type); - bool compile_locals_for_block (Resolver::Rib &rib, Bfunction *fndecl, + bool compile_locals_for_block (Resolver::Rib &rib, tree fndecl, std::vector &locals); tree coercion_site (tree compiled_ref, TyTy::BaseType *actual, diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h index 1128fa82cae..4c8f7223bc9 100644 --- a/gcc/rust/backend/rust-compile-context.h +++ b/gcc/rust/backend/rust-compile-context.h @@ -35,7 +35,7 @@ namespace Compile { struct fncontext { - ::Bfunction *fndecl; + ::tree fndecl; ::Bvariable *ret_addr; }; @@ -161,7 +161,7 @@ public: return true; } - void insert_function_decl (const TyTy::FnType *ref, ::Bfunction *fn) + void insert_function_decl (const TyTy::FnType *ref, tree fn) { auto id = ref->get_ty_ref (); auto dId = ref->get_id (); @@ -176,8 +176,7 @@ public: mono_fns[dId].push_back ({ref, fn}); } - bool lookup_function_decl (HirId id, ::Bfunction **fn, - DefId dId = UNKNOWN_DEFID, + bool lookup_function_decl (HirId id, tree *fn, DefId dId = UNKNOWN_DEFID, const TyTy::BaseType *ref = nullptr) { // for for any monomorphized fns @@ -192,7 +191,7 @@ public: for (auto &e : mono_fns[dId]) { const TyTy::BaseType *r = e.first; - ::Bfunction *f = e.second; + tree f = e.second; if (ref->is_equal (*r)) { *fn = f; @@ -237,7 +236,7 @@ public: return true; } - void push_fn (::Bfunction *fn, ::Bvariable *ret_addr) + void push_fn (tree fn, ::Bvariable *ret_addr) { fn_stack.push_back (fncontext{fn, ret_addr}); } @@ -247,7 +246,7 @@ public: void push_type (::tree t) { type_decls.push_back (t); } void push_var (::Bvariable *v) { var_decls.push_back (v); } void push_const (::tree c) { const_decls.push_back (c); } - void push_function (::Bfunction *f) { func_decls.push_back (f); } + void push_function (tree f) { func_decls.push_back (f); } void write_to_backend () { @@ -255,11 +254,11 @@ public: var_decls); } - bool function_completed (Bfunction *fn) + bool function_completed (tree fn) { for (auto it = func_decls.begin (); it != func_decls.end (); it++) { - Bfunction *i = (*it); + tree i = (*it); if (i == fn) { return true; @@ -320,7 +319,7 @@ private: std::vector fn_stack; std::map compiled_var_decls; std::map compiled_type_map; - std::map compiled_fn_map; + std::map compiled_fn_map; std::map compiled_consts; std::map compiled_labels; std::vector<::std::vector> statements; @@ -328,14 +327,14 @@ private: std::vector<::Bvariable *> loop_value_stack; std::vector<::Blabel *> loop_begin_labels; std::map> mono; - std::map>> + std::map>> mono_fns; // To GCC middle-end std::vector type_decls; std::vector<::Bvariable *> var_decls; std::vector const_decls; - std::vector<::Bfunction *> func_decls; + std::vector func_decls; }; class TyTyResolveCompile : public TyTy::TyConstVisitor diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 8786702498a..8b1da22efcf 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -209,7 +209,7 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref, Location expr_locus) { // lookup compiled functions since it may have already been compiled - Bfunction *fn = nullptr; + tree fn = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn)) { return ctx->get_backend ()->function_code_expression (fn, expr_locus); diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index 14d43450b42..f7392739e55 100644 --- a/gcc/rust/backend/rust-compile-expr.h +++ b/gcc/rust/backend/rust-compile-expr.h @@ -204,7 +204,7 @@ public: gcc_unreachable (); } - Bfunction *fn = nullptr; + tree fn = NULL_TREE; Bvariable *var = nullptr; if (ctx->lookup_const_decl (ref, &translated)) { diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h index 2d3d251bb30..aa73509f634 100644 --- a/gcc/rust/backend/rust-compile-extern.h +++ b/gcc/rust/backend/rust-compile-extern.h @@ -99,14 +99,14 @@ public: // items can be forward compiled which means we may not need to invoke this // code. We might also have already compiled this generic function as well. - Bfunction *lookup = nullptr; + tree lookup = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup, fntype->get_id (), fntype)) { // has this been added to the list then it must be finished if (ctx->function_completed (lookup)) { - Bfunction *dummy = nullptr; + tree dummy = NULL_TREE; if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &dummy)) ctx->insert_function_decl (fntype, lookup); @@ -123,7 +123,7 @@ public: if (fntype->get_abi () == ABI::INTRINSIC) { Intrinsics compile (ctx); - Bfunction *fndecl = compile.compile (fntype); + tree fndecl = compile.compile (fntype); ctx->insert_function_decl (fntype, fndecl); return; } @@ -139,7 +139,7 @@ public: std::string ir_symbol_name = function.get_item_name (); std::string asm_name = function.get_item_name (); - Bfunction *fndecl + tree fndecl = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, asm_name, flags, function.get_locus ()); ctx->insert_function_decl (fntype, fndecl); diff --git a/gcc/rust/backend/rust-compile-fnparam.h b/gcc/rust/backend/rust-compile-fnparam.h index 903f8395cb6..629f0f5a873 100644 --- a/gcc/rust/backend/rust-compile-fnparam.h +++ b/gcc/rust/backend/rust-compile-fnparam.h @@ -29,7 +29,7 @@ class CompileFnParam : public HIRCompileBase using Rust::Compile::HIRCompileBase::visit; public: - static Bvariable *compile (Context *ctx, Bfunction *fndecl, + static Bvariable *compile (Context *ctx, tree fndecl, HIR::FunctionParam *param, tree decl_type, Location locus) { @@ -51,13 +51,12 @@ public: } private: - CompileFnParam (Context *ctx, ::Bfunction *fndecl, tree decl_type, - Location locus) + CompileFnParam (Context *ctx, tree fndecl, tree decl_type, Location locus) : HIRCompileBase (ctx), fndecl (fndecl), decl_type (decl_type), locus (locus), translated (nullptr) {} - ::Bfunction *fndecl; + tree fndecl; tree decl_type; Location locus; ::Bvariable *translated; @@ -66,9 +65,8 @@ private: class CompileSelfParam : public HIRCompileBase { public: - static Bvariable *compile (Context *ctx, Bfunction *fndecl, - HIR::SelfParam &self, tree decl_type, - Location locus) + static Bvariable *compile (Context *ctx, tree fndecl, HIR::SelfParam &self, + tree decl_type, Location locus) { bool is_immutable = self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM diff --git a/gcc/rust/backend/rust-compile-implitem.h b/gcc/rust/backend/rust-compile-implitem.h index fb3b381144e..23b10d61de5 100644 --- a/gcc/rust/backend/rust-compile-implitem.h +++ b/gcc/rust/backend/rust-compile-implitem.h @@ -110,14 +110,14 @@ public: // items can be forward compiled which means we may not need to invoke this // code. We might also have already compiled this generic function as well. - Bfunction *lookup = nullptr; + tree lookup = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup, fntype->get_id (), fntype)) { // has this been added to the list then it must be finished if (ctx->function_completed (lookup)) { - Bfunction *dummy = nullptr; + tree dummy = NULL_TREE; if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &dummy)) { ctx->insert_function_decl (fntype, lookup); @@ -156,7 +156,7 @@ public: std::string asm_name = ctx->mangle_impl_item (self, fntype, function.get_function_name ()); - Bfunction *fndecl + tree fndecl = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, asm_name, flags, function.get_locus ()); ctx->insert_function_decl (fntype, fndecl); @@ -377,14 +377,14 @@ public: // items can be forward compiled which means we may not need to invoke this // code. We might also have already compiled this generic function as well. - Bfunction *lookup = nullptr; + tree lookup = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup, fntype->get_id (), fntype)) { // has this been added to the list then it must be finished if (ctx->function_completed (lookup)) { - Bfunction *dummy = nullptr; + tree dummy = NULL_TREE; if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &dummy)) { ctx->insert_function_decl (fntype, lookup); @@ -417,7 +417,7 @@ public: std::string fn_identifier = canonical_path->get (); std::string asm_name = ctx->mangle_item (fntype, *canonical_path); - Bfunction *fndecl + tree fndecl = ctx->get_backend ()->function (compiled_fn_type, fn_identifier, asm_name, flags, func.get_locus ()); ctx->insert_function_decl (fntype, fndecl); diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc index 66d36e32ecb..69626a930e9 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.cc +++ b/gcc/rust/backend/rust-compile-intrinsic.cc @@ -21,7 +21,7 @@ namespace Compile { Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {} -Bfunction * +tree Intrinsics::compile (TyTy::FnType *fntype) { rust_assert (fntype->get_abi () == ABI::INTRINSIC); @@ -77,7 +77,7 @@ Intrinsics::compile (TyTy::FnType *fntype) // }; // Some(cx.get_intrinsic(&llvm_name)) - Bfunction *builtin = ctx->get_backend ()->lookup_builtin_by_rust_name ( + tree builtin = ctx->get_backend ()->lookup_builtin_by_rust_name ( fntype->get_identifier ()); if (builtin != nullptr) return builtin; diff --git a/gcc/rust/backend/rust-compile-intrinsic.h b/gcc/rust/backend/rust-compile-intrinsic.h index 25e298aa57b..2d44baa037c 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.h +++ b/gcc/rust/backend/rust-compile-intrinsic.h @@ -27,7 +27,7 @@ class Intrinsics public: Intrinsics (Context *ctx); - Bfunction *compile (TyTy::FnType *fntype); + tree compile (TyTy::FnType *fntype); private: Context *ctx; diff --git a/gcc/rust/backend/rust-compile-item.h b/gcc/rust/backend/rust-compile-item.h index 0e7737c27f4..94a313e1aa8 100644 --- a/gcc/rust/backend/rust-compile-item.h +++ b/gcc/rust/backend/rust-compile-item.h @@ -147,14 +147,14 @@ public: // items can be forward compiled which means we may not need to invoke this // code. We might also have already compiled this generic function as well. - Bfunction *lookup = nullptr; + tree lookup = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup, fntype->get_id (), fntype)) { // has this been added to the list then it must be finished if (ctx->function_completed (lookup)) { - Bfunction *dummy = nullptr; + tree dummy = NULL_TREE; if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &dummy)) { ctx->insert_function_decl (fntype, lookup); @@ -201,7 +201,7 @@ public: asm_name = ctx->mangle_item (fntype, *canonical_path); } - Bfunction *fndecl + tree fndecl = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, asm_name, flags, function.get_locus ()); ctx->insert_function_decl (fntype, fndecl); diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index 81ffad8d147..cb3f0df8db0 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -92,7 +92,7 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment, if (lookup->get_kind () == TyTy::TypeKind::FNDEF) { TyTy::FnType *fntype = static_cast (lookup); - Bfunction *fn = nullptr; + tree fn = NULL_TREE; if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn)) { return ctx->get_backend ()->function_code_expression (fn, expr_locus); diff --git a/gcc/rust/backend/rust-compile-var-decl.h b/gcc/rust/backend/rust-compile-var-decl.h index deabd7df343..a964fa2206b 100644 --- a/gcc/rust/backend/rust-compile-var-decl.h +++ b/gcc/rust/backend/rust-compile-var-decl.h @@ -29,8 +29,7 @@ class CompileVarDecl : public HIRCompileBase using Rust::Compile::HIRCompileBase::visit; public: - static ::Bvariable *compile (::Bfunction *fndecl, HIR::Stmt *stmt, - Context *ctx) + static ::Bvariable *compile (tree fndecl, HIR::Stmt *stmt, Context *ctx) { CompileVarDecl compiler (ctx, fndecl); stmt->accept_vis (compiler); @@ -64,12 +63,12 @@ public: } private: - CompileVarDecl (Context *ctx, ::Bfunction *fndecl) + CompileVarDecl (Context *ctx, tree fndecl) : HIRCompileBase (ctx), fndecl (fndecl), translated_type (nullptr), translated (nullptr) {} - ::Bfunction *fndecl; + tree fndecl; tree translated_type; Location locus; ::Bvariable *translated; diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc index 8b74c779f45..71435f37e88 100644 --- a/gcc/rust/backend/rust-compile.cc +++ b/gcc/rust/backend/rust-compile.cc @@ -322,7 +322,7 @@ void CompileBlock::visit (HIR::BlockExpr &expr) { fncontext fnctx = ctx->peek_fn (); - Bfunction *fndecl = fnctx.fndecl; + tree fndecl = fnctx.fndecl; Location start_location = expr.get_locus (); Location end_location = expr.get_closing_locus (); auto body_mappings = expr.get_mappings (); @@ -393,7 +393,7 @@ void CompileConditionalBlocks::visit (HIR::IfExpr &expr) { fncontext fnctx = ctx->peek_fn (); - Bfunction *fndecl = fnctx.fndecl; + tree fndecl = fnctx.fndecl; tree condition_expr = CompileExpr::Compile (expr.get_if_condition (), ctx); Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx, result); @@ -407,7 +407,7 @@ void CompileConditionalBlocks::visit (HIR::IfExprConseqElse &expr) { fncontext fnctx = ctx->peek_fn (); - Bfunction *fndecl = fnctx.fndecl; + tree fndecl = fnctx.fndecl; tree condition_expr = CompileExpr::Compile (expr.get_if_condition (), ctx); Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx, result); @@ -423,7 +423,7 @@ void CompileConditionalBlocks::visit (HIR::IfExprConseqIf &expr) { fncontext fnctx = ctx->peek_fn (); - Bfunction *fndecl = fnctx.fndecl; + tree fndecl = fnctx.fndecl; tree condition_expr = CompileExpr::Compile (expr.get_if_condition (), ctx); Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx, result); @@ -478,7 +478,7 @@ CompileStructExprField::visit (HIR::StructExprFieldIdentifier &field) void HIRCompileBase::compile_function_body ( - Bfunction *fndecl, std::unique_ptr &function_body, + tree fndecl, std::unique_ptr &function_body, bool has_return_type) { for (auto &s : function_body->get_statements ()) @@ -523,7 +523,7 @@ HIRCompileBase::compile_function_body ( } bool -HIRCompileBase::compile_locals_for_block (Resolver::Rib &rib, Bfunction *fndecl, +HIRCompileBase::compile_locals_for_block (Resolver::Rib &rib, tree fndecl, std::vector &locals) { rib.iterate_decls ([&] (NodeId n, Location) mutable -> bool { diff --git a/gcc/rust/rust-backend.h b/gcc/rust/rust-backend.h index 22e2b6b2a2a..836f5190e8b 100644 --- a/gcc/rust/rust-backend.h +++ b/gcc/rust/rust-backend.h @@ -41,9 +41,6 @@ saw_errors (void); // frontend, and passed back to the backend. The types must be // defined by the backend using these names. -// The backend representation of a function definition or declaration. -class Bfunction; - // The backend representation of a block. class Bblock; @@ -81,7 +78,6 @@ public: // debug virtual void debug (tree) = 0; - virtual void debug (Bfunction *) = 0; virtual void debug (Bblock *) = 0; virtual void debug (Bvariable *) = 0; virtual void debug (Blabel *) = 0; @@ -314,7 +310,7 @@ public: // Create an expression for the address of a function. This is used to // get the address of the code for a function. - virtual tree function_code_expression (Bfunction *, Location) = 0; + virtual tree function_code_expression (tree, Location) = 0; // Create an expression that takes the address of an expression. virtual tree address_expression (tree, Location) = 0; @@ -329,7 +325,7 @@ public: // Return an expression that executes THEN_EXPR if CONDITION is true, or // ELSE_EXPR otherwise and returns the result as type BTYPE, within the // specified function FUNCTION. ELSE_EXPR may be NULL. BTYPE may be NULL. - virtual tree conditional_expression (Bfunction *function, tree btype, + virtual tree conditional_expression (tree function, tree btype, tree condition, tree then_expr, tree else_expr, Location) = 0; @@ -385,7 +381,7 @@ public: // Create an expression for a call to FN with ARGS, taking place within // caller CALLER. - virtual tree call_expression (Bfunction *caller, tree fn, + virtual tree call_expression (tree caller, tree fn, const std::vector &args, tree static_chain, Location) = 0; @@ -398,25 +394,22 @@ public: virtual tree error_statement () = 0; // Create an expression statement within the specified function. - virtual tree expression_statement (Bfunction *, tree) = 0; + virtual tree expression_statement (tree, tree) = 0; // Create a variable initialization statement in the specified // function. This initializes a local variable at the point in the // program flow where it is declared. - virtual tree init_statement (Bfunction *, Bvariable *var, tree init) = 0; + virtual tree init_statement (tree, Bvariable *var, tree init) = 0; // Create an assignment statement within the specified function. - virtual tree assignment_statement (Bfunction *, tree lhs, tree rhs, Location) - = 0; + virtual tree assignment_statement (tree, tree lhs, tree rhs, Location) = 0; // Create a return statement, passing the representation of the // function and the list of values to return. - virtual tree return_statement (Bfunction *, const std::vector &, - Location) - = 0; + virtual tree return_statement (tree, const std::vector &, Location) = 0; // Create an if statement within a function. ELSE_BLOCK may be NULL. - virtual tree if_statement (Bfunction *, tree condition, Bblock *then_block, + virtual tree if_statement (tree, tree condition, Bblock *then_block, Bblock *else_block, Location) = 0; @@ -433,7 +426,7 @@ public: // either end with a goto statement or will fall through into // STATEMENTS[i + 1]. CASES[i] is empty for the default clause, // which need not be last. FUNCTION is the current function. - virtual tree switch_statement (Bfunction *function, tree value, + virtual tree switch_statement (tree function, tree value, const std::vector > &cases, const std::vector &statements, Location) = 0; @@ -465,7 +458,7 @@ public: // the initial curly brace. END_LOCATION is the location of the end // of the block, more or less the location of the final curly brace. // The statements will be added after the block is created. - virtual Bblock *block (Bfunction *function, Bblock *enclosing, + virtual Bblock *block (tree function, Bblock *enclosing, const std::vector &vars, Location start_location, Location end_location) = 0; @@ -523,21 +516,21 @@ public: // the function, as otherwise the variable would be on the heap). // LOCATION is where the variable is defined. For each local variable // the frontend will call init_statement to set the initial value. - virtual Bvariable * - local_variable (Bfunction *function, const std::string &name, tree type, - Bvariable *decl_var, bool is_address_taken, Location location) + virtual Bvariable *local_variable (tree function, const std::string &name, + tree type, Bvariable *decl_var, + bool is_address_taken, Location location) = 0; // Create a function parameter. This is an incoming parameter, not // a result parameter (result parameters are treated as local // variables). The arguments are as for local_variable. - virtual Bvariable * - parameter_variable (Bfunction *function, const std::string &name, tree type, - bool is_address_taken, Location location) + virtual Bvariable *parameter_variable (tree function, const std::string &name, + tree type, bool is_address_taken, + Location location) = 0; // Create a static chain parameter. This is the closure parameter. - virtual Bvariable *static_chain_variable (Bfunction *function, + virtual Bvariable *static_chain_variable (tree function, const std::string &name, tree type, Location location) = 0; @@ -553,7 +546,7 @@ public: // variable, and may not be very useful. This function should // return a variable which can be referenced later and should set // *PSTATEMENT to a statement which initializes the variable. - virtual Bvariable *temporary_variable (Bfunction *, Bblock *, tree, tree init, + virtual Bvariable *temporary_variable (tree, Bblock *, tree, tree init, bool address_is_taken, Location location, tree *pstatement) = 0; @@ -676,7 +669,7 @@ public: // Create a new label. NAME will be empty if this is a label // created by the frontend for a loop construct. The location is // where the label is defined. - virtual Blabel *label (Bfunction *, const std::string &name, Location) = 0; + virtual Blabel *label (tree, const std::string &name, Location) = 0; // Create a statement which defines a label. This statement will be // put into the codestream at the point where the label should be @@ -696,7 +689,7 @@ public: // Create an error function. This is used for cases which should // not occur in a correct program, in order to keep the compilation // going without crashing. - virtual Bfunction *error_function () = 0; + virtual tree error_function () = 0; // Bit flags to pass to the function method. @@ -735,9 +728,9 @@ public: // string, is the name that should be used in the symbol table; this // will be non-empty if a magic extern comment is used. FLAGS is // bit flags described above. - virtual Bfunction *function (tree fntype, const std::string &name, - const std::string &asm_name, unsigned int flags, - Location) + virtual tree function (tree fntype, const std::string &name, + const std::string &asm_name, unsigned int flags, + Location) = 0; virtual tree specify_abi_attribute (tree type, Rust::ABI abi) = 0; @@ -746,7 +739,7 @@ public: // be a statement that looks like this in C++: // finish: // try { DEFER_RETURN; } catch { CHECK_DEFER; goto finish; } - virtual tree function_defer_statement (Bfunction *function, tree undefer, + virtual tree function_defer_statement (tree function, tree undefer, tree check_defer, Location) = 0; @@ -754,19 +747,19 @@ public: // This will only be called for a function definition. Returns true on // success, false on failure. virtual bool - function_set_parameters (Bfunction *function, + function_set_parameters (tree function, const std::vector ¶m_vars) = 0; // Set the function body for FUNCTION using the code in CODE_STMT. Returns // true on success, false on failure. - virtual bool function_set_body (Bfunction *function, tree code_stmt) = 0; + virtual bool function_set_body (tree function, tree code_stmt) = 0; // Look up a named built-in function in the current backend implementation. // Returns NULL if no built-in function by that name exists. - virtual Bfunction *lookup_gcc_builtin (const std::string &) = 0; + virtual tree lookup_gcc_builtin (const std::string &) = 0; - virtual Bfunction *lookup_builtin_by_rust_name (const std::string &) = 0; + virtual tree lookup_builtin_by_rust_name (const std::string &) = 0; // Utility. @@ -775,7 +768,7 @@ public: virtual void write_global_definitions (const std::vector &type_decls, const std::vector &constant_decls, - const std::vector &function_decls, + const std::vector &function_decls, const std::vector &variable_decls) = 0; diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc index 873e664f6b5..730835325db 100644 --- a/gcc/rust/rust-gcc.cc +++ b/gcc/rust/rust-gcc.cc @@ -70,12 +70,6 @@ private: // In gcc, types, expressions, and statements are all trees. -class Bfunction : public Gcc_tree -{ -public: - Bfunction (tree t) : Gcc_tree (t) {} -}; - class Bblock : public Gcc_tree { public: @@ -143,7 +137,6 @@ public: Gcc_backend (); void debug (tree t) { debug_tree (t); }; - void debug (Bfunction *t) { debug_tree (t->get_tree ()); }; void debug (Bblock *t) { debug_tree (t->get_tree ()); }; void debug (Bvariable *t) { debug_tree (t->get_decl ()); }; void debug (Blabel *t) { debug_tree (t->get_tree ()); }; @@ -305,7 +298,7 @@ public: tree convert_expression (tree type, tree expr, Location); - tree function_code_expression (Bfunction *, Location); + tree function_code_expression (tree, Location); tree address_expression (tree, Location); @@ -313,7 +306,7 @@ public: tree compound_expression (tree, tree, Location); - tree conditional_expression (Bfunction *, tree, tree, tree, tree, Location); + tree conditional_expression (tree, tree, tree, tree, tree, Location); tree negation_expression (NegationOperator op, tree expr, Location); @@ -335,26 +328,25 @@ public: tree array_index_expression (tree array, tree index, Location); - tree call_expression (Bfunction *caller, tree fn, - const std::vector &args, tree static_chain, - Location); + tree call_expression (tree caller, tree fn, const std::vector &args, + tree static_chain, Location); // Statements. tree error_statement () { return error_mark_node; } - tree expression_statement (Bfunction *, tree); + tree expression_statement (tree, tree); - tree init_statement (Bfunction *, Bvariable *var, tree init); + tree init_statement (tree, Bvariable *var, tree init); - tree assignment_statement (Bfunction *, tree lhs, tree rhs, Location); + tree assignment_statement (tree, tree lhs, tree rhs, Location); - tree return_statement (Bfunction *, const std::vector &, Location); + tree return_statement (tree, const std::vector &, Location); - tree if_statement (Bfunction *, tree condition, Bblock *then_block, + tree if_statement (tree, tree condition, Bblock *then_block, Bblock *else_block, Location); - tree switch_statement (Bfunction *function, tree value, + tree switch_statement (tree function, tree value, const std::vector> &cases, const std::vector &statements, Location); @@ -371,8 +363,8 @@ public: // Blocks. - Bblock *block (Bfunction *, Bblock *, const std::vector &, - Location, Location); + Bblock *block (tree, Bblock *, const std::vector &, Location, + Location); void block_add_statements (Bblock *, const std::vector &); @@ -389,17 +381,16 @@ public: void global_variable_set_init (Bvariable *, tree); - Bvariable *local_variable (Bfunction *, const std::string &, tree, - Bvariable *, bool, Location); + Bvariable *local_variable (tree, const std::string &, tree, Bvariable *, bool, + Location); - Bvariable *parameter_variable (Bfunction *, const std::string &, tree, - bool, Location); + Bvariable *parameter_variable (tree, const std::string &, tree, bool, + Location); - Bvariable *static_chain_variable (Bfunction *, const std::string &, tree, - Location); + Bvariable *static_chain_variable (tree, const std::string &, tree, Location); - Bvariable *temporary_variable (Bfunction *, Bblock *, tree, tree, bool, - Location, tree *); + Bvariable *temporary_variable (tree, Bblock *, tree, tree, bool, Location, + tree *); Bvariable *implicit_variable (const std::string &, const std::string &, tree, bool, bool, bool, int64_t); @@ -422,7 +413,7 @@ public: // Labels. - Blabel *label (Bfunction *, const std::string &name, Location); + Blabel *label (tree, const std::string &name, Location); tree label_definition_statement (Blabel *); @@ -432,35 +423,32 @@ public: // Functions. - Bfunction *error_function () { return this->make_function (error_mark_node); } + tree error_function () { return error_mark_node; } - Bfunction *function (tree fntype, const std::string &name, - const std::string &asm_name, unsigned int flags, - Location); + tree function (tree fntype, const std::string &name, + const std::string &asm_name, unsigned int flags, Location); - tree function_defer_statement (Bfunction *function, tree undefer, tree defer, + tree function_defer_statement (tree function, tree undefer, tree defer, Location); - bool function_set_parameters (Bfunction *function, + bool function_set_parameters (tree function, const std::vector &); - bool function_set_body (Bfunction *function, tree code_stmt); + bool function_set_body (tree function, tree code_stmt); - Bfunction *lookup_gcc_builtin (const std::string &); + tree lookup_gcc_builtin (const std::string &); - Bfunction *lookup_builtin_by_rust_name (const std::string &); + tree lookup_builtin_by_rust_name (const std::string &); void write_global_definitions (const std::vector &, const std::vector &, - const std::vector &, + const std::vector &, const std::vector &); void write_export_data (const char *bytes, unsigned int size); private: - Bfunction *make_function (tree t) { return new Bfunction (t); } - tree fill_in_fields (tree, const std::vector &); tree fill_in_array (tree, tree, tree); @@ -479,7 +467,7 @@ private: int flags); // A mapping of the GCC built-ins exposed to GCCRust. - std::map builtin_functions_; + std::map builtin_functions_; std::map rust_intrinsic_to_gcc_builtin; }; @@ -1458,9 +1446,8 @@ Gcc_backend::convert_expression (tree type_tree, tree expr_tree, // Get the address of a function. tree -Gcc_backend::function_code_expression (Bfunction *bfunc, Location location) +Gcc_backend::function_code_expression (tree func, Location location) { - tree func = bfunc->get_tree (); if (func == error_mark_node) return this->error_expression (); @@ -1527,9 +1514,9 @@ Gcc_backend::compound_expression (tree stat, tree expr, Location location) // ELSE_EXPR otherwise. tree -Gcc_backend::conditional_expression (Bfunction *, tree type_tree, - tree cond_expr, tree then_expr, - tree else_expr, Location location) +Gcc_backend::conditional_expression (tree, tree type_tree, tree cond_expr, + tree then_expr, tree else_expr, + Location location) { if (type_tree == error_mark_node || cond_expr == error_mark_node || then_expr == error_mark_node || else_expr == error_mark_node) @@ -1949,7 +1936,7 @@ Gcc_backend::array_index_expression (tree array_tree, tree index_tree, // Create an expression for a call to FN_EXPR with FN_ARGS. tree -Gcc_backend::call_expression (Bfunction *, // containing fcn for call +Gcc_backend::call_expression (tree, // containing fcn for call tree fn, const std::vector &fn_args, tree chain_expr, Location location) { @@ -2025,7 +2012,7 @@ Gcc_backend::call_expression (Bfunction *, // containing fcn for call // An expression as a statement. tree -Gcc_backend::expression_statement (Bfunction *, tree expr) +Gcc_backend::expression_statement (tree, tree expr) { return expr; } @@ -2033,7 +2020,7 @@ Gcc_backend::expression_statement (Bfunction *, tree expr) // Variable initialization. tree -Gcc_backend::init_statement (Bfunction *, Bvariable *var, tree init_tree) +Gcc_backend::init_statement (tree, Bvariable *var, tree init_tree) { tree var_tree = var->get_decl (); if (var_tree == error_mark_node || init_tree == error_mark_node) @@ -2065,7 +2052,7 @@ Gcc_backend::init_statement (Bfunction *, Bvariable *var, tree init_tree) // Assignment. tree -Gcc_backend::assignment_statement (Bfunction *bfn, tree lhs, tree rhs, +Gcc_backend::assignment_statement (tree bfn, tree lhs, tree rhs, Location location) { if (lhs == error_mark_node || rhs == error_mark_node) @@ -2093,10 +2080,9 @@ Gcc_backend::assignment_statement (Bfunction *bfn, tree lhs, tree rhs, // Return. tree -Gcc_backend::return_statement (Bfunction *bfunction, - const std::vector &vals, Location location) +Gcc_backend::return_statement (tree fntree, const std::vector &vals, + Location location) { - tree fntree = bfunction->get_tree (); if (fntree == error_mark_node) return this->error_statement (); tree result = DECL_RESULT (fntree); @@ -2208,7 +2194,7 @@ Gcc_backend::exception_handler_statement (tree try_stmt, tree except_stmt, // If. tree -Gcc_backend::if_statement (Bfunction *, tree cond_tree, Bblock *then_block, +Gcc_backend::if_statement (tree, tree cond_tree, Bblock *then_block, Bblock *else_block, Location location) { tree then_tree = then_block->get_tree (); @@ -2240,14 +2226,13 @@ Gcc_backend::exit_expression (tree cond_tree, Location locus) // Switch. tree -Gcc_backend::switch_statement (Bfunction *function, tree value, +Gcc_backend::switch_statement (tree decl, tree value, const std::vector> &cases, const std::vector &statements, Location switch_location) { gcc_assert (cases.size () == statements.size ()); - tree decl = function->get_tree (); if (DECL_STRUCT_FUNCTION (decl) == NULL) push_struct_function (decl); else @@ -2345,14 +2330,13 @@ Gcc_backend::statement_list (const std::vector &statements) // the Bblock. Bblock * -Gcc_backend::block (Bfunction *function, Bblock *enclosing, +Gcc_backend::block (tree fndecl, Bblock *enclosing, const std::vector &vars, Location start_location, Location) { tree block_tree = make_node (BLOCK); if (enclosing == NULL) { - tree fndecl = function->get_tree (); gcc_assert (fndecl != NULL_TREE); // We may have already created a block for local variables when @@ -2599,7 +2583,7 @@ Gcc_backend::global_variable_set_init (Bvariable *var, tree expr_tree) // Make a local variable. Bvariable * -Gcc_backend::local_variable (Bfunction *function, const std::string &name, +Gcc_backend::local_variable (tree function, const std::string &name, tree type_tree, Bvariable *decl_var, bool is_address_taken, Location location) { @@ -2607,7 +2591,7 @@ Gcc_backend::local_variable (Bfunction *function, const std::string &name, return this->error_variable (); tree decl = build_decl (location.gcc_location (), VAR_DECL, get_identifier_from_string (name), type_tree); - DECL_CONTEXT (decl) = function->get_tree (); + DECL_CONTEXT (decl) = function; TREE_USED (decl) = 1; if (is_address_taken) TREE_ADDRESSABLE (decl) = 1; @@ -2623,7 +2607,7 @@ Gcc_backend::local_variable (Bfunction *function, const std::string &name, // Make a function parameter variable. Bvariable * -Gcc_backend::parameter_variable (Bfunction *function, const std::string &name, +Gcc_backend::parameter_variable (tree function, const std::string &name, tree type_tree, bool is_address_taken, Location location) { @@ -2631,7 +2615,7 @@ Gcc_backend::parameter_variable (Bfunction *function, const std::string &name, return this->error_variable (); tree decl = build_decl (location.gcc_location (), PARM_DECL, get_identifier_from_string (name), type_tree); - DECL_CONTEXT (decl) = function->get_tree (); + DECL_CONTEXT (decl) = function; DECL_ARG_TYPE (decl) = type_tree; TREE_USED (decl) = 1; if (is_address_taken) @@ -2643,15 +2627,13 @@ Gcc_backend::parameter_variable (Bfunction *function, const std::string &name, // Make a static chain variable. Bvariable * -Gcc_backend::static_chain_variable (Bfunction *function, - const std::string &name, tree type_tree, - Location location) +Gcc_backend::static_chain_variable (tree fndecl, const std::string &name, + tree type_tree, Location location) { if (type_tree == error_mark_node) return this->error_variable (); tree decl = build_decl (location.gcc_location (), PARM_DECL, get_identifier_from_string (name), type_tree); - tree fndecl = function->get_tree (); DECL_CONTEXT (decl) = fndecl; DECL_ARG_TYPE (decl) = type_tree; TREE_USED (decl) = 1; @@ -2677,15 +2659,13 @@ Gcc_backend::static_chain_variable (Bfunction *function, // Make a temporary variable. Bvariable * -Gcc_backend::temporary_variable (Bfunction *function, Bblock *bblock, - tree type_tree, tree init_tree, - bool is_address_taken, Location location, - tree *pstatement) +Gcc_backend::temporary_variable (tree fndecl, Bblock *bblock, tree type_tree, + tree init_tree, bool is_address_taken, + Location location, tree *pstatement) { - gcc_assert (function != NULL); - tree decl = function->get_tree (); + gcc_assert (fndecl != NULL_TREE); if (type_tree == error_mark_node || init_tree == error_mark_node - || decl == error_mark_node) + || fndecl == error_mark_node) { *pstatement = this->error_statement (); return this->error_variable (); @@ -2695,10 +2675,10 @@ Gcc_backend::temporary_variable (Bfunction *function, Bblock *bblock, // We can only use create_tmp_var if the type is not addressable. if (!TREE_ADDRESSABLE (type_tree)) { - if (DECL_STRUCT_FUNCTION (decl) == NULL) - push_struct_function (decl); + if (DECL_STRUCT_FUNCTION (fndecl) == NULL) + push_struct_function (fndecl); else - push_cfun (DECL_STRUCT_FUNCTION (decl)); + push_cfun (DECL_STRUCT_FUNCTION (fndecl)); var = create_tmp_var (type_tree, "RUSTTMP"); pop_cfun (); @@ -2711,7 +2691,7 @@ Gcc_backend::temporary_variable (Bfunction *function, Bblock *bblock, DECL_ARTIFICIAL (var) = 1; DECL_IGNORED_P (var) = 1; TREE_USED (var) = 1; - DECL_CONTEXT (var) = decl; + DECL_CONTEXT (var) = fndecl; // We have to add this variable to the BLOCK and the BIND_EXPR. tree bind_tree = bblock->get_tree (); @@ -2739,7 +2719,7 @@ Gcc_backend::temporary_variable (Bfunction *function, Bblock *bblock, && (this->type_size (type_tree) == 0 || TREE_TYPE (init_tree) == void_type_node)) *pstatement = this->compound_statement ( - this->expression_statement (function, init_tree), *pstatement); + this->expression_statement (fndecl, init_tree), *pstatement); return new Bvariable (var); } @@ -2950,13 +2930,11 @@ Gcc_backend::immutable_struct_reference (const std::string &name, // Make a label. Blabel * -Gcc_backend::label (Bfunction *function, const std::string &name, - Location location) +Gcc_backend::label (tree func_tree, const std::string &name, Location location) { tree decl; if (name.empty ()) { - tree func_tree = function->get_tree (); if (DECL_STRUCT_FUNCTION (func_tree) == NULL) push_struct_function (func_tree); else @@ -2971,7 +2949,7 @@ Gcc_backend::label (Bfunction *function, const std::string &name, tree id = get_identifier_from_string (name); decl = build_decl (location.gcc_location (), LABEL_DECL, id, void_type_node); - DECL_CONTEXT (decl) = function->get_tree (); + DECL_CONTEXT (decl) = func_tree; } return new Blabel (decl); } @@ -3013,7 +2991,7 @@ Gcc_backend::label_address (Blabel *label, Location location) // Declare or define a new function. -Bfunction * +tree Gcc_backend::function (tree functype, const std::string &name, const std::string &asm_name, unsigned int flags, Location location) @@ -3061,7 +3039,7 @@ Gcc_backend::function (tree functype, const std::string &name, TREE_READONLY (decl) = 1; rust_preserve_from_gc (decl); - return new Bfunction (decl); + return decl; } // Create a statement that runs all deferred calls for FUNCTION. This should @@ -3070,19 +3048,17 @@ Gcc_backend::function (tree functype, const std::string &name, // try { UNDEFER; } catch { CHECK_DEFER; goto finish; } tree -Gcc_backend::function_defer_statement (Bfunction *function, tree undefer_tree, +Gcc_backend::function_defer_statement (tree function, tree undefer_tree, tree defer_tree, Location location) { - tree fntree = function->get_tree (); - if (undefer_tree == error_mark_node || defer_tree == error_mark_node - || fntree == error_mark_node) + || function == error_mark_node) return this->error_statement (); - if (DECL_STRUCT_FUNCTION (fntree) == NULL) - push_struct_function (fntree); + if (DECL_STRUCT_FUNCTION (function) == NULL) + push_struct_function (function); else - push_cfun (DECL_STRUCT_FUNCTION (fntree)); + push_cfun (DECL_STRUCT_FUNCTION (function)); tree stmt_list = NULL; Blabel *blabel = this->label (function, "", location); @@ -3106,10 +3082,9 @@ Gcc_backend::function_defer_statement (Bfunction *function, tree undefer_tree, bool Gcc_backend::function_set_parameters ( - Bfunction *function, const std::vector ¶m_vars) + tree function, const std::vector ¶m_vars) { - tree func_tree = function->get_tree (); - if (func_tree == error_mark_node) + if (function == error_mark_node) return false; tree params = NULL_TREE; @@ -3122,27 +3097,25 @@ Gcc_backend::function_set_parameters ( pp = &DECL_CHAIN (*pp); } *pp = NULL_TREE; - DECL_ARGUMENTS (func_tree) = params; + DECL_ARGUMENTS (function) = params; return true; } // Set the function body for FUNCTION using the code in CODE_BLOCK. bool -Gcc_backend::function_set_body (Bfunction *function, tree code_stmt) +Gcc_backend::function_set_body (tree function, tree code_stmt) { - tree func_tree = function->get_tree (); - - if (func_tree == error_mark_node || code_stmt == error_mark_node) + if (function == error_mark_node || code_stmt == error_mark_node) return false; - DECL_SAVED_TREE (func_tree) = code_stmt; + DECL_SAVED_TREE (function) = code_stmt; return true; } // Look up a named built-in function in the current backend implementation. // Returns NULL if no built-in function by that name exists. -Bfunction * +tree Gcc_backend::lookup_gcc_builtin (const std::string &name) { if (this->builtin_functions_.count (name) != 0) @@ -3150,7 +3123,7 @@ Gcc_backend::lookup_gcc_builtin (const std::string &name) return NULL; } -Bfunction * +tree Gcc_backend::lookup_builtin_by_rust_name (const std::string &name) { auto it = rust_intrinsic_to_gcc_builtin.find (name); @@ -3167,7 +3140,7 @@ Gcc_backend::lookup_builtin_by_rust_name (const std::string &name) void Gcc_backend::write_global_definitions ( const std::vector &type_decls, const std::vector &constant_decls, - const std::vector &function_decls, + const std::vector &function_decls, const std::vector &variable_decls) { size_t count_definitions = type_decls.size () + constant_decls.size () @@ -3211,10 +3184,10 @@ Gcc_backend::write_global_definitions ( ++i; } } - for (std::vector::const_iterator p = function_decls.begin (); + for (std::vector::const_iterator p = function_decls.begin (); p != function_decls.end (); ++p) { - tree decl = (*p)->get_tree (); + tree decl = (*p); if (decl != error_mark_node) { rust_preserve_from_gc (decl); @@ -3262,7 +3235,7 @@ Gcc_backend::define_builtin (const std::string rust_name, if ((flags & builtin_novops) != 0) DECL_IS_NOVOPS (decl) = 1; set_builtin_decl (bcode, decl, true); - this->builtin_functions_[name] = this->make_function (decl); + this->builtin_functions_[name] = decl; if (libname != NULL) { decl = add_builtin_function (libname, fntype, bcode, BUILT_IN_NORMAL, @@ -3273,7 +3246,7 @@ Gcc_backend::define_builtin (const std::string rust_name, TREE_THIS_VOLATILE (decl) = 1; if ((flags & builtin_novops) != 0) DECL_IS_NOVOPS (decl) = 1; - this->builtin_functions_[libname] = this->make_function (decl); + this->builtin_functions_[libname] = decl; } rust_intrinsic_to_gcc_builtin[rust_name] = name;