[Xtensa] Add vector conversion builtins

Intrinsics: __builtin_xtensa_ae_int32x2 and builtin_xtensa_int32
are convenience functions for easy integer-vector and vector-vector
conversions that conform to Xtensa coding style.
Xtensa C dialect allows for implicit conversion between wider and
narrower vector (via shuffle) and between integer and any vector (via
broadcast). Standard Clang vectors do not support this, so these
functions provide a handicap for better portability.

Author: maciej-czekaj

clang/include/clang/Basic/BuiltinsXtensaHIFI.def

@@ -2614,4 +2614,6 @@ BUILTIN(__builtin_xtensa_wur_ae_tablesize, "vi", "n")
 // void __builtin_xtensa_wur_ae_ts_fts_bu_bp(int art)
 BUILTIN(__builtin_xtensa_wur_ae_ts_fts_bu_bp, "vi", "n")
 
-#undef BUILTIN
+// Type conversion builtins
+BUILTIN(__builtin_xtensa_ae_int32x2, "V2i.", "nct")
+BUILTIN(__builtin_xtensa_ae_int32, "V1i.", "nct")

clang/include/clang/Sema/Sema.h

@@ -13641,7 +13641,8 @@ class Sema final {
   bool CheckNVPTXBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                      CallExpr *TheCall);
   bool CheckXtensaBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
- 
+  bool SemaBuiltinXtensaConversion(unsigned BuiltinID, CallExpr *TheCall);
+
   bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
   bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
   bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);

clang/lib/CodeGen/CGBuiltin.cpp

@@ -20596,12 +20596,61 @@ llvm::Value *CodeGenFunction::ConvertXtensaToBc(const Expr *ArgExpr,
   }
   return ArgCast;
 }
+llvm::Value *
+CodeGenFunction::EmitXtensaConversionExpr(unsigned BuiltinID, const CallExpr *E,
+                                          ReturnValueSlot ReturnValue,
+                                          llvm::Triple::ArchType Arch) {
+  unsigned MaxElems;
+  switch (BuiltinID) {
+  case Xtensa::BI__builtin_xtensa_ae_int32x2:
+    MaxElems = 2;
+    break;
+  case Xtensa::BI__builtin_xtensa_ae_int32:
+    MaxElems = 1;
+    break;
+  default:
+    llvm_unreachable("Unknown intrinsic ID");
+  }
+
+  Value *ArgVal = EmitScalarExpr(E->getArg(0));
+  QualType QT = E->getArg(0)->getType();
+  if (auto *VecTy = QT->getAs<VectorType>()) {
+    unsigned NumEl = VecTy->getNumElements();
+    llvm::Type *ElType = ConvertType(VecTy->getElementType());
+    if (ElType != Int32Ty || NumEl > MaxElems) {
+      CGM.Error(E->getExprLoc(), "Expected int32x1 or int32x2");
+      return ArgVal;
+    }
+    if (NumEl == MaxElems)
+      return ArgVal; // no-op
+    int Mask[] = {0,0};
+    Value *Result =
+        Builder.CreateShuffleVector(ArgVal, ArgVal, ArrayRef(Mask, MaxElems));
+    return Result;
+  } else if (QT->isIntegerType()) {
+    Value *Int32Val = (QT->isSignedIntegerType())
+                          ? Builder.CreateSExtOrTrunc(ArgVal, Int32Ty, "cast")
+                          : Builder.CreateZExtOrTrunc(ArgVal, Int32Ty, "cast");
+    Value *VecOps[] = {Int32Val,Int32Val};
+    Value *Result = BuildVector(ArrayRef(VecOps, MaxElems));
+    return Result;
+  }
+  llvm_unreachable("Invalid Argument type");
+}
 
 llvm::Value *
 CodeGenFunction::EmitXtensaBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
                                        ReturnValueSlot ReturnValue,
                                        llvm::Triple::ArchType Arch) {
 
+  switch (BuiltinID) {
+  case Xtensa::BI__builtin_xtensa_ae_int32x2:
+  case Xtensa::BI__builtin_xtensa_ae_int32:
+    return EmitXtensaConversionExpr(BuiltinID, E, ReturnValue, Arch);
+  default:
+    break;
+  };
+
   XtensaIntrinsicInfo Info = GetXtensaIntrinsic(BuiltinID);
   unsigned Intrinsic = Info.IntrinsicID;
 

clang/lib/CodeGen/CodeGenFunction.h

@@ -4424,6 +4424,9 @@ class CodeGenFunction : public CodeGenTypeCache {
   llvm::Value *EmitXtensaBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
                                      ReturnValueSlot ReturnValue,
                                      llvm::Triple::ArchType Arch);
+  llvm::Value *EmitXtensaConversionExpr(unsigned BuiltinID, const CallExpr *E,
+                                        ReturnValueSlot ReturnValue,
+                                        llvm::Triple::ArchType Arch);
   //===--------------------------------------------------------------------===//
   //                           Expression Emission
   //===--------------------------------------------------------------------===//

clang/lib/Sema/SemaChecking.cpp

@@ -5739,10 +5739,51 @@ bool Sema::CheckXtensaBuiltinFunctionCall(unsigned BuiltinID,
            SemaBuiltinConstantArgRange(TheCall, 3, 0, 7) &&
            SemaBuiltinConstantArgRange(TheCall, 4, 0, 7) &&
            SemaBuiltinConstantArgRange(TheCall, 5, 0, 7);
+  case Xtensa::BI__builtin_xtensa_ae_int32x2:
+  case Xtensa::BI__builtin_xtensa_ae_int32:
+    return SemaBuiltinXtensaConversion(BuiltinID, TheCall);
   }
   return SemaBuiltinConstantArgRange(TheCall, i, l, u);
 }
 
