[Matrix] Add __builtin_matrix_scalar_multiply to Clang (WIP).

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

[fhahn]

Superseded by D76794

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
 
 BUILTIN(__builtin_matrix_insert,  "v.", "nt")
 BUILTIN(__builtin_matrix_extract, "v.", "nt")
 BUILTIN(__builtin_matrix_subtract, "v.", "nt")
 BUILTIN(__builtin_matrix_add, "v.", "nt")
 BUILTIN(__builtin_matrix_multiply, "v.", "nt")
 BUILTIN(__builtin_matrix_transpose, "v.", "nFt")
+BUILTIN(__builtin_matrix_scalar_multiply, "v.", "nFt")
 BUILTIN(__builtin_matrix_column_load, "v.", "nFt")
 BUILTIN(__builtin_matrix_column_store, "v.", "nFt")
 
 // "Overloaded" Atomic operator builtins.  These are overloaded to support data
 // types of i8, i16, i32, i64, and i128.  The front-end sees calls to the
 // non-suffixed version of these (which has a bogus type) and transforms them to
 // the right overloaded version in Sema (plus casts).
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_builtin_matrix_type_match: Error<
   "Matrix types must match">;
 
 def err_builtin_matrix_dimension_error: Error<
   "Matrix dimensions do not match operation">;
 
 def err_builtin_matrix_implicit_cast_error: Error<
   "Implicit cast to from %0 to %1 failed">;
 
+def err_builtin_matrix_scalar_type_error: Error<
+  "%select{First|Scalar}0 argument must be a "
+  "%select{matrix|float or integer}0">;
+
 def err_preserve_field_info_not_field : Error<
   "__builtin_preserve_field_info argument %0 not a field access">;
 def err_preserve_field_info_not_const: Error<
   "__builtin_preserve_field_info argument %0 not a constant">;
 
 def err_bit_cast_non_trivially_copyable : Error<
   "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
 def err_bit_cast_type_size_mismatch : Error<

clang/include/clang/Sema/Sema.h

private:
 
   // Matrix Builtin intrinsic handling.
   ExprResult SemaBuiltinMatrixInsertOverload(CallExpr *TheCall,
                                              ExprResult CallResult);
   ExprResult SemaBuiltinExtractMatrixOverload(CallExpr *TheCall,
                                               ExprResult CallResult);
   ExprResult SemaBuiltinMatrixEltwiseOverload(CallExpr *TheCall,
                                               ExprResult CallResult);
