Rewrite OpenCL explicit conversion builtins handling (#2464)

Check that builtin is valid mostly by matching the regular expression - remove unneeded checks.
This is a follow-up to #2443

Author: vmaksimo

lib/SPIRV/OCLToSPIRV.cpp

@@ -744,56 +744,26 @@ void OCLToSPIRVBase::visitCallConvert(CallInst *CI, StringRef MangledName,
   if (auto *VecTy = dyn_cast<VectorType>(SrcTy))
     SrcTy = VecTy->getElementType();
   auto IsTargetInt = isa<IntegerType>(TargetTy);
-  auto TargetSigned = DemangledName[8] != 'u';
 
-  std::string TargetTyName(
-      DemangledName.substr(strlen(kOCLBuiltinName::ConvertPrefix)));
-  auto FirstUnderscoreLoc = TargetTyName.find('_');
-  if (FirstUnderscoreLoc != std::string::npos)
-    TargetTyName = TargetTyName.substr(0, FirstUnderscoreLoc);
-
-  // Validate target type name
-  std::regex Expr("([a-z]+)([0-9]*)$");
+  // Validate conversion function name and vector size if present
+  std::regex Expr(
+      "convert_(float|double|half|u?char|u?short|u?int|u?long)(2|3|4|8|16)*"
+      "(_sat)*(_rt[ezpn])*$");
   std::smatch DestTyMatch;
-  if (!std::regex_match(TargetTyName, DestTyMatch, Expr))
+  std::string ConversionFunc(DemangledName.str());
+  if (!std::regex_match(ConversionFunc, DestTyMatch, Expr))
     return;
 
   // The first sub_match is the whole string; the next
-  // sub_match is the first parenthesized expression.
-  std::string DestTy = DestTyMatch[1].str();
-
-  // check it's valid type name
-  static std::unordered_set<std::string> ValidTypes = {
-      "float",  "double", "half", "char", "uchar", "short",
-      "ushort", "int",    "uint", "long", "ulong"};
-
-  if (ValidTypes.find(DestTy) == ValidTypes.end())
-    return;
-
-  // check that it's allowed vector size
-  std::string VecSize = DestTyMatch[2].str();
-  if (!VecSize.empty()) {
-    int Size = stoi(VecSize);
-    switch (Size) {
-    case 2:
-    case 3:
-    case 4:
-    case 8:
-    case 16:
-      break;
-    default:
-      return;
-    }
-  }
-  DemangledName = DemangledName.drop_front(
-      strlen(kOCLBuiltinName::ConvertPrefix) + TargetTyName.size());
-  TargetTyName = std::string("_R") + TargetTyName;
+  // sub_matches are the parenthesized expressions.
+  enum { TypeIdx = 1, VecSizeIdx = 2, SatIdx = 3, RoundingIdx = 4 };
+  std::string DestTy = DestTyMatch[TypeIdx].str();
+  std::string VecSize = DestTyMatch[VecSizeIdx].str();
+  std::string Sat = DestTyMatch[SatIdx].str();
+  std::string Rounding = DestTyMatch[RoundingIdx].str();
 
-  if (!DemangledName.empty() && !DemangledName.starts_with("_sat") &&
-      !DemangledName.starts_with("_rt"))
-    return;
+  bool TargetSigned = DestTy[0] != 'u';
 
-  std::string Sat = DemangledName.find("_sat") != StringRef::npos ? "_sat" : "";
   if (isa<IntegerType>(SrcTy)) {
     bool Signed = isLastFuncParamSigned(MangledName);
     if (IsTargetInt) {
@@ -810,13 +780,13 @@ void OCLToSPIRVBase::visitCallConvert(CallInst *CI, StringRef MangledName,
     } else
       OC = OpFConvert;
   }
-  auto Loc = DemangledName.find("_rt");
-  std::string Rounding;
-  if (Loc != StringRef::npos && !(isa<IntegerType>(SrcTy) && IsTargetInt)) {
-    Rounding = DemangledName.substr(Loc, 4).str();
-  }
+
+  if (!Rounding.empty() && (isa<IntegerType>(SrcTy) && IsTargetInt))
+    return;
+
   assert(CI->getCalledFunction() && "Unexpected indirect call");
-  mutateCallInst(CI, getSPIRVFuncName(OC, TargetTyName + Sat + Rounding));
+  mutateCallInst(
+      CI, getSPIRVFuncName(OC, "_R" + DestTy + VecSize + Sat + Rounding));
 }
 
 void OCLToSPIRVBase::visitCallGroupBuiltin(CallInst *CI,

test/transcoding/OpenCL/convert_functions.ll

@@ -11,13 +11,18 @@
 ; RUN: FileCheck < %t.rev.ll %s -check-prefix=CHECK-LLVM
 
 ; CHECK-SPIRV: Name [[#Func:]] "_Z18convert_float_func"
-; CHECK-SPIRV: TypeVoid [[#VoidTy:]]
-; CHECK-SPIRV: TypeFloat [[#FloatTy:]] 32
+; CHECK-SPIRV: Name [[#Func1:]] "_Z20convert_uint_satfunc"
+; CHECK-SPIRV: Name [[#Func2:]] "_Z21convert_float_rtzfunc"
+; CHECK-SPIRV-DAG: TypeVoid [[#VoidTy:]]
+; CHECK-SPIRV-DAG: TypeFloat [[#FloatTy:]] 32
 
 ; CHECK-SPIRV: Function [[#VoidTy]] [[#Func]]
 ; CHECK-SPIRV: ConvertSToF [[#FloatTy]] [[#ConvertId:]] [[#]]
 ; CHECK-SPIRV: FunctionCall [[#VoidTy]] [[#]] [[#Func]] [[#ConvertId]]
+; CHECK-SPIRV: FunctionCall [[#VoidTy]] [[#]] [[#Func1]] [[#]]
+; CHECK-SPIRV: FunctionCall [[#VoidTy]] [[#]] [[#Func2]] [[#ConvertId]]
 ; CHECK-SPIRV-NOT: FConvert
+; CHECK-SPIRV-NOT: ConvertUToF
 
 target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
 target triple = "spir"
@@ -30,16 +35,30 @@ entry:
   ret void
 }
 
+define dso_local spir_func void @_Z20convert_uint_satfunc(i32 noundef %x) #0 {
+entry:
+  ret void
+}
+
+define dso_local spir_func void @_Z21convert_float_rtzfunc(float noundef %x) #0 {
+entry:
+  ret void
+}
+
 ; Function Attrs: convergent noinline norecurse nounwind optnone
 define dso_local spir_func void @convert_int_bf16(i32 noundef %x) #0 {
 entry:
   %x.addr = alloca i32, align 4
   store i32 %x, ptr %x.addr, align 4
   %0 = load i32, ptr %x.addr, align 4
 ; CHECK-LLVM: %[[Call:[a-z]+]] = sitofp i32 %[[#]] to float
-  %call = call spir_func float @_Z13convert_floati(i32 noundef %0) #1
 ; CHECK-LLVM: call spir_func void @_Z18convert_float_func(float %[[Call]])
+; CHECK-LLVM: call spir_func void @_Z20convert_uint_satfunc(i32 %[[#]])
+; CHECK-LLVM: call spir_func void @_Z21convert_float_rtzfunc(float %[[Call]])
+  %call = call spir_func float @_Z13convert_floati(i32 noundef %0) #1
   call spir_func void @_Z18convert_float_func(float noundef %call) #0
+  call spir_func void @_Z20convert_uint_satfunc(i32 noundef %0) #0
+  call spir_func void @_Z21convert_float_rtzfunc(float noundef %call) #0
   ret void
 }