Parse and lower llvm asm node

Add a new HIR LlvmInlineAsm HIR node as well as some structures to
represent it's options and operands. Lower AST::LlvmInlineAsm node to it
and then create a tree from that node.

gcc/rust/ChangeLog:

	* ast/rust-ast-collector.cc (TokenCollector::visit): Remove unreachable
	code.
	* ast/rust-expr.h (struct LlvmOperand): Add LlvmOperand struct to
	represent input and outputs.
	(class LlvmInlineAsm): Add input, output and clobber operands.
	(struct TupleTemplateStr): Add locus getter.
	* backend/rust-compile-block.h: Add visit for LlvmInlineAsm.
	* backend/rust-compile-expr.cc (CompileExpr::visit): Add llvm inline
	asm stmt compilation.
	* backend/rust-compile-expr.h: Add function prototype.
	* backend/rust-compile-asm.h (class CompileLlvmAsm): Add llvm asm hir
	not to gimple.
	* backend/rust-compile-asm.cc (CompileLlvmAsm::CompileLlvmAsm): Add
	constructor.
	(CompileLlvmAsm::construct_operands): Add function to construct operand
	tree.
	(CompileLlvmAsm::construct_clobbers): Add function to construct clobber
	tree.
	(CompileLlvmAsm::tree_codegen_asm): Generate the whole tree for a given
	llvm inline assembly node.
	* checks/errors/borrowck/rust-bir-builder-expr-stmt.cc (ExprStmtBuilder::visit):
	Add visit function.
	* checks/errors/borrowck/rust-bir-builder-expr-stmt.h: Add function
	prototype.
	* checks/errors/borrowck/rust-bir-builder-lazyboolexpr.h: Add visit
	function.
	* checks/errors/borrowck/rust-bir-builder-struct.h: Likewise.
	* checks/errors/borrowck/rust-function-collector.h: Likewise.
	* checks/errors/privacy/rust-privacy-reporter.cc (PrivacyReporter::visit):
	Likewise.
	* checks/errors/privacy/rust-privacy-reporter.h: Add visit function
	prototype.
	* checks/errors/rust-const-checker.cc (ConstChecker::visit): Add visit
	function.
	* checks/errors/rust-const-checker.h: Add visit function prototype.
	* checks/errors/rust-hir-pattern-analysis.cc (PatternChecker::visit):
	Add visit function.
	* checks/errors/rust-hir-pattern-analysis.h: Add visit function
	prototype.
	* checks/errors/rust-unsafe-checker.cc (UnsafeChecker::visit): Add
	visit function.
	* checks/errors/rust-unsafe-checker.h: Add function prototype.
	* expand/rust-macro-builtins-asm.cc (parse_llvm_templates): Parse
	templates.
	(parse_llvm_arguments): Add function to parse non template tokens.
	(parse_llvm_operands): Add function to parse operands, either input or
	output.
	(parse_llvm_outputs): Add function to parse and collect llvm asm
	outputs.
	(parse_llvm_inputs): Likewise with inputs.
	(parse_llvm_clobbers): Add function to parse llvm asm clobbers.
	(parse_llvm_options): Add function to parse llvm asm options.
	(parse_llvm_asm): Add function to parse llvm asm.
	* expand/rust-macro-builtins-asm.h (class LlvmAsmContext): Add context
	for llvm asm parser.
	(parse_llvm_outputs): Add function prototype.
	(parse_llvm_inputs): Likewise.
	(parse_llvm_clobbers): Likewise.
	(parse_llvm_options): Likewise.
	* hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Lower AST llvm
	asm node to HIR.
	* hir/rust-ast-lower-expr.h: Add function prototype.
	* hir/rust-hir-dump.cc (Dump::visit): Add visit function.
	* hir/rust-hir-dump.h: Add function prototype.
	* hir/tree/rust-hir-expr-abstract.h: Add HIR llvm asm node kind.
	* hir/tree/rust-hir-expr.h (struct LlvmOperand): Add LlvmOperand type
	to represent input and outputs.
	(class LlvmInlineAsm): Add LlvmInlineAsm hir node.
	* hir/tree/rust-hir-full-decls.h (class LlvmInlineAsm): Add
	LlvmInlineAsm hir node forward declaration.
	* hir/tree/rust-hir-visitor.h: Add visit functions for LlvmInlineAsm
	hir node.
	* hir/tree/rust-hir.cc (LlvmInlineAsm::accept_vis): Add hir node
	visitor related functions.
	* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit):
	Type check input and output operands.
	* typecheck/rust-hir-type-check-expr.h: Add function prototype.
	* ast/rust-ast-visitor.cc (DefaultASTVisitor::visit): Visit input and
	output operand expressions.
	* resolve/rust-ast-resolve-expr.cc (ResolveExpr::visit): Resolve input
	and output expressions.
	* resolve/rust-ast-resolve-expr.h: Add function prototypes.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

