[Clang][VE] Add vector load intrinsics

[kaz7]

Summary

Add vector load intrinsic instructions for VE.

[kaz7]

Add intrinsics for not only VLD instructions but also VLD2D instructions

clang/include/clang/Basic/BuiltinsVE.def

+//===--- BuiltinsVE.def - VE Builtin function database ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the VE-specific builtin function database.  Users of
+// this file must define the BUILTIN macro to make use of this information.
+//
+//===----------------------------------------------------------------------===//
+
+// Use generated BUILTIN definitions
+#include "clang/Basic/BuiltinsVEVL.gen.def"
+
+#undef BUILTIN

clang/include/clang/Basic/BuiltinsVEVL.gen.def

+BUILTIN(__builtin_ve_vl_vld_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vld_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldnc_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldnc_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldu_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldu_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldunc_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldunc_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldlsx_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldlsx_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldlsxnc_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldlsxnc_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldlzx_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldlzx_vssvl, "V256dLUivC*V256dUi", "n")
+BUILTIN(__builtin_ve_vl_vldlzxnc_vssl, "V256dLUivC*Ui", "n")
+BUILTIN(__builtin_ve_vl_vldlzxnc_vssvl, "V256dLUivC*V256dUi", "n")

clang/include/clang/Basic/TargetBuiltins.h

 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 #include "clang/Basic/BuiltinsX86_64.def"
     LastTSBuiltin
   };
   }
 
   /// VE builtins
   namespace VE {
-  enum { LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, LastTSBuiltin };
+  enum {
+    LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
+#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#include "clang/Basic/BuiltinsVE.def"
+    LastTSBuiltin
+  };
   }
 
   namespace RISCVVector {
   enum {
     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 #include "clang/Basic/BuiltinsRISCVVector.def"
     FirstTSBuiltin,

clang/include/clang/module.modulemap

module Clang_Basic {
   textual header "Basic/BuiltinsMips.def"
   textual header "Basic/BuiltinsNEON.def"
   textual header "Basic/BuiltinsNVPTX.def"
   textual header "Basic/BuiltinsPPC.def"
   textual header "Basic/BuiltinsRISCV.def"
   textual header "Basic/BuiltinsRISCVVector.def"
   textual header "Basic/BuiltinsSVE.def"
   textual header "Basic/BuiltinsSystemZ.def"
+  textual header "Basic/BuiltinsVE.def"
   textual header "Basic/BuiltinsWebAssembly.def"
   textual header "Basic/BuiltinsX86.def"
   textual header "Basic/BuiltinsX86_64.def"
   textual header "Basic/BuiltinsXCore.def"
   textual header "Basic/CodeGenOptions.def"
   textual header "Basic/DiagnosticOptions.def"
   textual header "Basic/Features.def"
   textual header "Basic/FPOptions.def"

clang/lib/Basic/Targets/VE.cpp

 #include "VE.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
 
 using namespace clang;
 using namespace clang::targets;
 
+const Builtin::Info VETargetInfo::BuiltinInfo[] = {
+#define BUILTIN(ID, TYPE, ATTRS)                                               \
+  {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
+#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
+  {#ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr},
+#include "clang/Basic/BuiltinsVE.def"
+};
+
 void VETargetInfo::getTargetDefines(const LangOptions &Opts,
                                     MacroBuilder &Builder) const {
   Builder.defineMacro("_LP64", "1");
   Builder.defineMacro("unix", "1");
   Builder.defineMacro("__unix__", "1");
   Builder.defineMacro("__linux__", "1");
   Builder.defineMacro("__ve", "1");
   Builder.defineMacro("__ve__", "1");
   Builder.defineMacro("__STDC_HOSTED__", "1");
   Builder.defineMacro("__STDC__", "1");
   Builder.defineMacro("__NEC__", "1");
   // FIXME: define __FAST_MATH__ 1 if -ffast-math is enabled
   // FIXME: define __OPTIMIZE__ n if -On is enabled
   // FIXME: define __VECTOR__ n 1 if automatic vectorization is enabled
 }
 
 ArrayRef<Builtin::Info> VETargetInfo::getTargetBuiltins() const {
-  return ArrayRef<Builtin::Info>();
+  return llvm::makeArrayRef(BuiltinInfo,
+                            clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin);
 }

clang/lib/Headers/CMakeLists.txt

set(files
   x86intrin.h
   xmmintrin.h
   xopintrin.h
   xsavecintrin.h
   xsaveintrin.h
   xsaveoptintrin.h
   xsavesintrin.h
   xtestintrin.h
+  velintrin.h
+  velintrin_gen.h
   )
 
 set(cuda_wrapper_files
   cuda_wrappers/algorithm
   cuda_wrappers/complex
   cuda_wrappers/new
 )
 

clang/lib/Headers/velintrin.h

+/*===---- velintrin.h - VEL intrinsics for VE ------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __VEL_INTRIN_H__
+#define __VEL_INTRIN_H__
+
+// Vector registers
+typedef double __vr __attribute__((__vector_size__(2048)));
+
+// TODO: Vector mask registers
+// Depend on https://reviews.llvm.org/D88905
+#if 0
+#if __STDC_VERSION__ >= 199901L
+// For C99
+typedef _Bool __vm    __attribute__((ext_vector_type(256)));
+typedef _Bool __vm256 __attribute__((ext_vector_type(256)));
+typedef _Bool __vm512 __attribute__((ext_vector_type(512)));
+#else
+#ifdef __cplusplus
+// For C++
+typedef bool __vm    __attribute__((ext_vector_type(256)));
+typedef bool __vm256 __attribute__((ext_vector_type(256)));
+typedef bool __vm512 __attribute__((ext_vector_type(512)));
+#else
+#error need C++ or C99 to use vector intrinsics for VE
+#endif
+#endif
+#endif
+
+// Use generated intrinsic name definitions
+#include <velintrin_gen.h>
+
+#endif

clang/lib/Headers/velintrin_gen.h

+#define _vel_vld_vssl __builtin_ve_vl_vld_vssl
+#define _vel_vld_vssvl __builtin_ve_vl_vld_vssvl
+#define _vel_vldnc_vssl __builtin_ve_vl_vldnc_vssl
+#define _vel_vldnc_vssvl __builtin_ve_vl_vldnc_vssvl
+#define _vel_vldu_vssl __builtin_ve_vl_vldu_vssl
+#define _vel_vldu_vssvl __builtin_ve_vl_vldu_vssvl
+#define _vel_vldunc_vssl __builtin_ve_vl_vldunc_vssl
+#define _vel_vldunc_vssvl __builtin_ve_vl_vldunc_vssvl
+#define _vel_vldlsx_vssl __builtin_ve_vl_vldlsx_vssl
+#define _vel_vldlsx_vssvl __builtin_ve_vl_vldlsx_vssvl
+#define _vel_vldlsxnc_vssl __builtin_ve_vl_vldlsxnc_vssl
+#define _vel_vldlsxnc_vssvl __builtin_ve_vl_vldlsxnc_vssvl
+#define _vel_vldlzx_vssl __builtin_ve_vl_vldlzx_vssl
+#define _vel_vldlzx_vssvl __builtin_ve_vl_vldlzx_vssvl
+#define _vel_vldlzxnc_vssl __builtin_ve_vl_vldlzxnc_vssl
+#define _vel_vldlzxnc_vssvl __builtin_ve_vl_vldlzxnc_vssvl

clang/test/CodeGen/VE/ve-velintrin.c

+// REQUIRES: ve-registered-target
+
+// RUN: %clang_cc1 -S -emit-llvm -triple ve-unknown-linux-gnu \
+// RUN:   -ffreestanding %s -o - | FileCheck %s
+
+#include <velintrin.h>
+
+__vr vr1;
+
+void __attribute__((noinline))
+test_vld_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vld_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vld.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vld_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vld_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vld_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vld.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vld_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldnc_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldnc_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldnc.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldnc_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldnc_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldnc_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldnc.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldnc_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldu_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldu_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldu.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldu_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldu_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldu_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldu.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldu_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldunc_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldunc_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldunc.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldunc_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldunc_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldunc_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldunc.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldunc_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldlsx_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlsx_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlsx.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldlsx_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldlsx_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlsx_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlsx.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldlsx_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldlsxnc_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlsxnc_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlsxnc.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldlsxnc_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldlsxnc_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlsxnc_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlsxnc.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldlsxnc_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldlzx_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlzx_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlzx.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldlzx_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldlzx_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlzx_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlzx.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldlzx_vssvl(idx, p, vr1, 256);
+}
+
+void __attribute__((noinline))
+test_vldlzxnc_vssl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlzxnc_vssl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlzxnc.vssl(i64 %{{.*}}, i8* %{{.*}}, i32 256)
+  vr1 = _vel_vldlzxnc_vssl(idx, p, 256);
+}
+
+void __attribute__((noinline))
+test_vldlzxnc_vssvl(char* p, long idx) {
+  // CHECK-LABEL: @test_vldlzxnc_vssvl
+  // CHECK: call <256 x double> @llvm.ve.vl.vldlzxnc.vssvl(i64 %{{.*}}, i8* %{{.*}}, <256 x double> %{{.*}}, i32 256)
+  vr1 = _vel_vldlzxnc_vssvl(idx, p, vr1, 256);
+}