1 files changed, 447 insertions, 0 deletions
diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
new file mode 100644
index 0000000..bdf487e
--- /dev/null
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -0,0 +1,447 @@
+// Copyright (C) 2020 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-hir-map.h"
+#include "rust-ast-full.h"
+#include "rust-hir-full.h"
+
+namespace Rust {
+namespace Analysis {
+
+NodeMapping::NodeMapping (CrateNum crateNum, NodeId nodeId, HirId hirId,
+			  LocalDefId localDefId)
+  : crateNum (crateNum), nodeId (nodeId), hirId (hirId), localDefId (localDefId)
+{}
+
+NodeMapping::~NodeMapping () {}
+
+NodeMapping
+NodeMapping::get_error ()
+{
+  return NodeMapping (UNKNOWN_CREATENUM, UNKNOWN_NODEID, UNKNOWN_HIRID,
+		      UNKNOWN_LOCAL_DEFID);
+}
+
+CrateNum
+NodeMapping::get_crate_num () const
+{
+  return crateNum;
+}
+
+NodeId
+NodeMapping::get_nodeid () const
+{
+  return nodeId;
+}
+
+HirId
+NodeMapping::get_hirid () const
+{
+  return hirId;
+}
+
+LocalDefId
+NodeMapping::get_local_defid () const
+{
+  return localDefId;
+}
+
+DefId
+NodeMapping::get_defid () const
+{
+  return get_defid (get_crate_num (), get_local_defid ());
+}
+
+DefId
+NodeMapping::get_defid (CrateNum crate_num, LocalDefId local_defid)
+{
+  DefId val = 0;
+  val |= crate_num;
+  val = val << sizeof (uint32_t);
+  val |= local_defid;
+  return val;
+}
+
+std::string
+NodeMapping::as_string () const
+{
+  std::ostringstream ss;
+  ss << "["
+     << "C: " << get_crate_num ();
+  if (get_nodeid () != UNKNOWN_NODEID)
+    ss << " Nid: " << get_nodeid ();
+
+  if (get_hirid () != UNKNOWN_HIRID)
+    ss << " Hid: " << get_hirid ();
+
+  if (get_local_defid () != UNKNOWN_LOCAL_DEFID)
+    ss << " Lid: " << get_local_defid ();
+
+  ss << "]";
+  return ss.str ();
+}
+
+// Mappings Class now
+
+Mappings::Mappings () {}
+
+Mappings::~Mappings () {}
+
+Mappings *
+Mappings::get ()
+{
+  static std::unique_ptr<Mappings> instance;
+  if (!instance)
+    instance = std::move (std::unique_ptr<Mappings> (new Mappings ()));
+
+  return instance.get ();
+}
+
+CrateNum
+Mappings::get_next_crate_num ()
+{
+  return crateNumItr++;
+}
+
+void
+Mappings::set_current_crate (CrateNum crateNum)
+{
+  currentCrateNum = crateNum;
+}
+
+CrateNum
+Mappings::get_current_crate ()
+{
+  // HACK
+  if (hirIdIter.find (currentCrateNum) == hirIdIter.end ())
+    {
+      hirIdIter[currentCrateNum] = UNKNOWN_HIRID;
+      nodeIdIter[currentCrateNum] = UNKNOWN_NODEID;
+      localIdIter[currentCrateNum] = UNKNOWN_LOCAL_DEFID;
+      nodeIdToHirMappings[currentCrateNum] = {};
+      locations[currentCrateNum] = {};
+    }
+
+  return currentCrateNum;
+}
+
+NodeId
+Mappings::get_next_node_id (CrateNum crateNum)
+{
+  auto it = nodeIdIter.find (crateNum);
+  rust_assert (it != nodeIdIter.end ());
+
+  auto id = it->second + 1;
+  nodeIdIter[crateNum] = id;
+  return id;
+}
+
+HirId
+Mappings::get_next_hir_id (CrateNum crateNum)
+{
+  auto it = hirIdIter.find (crateNum);
+  rust_assert (it != hirIdIter.end ());
+
+  auto id = it->second + 1;
+  hirIdIter[crateNum] = id;
+  return id;
+}
+
+LocalDefId
+Mappings::get_next_localdef_id (CrateNum crateNum)
+{
+  auto it = localIdIter.find (crateNum);
+  rust_assert (it != localIdIter.end ());
+
+  auto id = it->second + 1;
+  localIdIter[crateNum] = id;
+  return id;
+}
+
+AST::Crate *
+Mappings::get_ast_crate (CrateNum crateNum)
+{
+  auto it = astCrateMappings.find (crateNum);
+  if (it == astCrateMappings.end ())
+    return nullptr;
+
+  return it->second;
+}
+
+void
+Mappings::insert_ast_crate (AST::Crate *crate)
+{
+  CrateNum crateNum = get_current_crate ();
+  rust_assert (get_ast_crate (crateNum) == nullptr);
+
+  astCrateMappings[crateNum] = crate;
+}
+
+HIR::Crate *
+Mappings::get_hir_crate (CrateNum crateNum)
+{
+  auto it = hirCrateMappings.find (crateNum);
+  if (it == hirCrateMappings.end ())
+    return nullptr;
+
+  return it->second;
+}
+
+void
+Mappings::insert_hir_crate (HIR::Crate *crate)
+{
+  CrateNum crateNum = crate->get_mappings ().get_crate_num ();
+  rust_assert (get_hir_crate (crateNum) == nullptr);
+
+  hirCrateMappings[crateNum] = crate;
+}
+
+void
+Mappings::insert_defid_mapping (DefId id, HIR::Item *item)
+{
+  CrateNum crateNum = (id & DEF_ID_CRATE_MASK) >> sizeof (uint32_t);
+  LocalDefId localDefId = id & DEF_ID_LOCAL_DEF_MASK;
+
+  rust_assert (lookup_defid (id) == nullptr);
+  rust_assert (lookup_local_defid (crateNum, localDefId) == nullptr);
+
+  defIdMappings[id] = item;
+  insert_local_defid_mapping (crateNum, localDefId, item);
+}
+
+HIR::Item *
+Mappings::lookup_defid (DefId id)
+{
+  auto it = defIdMappings.find (id);
+  if (it == defIdMappings.end ())
+    return nullptr;
+
+  return it->second;
+}
+
+void
+Mappings::insert_hir_item (CrateNum crateNum, HirId id, HIR::Item *item)
+{
+  rust_assert (lookup_hir_item (crateNum, id) == nullptr);
+
+  hirItemMappings[crateNum][id] = item;
+  nodeIdToHirMappings[crateNum][item->get_mappings ().get_nodeid ()] = id;
+}
+
+HIR::Item *
+Mappings::lookup_hir_item (CrateNum crateNum, HirId id)
+{
+  auto it = hirItemMappings.find (crateNum);
+  if (it == hirItemMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr)
+{
+  rust_assert (lookup_hir_expr (crateNum, id) == nullptr);
+
+  hirExprMappings[crateNum][id] = expr;
+  nodeIdToHirMappings[crateNum][expr->get_mappings ().get_nodeid ()] = id;
+  insert_location (crateNum, id, expr->get_locus_slow ());
+}
+
+HIR::Expr *
+Mappings::lookup_hir_expr (CrateNum crateNum, HirId id)
+{
+  auto it = hirExprMappings.find (crateNum);
+  if (it == hirExprMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::insert_hir_type (CrateNum crateNum, HirId id, HIR::Type *type)
+{
+  rust_assert (lookup_hir_type (crateNum, id) == nullptr);
+
+  hirTypeMappings[crateNum][id] = type;
+  nodeIdToHirMappings[crateNum][type->get_mappings ().get_nodeid ()] = id;
+}
+
+HIR::Type *
+Mappings::lookup_hir_type (CrateNum crateNum, HirId id)
+{
+  auto it = hirTypeMappings.find (crateNum);
+  if (it == hirTypeMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::insert_hir_stmt (CrateNum crateNum, HirId id, HIR::Stmt *type)
+{
+  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+
+  hirStmtMappings[crateNum][id] = type;
+  nodeIdToHirMappings[crateNum][type->get_mappings ().get_nodeid ()] = id;
+}
+
+HIR::Stmt *
+Mappings::lookup_hir_stmt (CrateNum crateNum, HirId id)
+{
+  auto it = hirStmtMappings.find (crateNum);
+  if (it == hirStmtMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::insert_hir_param (CrateNum crateNum, HirId id,
+			    HIR::FunctionParam *param)
+{
+  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+
+  printf ("inserting param with node id %u hir id: %u\n",
+	  param->get_mappings ()->get_nodeid (), id);
+  hirParamMappings[crateNum][id] = param;
+  nodeIdToHirMappings[crateNum][param->get_mappings ()->get_nodeid ()] = id;
+}
+
+HIR::FunctionParam *
+Mappings::lookup_hir_param (CrateNum crateNum, HirId id)
+{
+  auto it = hirParamMappings.find (crateNum);
+  if (it == hirParamMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
+				      HIR::Item *item)
+{
+  rust_assert (lookup_local_defid (crateNum, id) == nullptr);
+
+  localDefIdMappings[crateNum][id] = item;
+}
+
+HIR::Item *
+Mappings::lookup_local_defid (CrateNum crateNum, LocalDefId id)
+{
+  auto it = localDefIdMappings.find (crateNum);
+  if (it == localDefIdMappings.end ())
+    return nullptr;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return nullptr;
+
+  return iy->second;
+}
+
+void
+Mappings::walk_local_defids_for_crate (CrateNum crateNum,
+				       std::function<bool (HIR::Item *)> cb)
+{
+  auto it = localDefIdMappings.find (crateNum);
+  if (it == localDefIdMappings.end ())
+    return;
+
+  for (auto iy = it->second.begin (); iy != it->second.end (); iy++)
+    {
+      if (!cb (iy->second))
+	return;
+    }
+}
+
+bool
+Mappings::lookup_node_to_hir (CrateNum crate, NodeId id, HirId *ref)
+{
+  auto it = nodeIdToHirMappings.find (crate);
+  if (it == nodeIdToHirMappings.end ())
+    return false;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return false;
+
+  *ref = iy->second;
+  return true;
+}
+
+void
+Mappings::insert_location (CrateNum crate, HirId id, Location locus)
+{
+  locations[crate][id] = locus;
+}
+
+Location
+Mappings::lookup_location (CrateNum crate, HirId id)
+{
+  auto it = locations.find (crate);
+  if (it == locations.end ())
+    return Location ();
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return Location ();
+
+  return iy->second;
+}
+
+bool
+Mappings::resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt)
+{
+  auto it = nodeIdToHirMappings.find (crate);
+  if (it == nodeIdToHirMappings.end ())
+    return false;
+
+  auto iy = it->second.find (id);
+  if (iy == it->second.end ())
+    return false;
+
+  HirId resolved = iy->second;
+  auto resolved_stmt = lookup_hir_stmt (crate, resolved);
+  *stmt = resolved_stmt;
+  return resolved_stmt != nullptr;
+}
+
+} // namespace Analysis
+} // namespace Rust