+  ExprResult SemaBuiltinMatrixScalarOverload(CallExpr *TheCall,
+                                             ExprResult CallResult);
   ExprResult SemaBuiltinMatrixMultiplyOverload(CallExpr *TheCall,
                                                ExprResult CallResult);
   ExprResult SemaBuiltinMatrixTransposeOverload(CallExpr *TheCall,
                                                 ExprResult CallResult);
 
   ExprResult SemaBuiltinMatrixColumnLoadOverload(CallExpr *TheCall,
                                                  ExprResult CallResult);
   ExprResult SemaBuiltinMatrixColumnStoreOverload(CallExpr *TheCall,

clang/lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_matrix_multiply: {
     const MatrixType *Matrix1Ty = getMatrixTy(E->getArg(0)->getType());
     const MatrixType *Matrix2Ty = getMatrixTy(E->getArg(1)->getType());
     Value *Result = MB.CreateMatrixMultiply(
         Matrix1, Matrix2, Matrix1Ty->getNumRows(), Matrix1Ty->getNumColumns(),
         Matrix2Ty->getNumColumns());
     return RValue::get(Result);
   }
 
+  case Builtin::BI__builtin_matrix_scalar_multiply: {
+    MatrixBuilder<CGBuilderTy> MB(Builder);
+    Value *Matrix = EmitScalarExpr(E->getArg(0));
+    Value *Scalar = EmitScalarExpr(E->getArg(1));
+    Value *Result = MB.CreateScalarMultiply(Matrix, Scalar);
+    return RValue::get(Result);
+  }
+
   case Builtin::BIfinite:
   case Builtin::BI__finite:
   case Builtin::BIfinitef:
   case Builtin::BI__finitef:
   case Builtin::BIfinitel:
   case Builtin::BI__finitel:
   case Builtin::BI__builtin_isinf:
   case Builtin::BI__builtin_isfinite: {

clang/lib/Sema/SemaChecking.cpp

case Builtin::BI__builtin_os_log_format_buffer_size:
     break;
 
   case Builtin::BI__builtin_matrix_insert:
   case Builtin::BI__builtin_matrix_extract:
   case Builtin::BI__builtin_matrix_add:
   case Builtin::BI__builtin_matrix_subtract:
   case Builtin::BI__builtin_matrix_multiply:
   case Builtin::BI__builtin_matrix_transpose:
+  case Builtin::BI__builtin_matrix_scalar_multiply:
   case Builtin::BI__builtin_matrix_column_load:
   case Builtin::BI__builtin_matrix_column_store:
     if (!getLangOpts().EnableMatrix) {
       Diag(TheCall->getBeginLoc(), diag::err_builtin_matrix_disabled);
       return ExprError();
     }
 
     switch (BuiltinID) {
     case Builtin::BI__builtin_matrix_insert:
       return SemaBuiltinMatrixInsertOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_extract:
       return SemaBuiltinExtractMatrixOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_add:
     case Builtin::BI__builtin_matrix_subtract:
       return SemaBuiltinMatrixEltwiseOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_multiply:
       return SemaBuiltinMatrixMultiplyOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_transpose:
       return SemaBuiltinMatrixTransposeOverload(TheCall, TheCallResult);
+    case Builtin::BI__builtin_matrix_scalar_multiply:
+      return SemaBuiltinMatrixScalarOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_column_load:
       return SemaBuiltinMatrixColumnLoadOverload(TheCall, TheCallResult);
     case Builtin::BI__builtin_matrix_column_store:
       return SemaBuiltinMatrixColumnStoreOverload(TheCall, TheCallResult);
     default:
       llvm_unreachable("All matrix builtins should be handled here!");
     }
   }
ExprResult Sema::SemaBuiltinMatrixTransposeOverload(CallExpr *TheCall,
 
   // Change the result type of the call to match the original value type. This
   // is arbitrary, but the codegen for these builtins ins design to handle it
   // gracefully.
   TheCall->setType(ResultType);
   return CallResult;
 }
 
+ExprResult Sema::SemaBuiltinMatrixScalarOverload(CallExpr *TheCall,
+                                                 ExprResult CallResult) {
+  if (checkArgCount(*this, TheCall, 2)) {
+    return ExprError();
+  }
+
+  // First argument must be a matrix type
+  Expr *MatrixArg = TheCall->getArg(0);
+  Expr *ScalarArg = TheCall->getArg(1);
+
+  if (!MatrixArg->getType()->isMatrixType()) {
+    Diag(MatrixArg->getBeginLoc(), diag::err_builtin_matrix_scalar_type_error)
+        << 0;
+    return ExprError();
+  }
+
+  MatrixType const *MType =
+      cast<MatrixType const>(MatrixArg->getType().getCanonicalType());
+
+  // If the scalar type and matrix type don't match, try to cast it, otherwise,
+  // be sad
+  if (MType->getElementType() != ScalarArg->getType()) {
+    ExprResult TypeCastRes = ImplicitCastExpr::Create(
+        Context, MType->getElementType(), CK_IntegralToFloating, ScalarArg,
+        nullptr, VK_RValue);
+
+    if (!ScalarArg->getType()->isFloatingType() &&
+        !ScalarArg->getType()->isIntegralType(Context)) {
+      Diag(ScalarArg->getBeginLoc(), diag::err_builtin_matrix_scalar_type_error)
+          << 1;
+      return ExprError();
+    }
+
+    if (TypeCastRes.isInvalid()) {
+      Diag(MatrixArg->getBeginLoc(),
+           diag::err_builtin_matrix_implicit_cast_error)
+          << MType->getElementType() << ScalarArg->getType();
+      return ExprError();
+    }
+
+    ScalarArg = TypeCastRes.get();
+    TheCall->setArg(1, ScalarArg);
+  }
+
+  if (!MatrixArg->isRValue()) {
+    ExprResult CastExprResult = ImplicitCastExpr::Create(
+        Context, MatrixArg->getType(), CK_LValueToRValue, MatrixArg, nullptr,
+        VK_RValue);
+    assert(!CastExprResult.isInvalid() && "Matrix cast to R-value failed");
+    MatrixArg = CastExprResult.get();
+    TheCall->setArg(0, MatrixArg);
+  }
+
+  // Create the new function prototype
+  llvm::SmallVector<QualType, 2> ParameterTypes = {MatrixArg->getType(),
+                                                   ScalarArg->getType()};
+
+  Expr *Callee = TheCall->getCallee();
+  DeclRefExpr *DRE = cast<DeclRefExpr>(Callee->IgnoreParenCasts());
+  FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
+
+  // Create a new DeclRefExpr to refer to the new decl.
+  DeclRefExpr *NewDRE = DeclRefExpr::Create(
+      Context, DRE->getQualifierLoc(), SourceLocation(), FDecl,
+      /*enclosing*/ false, DRE->getLocation(), Context.BuiltinFnTy,
+      DRE->getValueKind(), nullptr, nullptr, DRE->isNonOdrUse());
+
+  // Set the callee in the CallExpr.
+  // FIXME: This loses syntactic information.
+  QualType CalleePtrTy = Context.getPointerType(FDecl->getType());
+  ExprResult PromotedCall = ImpCastExprToType(NewDRE, CalleePtrTy,
+                                              CK_BuiltinFnToFnPtr);
+  TheCall->setCallee(PromotedCall.get());
+
+  // Change the result type of the call to match the original value type. This
+  // is arbitrary, but the codegen for these builtins ins design to handle it
+  // gracefully.
+  TheCall->setType(MatrixArg->getType());
+
+
+  return CallResult;
+}
+
 ExprResult Sema::SemaBuiltinMatrixColumnLoadOverload(CallExpr *TheCall,
                                                      ExprResult CallResult) {
   // Must have exactly four operands
   // 1: Pointer to data
   // 2: Rows (constant)
   // 3: Columns (constant)
   // 5: Stride