Implement resolve expr for inline asm ast

gcc/rust/ChangeLog:

	* resolve/rust-ast-resolve-expr.cc (ResolveExpr::visit):
	Implement resolve expr for inline asm ast
	(translate_operand): Likewise.
	* resolve/rust-ast-resolve-expr.h: Likewise.

diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.cc b/gcc/rust/resolve/rust-ast-resolve-expr.cc
index 1bb3fc601539f55e1b71752593a4bc02eca24b9b..cc7c11ccf22cf635eb6845855d00b6419b6a96c9 100644 (file)
--- a/gcc/rust/resolve/rust-ast-resolve-expr.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.cc
@@ -346,6 +346,60 @@ ResolveExpr::visit (AST::BlockExpr &expr)
   resolver->get_label_scope ().pop ();
 }
 
+void
+translate_operand (AST::InlineAsm &expr, const CanonicalPath &prefix,
+                  const CanonicalPath &canonical_prefix)
+{
+  const auto &operands = expr.get_operands ();
+  using RegisterType = AST::InlineAsmOperand::RegisterType;
+  for (auto &operand : operands)
+    {
+      switch (operand.get_register_type ())
+       {
+         case RegisterType::In: {
+           auto in = operand.get_in ();
+           ResolveExpr::go (*in.expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::Out: {
+           auto out = operand.get_out ();
+           ResolveExpr::go (*out.expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::InOut: {
+           auto in_out = operand.get_in_out ();
+           ResolveExpr::go (*in_out.expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::SplitInOut: {
+           auto split_in_out = operand.get_split_in_out ();
+           ResolveExpr::go (*split_in_out.in_expr, prefix, canonical_prefix);
+           ResolveExpr::go (*split_in_out.out_expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::Const: {
+           auto anon_const = operand.get_const ().anon_const;
+           ResolveExpr::go (*anon_const.expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::Sym: {
+           auto sym = operand.get_sym ();
+           ResolveExpr::go (*sym.expr, prefix, canonical_prefix);
+           break;
+         }
+         case RegisterType::Label: {
+           auto label = operand.get_label ();
+           ResolveExpr::go (*label.expr, prefix, canonical_prefix);
+           break;
+         }
+       }
+    }
+}
+void
+ResolveExpr::visit (AST::InlineAsm &expr)
+{
+  translate_operand (expr, prefix, canonical_prefix);
+}
 void
 ResolveExpr::visit (AST::UnsafeBlockExpr &expr)
 {
@@ -477,12 +531,13 @@ ResolveExpr::visit (AST::BreakExpr &expr)
       auto &break_expr = expr.get_break_expr ();
       if (break_expr.get_ast_kind () == AST::Kind::IDENTIFIER)
        {
-         /* This is a break with an expression, and the expression is just a
-            single identifier.  See if the identifier is either "rust" or
-            "gcc", in which case we have "break rust" or "break gcc", and so
-            may need to emit our funny error.  We cannot yet emit the error
-            here though, because the identifier may still be in scope, and
-            ICE'ing on valid programs would not be very funny.  */
+         /* This is a break with an expression, and the expression is
+            just a single identifier.  See if the identifier is either
+            "rust" or "gcc", in which case we have "break rust" or "break
+            gcc", and so may need to emit our funny error.  We cannot yet
+            emit the error here though, because the identifier may still
+            be in scope, and ICE'ing on valid programs would not be very
+            funny.  */
          std::string ident
            = static_cast<AST::IdentifierExpr &> (break_expr).as_string ();
          if (ident == "rust" || ident == "gcc")

diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index 4897650396d549f6c52a362d489af69395de6bcd..12b4868e31e2489bfd57c771c61ed3baeed89a12 100644 (file)
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -20,6 +20,7 @@
 #define RUST_AST_RESOLVE_EXPR_H
 
 #include "rust-ast-resolve-base.h"
+#include "rust-ast.h"
 #include "rust-ast-resolve-pattern.h"
 
 namespace Rust {
@@ -54,6 +55,7 @@ public:
   void visit (AST::IfLetExpr &expr) override;
   void visit (AST::IfLetExprConseqElse &expr) override;
   void visit (AST::BlockExpr &expr) override;
+  void visit (AST::InlineAsm &expr) override;
   void visit (AST::UnsafeBlockExpr &expr) override;
   void visit (AST::ArrayElemsValues &elems) override;
   void visit (AST::ArrayExpr &expr) override;