+bool Sema::SemaBuiltinXtensaConversion(unsigned BuiltinID, CallExpr *TheCall) {
+  unsigned MaxElems;
+  switch (BuiltinID) {
+  case Xtensa::BI__builtin_xtensa_ae_int32x2:
+    MaxElems = 2;
+    break;
+  case Xtensa::BI__builtin_xtensa_ae_int32:
+    MaxElems = 1;
+    break;
+  default:
+    llvm_unreachable("Unknown intrinsic ID");
+  }
+  if (checkArgCount(*this, TheCall, 1))
+    return true;
+  Expr *Arg = TheCall->getArg(0);
+  QualType QT = Arg->getType();
+  if (auto *VecTy = QT->getAs<VectorType>()) {
+    unsigned NumEl = VecTy->getNumElements();
+    QualType ElType = VecTy->getElementType();
+    unsigned ElWidth = Context.getIntWidth(ElType);
+    QualType VecType = Context.getVectorType(Context.IntTy, MaxElems,
+                                             VectorType::GenericVector);
+    if (ElWidth != 32 || NumEl > MaxElems)
+      return Diag(TheCall->getBeginLoc(),
+                  diag::err_typecheck_convert_incompatible)
+             << QT << VecType << 1 << 0 << 0;
+    return false;
+  } else {
+    if (!QT->isIntegerType())
+      return Diag(TheCall->getBeginLoc(),
+                  diag::err_typecheck_convert_incompatible)
+             << QT << Context.IntTy << 1 << 0 << 0;
+
+    return false;
+  }
+  return false;
+}
+
 void Sema::checkRVVTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D) {
   const TargetInfo &TI = Context.getTargetInfo();
   // (ELEN, LMUL) pairs of (8, mf8), (16, mf4), (32, mf2), (64, m1) requires at
@@ -5776,7 +5817,6 @@ bool Sema::CheckNVPTXBuiltinFunctionCall(const TargetInfo &TI,
   case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
     return checkArgCountAtMost(*this, TheCall, 3);
   }
-
   return false;
 }
 

clang/test/CodeGen/Xtensa/xtensa-hifi-conversions.c

@@ -0,0 +1,48 @@
+// RUN: split-file %s %t
+// RUN: %clang -target xtensa -mcpu=cnl -S -emit-llvm -O1 -o - %t/correct.c | FileCheck %t/correct.c
+// RUN: not %clang -target xtensa -mcpu=cnl -S -emit-llvm -O1 -o - %t/bad_vec.c 2>&1 | FileCheck %t/bad_vec.c
+
+//--- correct.c
+
+typedef int ae_int32 __attribute__(( vector_size(4)));
+typedef int ae_int32x2 __attribute__(( vector_size(8)));
+
+ae_int32x2 test_ae_int32x2_from_int(int a) {
+// CHECK-LABEL: @test_ae_int32x2_from_int(i
+// CHECK:       %[[INS:.*]] = insertelement <2 x i32> poison, i32 %{{.*}}, i64 0
+// CHECK:       %[[SHUF:.*]] = shufflevector <2 x i32> %[[INS]], <2 x i32> poison, <2 x i32> zeroinitializer
+// CHECK:       ret <2 x i32> %[[SHUF]]
+return __builtin_xtensa_ae_int32x2(a);
+}
+
+ae_int32x2 test_ae_int32x2_from_ae_int32(ae_int32 a) {
+// CHECK-LABEL: @test_ae_int32x2_from_ae_int32(
+// CHECK:       %[[SHUF:.*]] = shufflevector <1 x i32> %{{.*}}, <1 x i32> poison, <2 x i32> zeroinitializer
+// CHECK:       ret <2 x i32> %[[SHUF]]
+return __builtin_xtensa_ae_int32x2(a);
+}
+
+ae_int32x2 test_ae_int32x2_from_ae_int32x2(ae_int32x2 a) {
+// CHECK: {{.*}}<2 x i32> @test_ae_int32x2_from_ae_int32x2(<2 x i32>{{.*}} %[[A:.*]])
+// CHECK:       ret <2 x i32> %[[A]]
+return __builtin_xtensa_ae_int32x2(a);
+}
+
+ae_int32x2 test_ae_int32x2_from_short(short a) {
+// CHECK-LABEL: @test_ae_int32x2_from_short(
+// CHECK:       %[[SEXT:.*]] = sext i16 %{{.*}} to i32
+// CHECK:       %[[INS:.*]] = insertelement <2 x i32> poison, i32 %[[SEXT]], i64 0
+// CHECK:       %[[SHUF:.*]] = shufflevector <2 x i32> %[[INS]], <2 x i32> poison, <2 x i32> zeroinitializer
+// CHECK:       ret <2 x i32> %[[SHUF]]
+return __builtin_xtensa_ae_int32x2(a);
+}
+
+//--- bad_vec.c
+
+typedef short ae_int16x4 __attribute__(( vector_size(8)));
+typedef int ae_int32x2 __attribute__(( vector_size(8)));
+
+ae_int32x2 test_ae_int32x2_from_bad_vec(ae_int16x4 a) {
+// CHECK: error: passing 'ae_int16x4' {{.*}} to parameter of incompatible type
+return __builtin_xtensa_ae_int32x2(a);
+}