[WebAssembly] Add builtin functions for creating vector constants

[tlively]

Summary

These builtins do not offer any functionality over the normal
aggregate initialization for vector types, except that they enforce
that their arguments constant fold to integer expressions so they
always generate a vector constant. They are meant for use in the new
WebAssembly SIMD intrinsic header.

[tlively]

This CL does not provide a mechanism for enforcing that the lanes of a floating point vector are constant, and it doesn't look like clang supports that kind of check. That makes this CL a half-baked solution, so I'm not sure we should actually go in this direction.

clang/include/clang/Basic/BuiltinsWebAssembly.def

 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i32_f64, "id", "nc", "nontrapping-fptoint")
 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i32_f64, "id", "nc", "nontrapping-fptoint")
 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i64_f32, "LLif", "nc", "nontrapping-fptoint")
 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i64_f32, "LLif", "nc", "nontrapping-fptoint")
 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i64_f64, "LLid", "nc", "nontrapping-fptoint")
 TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i64_f64, "LLid", "nc", "nontrapping-fptoint")
 
 // SIMD builtins
+TARGET_BUILTIN(__builtin_wasm_const_i8x16, "V16cIcIcIcIcIcIcIcIcIcIcIcIcIcIcIcIc", "nc", "simd128")
+TARGET_BUILTIN(__builtin_wasm_const_i16x8, "V8sIsIsIsIsIsIsIsIs", "nc", "simd128")
+TARGET_BUILTIN(__builtin_wasm_const_i32x4, "V4iIiIiIiIi", "nc", "simd128")
+TARGET_BUILTIN(__builtin_wasm_const_i64x2, "V2LLiILLiILLi", "nc", "unimplemented-simd128")
+
 TARGET_BUILTIN(__builtin_wasm_extract_lane_s_i8x16, "iV16cIi", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_u_i8x16, "iV16cIi", "nc", "unimplemented-simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_s_i16x8, "iV8sIi", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_u_i16x8, "iV8sIi", "nc", "unimplemented-simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_i32x4, "iV4iIi", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_i64x2, "LLiV2LLiIi", "nc", "unimplemented-simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_f32x4, "fV4fIi", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_extract_lane_f64x2, "dV2dIi", "nc", "unimplemented-simd128")

clang/lib/CodeGen/CGBuiltin.cpp

Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
   case WebAssembly::BI__builtin_wasm_max_f32x4:
   case WebAssembly::BI__builtin_wasm_max_f64x2: {
     Value *LHS = EmitScalarExpr(E->getArg(0));
     Value *RHS = EmitScalarExpr(E->getArg(1));
     Function *Callee = CGM.getIntrinsic(Intrinsic::maximum,
                                      ConvertType(E->getType()));
     return Builder.CreateCall(Callee, {LHS, RHS});
   }
+  case WebAssembly::BI__builtin_wasm_const_i8x16:
+  case WebAssembly::BI__builtin_wasm_const_i16x8:
+  case WebAssembly::BI__builtin_wasm_const_i32x4:
+  case WebAssembly::BI__builtin_wasm_const_i64x2: {
+    SmallVector<llvm::Constant *, 16> Args;
+    for (size_t i = 0; i < E->getNumArgs(); ++i) {
+      llvm::APSInt Const;
+      if (!E->getArg(i)->isIntegerConstantExpr(Const, getContext()))
+        llvm_unreachable("Constant arg isn't actually constant?");
+      Args.push_back(llvm::ConstantInt::get(getLLVMContext(), Const));
+    }
+    return Builder.Insert(llvm::ConstantVector::get(Args));
+  }
   case WebAssembly::BI__builtin_wasm_extract_lane_s_i8x16:
   case WebAssembly::BI__builtin_wasm_extract_lane_u_i8x16:
   case WebAssembly::BI__builtin_wasm_extract_lane_s_i16x8:
   case WebAssembly::BI__builtin_wasm_extract_lane_u_i16x8:
   case WebAssembly::BI__builtin_wasm_extract_lane_i32x4:
   case WebAssembly::BI__builtin_wasm_extract_lane_i64x2:
   case WebAssembly::BI__builtin_wasm_extract_lane_f32x4:
   case WebAssembly::BI__builtin_wasm_extract_lane_f64x2: {

clang/test/CodeGen/builtins-wasm.c

 }
 
 double max_f64(double x, double y) {
   return __builtin_wasm_max_f64(x, y);
   // WEBASSEMBLY: call double @llvm.maximum.f64(double %x, double %y)
   // WEBASSEMBLY-NEXT: ret
 }
 
+i8x16 const_i8x16() {
+  // MISSING-SIMD: error: '__builtin_wasm_const_i8x16' needs target feature simd128
+  // WEBASSEMBLY: ret <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>
+  return __builtin_wasm_const_i8x16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+i16x8 const_i16x8() {
+  // WEBASSEMBLY: ret <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>
+  return __builtin_wasm_const_i16x8(0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+i32x4 const_i32x4() {
+  // WEBASSEMBLY: ret <4 x i32> <i32 0, i32 1, i32 2, i32 3>
+  return __builtin_wasm_const_i32x4(0, 1, 2, 3);
+}
+
+i64x2 const_i64x2() {
+  // WEBASSEMBLY: ret <2 x i64> <i64 0, i64 1>
+  return __builtin_wasm_const_i64x2(0, 1);
+}
 
 int extract_lane_s_i8x16(i8x16 v) {
   return __builtin_wasm_extract_lane_s_i8x16(v, 13);
-  // MISSING-SIMD: error: '__builtin_wasm_extract_lane_s_i8x16' needs target feature simd128
   // WEBASSEMBLY: extractelement <16 x i8> %v, i32 13
   // WEBASSEMBLY-NEXT: sext
   // WEBASSEMBLY-NEXT: ret
 }
 
 int extract_lane_u_i8x16(i8x16 v) {
   return __builtin_wasm_extract_lane_u_i8x16(v, 13);
   // WEBASSEMBLY: extractelement <16 x i8> %v, i32 13