WebAssembly: add basic int/fp instruction codegen.

[jfb]

Summary

This patch has the most basic instruction codegen for 32 and 64 bit int/fp.

[sunfish]

lgtm, with a few comments:

lib/Target/WebAssembly/WebAssemblyInstrFloat.td

24 ↗

(On Diff #29702)

This should use ftrunc, rather than frint.

Since WebAssembly doesn't expose floating-point exceptions, frint should map to the nearestint operator, similar to fnearbyint.

39 ↗

(On Diff #29702)

WebAssembly's current min and max operators return NaN if either operand is NaN, so they aren't the same as LLVM's fminnum and fmaxnum. (Actual minNum and maxNum operators are being considered as possible future features.)

It's fine to just defer defining these for now. The NEON backends have similar instructions and will serve as examples of how to utilize them, when we're ready.

lib/Target/WebAssembly/WebAssemblyInstrFormats.td

33 ↗

(On Diff #29702)

It's common and nice to prefix multiclass def names with an underscore, since they are concatenated onto the end of the instruction names they expand into. ADD_I32 will be nicer than ADDI32, especially as we add more opcodes where the concatenation can lead to ambiguous-looking names.

[jfb]

• Address sunfish's comments.

[jfb]

Comments addressed.

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrFloat.td

 // WebAssemblyInstrFloat.td-WebAssembly Float codegen support ---*- tablegen -*-
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief WebAssembly Floating-point operand code-gen constructs.
 ///
 //===----------------------------------------------------------------------===//
 
+defm FADD : BinaryFP<fadd>;
+defm FSUB : BinaryFP<fsub>;
+defm FMUL : BinaryFP<fmul>;
+defm FDIV : BinaryFP<fdiv>;
+defm FABS : UnaryFP<fabs>;
+defm FNEG : UnaryFP<fneg>;
+defm COPYSIGN : BinaryFP<fcopysign>;
+defm CEIL : UnaryFP<fceil>;
+defm FLOOR : UnaryFP<ffloor>;
+defm TRUNC : UnaryFP<ftrunc>;
+defm NEARESTINT : UnaryFP<fnearbyint>;
+
 /*
  * TODO(jfb): Add the following for 32-bit and 64-bit.
  *
- * float32.add: addition
- * float32.sub: subtraction
- * float32.mul: multiplication
- * float32.div: division
- * float32.abs: absolute value
- * float32.neg: negation
- * float32.copysign: copysign
- * float32.ceil: ceiling operation
- * float32.floor: floor operation
- * float32.trunc: round to nearest integer towards zero
- * float32.nearestint: round to nearest integer, ties to even
  * float32.eq: compare equal
  * float32.lt: less than
  * float32.le: less than or equal
  * float32.gt: greater than
  * float32.ge: greater than or equal
- * float32.sqrt: square root
+ */
+
+defm SQRT : UnaryFP<fsqrt>;
+
+/*
+ * TODO(jfb): Add the following for 32-bit and 64-bit.
+ *
  * float32.min: minimum (binary operator); if either operand is NaN, returns NaN
  * float32.max: maximum (binary operator); if either operand is NaN, returns NaN
  */

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrFormats.td

 
 // Normal instructions
 class I<dag oops, dag iops, list<dag> pattern, string cstr = "">
     : WebAssemblyInst<cstr> {
   dag OutOperandList = oops;
   dag InOperandList  = iops;
   let Pattern        = pattern;
 }
+
+// Unary and binary instructions, for the local types that WebAssembly supports.
+multiclass UnaryInt<SDNode node> {
+  def _I32 : I<(outs Int32:$dst), (ins Int32:$src),
+               [(set Int32:$dst, (node Int32:$src))]>;
+  def _I64 : I<(outs Int64:$dst), (ins Int64:$src),
+               [(set Int64:$dst, (node Int64:$src))]>;
+}
+multiclass BinaryInt<SDNode node> {
+  def _I32 : I<(outs Int32:$dst), (ins Int32:$lhs, Int32:$rhs),
+               [(set Int32:$dst, (node Int32:$lhs, Int32:$rhs))]>;
+  def _I64 : I<(outs Int64:$dst), (ins Int64:$lhs, Int64:$rhs),
+               [(set Int64:$dst, (node Int64:$lhs, Int64:$rhs))]>;
+}
+multiclass UnaryFP<SDNode node> {
+  def _F32 : I<(outs Float32:$dst), (ins Float32:$src),
+               [(set Float32:$dst, (node Float32:$src))]>;
+  def _F64 : I<(outs Float64:$dst), (ins Float64:$src),
+               [(set Float64:$dst, (node Float64:$src))]>;
+}
+multiclass BinaryFP<SDNode node> {
+  def _F32 : I<(outs Float32:$dst), (ins Float32:$lhs, Float32:$rhs),
+               [(set Float32:$dst, (node Float32:$lhs, Float32:$rhs))]>;
+  def _F64 : I<(outs Float64:$dst), (ins Float64:$lhs, Float64:$rhs),
+               [(set Float64:$dst, (node Float64:$lhs, Float64:$rhs))]>;
+}

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrInteger.td

 // WebAssemblyInstrInteger.td-WebAssembly Integer codegen -------*- tablegen -*-
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief WebAssembly Integer operand code-gen constructs.
 ///
 //===----------------------------------------------------------------------===//
 
+defm ADD : BinaryInt<add>;
+defm SUB : BinaryInt<sub>;
+defm MUL : BinaryInt<mul>;
+defm SDIV : BinaryInt<sdiv>;
+defm UDIV : BinaryInt<udiv>;
+defm SREM : BinaryInt<srem>;
+defm UREM : BinaryInt<urem>;
+defm AND : BinaryInt<and>;
+defm IOR : BinaryInt<or>;
+defm XOR : BinaryInt<xor>;
+defm SHL : BinaryInt<shl>;
+defm SHR : BinaryInt<srl>;
+defm SAR : BinaryInt<sra>;
+
 /*
  * TODO(jfb): Add the following for 32-bit and 64-bit.
  *
- * int32.add: signed-less addition
- * int32.sub: signed-less subtraction
- * int32.mul: signed-less multiplication (lower 32-bits)
- * int32.sdiv: signed division
- * int32.udiv: unsigned division
- * int32.srem: signed remainder
- * int32.urem: unsigned remainder
- * int32.and: signed-less logical and
- * int32.ior: signed-less inclusive or
- * int32.xor: signed-less exclusive or
- * int32.shl: signed-less shift left
- * int32.shr: signed-less logical shift right
- * int32.sar: signed-less arithmetic shift right
  * int32.eq: signed-less compare equal
  * int32.slt: signed less than
  * int32.sle: signed less than or equal
  * int32.ult: unsigned less than
  * int32.ule: unsigned less than or equal
  * int32.sgt: signed greater than
  * int32.sge: signed greater than or equal
  * int32.ugt: unsigned greater than
  * int32.uge: unsigned greater than or equal
- * int32.clz: count leading zeroes (defined for all values, including zero)
- * int32.ctz: count trailing zeroes (defined for all values, including zero)
- * int32.popcnt: count number of ones
  */
+
+defm CLZ : UnaryInt<ctlz>;
+defm CTZ : UnaryInt<cttz>;
+defm POPCNT : UnaryInt<ctpop>;