unittests/Analysis/VectorFunctionABITest.cpp

   1 //===------- VectorFunctionABITest.cpp - VFABI Unittests  ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Analysis/VectorUtils.h"
  10 #include "gtest/gtest.h"
  11
  12 using namespace llvm;
  13
  14 // This test makes sure that the getFromVFABI method succeeds only on
  15 // valid values of the string.
  16 TEST(VectorFunctionABITests, OnlyValidNames) {
  17   // Incomplete string.
  18   EXPECT_FALSE(VFABI::tryDemangleForVFABI("").hasValue());
  19   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGV").hasValue());
  20   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVn").hasValue());
  21   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN").hasValue());
  22   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2").hasValue());
  23   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v").hasValue());
  24   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_").hasValue());
  25   // Missing parameters.
  26   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2_foo").hasValue());
  27   // Missing _ZGV prefix.
  28   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZVnN2v_foo").hasValue());
  29   // Missing <isa>.
  30   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVN2v_foo").hasValue());
  31   // Missing <mask>.
  32   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVn2v_foo").hasValue());
  33   // Missing <vlen>.
  34   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnNv_foo").hasValue());
  35   // Missing <scalarname>.
  36   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_").hasValue());
  37   // Missing _ separator.
  38   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2vfoo").hasValue());
  39   // Missing <vectorname>.
  40   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_foo()").hasValue());
  41   // Unterminated name.
  42   EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_foo(bar").hasValue());
  43 }
  44
  45 TEST(VectorFunctionABITests, ParamListParsing) {
  46   // Testing "vl16Ls32R3l"
  47   const auto OptVFS = VFABI::tryDemangleForVFABI("_ZGVnN2vl16Ls32R3l_foo");
  48   EXPECT_TRUE(OptVFS.hasValue());
  49   const VFInfo VFS = OptVFS.getValue();
  50   EXPECT_EQ(VFS.Shape.Parameters.size(), (unsigned)5);
  51   EXPECT_EQ(VFS.Shape.Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
  52   EXPECT_EQ(VFS.Shape.Parameters[1],
  53             VFParameter({1, VFParamKind::OMP_Linear, 16}));
  54   EXPECT_EQ(VFS.Shape.Parameters[2],
  55             VFParameter({2, VFParamKind::OMP_LinearValPos, 32}));
  56   EXPECT_EQ(VFS.Shape.Parameters[3],
  57             VFParameter({3, VFParamKind::OMP_LinearRef, 3}));
  58   EXPECT_EQ(VFS.Shape.Parameters[4],
  59             VFParameter({4, VFParamKind::OMP_Linear, 1}));
  60 }
  61
  62 TEST(VectorFunctionABITests, ScalarNameAndVectorName) {
  63   // Parse Scalar Name
  64   const auto A = VFABI::tryDemangleForVFABI("_ZGVnM2v_sin");
  65   const auto B = VFABI::tryDemangleForVFABI("_ZGVnM2v_sin(UserFunc)");
  66   const auto C = VFABI::tryDemangleForVFABI("_ZGVnM2v___sin_sin_sin");
  67   EXPECT_TRUE(A.hasValue());
  68   EXPECT_TRUE(B.hasValue());
  69   EXPECT_TRUE(C.hasValue());
  70   EXPECT_EQ(A.getValue().ScalarName, "sin");
  71   EXPECT_EQ(B.getValue().ScalarName, "sin");
  72   EXPECT_EQ(C.getValue().ScalarName, "__sin_sin_sin");
  73   EXPECT_EQ(A.getValue().VectorName, "_ZGVnM2v_sin");
  74   EXPECT_EQ(B.getValue().VectorName, "UserFunc");
  75   EXPECT_EQ(C.getValue().VectorName, "_ZGVnM2v___sin_sin_sin");
  76 }
  77
  78 namespace {
  79 // Test fixture needed that holds the veariables needed by the parser.
  80 class VFABIParserTest : public ::testing::Test {
  81 private:
  82   // Parser output.
  83   VFInfo Info;
  84   // Reset the parser output references.
  85   void reset() { Info = VFInfo(); }
  86
  87 protected:
  88   // Referencies to the parser output field.
  89   unsigned &VF = Info.Shape.VF;
  90   VFISAKind &ISA = Info.Shape.ISA;
  91   SmallVector<VFParameter, 8> &Parameters = Info.Shape.Parameters;
  92   StringRef &ScalarName = Info.ScalarName;
  93   StringRef &VectorName = Info.VectorName;
  94   bool &IsScalable = Info.Shape.IsScalable;
  95   // Invoke the parser.
  96   bool invokeParser(const StringRef MangledName) {
  97     reset();
  98     const auto OptInfo = VFABI::tryDemangleForVFABI(MangledName);
  99     if (OptInfo.hasValue()) {
 100       Info = OptInfo.getValue();
 101       return true;
 102     }
 103
 104     return false;
 105   }
 106   // Checks that 1. the last Parameter in the Shape is of type
 107   // VFParamKind::GlobalPredicate and 2. it is the only one of such
 108   // type.
 109   bool IsMasked() const {
 110     const auto NGlobalPreds =
 111         std::count_if(Info.Shape.Parameters.begin(),
 112                       Info.Shape.Parameters.end(), [](const VFParameter PK) {
 113                         return PK.ParamKind == VFParamKind::GlobalPredicate;
 114                       });
 115     return NGlobalPreds == 1 && Info.Shape.Parameters.back().ParamKind ==
 116                                     VFParamKind::GlobalPredicate;
 117   }
 118 };
 119 } // unnamed namespace
 120
 121 TEST_F(VFABIParserTest, Parse) {
 122   EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin"));
 123   EXPECT_EQ(VF, (unsigned)2);
 124   EXPECT_FALSE(IsMasked());
 125   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 126   EXPECT_FALSE(IsScalable);
 127   EXPECT_EQ(Parameters.size(), (unsigned)9);
 128   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
 129   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearPos, 2}));
 130   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearValPos, 27}));
 131   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}));
 132   EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}));
 133   EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_Linear, 1}));
 134   EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearVal, 10}));
 135   EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, 100}));
 136   EXPECT_EQ(Parameters[8], VFParameter({8, VFParamKind::OMP_LinearRef, 1000}));
 137   EXPECT_EQ(ScalarName, "sin");
 138   EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin");
 139 }
 140
 141 TEST_F(VFABIParserTest, ParseVectorName) {
 142   EXPECT_TRUE(invokeParser("_ZGVnN2v_sin(my_v_sin)"));
 143   EXPECT_EQ(VF, (unsigned)2);
 144   EXPECT_FALSE(IsMasked());
 145   EXPECT_FALSE(IsScalable);
 146   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 147   EXPECT_EQ(Parameters.size(), (unsigned)1);
 148   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
 149   EXPECT_EQ(ScalarName, "sin");
 150   EXPECT_EQ(VectorName, "my_v_sin");
 151 }
 152
 153 TEST_F(VFABIParserTest, LinearWithCompileTimeNegativeStep) {
 154   EXPECT_TRUE(invokeParser("_ZGVnN2ln1Ln10Un100Rn1000_sin"));
 155   EXPECT_EQ(VF, (unsigned)2);
 156   EXPECT_FALSE(IsMasked());
 157   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 158   EXPECT_FALSE(IsScalable);
 159   EXPECT_EQ(Parameters.size(), (unsigned)4);
 160   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, -1}));
 161   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, -10}));
 162   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearUVal, -100}));
 163   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, -1000}));
 164   EXPECT_EQ(ScalarName, "sin");
 165   EXPECT_EQ(VectorName, "_ZGVnN2ln1Ln10Un100Rn1000_sin");
 166 }
 167
 168 TEST_F(VFABIParserTest, ParseScalableSVE) {
 169   EXPECT_TRUE(invokeParser("_ZGVsMxv_sin"));
 170   EXPECT_EQ(VF, (unsigned)0);
 171   EXPECT_TRUE(IsMasked());
 172   EXPECT_TRUE(IsScalable);
 173   EXPECT_EQ(ISA, VFISAKind::SVE);
 174   EXPECT_EQ(ScalarName, "sin");
 175   EXPECT_EQ(VectorName, "_ZGVsMxv_sin");
 176 }
 177
 178 TEST_F(VFABIParserTest, ParseFixedWidthSVE) {
 179   EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
 180   EXPECT_EQ(VF, (unsigned)2);
 181   EXPECT_TRUE(IsMasked());
 182   EXPECT_FALSE(IsScalable);
 183   EXPECT_EQ(ISA, VFISAKind::SVE);
 184   EXPECT_EQ(ScalarName, "sin");
 185   EXPECT_EQ(VectorName, "_ZGVsM2v_sin");
 186 }
 187
 188 TEST_F(VFABIParserTest, NotAVectorFunctionABIName) {
 189   // Vector names should start with `_ZGV`.
 190   EXPECT_FALSE(invokeParser("ZGVnN2v_sin"));
 191 }
 192
 193 TEST_F(VFABIParserTest, LinearWithRuntimeStep) {
 194   EXPECT_FALSE(invokeParser("_ZGVnN2ls_sin"))
 195       << "A number should be present after \"ls\".";
 196   EXPECT_TRUE(invokeParser("_ZGVnN2ls2_sin"));
 197   EXPECT_FALSE(invokeParser("_ZGVnN2Rs_sin"))
 198       << "A number should be present after \"Rs\".";
 199   EXPECT_TRUE(invokeParser("_ZGVnN2Rs4_sin"));
 200   EXPECT_FALSE(invokeParser("_ZGVnN2Ls_sin"))
 201       << "A number should be present after \"Ls\".";
 202   EXPECT_TRUE(invokeParser("_ZGVnN2Ls6_sin"));
 203   EXPECT_FALSE(invokeParser("_ZGVnN2Us_sin"))
 204       << "A number should be present after \"Us\".";
 205   EXPECT_TRUE(invokeParser("_ZGVnN2Us8_sin"));
 206 }
 207
 208 TEST_F(VFABIParserTest, LinearWithoutCompileTime) {
 209   EXPECT_TRUE(invokeParser("_ZGVnN3lLRUlnLnRnUn_sin"));
 210   EXPECT_EQ(Parameters.size(), (unsigned)8);
 211   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, 1}));
 212   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, 1}));
 213   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearRef, 1}));
 214   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUVal, 1}));
 215   EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_Linear, -1}));
 216   EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_LinearVal, -1}));
 217   EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearRef, -1}));
 218   EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, -1}));
 219 }
 220
 221 TEST_F(VFABIParserTest, ISA) {
 222   EXPECT_TRUE(invokeParser("_ZGVqN2v_sin"));
 223   EXPECT_EQ(ISA, VFISAKind::Unknown);
 224
 225   EXPECT_TRUE(invokeParser("_ZGVnN2v_sin"));
 226   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 227
 228   EXPECT_TRUE(invokeParser("_ZGVsN2v_sin"));
 229   EXPECT_EQ(ISA, VFISAKind::SVE);
 230
 231   EXPECT_TRUE(invokeParser("_ZGVbN2v_sin"));
 232   EXPECT_EQ(ISA, VFISAKind::SSE);
 233
 234   EXPECT_TRUE(invokeParser("_ZGVcN2v_sin"));
 235   EXPECT_EQ(ISA, VFISAKind::AVX);
 236
 237   EXPECT_TRUE(invokeParser("_ZGVdN2v_sin"));
 238   EXPECT_EQ(ISA, VFISAKind::AVX2);
 239
 240   EXPECT_TRUE(invokeParser("_ZGVeN2v_sin"));
 241   EXPECT_EQ(ISA, VFISAKind::AVX512);
 242 }
 243
 244 TEST_F(VFABIParserTest, InvalidMask) {
 245   EXPECT_FALSE(invokeParser("_ZGVsK2v_sin"));
 246 }
 247
 248 TEST_F(VFABIParserTest, InvalidParameter) {
 249   EXPECT_FALSE(invokeParser("_ZGVsM2vX_sin"));
 250 }
 251
 252 TEST_F(VFABIParserTest, Align) {
 253   EXPECT_TRUE(invokeParser("_ZGVsN2l2a2_sin"));
 254   EXPECT_EQ(Parameters.size(), (unsigned)1);
 255   EXPECT_EQ(Parameters[0].Alignment, Align(2));
 256
 257   // Missing alignement value.
 258   EXPECT_FALSE(invokeParser("_ZGVsM2l2a_sin"));
 259   // Invalid alignment token "x".
 260   EXPECT_FALSE(invokeParser("_ZGVsM2l2ax_sin"));
 261   // Alignment MUST be associated to a paramater.
 262   EXPECT_FALSE(invokeParser("_ZGVsM2a2_sin"));
 263   // Alignment must be a power of 2.
 264   EXPECT_FALSE(invokeParser("_ZGVsN2l2a0_sin"));
 265   EXPECT_TRUE(invokeParser("_ZGVsN2l2a1_sin"));
 266   EXPECT_FALSE(invokeParser("_ZGVsN2l2a3_sin"));
 267   EXPECT_FALSE(invokeParser("_ZGVsN2l2a6_sin"));
 268 }
 269
 270 TEST_F(VFABIParserTest, ParseUniform) {
 271   EXPECT_TRUE(invokeParser("_ZGVnN2u0_sin"));
 272   EXPECT_EQ(VF, (unsigned)2);
 273   EXPECT_FALSE(IsMasked());
 274   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 275   EXPECT_FALSE(IsScalable);
 276   EXPECT_EQ(Parameters.size(), (unsigned)1);
 277   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Uniform, 0}));
 278   EXPECT_EQ(ScalarName, "sin");
 279   EXPECT_EQ(VectorName, "_ZGVnN2u0_sin");
 280
 281   EXPECT_FALSE(invokeParser("_ZGVnN2u_sin"));
 282   EXPECT_FALSE(invokeParser("_ZGVnN2ul_sin"));
 283 }
 284
 285 TEST_F(VFABIParserTest, ISAIndependentMangling) {
 286   // This test makes sure that the mangling of the parameters in
 287   // independent on the <isa> token.
 288   const SmallVector<VFParameter, 8> ExpectedParams = {
 289       VFParameter({0, VFParamKind::Vector, 0}),
 290       VFParameter({1, VFParamKind::OMP_LinearPos, 2}),
 291       VFParameter({2, VFParamKind::OMP_LinearValPos, 27}),
 292       VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}),
 293       VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}),
 294       VFParameter({5, VFParamKind::OMP_Linear, 1}),
 295       VFParameter({6, VFParamKind::OMP_LinearVal, 10}),
 296       VFParameter({7, VFParamKind::OMP_LinearUVal, 100}),
 297       VFParameter({8, VFParamKind::OMP_LinearRef, 1000}),
 298       VFParameter({9, VFParamKind::OMP_Uniform, 2}),
 299   };
 300
 301 #define __COMMON_CHECKS                                                        \
 302   do {                                                                         \
 303     EXPECT_EQ(VF, (unsigned)2);                                                \
 304     EXPECT_FALSE(IsMasked());                                                  \
 305     EXPECT_FALSE(IsScalable);                                                  \
 306     EXPECT_EQ(Parameters.size(), (unsigned)10);                                \
 307     EXPECT_EQ(Parameters, ExpectedParams);                                     \
 308     EXPECT_EQ(ScalarName, "sin");                                              \
 309   } while (0)
 310
 311   // Advanced SIMD: <isa> = "n"
 312   EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 313   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 314   __COMMON_CHECKS;
 315   EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 316
 317   // SVE: <isa> = "s"
 318   EXPECT_TRUE(invokeParser("_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 319   EXPECT_EQ(ISA, VFISAKind::SVE);
 320   __COMMON_CHECKS;
 321   EXPECT_EQ(VectorName, "_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 322
 323   // SSE: <isa> = "b"
 324   EXPECT_TRUE(invokeParser("_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 325   EXPECT_EQ(ISA, VFISAKind::SSE);
 326   __COMMON_CHECKS;
 327   EXPECT_EQ(VectorName, "_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 328
 329   // AVX: <isa> = "c"
 330   EXPECT_TRUE(invokeParser("_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 331   EXPECT_EQ(ISA, VFISAKind::AVX);
 332   __COMMON_CHECKS;
 333   EXPECT_EQ(VectorName, "_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 334
 335   // AVX2: <isa> = "d"
 336   EXPECT_TRUE(invokeParser("_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 337   EXPECT_EQ(ISA, VFISAKind::AVX2);
 338   __COMMON_CHECKS;
 339   EXPECT_EQ(VectorName, "_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 340
 341   // AVX512: <isa> = "e"
 342   EXPECT_TRUE(invokeParser("_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 343   EXPECT_EQ(ISA, VFISAKind::AVX512);
 344   __COMMON_CHECKS;
 345   EXPECT_EQ(VectorName, "_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 346
 347   // Unknown ISA (randomly using "q"). This test will need update if
 348   // some targets decide to use "q" as their ISA token.
 349   EXPECT_TRUE(invokeParser("_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
 350   EXPECT_EQ(ISA, VFISAKind::Unknown);
 351   __COMMON_CHECKS;
 352   EXPECT_EQ(VectorName, "_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 353
 354 #undef __COMMON_CHECKS
 355 }
 356
 357 TEST_F(VFABIParserTest, MissingScalarName) {
 358   EXPECT_FALSE(invokeParser("_ZGVnN2v_"));
 359 }
 360
 361 TEST_F(VFABIParserTest, MissingVectorName) {
 362   EXPECT_FALSE(invokeParser("_ZGVnN2v_foo()"));
 363 }
 364
 365 TEST_F(VFABIParserTest, MissingVectorNameTermination) {
 366   EXPECT_FALSE(invokeParser("_ZGVnN2v_foo(bar"));
 367 }
 368
 369 TEST_F(VFABIParserTest, ParseMaskingNEON) {
 370   EXPECT_TRUE(invokeParser("_ZGVnM2v_sin"));
 371   EXPECT_EQ(VF, (unsigned)2);
 372   EXPECT_TRUE(IsMasked());
 373   EXPECT_FALSE(IsScalable);
 374   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
 375   EXPECT_EQ(Parameters.size(), (unsigned)2);
 376   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 377   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 378   EXPECT_EQ(ScalarName, "sin");
 379 }
 380
 381 TEST_F(VFABIParserTest, ParseMaskingSVE) {
 382   EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
 383   EXPECT_EQ(VF, (unsigned)2);
 384   EXPECT_TRUE(IsMasked());
 385   EXPECT_FALSE(IsScalable);
 386   EXPECT_EQ(ISA, VFISAKind::SVE);
 387   EXPECT_EQ(Parameters.size(), (unsigned)2);
 388   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 389   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 390   EXPECT_EQ(ScalarName, "sin");
 391 }
 392
 393 TEST_F(VFABIParserTest, ParseMaskingSSE) {
 394   EXPECT_TRUE(invokeParser("_ZGVbM2v_sin"));
 395   EXPECT_EQ(VF, (unsigned)2);
 396   EXPECT_TRUE(IsMasked());
 397   EXPECT_FALSE(IsScalable);
 398   EXPECT_EQ(ISA, VFISAKind::SSE);
 399   EXPECT_EQ(Parameters.size(), (unsigned)2);
 400   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 401   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 402   EXPECT_EQ(ScalarName, "sin");
 403 }
 404
 405 TEST_F(VFABIParserTest, ParseMaskingAVX) {
 406   EXPECT_TRUE(invokeParser("_ZGVcM2v_sin"));
 407   EXPECT_EQ(VF, (unsigned)2);
 408   EXPECT_TRUE(IsMasked());
 409   EXPECT_FALSE(IsScalable);
 410   EXPECT_EQ(ISA, VFISAKind::AVX);
 411   EXPECT_EQ(Parameters.size(), (unsigned)2);
 412   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 413   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 414   EXPECT_EQ(ScalarName, "sin");
 415 }
 416
 417 TEST_F(VFABIParserTest, ParseMaskingAVX2) {
 418   EXPECT_TRUE(invokeParser("_ZGVdM2v_sin"));
 419   EXPECT_EQ(VF, (unsigned)2);
 420   EXPECT_TRUE(IsMasked());
 421   EXPECT_FALSE(IsScalable);
 422   EXPECT_EQ(ISA, VFISAKind::AVX2);
 423   EXPECT_EQ(Parameters.size(), (unsigned)2);
 424   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 425   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 426   EXPECT_EQ(ScalarName, "sin");
 427 }
 428
 429 TEST_F(VFABIParserTest, ParseMaskingAVX512) {
 430   EXPECT_TRUE(invokeParser("_ZGVeM2v_sin"));
 431   EXPECT_EQ(VF, (unsigned)2);
 432   EXPECT_TRUE(IsMasked());
 433   EXPECT_FALSE(IsScalable);
 434   EXPECT_EQ(ISA, VFISAKind::AVX512);
 435   EXPECT_EQ(Parameters.size(), (unsigned)2);
 436   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
 437   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
 438   EXPECT_EQ(ScalarName, "sin");
 439 }