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, 53 insertions, 8 deletions

diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index 0dfb4e5..fdb6360 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -4885,6 +4885,27 @@ struct InlineAsmRegOrRegClass
   location_t locus;
 };
 
+struct LlvmOperand
+{
+  std::string constraint;
+  std::unique_ptr<Expr> expr;
+
+  LlvmOperand (std::string constraint, std::unique_ptr<Expr> &&expr)
+    : constraint (constraint), expr (std::move (expr))
+  {}
+
+  LlvmOperand (const LlvmOperand &other)
+    : constraint (other.constraint), expr (other.expr->clone_expr ())
+  {}
+  LlvmOperand &operator= (const LlvmOperand &other)
+  {
+    constraint = other.constraint;
+    expr = other.expr->clone_expr ();
+
+    return *this;
+  }
+};
+
 class InlineAsmOperand
 {
 public:
@@ -5258,6 +5279,7 @@ struct TupleTemplateStr
   location_t loc;
   std::string symbol;
 
+  location_t get_locus () { return loc; }
   TupleTemplateStr (location_t loc, const std::string &symbol)
     : loc (loc), symbol (symbol)
   {}
@@ -5335,18 +5357,23 @@ class LlvmInlineAsm : public ExprWithoutBlock
   // llvm_asm!("" :         : "r"(&mut dummy) : "memory" : "volatile");
   //           Asm, Outputs, Inputs,            Clobbers, Options,
 
-private:
-  location_t locus;
-  std::vector<Attribute> outer_attrs;
-
-  std::vector<TupleClobber> clobber_abi;
-  bool is_volatile;
-  bool align_stack;
+public:
   enum class Dialect
   {
     Att,
     Intel,
-  } dialect;
+  };
+
+private:
+  location_t locus;
+  std::vector<Attribute> outer_attrs;
+  std::vector<LlvmOperand> inputs;
+  std::vector<LlvmOperand> outputs;
+  std::vector<TupleTemplateStr> templates;
+  std::vector<TupleClobber> clobbers;
+  bool volatility;
+  bool align_stack;
+  Dialect dialect;
 
 public:
   LlvmInlineAsm (location_t locus) : locus (locus) {}
@@ -5372,10 +5399,28 @@ public:
     return new LlvmInlineAsm (*this);
   }
 
+  std::vector<TupleTemplateStr> &get_templates () { return templates; }
+
   Expr::Kind get_expr_kind () const override
   {
     return Expr::Kind::LlvmInlineAsm;
   }
+
+  void set_align_stack (bool align_stack) { this->align_stack = align_stack; }
+  bool is_stack_aligned () { return align_stack; }
+
+  void set_volatile (bool volatility) { this->volatility = volatility; }
+  bool is_volatile () { return volatility; }
+
+  void set_dialect (Dialect dialect) { this->dialect = dialect; }
+
+  void set_inputs (std::vector<LlvmOperand> operands) { inputs = operands; }
+  void set_outputs (std::vector<LlvmOperand> operands) { outputs = operands; }
+
+  std::vector<LlvmOperand> &get_inputs () { return inputs; }
+  std::vector<LlvmOperand> &get_outputs () { return outputs; }
+
+  std::vector<TupleClobber> &get_clobbers () { return clobbers; }
 };
 
 } // namespace AST