| // Copyright (C) 2020-2026 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::get () | |
| { | |
| static Context *instance; | |
| if (instance == nullptr) | |
| instance = new Context (); | |
| return instance; | |
| } | |
| Context::Context () | |
| : tyctx (Resolver::TypeCheckContext::get ()), | |
| mappings (Analysis::Mappings::get ()), mangler (Mangler ()) | |
| { | |
| setup_builtins (); | |
| } | |
| void | |
| Context::setup_builtins () | |
| { | |
| for (auto &builtin : tyctx->get_builtins ()) | |
| TyTyResolveCompile::compile (this, builtin.get ()); | |
| } | |
| hashval_t | |
| Context::type_hasher (tree type) | |
| { | |
| hash_set<tree> active_types; | |
| return type_hasher (type, active_types); | |
| } | |
| hashval_t | |
| Context::type_hasher (tree type, hash_set<tree> &active_types) | |
| { | |
| 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); | |
| } | |
| 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))); | |
| /* recursive guard */ | |
| bool found = active_types.contains (type); | |
| if (found) | |
| { | |
| hstate.add_int (TYPE_UID (TYPE_MAIN_VARIANT (type))); | |
| return hstate.end (); | |
| } | |
| active_types.add (type); | |
| 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), active_types); | |
| hstate.add_object (name_hash); | |
| hstate.add_object (type_hash); | |
| } | |
| } | |
| break; | |
| case BOOLEAN_TYPE: | |
| break; | |
| case REFERENCE_TYPE: | |
| case POINTER_TYPE: | |
| { | |
| hashval_t type_hash = type_hasher (TREE_TYPE (type), active_types); | |
| hstate.add_object (type_hash); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| active_types.remove (type); | |
| return hstate.end (); | |
| } | |
| void | |
| Context::push_closure_context (HirId id) | |
| { | |
| auto it = closure_bindings.find (id); | |
| rust_assert (it == closure_bindings.end ()); | |
| closure_bindings.insert ({id, {}}); | |
| closure_scope_bindings.push_back (id); | |
| } | |
| void | |
| Context::pop_closure_context () | |
| { | |
| rust_assert (!closure_scope_bindings.empty ()); | |
| HirId ref = closure_scope_bindings.back (); | |
| closure_scope_bindings.pop_back (); | |
| closure_bindings.erase (ref); | |
| } | |
| void | |
| Context::insert_closure_binding (HirId id, tree expr) | |
| { | |
| rust_assert (!closure_scope_bindings.empty ()); | |
| HirId ref = closure_scope_bindings.back (); | |
| closure_bindings[ref].insert ({id, expr}); | |
| } | |
| bool | |
| Context::lookup_closure_binding (HirId id, tree *expr) | |
| { | |
| if (closure_scope_bindings.empty ()) | |
| return false; | |
| HirId ref = closure_scope_bindings.back (); | |
| auto it = closure_bindings.find (ref); | |
| rust_assert (it != closure_bindings.end ()); | |
| auto iy = it->second.find (id); | |
| if (iy == it->second.end ()) | |
| return false; | |
| *expr = iy->second; | |
| return true; | |
| } | |
| } // namespace Compile | |
| } // namespace Rust |