From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 0979C3810AEE; Wed, 8 Jun 2022 12:48:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0979C3810AEE 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] Canonicalize types based on hashing than HirIds and TyTy equality X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 5ad0ea3e0ed288569d52556b9aa796beea73d8a3 X-Git-Newrev: 39ae84825c5cc15edbb2fa9f5ecc70f93870e3ee Message-Id: <20220608124833.0979C3810AEE@sourceware.org> Date: Wed, 8 Jun 2022 12:48:33 +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 12:48:33 -0000 https://gcc.gnu.org/g:39ae84825c5cc15edbb2fa9f5ecc70f93870e3ee commit 39ae84825c5cc15edbb2fa9f5ecc70f93870e3ee Author: Philip Herron Date: Fri May 20 13:35:54 2022 +0100 Canonicalize types based on hashing than HirIds and TyTy equality When we compile types for GCC we need to make sure we canonicalize them, this means that for any user defined type such as Structs or Tuples we want all expressions or declarations to use the same tree. Even if we have duplicate tree's we can end up confusing the middle-end and lose out on optimizations as we will be using view_convert_exprs to maintain the consistancy which will marshall between the objects unnessecarily. The old method for doing this kept mappings of HirIds which was fine for simple cases but when generics are involved new Id's are generated so this meant we ended up having a vector of pairs {TyTy::BaseType, tree} and we did a liner search to find the relevant TyTy::BaseType that we equaled to. This was not only slow but did not handle the cases for generic associated types or nested generics. So we needed a more general faster implementation therefore hashing. This patch takes the gcc/tree.h type_hash_canon code and adds in hashing for RECORD and UNION types. This means we will generate a duplicate type then hash it and look for an existing type. This patch will also allow us to fix how we implement monomorphization of functions by nesting the hashes behind DefId's. Diff: --- gcc/rust/Make-lang.in | 1 + gcc/rust/backend/rust-compile-block.h | 1 - gcc/rust/backend/rust-compile-context.cc | 139 ++++++++++++ gcc/rust/backend/rust-compile-context.h | 71 ++---- gcc/rust/backend/rust-compile-expr.h | 1 - gcc/rust/backend/rust-compile-resolve-path.h | 1 - gcc/rust/backend/rust-compile-stmt.h | 1 - gcc/rust/backend/rust-compile-struct-field-expr.h | 1 - gcc/rust/backend/rust-compile-type.cc | 202 ++++++++++------- gcc/rust/backend/rust-compile-type.h | 12 +- gcc/rust/backend/rust-compile-tyty.h | 260 ---------------------- gcc/rust/backend/rust-mangle.h | 3 +- 12 files changed, 291 insertions(+), 402 deletions(-) diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 11994740e78..5d97a162c30 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -130,6 +130,7 @@ GRS_OBJS = \ rust/rust-constexpr.o \ rust/rust-compile-base.o \ rust/rust-tree.o \ + rust/rust-compile-context.o \ $(END) # removed object files from here diff --git a/gcc/rust/backend/rust-compile-block.h b/gcc/rust/backend/rust-compile-block.h index 4a3c6f52c3d..0595ee905ab 100644 --- a/gcc/rust/backend/rust-compile-block.h +++ b/gcc/rust/backend/rust-compile-block.h @@ -20,7 +20,6 @@ #define RUST_COMPILE_BLOCK #include "rust-compile-base.h" -#include "rust-compile-tyty.h" namespace Rust { namespace Compile { diff --git a/gcc/rust/backend/rust-compile-context.cc b/gcc/rust/backend/rust-compile-context.cc new file mode 100644 index 00000000000..463ac27aa5a --- /dev/null +++ b/gcc/rust/backend/rust-compile-context.cc @@ -0,0 +1,139 @@ +// Copyright (C) 2020-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +#include "rust-compile-context.h" +#include "rust-compile-type.h" + +namespace Rust { +namespace Compile { + +Context::Context (::Backend *backend) + : backend (backend), resolver (Resolver::Resolver::get ()), + tyctx (Resolver::TypeCheckContext::get ()), + mappings (Analysis::Mappings::get ()), mangler (Mangler ()) +{ + setup_builtins (); +} + +void +Context::setup_builtins () +{ + auto builtins = resolver->get_builtin_types (); + for (auto it = builtins.begin (); it != builtins.end (); it++) + { + HirId ref; + bool ok = tyctx->lookup_type_by_node_id ((*it)->get_node_id (), &ref); + rust_assert (ok); + + TyTy::BaseType *lookup; + ok = tyctx->lookup_type (ref, &lookup); + rust_assert (ok); + + TyTyResolveCompile::compile (this, lookup); + } +} + +hashval_t +Context::type_hasher (tree type) +{ + inchash::hash hstate; + + hstate.add_int (TREE_CODE (type)); + + if (TYPE_NAME (type)) + { + hashval_t record_name_hash + = IDENTIFIER_HASH_VALUE (DECL_NAME (TYPE_NAME (type))); + hstate.add_object (record_name_hash); + } + + if (TREE_TYPE (type)) + hstate.add_object (TYPE_HASH (TREE_TYPE (type))); + + for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t)) + /* Just the identifier is adequate to distinguish. */ + hstate.add_object (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (t))); + + switch (TREE_CODE (type)) + { + case METHOD_TYPE: + hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type))); + /* FALLTHROUGH. */ + case FUNCTION_TYPE: + for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t)) + if (TREE_VALUE (t) != error_mark_node) + hstate.add_object (TYPE_HASH (TREE_VALUE (t))); + break; + + case OFFSET_TYPE: + hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type))); + break; + + case ARRAY_TYPE: { + if (TYPE_DOMAIN (type)) + hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type))); + if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) + { + unsigned typeless = TYPE_TYPELESS_STORAGE (type); + hstate.add_object (typeless); + } + } + break; + + case INTEGER_TYPE: { + tree t = TYPE_MAX_VALUE (type); + if (!t) + t = TYPE_MIN_VALUE (type); + for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++) + hstate.add_object (TREE_INT_CST_ELT (t, i)); + break; + } + + case REAL_TYPE: + case FIXED_POINT_TYPE: { + unsigned prec = TYPE_PRECISION (type); + hstate.add_object (prec); + break; + } + + case VECTOR_TYPE: + hstate.add_poly_int (TYPE_VECTOR_SUBPARTS (type)); + break; + + case RECORD_TYPE: + case UNION_TYPE: + case QUAL_UNION_TYPE: { + for (tree t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t)) + { + hashval_t name_hash = IDENTIFIER_HASH_VALUE (DECL_NAME (t)); + hashval_t type_hash = type_hasher (TREE_TYPE (t)); + hstate.add_object (name_hash); + hstate.add_object (type_hash); + } + } + break; + + default: + break; + } + + return hstate.end (); +} + +} // namespace Compile +} // namespace Rust diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h index d17034b51df..83785549259 100644 --- a/gcc/rust/backend/rust-compile-context.h +++ b/gcc/rust/backend/rust-compile-context.h @@ -24,7 +24,6 @@ #include "rust-name-resolver.h" #include "rust-hir-type-check.h" #include "rust-backend.h" -#include "rust-compile-tyty.h" #include "rust-hir-full.h" #include "rust-mangle.h" #include "rust-tree.h" @@ -41,50 +40,14 @@ struct fncontext class Context { public: - Context (::Backend *backend) - : backend (backend), resolver (Resolver::Resolver::get ()), - tyctx (Resolver::TypeCheckContext::get ()), - mappings (Analysis::Mappings::get ()), mangler (Mangler ()) - { - // insert the builtins - auto builtins = resolver->get_builtin_types (); - for (auto it = builtins.begin (); it != builtins.end (); it++) - { - HirId ref; - bool ok = tyctx->lookup_type_by_node_id ((*it)->get_node_id (), &ref); - rust_assert (ok); - - TyTy::BaseType *lookup; - ok = tyctx->lookup_type (ref, &lookup); - rust_assert (ok); + Context (::Backend *backend); - tree compiled = TyTyCompile::compile (backend, lookup); - compiled_type_map.insert (std::pair (ref, compiled)); - builtin_range.insert (ref); - } - } + void setup_builtins (); - bool lookup_compiled_types (HirId id, tree *type, - const TyTy::BaseType *ref = nullptr) + bool lookup_compiled_types (tree t, tree *type) { - if (ref != nullptr) - { - for (auto it = mono.begin (); it != mono.end (); it++) - { - std::pair &val = it->second; - const TyTy::BaseType *r = it->first; - - if (ref->is_equal (*r)) - { - *type = val.second; - - return true; - } - } - return false; - } - - auto it = compiled_type_map.find (id); + hashval_t h = type_hasher (t); + auto it = compiled_type_map.find (h); if (it == compiled_type_map.end ()) return false; @@ -92,16 +55,16 @@ public: return true; } - void insert_compiled_type (HirId id, tree type, - const TyTy::BaseType *ref = nullptr) + tree insert_compiled_type (tree type) { - rust_assert (builtin_range.find (id) == builtin_range.end ()); - compiled_type_map.insert (std::pair (id, type)); - if (ref != nullptr) - { - std::pair elem (id, type); - mono[ref] = std::move (elem); - } + hashval_t h = type_hasher (type); + auto it = compiled_type_map.find (h); + if (it != compiled_type_map.end ()) + return it->second; + + compiled_type_map.insert ({h, type}); + push_type (type); + return type; } ::Backend *get_backend () { return backend; } @@ -328,18 +291,19 @@ public: std::vector &get_const_decls () { return const_decls; } std::vector &get_func_decls () { return func_decls; } + static hashval_t type_hasher (tree type); + private: ::Backend *backend; Resolver::Resolver *resolver; Resolver::TypeCheckContext *tyctx; Analysis::Mappings *mappings; - std::set builtin_range; Mangler mangler; // state std::vector fn_stack; std::map compiled_var_decls; - std::map compiled_type_map; + std::map compiled_type_map; std::map compiled_fn_map; std::map compiled_consts; std::map compiled_labels; @@ -347,7 +311,6 @@ private: std::vector scope_stack; std::vector<::Bvariable *> loop_value_stack; std::vector loop_begin_labels; - std::map> mono; std::map>> mono_fns; std::map implicit_pattern_bindings; diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index b05b129324c..655ffbb263e 100644 --- a/gcc/rust/backend/rust-compile-expr.h +++ b/gcc/rust/backend/rust-compile-expr.h @@ -20,7 +20,6 @@ #define RUST_COMPILE_EXPR #include "rust-compile-base.h" -#include "rust-compile-tyty.h" #include "rust-compile-resolve-path.h" #include "rust-compile-block.h" #include "rust-compile-struct-field-expr.h" diff --git a/gcc/rust/backend/rust-compile-resolve-path.h b/gcc/rust/backend/rust-compile-resolve-path.h index 37dec0b0e1b..f0360bdc739 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.h +++ b/gcc/rust/backend/rust-compile-resolve-path.h @@ -20,7 +20,6 @@ #define RUST_COMPILE_RESOLVE_PATH #include "rust-compile-base.h" -#include "rust-compile-tyty.h" namespace Rust { namespace Compile { diff --git a/gcc/rust/backend/rust-compile-stmt.h b/gcc/rust/backend/rust-compile-stmt.h index ad3425332fc..5f1777736db 100644 --- a/gcc/rust/backend/rust-compile-stmt.h +++ b/gcc/rust/backend/rust-compile-stmt.h @@ -20,7 +20,6 @@ #define RUST_COMPILE_STMT #include "rust-compile-base.h" -#include "rust-compile-tyty.h" #include "rust-compile-expr.h" namespace Rust { diff --git a/gcc/rust/backend/rust-compile-struct-field-expr.h b/gcc/rust/backend/rust-compile-struct-field-expr.h index c5e986e0b9b..6968c069f0f 100644 --- a/gcc/rust/backend/rust-compile-struct-field-expr.h +++ b/gcc/rust/backend/rust-compile-struct-field-expr.h @@ -20,7 +20,6 @@ #define RUST_COMPILE_STRUCT_FIELD_EXPR #include "rust-compile-base.h" -#include "rust-compile-tyty.h" namespace Rust { namespace Compile { diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 03c2ca487f2..38740274a44 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -21,11 +21,27 @@ #include "rust-constexpr.h" #include "tree.h" -#include "print-tree.h" namespace Rust { namespace Compile { +tree +TyTyResolveCompile::compile (Context *ctx, const TyTy::BaseType *ty, + bool trait_object_mode) +{ + TyTyResolveCompile compiler (ctx, trait_object_mode); + ty->accept_vis (compiler); + + if (compiler.translated != error_mark_node + && TYPE_NAME (compiler.translated) != NULL) + { + // canonicalize the type + compiler.translated = ctx->insert_compiled_type (compiler.translated); + } + + return compiler.translated; +} + static const std::string RUST_ENUM_DISR_FIELD_NAME = "RUST$ENUM$DISR"; // see: gcc/c/c-decl.cc:8230-8241 @@ -96,6 +112,7 @@ TyTyResolveCompile::visit (const TyTy::PlaceholderType &type) void TyTyResolveCompile::visit (const TyTy::ParamType ¶m) { + // FIXME make this reuse the same machinery from constexpr code recursion_count++; rust_assert (recursion_count < kDefaultRecusionLimit); @@ -163,9 +180,6 @@ TyTyResolveCompile::visit (const TyTy::FnPtr &type) void TyTyResolveCompile::visit (const TyTy::ADTType &type) { - if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type)) - return; - tree type_record = error_mark_node; if (!type.is_enum ()) { @@ -302,14 +316,8 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) std::string named_struct_str = type.get_ident ().path.get () + type.subst_as_string (); - tree named_struct - = ctx->get_backend ()->named_type (named_struct_str, type_record, - type.get_ident ().locus); - - ctx->push_type (named_struct); - translated = named_struct; - - ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type); + translated = ctx->get_backend ()->named_type (named_struct_str, type_record, + type.get_ident ().locus); } void @@ -321,10 +329,6 @@ TyTyResolveCompile::visit (const TyTy::TupleType &type) return; } - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type); - if (ok) - return; - // create implicit struct std::vector fields; for (size_t i = 0; i < type.num_fields (); i++) @@ -345,13 +349,9 @@ TyTyResolveCompile::visit (const TyTy::TupleType &type) } tree struct_type_record = ctx->get_backend ()->struct_type (fields); - tree named_struct + translated = ctx->get_backend ()->named_type (type.as_string (), struct_type_record, type.get_ident ().locus); - - ctx->push_type (named_struct); - ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type); - translated = named_struct; } void @@ -369,9 +369,6 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type) void TyTyResolveCompile::visit (const TyTy::SliceType &type) { - if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type)) - return; - std::vector fields; tree element_type @@ -393,77 +390,141 @@ TyTyResolveCompile::visit (const TyTy::SliceType &type) std::string named_struct_str = std::string ("[") + type.get_element_type ()->get_name () + "]"; - tree named_struct - = ctx->get_backend ()->named_type (named_struct_str, type_record, - type.get_ident ().locus); - - ctx->push_type (named_struct); - translated = named_struct; - - ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type); + translated = ctx->get_backend ()->named_type (named_struct_str, type_record, + type.get_ident ().locus); } void TyTyResolveCompile::visit (const TyTy::BoolType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + translated + = ctx->get_backend ()->named_type ("bool", + ctx->get_backend ()->bool_type (), + Linemap::predeclared_location ()); } void TyTyResolveCompile::visit (const TyTy::IntType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + switch (type.get_int_kind ()) + { + case TyTy::IntType::I8: + translated = ctx->get_backend ()->named_type ( + "i8", ctx->get_backend ()->integer_type (false, 8), + Linemap::predeclared_location ()); + return; + + case TyTy::IntType::I16: + translated = ctx->get_backend ()->named_type ( + "i16", ctx->get_backend ()->integer_type (false, 16), + Linemap::predeclared_location ()); + return; + + case TyTy::IntType::I32: + translated = ctx->get_backend ()->named_type ( + "i32", ctx->get_backend ()->integer_type (false, 32), + Linemap::predeclared_location ()); + return; + + case TyTy::IntType::I64: + translated = ctx->get_backend ()->named_type ( + "i64", ctx->get_backend ()->integer_type (false, 64), + Linemap::predeclared_location ()); + return; + + case TyTy::IntType::I128: + translated = ctx->get_backend ()->named_type ( + "i128", ctx->get_backend ()->integer_type (false, 128), + Linemap::predeclared_location ()); + return; + } } void TyTyResolveCompile::visit (const TyTy::UintType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + switch (type.get_uint_kind ()) + { + case TyTy::UintType::U8: + translated = ctx->get_backend ()->named_type ( + "u8", ctx->get_backend ()->integer_type (true, 8), + Linemap::predeclared_location ()); + return; + + case TyTy::UintType::U16: + translated = ctx->get_backend ()->named_type ( + "u16", ctx->get_backend ()->integer_type (true, 16), + Linemap::predeclared_location ()); + return; + + case TyTy::UintType::U32: + translated = ctx->get_backend ()->named_type ( + "u32", ctx->get_backend ()->integer_type (true, 32), + Linemap::predeclared_location ()); + return; + + case TyTy::UintType::U64: + translated = ctx->get_backend ()->named_type ( + "u64", ctx->get_backend ()->integer_type (true, 64), + Linemap::predeclared_location ()); + return; + + case TyTy::UintType::U128: + translated = ctx->get_backend ()->named_type ( + "u128", ctx->get_backend ()->integer_type (true, 128), + Linemap::predeclared_location ()); + return; + } } void TyTyResolveCompile::visit (const TyTy::FloatType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + switch (type.get_float_kind ()) + { + case TyTy::FloatType::F32: + translated + = ctx->get_backend ()->named_type ("f32", + ctx->get_backend ()->float_type (32), + Linemap::predeclared_location ()); + return; + + case TyTy::FloatType::F64: + translated + = ctx->get_backend ()->named_type ("f64", + ctx->get_backend ()->float_type (64), + Linemap::predeclared_location ()); + return; + } } void TyTyResolveCompile::visit (const TyTy::USizeType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + translated = ctx->get_backend ()->named_type ( + "usize", + ctx->get_backend ()->integer_type ( + true, ctx->get_backend ()->get_pointer_size ()), + Linemap::predeclared_location ()); } void TyTyResolveCompile::visit (const TyTy::ISizeType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + translated = ctx->get_backend ()->named_type ( + "isize", + ctx->get_backend ()->integer_type ( + false, ctx->get_backend ()->get_pointer_size ()), + Linemap::predeclared_location ()); } void TyTyResolveCompile::visit (const TyTy::CharType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + translated + = ctx->get_backend ()->named_type ("char", + ctx->get_backend ()->wchar_type (), + Linemap::predeclared_location ()); } void @@ -501,10 +562,10 @@ TyTyResolveCompile::visit (const TyTy::PointerType &type) void TyTyResolveCompile::visit (const TyTy::StrType &type) { - tree compiled_type = nullptr; - bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type); - rust_assert (ok); - translated = compiled_type; + tree raw_str = ctx->get_backend ()->raw_str_type (); + translated + = ctx->get_backend ()->named_type ("str", raw_str, + Linemap::predeclared_location ()); } void @@ -523,9 +584,6 @@ TyTyResolveCompile::visit (const TyTy::DynamicObjectType &type) return; } - if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type)) - return; - // create implicit struct auto items = type.get_object_items (); std::vector fields; @@ -547,14 +605,8 @@ TyTyResolveCompile::visit (const TyTy::DynamicObjectType &type) fields.push_back (std::move (vtf)); tree type_record = ctx->get_backend ()->struct_type (fields); - tree named_struct - = ctx->get_backend ()->named_type (type.get_name (), type_record, - type.get_ident ().locus); - - ctx->push_type (named_struct); - translated = named_struct; - - ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type); + translated = ctx->get_backend ()->named_type (type.get_name (), type_record, + type.get_ident ().locus); } } // namespace Compile diff --git a/gcc/rust/backend/rust-compile-type.h b/gcc/rust/backend/rust-compile-type.h index 4f9c40349e4..3e1f903f761 100644 --- a/gcc/rust/backend/rust-compile-type.h +++ b/gcc/rust/backend/rust-compile-type.h @@ -28,12 +28,7 @@ class TyTyResolveCompile : public TyTy::TyConstVisitor { public: static tree compile (Context *ctx, const TyTy::BaseType *ty, - bool trait_object_mode = false) - { - TyTyResolveCompile compiler (ctx, trait_object_mode); - ty->accept_vis (compiler); - return compiler.translated; - } + bool trait_object_mode = false); static tree get_implicit_enumeral_node_type (Context *ctx); @@ -62,6 +57,9 @@ public: void visit (const TyTy::DynamicObjectType &) override; void visit (const TyTy::ClosureType &) override; +public: + static hashval_t type_hasher (tree type); + private: TyTyResolveCompile (Context *ctx, bool trait_object_mode) : ctx (ctx), trait_object_mode (trait_object_mode), @@ -72,8 +70,8 @@ private: bool trait_object_mode; tree translated; + // FIXME this needs to be derived from the gcc config option size_t recursion_count; - static const size_t kDefaultRecusionLimit = 5; }; diff --git a/gcc/rust/backend/rust-compile-tyty.h b/gcc/rust/backend/rust-compile-tyty.h deleted file mode 100644 index 52ad2f94c12..00000000000 --- a/gcc/rust/backend/rust-compile-tyty.h +++ /dev/null @@ -1,260 +0,0 @@ -// Copyright (C) 2020-2022 Free Software Foundation, Inc. - -// This file is part of GCC. - -// GCC is free software; you can redistribute it and/or modify it under -// the terms of the GNU General Public License as published by the Free -// Software Foundation; either version 3, or (at your option) any later -// version. - -// GCC is distributed in the hope that it will be useful, but WITHOUT ANY -// WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -// for more details. - -// You should have received a copy of the GNU General Public License -// along with GCC; see the file COPYING3. If not see -// . - -#ifndef RUST_COMPILE_TYTY -#define RUST_COMPILE_TYTY - -#include "rust-system.h" -#include "rust-location.h" -#include "rust-diagnostics.h" -#include "rust-backend.h" -#include "rust-tyty.h" -#include "rust-tyty-visitor.h" -#include "rust-hir-map.h" -#include "rust-hir-full.h" - -namespace Rust { -namespace Compile { - -class TyTyCompile : public TyTy::TyVisitor -{ -public: - static tree compile (::Backend *backend, TyTy::BaseType *ty) - { - TyTyCompile compiler (backend); - ty->accept_vis (compiler); - rust_assert (compiler.translated != nullptr); - return compiler.translated; - } - - void visit (TyTy::ErrorType &) override { gcc_unreachable (); } - - void visit (TyTy::InferType &) override { gcc_unreachable (); } - - void visit (TyTy::ADTType &) override { gcc_unreachable (); } - - void visit (TyTy::PlaceholderType &) override { gcc_unreachable (); } - - void visit (TyTy::ProjectionType &) override { gcc_unreachable (); } - - void visit (TyTy::TupleType &type) override - { - // this interface is only for unit-type the -type interface takes into - // account the context - rust_assert (type.num_fields () == 0); - translated = backend->unit_type (); - } - - void visit (TyTy::ArrayType &) override { gcc_unreachable (); } - - void visit (TyTy::SliceType &) override { gcc_unreachable (); } - - void visit (TyTy::ReferenceType &) override { gcc_unreachable (); } - - void visit (TyTy::PointerType &) override { gcc_unreachable (); } - - void visit (TyTy::ParamType &) override { gcc_unreachable (); } - - void visit (TyTy::FnPtr &) override { gcc_unreachable (); } - - void visit (TyTy::FnType &type) override - { - Backend::typed_identifier receiver; - std::vector parameters; - std::vector results; - - if (!type.get_return_type ()->is_unit ()) - { - auto hir_type = type.get_return_type (); - auto ret = TyTyCompile::compile (backend, hir_type); - results.push_back (Backend::typed_identifier ( - "_", ret, mappings->lookup_location (hir_type->get_ref ()))); - } - - for (auto ¶ms : type.get_params ()) - { - auto param_pattern = params.first; - auto param_tyty = params.second; - auto compiled_param_type = TyTyCompile::compile (backend, param_tyty); - - auto compiled_param = Backend::typed_identifier ( - param_pattern->as_string (), compiled_param_type, - mappings->lookup_location (param_tyty->get_ref ())); - - parameters.push_back (compiled_param); - } - - if (!type.is_varadic ()) - translated - = backend->function_type (receiver, parameters, results, NULL, - mappings->lookup_location (type.get_ref ())); - else - translated - = backend->function_type_varadic (receiver, parameters, results, NULL, - mappings->lookup_location ( - type.get_ref ())); - } - - void visit (TyTy::BoolType &) override - { - translated = backend->named_type ("bool", backend->bool_type (), - Linemap::predeclared_location ()); - } - - void visit (TyTy::IntType &type) override - { - switch (type.get_int_kind ()) - { - case TyTy::IntType::I8: - translated - = backend->named_type ("i8", backend->integer_type (false, 8), - Linemap::predeclared_location ()); - return; - - case TyTy::IntType::I16: - translated - = backend->named_type ("i16", backend->integer_type (false, 16), - Linemap::predeclared_location ()); - return; - - case TyTy::IntType::I32: - translated - = backend->named_type ("i32", backend->integer_type (false, 32), - Linemap::predeclared_location ()); - return; - - case TyTy::IntType::I64: - translated - = backend->named_type ("i64", backend->integer_type (false, 64), - Linemap::predeclared_location ()); - return; - - case TyTy::IntType::I128: - translated - = backend->named_type ("i128", backend->integer_type (false, 128), - Linemap::predeclared_location ()); - return; - } - gcc_unreachable (); - } - - void visit (TyTy::UintType &type) override - { - switch (type.get_uint_kind ()) - { - case TyTy::UintType::U8: - translated = backend->named_type ("u8", backend->integer_type (true, 8), - Linemap::predeclared_location ()); - return; - - case TyTy::UintType::U16: - translated - = backend->named_type ("u16", backend->integer_type (true, 16), - Linemap::predeclared_location ()); - return; - - case TyTy::UintType::U32: - translated - = backend->named_type ("u32", backend->integer_type (true, 32), - Linemap::predeclared_location ()); - return; - - case TyTy::UintType::U64: - translated - = backend->named_type ("u64", backend->integer_type (true, 64), - Linemap::predeclared_location ()); - return; - - case TyTy::UintType::U128: - translated - = backend->named_type ("u128", backend->integer_type (true, 128), - Linemap::predeclared_location ()); - return; - } - gcc_unreachable (); - } - - void visit (TyTy::FloatType &type) override - { - switch (type.get_float_kind ()) - { - case TyTy::FloatType::F32: - translated = backend->named_type ("f32", backend->float_type (32), - Linemap::predeclared_location ()); - return; - - case TyTy::FloatType::F64: - translated = backend->named_type ("f64", backend->float_type (64), - Linemap::predeclared_location ()); - return; - } - - gcc_unreachable (); - } - - void visit (TyTy::USizeType &) override - { - translated = backend->named_type ( - "usize", backend->integer_type (true, backend->get_pointer_size ()), - Linemap::predeclared_location ()); - } - - void visit (TyTy::ISizeType &) override - { - translated = backend->named_type ( - "isize", backend->integer_type (false, backend->get_pointer_size ()), - Linemap::predeclared_location ()); - } - - void visit (TyTy::CharType &) override - { - translated = backend->named_type ("char", backend->wchar_type (), - Linemap::predeclared_location ()); - } - - void visit (TyTy::StrType &) override - { - tree raw_str = backend->raw_str_type (); - translated - = backend->named_type ("str", raw_str, Linemap::predeclared_location ()); - } - - void visit (TyTy::NeverType &) override - { - translated = backend->unit_type (); - } - - void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); } - - void visit (TyTy::ClosureType &) override { gcc_unreachable (); } - -private: - TyTyCompile (::Backend *backend) - : backend (backend), translated (nullptr), - mappings (Analysis::Mappings::get ()) - {} - - ::Backend *backend; - tree translated; - Analysis::Mappings *mappings; -}; - -} // namespace Compile -} // namespace Rust - -#endif // RUST_COMPILE_TYTY diff --git a/gcc/rust/backend/rust-mangle.h b/gcc/rust/backend/rust-mangle.h index 03e1dc622a1..6d5a64f8bce 100644 --- a/gcc/rust/backend/rust-mangle.h +++ b/gcc/rust/backend/rust-mangle.h @@ -17,7 +17,8 @@ #ifndef RUST_MANGLE_H #define RUST_MANGLE_H -#include "rust-compile-tyty.h" +#include "rust-system.h" +#include "rust-tyty.h" namespace Rust { namespace Compile {