diff options
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/rust/Make-lang.in | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-block.h | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-context.cc | 139 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-context.h | 71 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-expr.h | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-resolve-path.h | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-stmt.h | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-struct-field-expr.h | 1 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-type.cc | 202 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-type.h | 12 | ||||
| -rw-r--r-- | gcc/rust/backend/rust-compile-tyty.h | 260 | ||||
| -rw-r--r-- | 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 11994740..5d97a16 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 4a3c6f5..0595ee9 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 0000000..463ac27 --- /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 +// <http://www.gnu.org/licenses/>. + +#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 d17034b..8378554 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<HirId, tree> (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<HirId, tree> &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<HirId, tree> (id, type)); - if (ref != nullptr) - { - std::pair<HirId, tree> 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<tree> &get_const_decls () { return const_decls; } std::vector<tree> &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<HirId> builtin_range; Mangler mangler; // state std::vector<fncontext> fn_stack; std::map<HirId, ::Bvariable *> compiled_var_decls; - std::map<HirId, tree> compiled_type_map; + std::map<hashval_t, tree> compiled_type_map; std::map<HirId, tree> compiled_fn_map; std::map<HirId, tree> compiled_consts; std::map<HirId, tree> compiled_labels; @@ -347,7 +311,6 @@ private: std::vector<tree> scope_stack; std::vector<::Bvariable *> loop_value_stack; std::vector<tree> loop_begin_labels; - std::map<const TyTy::BaseType *, std::pair<HirId, tree>> mono; std::map<DefId, std::vector<std::pair<const TyTy::BaseType *, tree>>> mono_fns; std::map<HirId, tree> implicit_pattern_bindings; diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index b05b129..655ffbb 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 37dec0b..f0360bd 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 ad34253..5f17777 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 c5e986e..6968c06 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 03c2ca4..3874027 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<Backend::typed_identifier> 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<Backend::typed_identifier> 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<Backend::typed_identifier> 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 4f9c403..3e1f903 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 52ad2f9..0000000 --- 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 -// <http://www.gnu.org/licenses/>. - -#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<Backend::typed_identifier> parameters; - std::vector<Backend::typed_identifier> 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 03e1dc6..6d5a64f 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 { |