1 files changed, 208 insertions, 0 deletions

diff --git a/gcc/rust/expand/rust-macro-builtins-asm.cc b/gcc/rust/expand/rust-macro-builtins-asm.cc
index d905ae9..633fe24 100644
--- a/gcc/rust/expand/rust-macro-builtins-asm.cc
+++ b/gcc/rust/expand/rust-macro-builtins-asm.cc
@@ -22,6 +22,7 @@
 #include "rust-ast.h"
 #include "rust-fmt.h"
 #include "rust-stmt.h"
+#include "rust-parse.h"
 
 namespace Rust {
 std::map<AST::InlineAsmOption, std::string> InlineAsmOptionMap{
@@ -980,6 +981,184 @@ validate (InlineAsmContext inline_asm_ctx)
   return tl::expected<InlineAsmContext, InlineAsmParseError> (inline_asm_ctx);
 }
 
+tl::optional<LlvmAsmContext>
+parse_llvm_templates (LlvmAsmContext ctx)
+{
+  auto &parser = ctx.parser;
+
+  auto token = parser.peek_current_token ();
+
+  if (token->get_id () == ctx.last_token_id
+      || token->get_id () != STRING_LITERAL)
+    {
+      return tl::nullopt;
+    }
+
+  ctx.llvm_asm.get_templates ().emplace_back (token->get_locus (),
+					      strip_double_quotes (
+						token->as_string ()));
+  ctx.parser.skip_token ();
+
+  token = parser.peek_current_token ();
+  if (token->get_id () != ctx.last_token_id && token->get_id () != COLON
+      && token->get_id () != SCOPE_RESOLUTION)
+    {
+      // We do not handle multiple template string, we provide minimal support
+      // for the black_box intrinsics.
+      rust_unreachable ();
+    }
+
+  return ctx;
+}
+
+tl::optional<LlvmAsmContext>
+parse_llvm_arguments (LlvmAsmContext ctx)
+{
+  auto &parser = ctx.parser;
+  enum State
+  {
+    Templates = 0,
+    Output,
+    Input,
+    Clobbers,
+    Options
+  } current_state
+    = State::Templates;
+
+  while (parser.peek_current_token ()->get_id () != ctx.last_token_id
+	 && parser.peek_current_token ()->get_id () != END_OF_FILE)
+    {
+      if (parser.peek_current_token ()->get_id () == SCOPE_RESOLUTION)
+	{
+	  parser.skip_token (SCOPE_RESOLUTION);
+	  current_state = static_cast<State> (current_state + 2);
+	}
+      else
+	{
+	  parser.skip_token (COLON);
+	  current_state = static_cast<State> (current_state + 1);
+	}
+
+      switch (current_state)
+	{
+	case State::Output:
+	  parse_llvm_outputs (ctx);
+	  break;
+	case State::Input:
+	  parse_llvm_inputs (ctx);
+	  break;
+	case State::Clobbers:
+	  parse_llvm_clobbers (ctx);
+	  break;
+	case State::Options:
+	  parse_llvm_options (ctx);
+	  break;
+	case State::Templates:
+	default:
+	  rust_unreachable ();
+	}
+    }
+
+  return ctx;
+}
+
+void
+parse_llvm_operands (LlvmAsmContext &ctx, std::vector<AST::LlvmOperand> &result)
+{
+  auto &parser = ctx.parser;
+  auto token = parser.peek_current_token ();
+  while (token->get_id () != COLON && token->get_id () != SCOPE_RESOLUTION
+	 && token->get_id () != ctx.last_token_id)
+    {
+      std::string constraint;
+      if (token->get_id () == STRING_LITERAL)
+	{
+	  constraint = strip_double_quotes (token->as_string ());
+	}
+      parser.skip_token (STRING_LITERAL);
+      parser.skip_token (LEFT_PAREN);
+
+      token = parser.peek_current_token ();
+
+      ParseRestrictions restrictions;
+      restrictions.expr_can_be_null = true;
+      auto expr = parser.parse_expr ();
+
+      parser.skip_token (RIGHT_PAREN);
+
+      result.emplace_back (constraint, std::move (expr));
+
+      if (parser.peek_current_token ()->get_id () == COMMA)
+	parser.skip_token (COMMA);
+
+      token = parser.peek_current_token ();
+    }
+}
+
+void
+parse_llvm_outputs (LlvmAsmContext &ctx)
+{
+  parse_llvm_operands (ctx, ctx.llvm_asm.get_outputs ());
+}
+
+void
+parse_llvm_inputs (LlvmAsmContext &ctx)
+{
+  parse_llvm_operands (ctx, ctx.llvm_asm.get_inputs ());
+}
+
+void
+parse_llvm_clobbers (LlvmAsmContext &ctx)
+{
+  auto &parser = ctx.parser;
+  auto token = parser.peek_current_token ();
+  while (token->get_id () != COLON && token->get_id () != ctx.last_token_id)
+    {
+      if (token->get_id () == STRING_LITERAL)
+	{
+	  ctx.llvm_asm.get_clobbers ().push_back (
+	    {strip_double_quotes (token->as_string ()), token->get_locus ()});
+	}
+      parser.skip_token (STRING_LITERAL);
+      token = parser.peek_current_token ();
+    }
+}
+
+void
+parse_llvm_options (LlvmAsmContext &ctx)
+{
+  auto &parser = ctx.parser;
+  auto token = parser.peek_current_token ();
+
+  while (token->get_id () != ctx.last_token_id)
+    {
+      if (token->get_id () == STRING_LITERAL)
+	{
+	  auto token_str = strip_double_quotes (token->as_string ());
+
+	  if (token_str == "volatile")
+	    ctx.llvm_asm.set_volatile (true);
+	  else if (token_str == "alignstack")
+	    ctx.llvm_asm.set_align_stack (true);
+	  else if (token_str == "intel")
+	    ctx.llvm_asm.set_dialect (AST::LlvmInlineAsm::Dialect::Intel);
+	  else
+	    rust_error_at (token->get_locus (),
+			   "Unknown llvm assembly option %qs",
+			   token_str.c_str ());
+	}
+      parser.skip_token (STRING_LITERAL);
+
+      token = parser.peek_current_token ();
+
+      if (token->get_id () == ctx.last_token_id)
+	continue;
+      parser.skip_token (COMMA);
+    }
+
+  parser.skip_token ();
+}
+
 tl::optional<AST::Fragment>
 parse_llvm_asm (location_t invoc_locus, AST::MacroInvocData &invoc,
 		AST::InvocKind semicolon, AST::AsmKind is_global_asm)
@@ -989,6 +1168,35 @@ parse_llvm_asm (location_t invoc_locus, AST::MacroInvocData &invoc,
   auto last_token_id = macro_end_token (invoc.get_delim_tok_tree (), parser);
 
   AST::LlvmInlineAsm llvm_asm{invoc_locus};
+
+  auto asm_ctx = LlvmAsmContext (llvm_asm, parser, last_token_id);
+
+  auto resulting_context
+    = parse_llvm_templates (asm_ctx).and_then (parse_llvm_arguments);
+
+  if (resulting_context)
+    {
+      auto node = (*resulting_context).llvm_asm.clone_expr_without_block ();
+
+      std::vector<AST::SingleASTNode> single_vec = {};
+
+      // If the macro invocation has a semicolon (`asm!("...");`), then we
+      // need to make it a statement. This way, it will be expanded
+      // properly.
+      if (semicolon == AST::InvocKind::Semicoloned)
+	single_vec.emplace_back (AST::SingleASTNode (
+	  std::make_unique<AST::ExprStmt> (std::move (node), invoc_locus,
+					   semicolon
+					     == AST::InvocKind::Semicoloned)));
+      else
+	single_vec.emplace_back (AST::SingleASTNode (std::move (node)));
+
+      AST::Fragment fragment_ast
+	= AST::Fragment (single_vec,
+			 std::vector<std::unique_ptr<AST::Token>> ());
+      return fragment_ast;
+    }
+  return tl::nullopt;
 }
 
 } // namespace Rust