From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 7905) id 9BF793857BB5; Tue, 16 Jan 2024 18:09:27 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 9BF793857BB5 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1705428567; bh=6Yaz86CFif2aACu5ZdZAhyzeseeZ47baJlPph69/2CE=; h=From:To:Subject:Date:From; b=vFwd6sVTzkhXehOcDstAzVJWmZ5dEEcGRciV4b45DEAboikGLYzEL0L/lRmn5Y9fQ 9CdMosQBvF6nwxw/XRMQH6uksxrV1+3MkRsQeTn9B3dUjXMtkiE3+QJh1epzIyc6rN YrzBFtxR8ig8ZxryRF7B7yN9uuMZnhZgszyNP6dg= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Arthur Cohen To: gcc-cvs@gcc.gnu.org Subject: [gcc r14-7966] gccrs: Move some simple expression-related methods into base class Backend X-Act-Checkin: gcc X-Git-Author: Owen Avery X-Git-Refname: refs/heads/trunk X-Git-Oldrev: 88045f3524d805f09ba24d07d54ba975f043ec93 X-Git-Newrev: 55caa88646a6b2e15ffa3e01fdde487548af692f Message-Id: <20240116180927.9BF793857BB5@sourceware.org> Date: Tue, 16 Jan 2024 18:09:27 +0000 (GMT) List-Id: https://gcc.gnu.org/g:55caa88646a6b2e15ffa3e01fdde487548af692f commit r14-7966-g55caa88646a6b2e15ffa3e01fdde487548af692f Author: Owen Avery Date: Thu Aug 31 16:23:53 2023 -0400 gccrs: Move some simple expression-related methods into base class Backend gcc/rust/ChangeLog: * rust-backend.h (Backend::zero_expression): Make non-virtual. (Backend::var_expression): Likewise. (Backend::integer_constant_expression): Likewise. (Backend::float_constant_expression): Likewise. (Backend::complex_constant_expression): Likewise. (Backend::string_constant_expression): Likewise. (Backend::char_constant_literal): Likewise. (Backend::wchar_constant_literal): Likewise. (Backend::boolean_constant_expression): Likewise. (Gcc_backend::zero_expression): Remove. (Gcc_backend::var_expression): Remove. (Gcc_backend::integer_constant_expression): Remove. (Gcc_backend::float_constant_expression): Remove. (Gcc_backend::complex_constant_expression): Remove. (Gcc_backend::string_constant_expression): Remove. (Gcc_backend::wchar_constant_expression): Remove. (Gcc_backend::char_constant_expression): Remove. (Gcc_backend::boolean_constant_expression): Remove. * rust-gcc.cc (Gcc_backend::zero_expression): Rename to ... (Backend::zero_expression): ... here. (Gcc_backend::var_expression): Rename to ... (Backend::var_expression): ... here. (Gcc_backend::integer_constant_expression): Rename to ... (Backend::integer_constant_expression): ... here. (Gcc_backend::float_constant_expression): Rename to ... (Backend::float_constant_expression): ... here. (Gcc_backend::complex_constant_expression): Rename to ... (Backend::complex_constant_expression): ... here. (Gcc_backend::string_constant_expression): Rename to ... (Backend::string_constant_expression): ... here. (Gcc_backend::wchar_constant_expression): Rename to ... (Backend::wchar_constant_expression): ... here. (Gcc_backend::char_constant_expression): Rename to ... (Backend::char_constant_expression): ... here. (Gcc_backend::boolean_constant_expression): Rename to ... (Backend::boolean_constant_expression): ... here. Signed-off-by: Owen Avery Diff: --- gcc/rust/rust-backend.h | 36 +++++++++--------------------------- gcc/rust/rust-gcc.cc | 18 +++++++++--------- 2 files changed, 18 insertions(+), 36 deletions(-) diff --git a/gcc/rust/rust-backend.h b/gcc/rust/rust-backend.h index dd849b8abd9..0633d005d87 100644 --- a/gcc/rust/rust-backend.h +++ b/gcc/rust/rust-backend.h @@ -157,31 +157,31 @@ public: // Return an expression for a zero value of the given type. This is // used for cases such as local variable initialization and // converting nil to other types. - virtual tree zero_expression (tree) = 0; + tree zero_expression (tree); // Create a reference to a variable. - virtual tree var_expression (Bvariable *var, location_t) = 0; + tree var_expression (Bvariable *var, location_t); // Return an expression for the multi-precision integer VAL in BTYPE. - virtual tree integer_constant_expression (tree btype, mpz_t val) = 0; + tree integer_constant_expression (tree btype, mpz_t val); // Return an expression for the floating point value VAL in BTYPE. - virtual tree float_constant_expression (tree btype, mpfr_t val) = 0; + tree float_constant_expression (tree btype, mpfr_t val); // Return an expression for the complex value VAL in BTYPE. - virtual tree complex_constant_expression (tree btype, mpc_t val) = 0; + tree complex_constant_expression (tree btype, mpc_t val); // Return an expression for the string value VAL. - virtual tree string_constant_expression (const std::string &val) = 0; + tree string_constant_expression (const std::string &val); // Get a char literal - virtual tree char_constant_expression (char c) = 0; + tree char_constant_expression (char c); // Get a char literal - virtual tree wchar_constant_expression (wchar_t c) = 0; + tree wchar_constant_expression (wchar_t c); // Return an expression for the boolean value VAL. - virtual tree boolean_constant_expression (bool val) = 0; + tree boolean_constant_expression (bool val); // Return an expression for the real part of BCOMPLEX. virtual tree real_part_expression (tree bcomplex, location_t) = 0; @@ -502,24 +502,6 @@ public: // Expressions. - tree zero_expression (tree); - - tree var_expression (Bvariable *var, location_t); - - tree integer_constant_expression (tree type, mpz_t val); - - tree float_constant_expression (tree type, mpfr_t val); - - tree complex_constant_expression (tree type, mpc_t val); - - tree string_constant_expression (const std::string &val); - - tree wchar_constant_expression (wchar_t c); - - tree char_constant_expression (char c); - - tree boolean_constant_expression (bool val); - tree real_part_expression (tree bcomplex, location_t); tree imag_part_expression (tree bcomplex, location_t); diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc index eddcb0fc9d7..2e3612f45c5 100644 --- a/gcc/rust/rust-gcc.cc +++ b/gcc/rust/rust-gcc.cc @@ -781,7 +781,7 @@ Backend::type_field_offset (tree struct_tree, size_t index) // Return the zero value for a type. tree -Gcc_backend::zero_expression (tree t) +Backend::zero_expression (tree t) { tree ret; if (t == error_mark_node) @@ -794,7 +794,7 @@ Gcc_backend::zero_expression (tree t) // An expression that references a variable. tree -Gcc_backend::var_expression (Bvariable *var, location_t location) +Backend::var_expression (Bvariable *var, location_t location) { return var->get_tree (location); } @@ -803,7 +803,7 @@ Gcc_backend::var_expression (Bvariable *var, location_t location) // This function does not release the memory of @val tree -Gcc_backend::integer_constant_expression (tree t, mpz_t val) +Backend::integer_constant_expression (tree t, mpz_t val) { if (t == error_mark_node) return error_mark_node; @@ -815,7 +815,7 @@ Gcc_backend::integer_constant_expression (tree t, mpz_t val) // Return a typed value as a constant floating-point number. tree -Gcc_backend::float_constant_expression (tree t, mpfr_t val) +Backend::float_constant_expression (tree t, mpfr_t val) { tree ret; if (t == error_mark_node) @@ -832,7 +832,7 @@ Gcc_backend::float_constant_expression (tree t, mpfr_t val) // Return a typed real and imaginary value as a constant complex number. tree -Gcc_backend::complex_constant_expression (tree t, mpc_t val) +Backend::complex_constant_expression (tree t, mpc_t val) { tree ret; if (t == error_mark_node) @@ -856,7 +856,7 @@ Gcc_backend::complex_constant_expression (tree t, mpc_t val) // Make a constant string expression. tree -Gcc_backend::string_constant_expression (const std::string &val) +Backend::string_constant_expression (const std::string &val) { tree index_type = build_index_type (size_int (val.length ())); tree const_char_type = build_qualified_type (char_type_node, TYPE_QUAL_CONST); @@ -869,13 +869,13 @@ Gcc_backend::string_constant_expression (const std::string &val) } tree -Gcc_backend::wchar_constant_expression (wchar_t c) +Backend::wchar_constant_expression (wchar_t c) { return build_int_cst (wchar_type (), c); } tree -Gcc_backend::char_constant_expression (char c) +Backend::char_constant_expression (char c) { return build_int_cst (char_type_node, c); } @@ -883,7 +883,7 @@ Gcc_backend::char_constant_expression (char c) // Make a constant boolean expression. tree -Gcc_backend::boolean_constant_expression (bool val) +Backend::boolean_constant_expression (bool val) { return val ? boolean_true_node : boolean_false_node; }