public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc/devel/rust/master] Refactor lang item mappings enum into its own header
@ 2022-06-08 12:10 Thomas Schwinge
0 siblings, 0 replies; only message in thread
From: Thomas Schwinge @ 2022-06-08 12:10 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:87aeea25837515cf31c8783238419e6e6936290d
commit 87aeea25837515cf31c8783238419e6e6936290d
Author: Philip Herron <philip.herron@embecosm.com>
Date: Sun Feb 20 15:42:12 2022 +0000
Refactor lang item mappings enum into its own header
Diff:
---
gcc/rust/util/rust-hir-map.h | 270 +------------------------------------
gcc/rust/util/rust-lang-item.h | 294 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 295 insertions(+), 269 deletions(-)
diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 799351b41fd..9bac328ee0f 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -25,279 +25,11 @@
#include "rust-canonical-path.h"
#include "rust-ast-full-decls.h"
#include "rust-hir-full-decls.h"
-#include "operator.h"
+#include "rust-lang-item.h"
namespace Rust {
namespace Analysis {
-// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs
-class RustLangItem
-{
-public:
- enum ItemType
- {
- ADD,
- SUBTRACT,
- MULTIPLY,
- DIVIDE,
- REMAINDER,
- BITAND,
- BITOR,
- BITXOR,
- SHL,
- SHR,
-
- NEGATION,
- NOT,
-
- ADD_ASSIGN,
- SUB_ASSIGN,
- MUL_ASSIGN,
- DIV_ASSIGN,
- REM_ASSIGN,
- BITAND_ASSIGN,
- BITOR_ASSIGN,
- BITXOR_ASSIGN,
- SHL_ASSIGN,
- SHR_ASSIGN,
-
- DEREF,
- DEREF_MUT,
-
- UNKNOWN,
- };
-
- static ItemType Parse (const std::string &item)
- {
- if (item.compare ("add") == 0)
- {
- return ItemType::ADD;
- }
- else if (item.compare ("sub") == 0)
- {
- return ItemType::SUBTRACT;
- }
- else if (item.compare ("mul") == 0)
- {
- return ItemType::MULTIPLY;
- }
- else if (item.compare ("div") == 0)
- {
- return ItemType::DIVIDE;
- }
- else if (item.compare ("rem") == 0)
- {
- return ItemType::REMAINDER;
- }
- else if (item.compare ("bitand") == 0)
- {
- return ItemType::BITAND;
- }
- else if (item.compare ("bitor") == 0)
- {
- return ItemType::BITOR;
- }
- else if (item.compare ("bitxor") == 0)
- {
- return ItemType::BITXOR;
- }
- else if (item.compare ("shl") == 0)
- {
- return ItemType::SHL;
- }
- else if (item.compare ("shr") == 0)
- {
- return ItemType::SHR;
- }
- else if (item.compare ("neg") == 0)
- {
- return ItemType::NEGATION;
- }
- else if (item.compare ("not") == 0)
- {
- return ItemType::NOT;
- }
- else if (item.compare ("add_assign") == 0)
- {
- return ItemType::ADD_ASSIGN;
- }
- else if (item.compare ("sub_assign") == 0)
- {
- return ItemType::SUB_ASSIGN;
- }
- else if (item.compare ("mul_assign") == 0)
- {
- return ItemType::MUL_ASSIGN;
- }
- else if (item.compare ("div_assign") == 0)
- {
- return ItemType::DIV_ASSIGN;
- }
- else if (item.compare ("rem_assign") == 0)
- {
- return ItemType::REM_ASSIGN;
- }
- else if (item.compare ("bitand_assign") == 0)
- {
- return ItemType::BITAND_ASSIGN;
- }
- else if (item.compare ("bitor_assign") == 0)
- {
- return ItemType::BITOR_ASSIGN;
- }
- else if (item.compare ("bitxor_assign") == 0)
- {
- return ItemType::BITXOR_ASSIGN;
- }
- else if (item.compare ("shl_assign") == 0)
- {
- return ItemType::SHL_ASSIGN;
- }
- else if (item.compare ("shr_assign") == 0)
- {
- return ItemType::SHR_ASSIGN;
- }
- else if (item.compare ("deref") == 0)
- {
- return ItemType::DEREF;
- }
- else if (item.compare ("deref_mut") == 0)
- {
- return ItemType::DEREF_MUT;
- }
-
- return ItemType::UNKNOWN;
- }
-
- static std::string ToString (ItemType type)
- {
- switch (type)
- {
- case ADD:
- return "add";
- case SUBTRACT:
- return "sub";
- case MULTIPLY:
- return "mul";
- case DIVIDE:
- return "div";
- case REMAINDER:
- return "rem";
- case BITAND:
- return "bitand";
- case BITOR:
- return "bitor";
- case BITXOR:
- return "bitxor";
- case SHL:
- return "shl";
- case SHR:
- return "shr";
- case NEGATION:
- return "neg";
- case NOT:
- return "not";
- case ADD_ASSIGN:
- return "add_assign";
- case SUB_ASSIGN:
- return "sub_assign";
- case MUL_ASSIGN:
- return "mul_assign";
- case DIV_ASSIGN:
- return "div_assign";
- case REM_ASSIGN:
- return "rem_assign";
- case BITAND_ASSIGN:
- return "bitand_assign";
- case BITOR_ASSIGN:
- return "bitor_assign";
- case BITXOR_ASSIGN:
- return "bitxor_assign";
- case SHL_ASSIGN:
- return "shl_assign";
- case SHR_ASSIGN:
- return "shr_assign";
- case DEREF:
- return "deref";
- case DEREF_MUT:
- return "deref_mut";
-
- case UNKNOWN:
- return "<UNKNOWN>";
- }
- return "<UNKNOWN>";
- }
-
- static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op)
- {
- switch (op)
- {
- case ArithmeticOrLogicalOperator::ADD:
- return ItemType::ADD;
- case ArithmeticOrLogicalOperator::SUBTRACT:
- return ItemType::SUBTRACT;
- case ArithmeticOrLogicalOperator::MULTIPLY:
- return ItemType::MULTIPLY;
- case ArithmeticOrLogicalOperator::DIVIDE:
- return ItemType::DIVIDE;
- case ArithmeticOrLogicalOperator::MODULUS:
- return ItemType::REMAINDER;
- case ArithmeticOrLogicalOperator::BITWISE_AND:
- return ItemType::BITAND;
- case ArithmeticOrLogicalOperator::BITWISE_OR:
- return ItemType::BITOR;
- case ArithmeticOrLogicalOperator::BITWISE_XOR:
- return ItemType::BITXOR;
- case ArithmeticOrLogicalOperator::LEFT_SHIFT:
- return ItemType::SHL;
- case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
- return ItemType::SHR;
- }
- return ItemType::UNKNOWN;
- }
-
- static ItemType
- CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op)
- {
- switch (op)
- {
- case ArithmeticOrLogicalOperator::ADD:
- return ItemType::ADD_ASSIGN;
- case ArithmeticOrLogicalOperator::SUBTRACT:
- return ItemType::SUB_ASSIGN;
- case ArithmeticOrLogicalOperator::MULTIPLY:
- return ItemType::MUL_ASSIGN;
- case ArithmeticOrLogicalOperator::DIVIDE:
- return ItemType::DIV_ASSIGN;
- case ArithmeticOrLogicalOperator::MODULUS:
- return ItemType::REM_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_AND:
- return ItemType::BITAND_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_OR:
- return ItemType::BITOR_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_XOR:
- return ItemType::BITXOR_ASSIGN;
- case ArithmeticOrLogicalOperator::LEFT_SHIFT:
- return ItemType::SHL_ASSIGN;
- case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
- return ItemType::SHR_ASSIGN;
- }
- return ItemType::UNKNOWN;
- }
-
- static ItemType NegationOperatorToLangItem (NegationOperator op)
- {
- switch (op)
- {
- case NegationOperator::NEGATE:
- return ItemType::NEGATION;
- case NegationOperator::NOT:
- return ItemType::NOT;
- }
- return ItemType::UNKNOWN;
- }
-};
-
class NodeMapping
{
public:
diff --git a/gcc/rust/util/rust-lang-item.h b/gcc/rust/util/rust-lang-item.h
new file mode 100644
index 00000000000..abf210d1c46
--- /dev/null
+++ b/gcc/rust/util/rust-lang-item.h
@@ -0,0 +1,294 @@
+// 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-system.h"
+#include "operator.h"
+
+namespace Rust {
+namespace Analysis {
+
+// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs
+class RustLangItem
+{
+public:
+ enum ItemType
+ {
+ ADD,
+ SUBTRACT,
+ MULTIPLY,
+ DIVIDE,
+ REMAINDER,
+ BITAND,
+ BITOR,
+ BITXOR,
+ SHL,
+ SHR,
+
+ NEGATION,
+ NOT,
+
+ ADD_ASSIGN,
+ SUB_ASSIGN,
+ MUL_ASSIGN,
+ DIV_ASSIGN,
+ REM_ASSIGN,
+ BITAND_ASSIGN,
+ BITOR_ASSIGN,
+ BITXOR_ASSIGN,
+ SHL_ASSIGN,
+ SHR_ASSIGN,
+
+ DEREF,
+ DEREF_MUT,
+
+ UNKNOWN,
+ };
+
+ static ItemType Parse (const std::string &item)
+ {
+ if (item.compare ("add") == 0)
+ {
+ return ItemType::ADD;
+ }
+ else if (item.compare ("sub") == 0)
+ {
+ return ItemType::SUBTRACT;
+ }
+ else if (item.compare ("mul") == 0)
+ {
+ return ItemType::MULTIPLY;
+ }
+ else if (item.compare ("div") == 0)
+ {
+ return ItemType::DIVIDE;
+ }
+ else if (item.compare ("rem") == 0)
+ {
+ return ItemType::REMAINDER;
+ }
+ else if (item.compare ("bitand") == 0)
+ {
+ return ItemType::BITAND;
+ }
+ else if (item.compare ("bitor") == 0)
+ {
+ return ItemType::BITOR;
+ }
+ else if (item.compare ("bitxor") == 0)
+ {
+ return ItemType::BITXOR;
+ }
+ else if (item.compare ("shl") == 0)
+ {
+ return ItemType::SHL;
+ }
+ else if (item.compare ("shr") == 0)
+ {
+ return ItemType::SHR;
+ }
+ else if (item.compare ("neg") == 0)
+ {
+ return ItemType::NEGATION;
+ }
+ else if (item.compare ("not") == 0)
+ {
+ return ItemType::NOT;
+ }
+ else if (item.compare ("add_assign") == 0)
+ {
+ return ItemType::ADD_ASSIGN;
+ }
+ else if (item.compare ("sub_assign") == 0)
+ {
+ return ItemType::SUB_ASSIGN;
+ }
+ else if (item.compare ("mul_assign") == 0)
+ {
+ return ItemType::MUL_ASSIGN;
+ }
+ else if (item.compare ("div_assign") == 0)
+ {
+ return ItemType::DIV_ASSIGN;
+ }
+ else if (item.compare ("rem_assign") == 0)
+ {
+ return ItemType::REM_ASSIGN;
+ }
+ else if (item.compare ("bitand_assign") == 0)
+ {
+ return ItemType::BITAND_ASSIGN;
+ }
+ else if (item.compare ("bitor_assign") == 0)
+ {
+ return ItemType::BITOR_ASSIGN;
+ }
+ else if (item.compare ("bitxor_assign") == 0)
+ {
+ return ItemType::BITXOR_ASSIGN;
+ }
+ else if (item.compare ("shl_assign") == 0)
+ {
+ return ItemType::SHL_ASSIGN;
+ }
+ else if (item.compare ("shr_assign") == 0)
+ {
+ return ItemType::SHR_ASSIGN;
+ }
+ else if (item.compare ("deref") == 0)
+ {
+ return ItemType::DEREF;
+ }
+ else if (item.compare ("deref_mut") == 0)
+ {
+ return ItemType::DEREF_MUT;
+ }
+
+ return ItemType::UNKNOWN;
+ }
+
+ static std::string ToString (ItemType type)
+ {
+ switch (type)
+ {
+ case ADD:
+ return "add";
+ case SUBTRACT:
+ return "sub";
+ case MULTIPLY:
+ return "mul";
+ case DIVIDE:
+ return "div";
+ case REMAINDER:
+ return "rem";
+ case BITAND:
+ return "bitand";
+ case BITOR:
+ return "bitor";
+ case BITXOR:
+ return "bitxor";
+ case SHL:
+ return "shl";
+ case SHR:
+ return "shr";
+ case NEGATION:
+ return "neg";
+ case NOT:
+ return "not";
+ case ADD_ASSIGN:
+ return "add_assign";
+ case SUB_ASSIGN:
+ return "sub_assign";
+ case MUL_ASSIGN:
+ return "mul_assign";
+ case DIV_ASSIGN:
+ return "div_assign";
+ case REM_ASSIGN:
+ return "rem_assign";
+ case BITAND_ASSIGN:
+ return "bitand_assign";
+ case BITOR_ASSIGN:
+ return "bitor_assign";
+ case BITXOR_ASSIGN:
+ return "bitxor_assign";
+ case SHL_ASSIGN:
+ return "shl_assign";
+ case SHR_ASSIGN:
+ return "shr_assign";
+ case DEREF:
+ return "deref";
+ case DEREF_MUT:
+ return "deref_mut";
+
+ case UNKNOWN:
+ return "<UNKNOWN>";
+ }
+ return "<UNKNOWN>";
+ }
+
+ static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op)
+ {
+ switch (op)
+ {
+ case ArithmeticOrLogicalOperator::ADD:
+ return ItemType::ADD;
+ case ArithmeticOrLogicalOperator::SUBTRACT:
+ return ItemType::SUBTRACT;
+ case ArithmeticOrLogicalOperator::MULTIPLY:
+ return ItemType::MULTIPLY;
+ case ArithmeticOrLogicalOperator::DIVIDE:
+ return ItemType::DIVIDE;
+ case ArithmeticOrLogicalOperator::MODULUS:
+ return ItemType::REMAINDER;
+ case ArithmeticOrLogicalOperator::BITWISE_AND:
+ return ItemType::BITAND;
+ case ArithmeticOrLogicalOperator::BITWISE_OR:
+ return ItemType::BITOR;
+ case ArithmeticOrLogicalOperator::BITWISE_XOR:
+ return ItemType::BITXOR;
+ case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+ return ItemType::SHL;
+ case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+ return ItemType::SHR;
+ }
+ return ItemType::UNKNOWN;
+ }
+
+ static ItemType
+ CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op)
+ {
+ switch (op)
+ {
+ case ArithmeticOrLogicalOperator::ADD:
+ return ItemType::ADD_ASSIGN;
+ case ArithmeticOrLogicalOperator::SUBTRACT:
+ return ItemType::SUB_ASSIGN;
+ case ArithmeticOrLogicalOperator::MULTIPLY:
+ return ItemType::MUL_ASSIGN;
+ case ArithmeticOrLogicalOperator::DIVIDE:
+ return ItemType::DIV_ASSIGN;
+ case ArithmeticOrLogicalOperator::MODULUS:
+ return ItemType::REM_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_AND:
+ return ItemType::BITAND_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_OR:
+ return ItemType::BITOR_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_XOR:
+ return ItemType::BITXOR_ASSIGN;
+ case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+ return ItemType::SHL_ASSIGN;
+ case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+ return ItemType::SHR_ASSIGN;
+ }
+ return ItemType::UNKNOWN;
+ }
+
+ static ItemType NegationOperatorToLangItem (NegationOperator op)
+ {
+ switch (op)
+ {
+ case NegationOperator::NEGATE:
+ return ItemType::NEGATION;
+ case NegationOperator::NOT:
+ return ItemType::NOT;
+ }
+ return ItemType::UNKNOWN;
+ }
+};
+
+} // namespace Analysis
+} // namespace Rust
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-06-08 12:10 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-06-08 12:10 [gcc/devel/rust/master] Refactor lang item mappings enum into its own header Thomas Schwinge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).