[Matrix] Implement C-style explicit type conversions for matrix types

[SaurabhJha]

Summary

[Matrix] Implement explicit type conversions for MatrixType.
Bugzilla ticket is here: https://bugs.llvm.org/show_bug.cgi?id=47141

[fhahn]

Thanks for the patch! I think this also needs changes in code-gen & code-gen tests.

clang/include/clang/Sema/Sema.h

11715

nit: casting beween

11717

nit: should be a full sentence and also go in the previous row?

[SaurabhJha]

In D99037#2640388, @fhahn wrote:

Thanks for the patch! I think this also needs changes in code-gen & code-gen tests.

Hey @fhahn I searched but could not find the relevant code-gen and code-gen tests I need to fix. Can you please point me to where vectors casts are handled in code gen? I could probably use that for matrices.

[fhahn]

Thanks for the patch! I think this also needs changes in code-gen & code-gen tests.

In D99037#2642598, @SaurabhJha wrote:

In D99037#2640388, @fhahn wrote:

Thanks for the patch! I think this also needs changes in code-gen & code-gen tests.

Hey @fhahn I searched but could not find the relevant code-gen and code-gen tests I need to fix. Can you please point me to where vectors casts are handled in code gen? I could probably use that for matrices.

I think you probably need to add new files for the tests, e.g. matrix-type-casts.cpp & matrix-type-casts.c and then just add tests for various valid cast combinations. Is that enough to get you started? You can look at some of the existing matrix codegen tests for inspiration for the run-line & CHECK lines.

[SaurabhJha]

I think you probably need to add new files for the tests, e.g. matrix-type-casts.cpp & matrix-type-casts.c and then just add tests for various valid cast combinations. Is that enough to get you started? You can look at some of the existing matrix codegen tests for inspiration for the run-line & CHECK lines.

Oh yes, missed the obvious thing I could have done, Cheers!

[SaurabhJha]

Hey @fhahn ,

I realise, as you pointed out before, that we need to do some changes in CodeGen too. I think its going to be more involved so before starting on that, it would be great if you can confirm whether I am on the right path. I will describe what I did, what happened, and what I inferred from that.

I ran this simple cast.

typedef char cx4x4 __attribute__((matrix_type(4, 4)));
typedef int ix4x4 __attribute__((matrix_type(4, 4)));
cx4x4 c = (cx4x4) i;

This crashed the compiler with this stack trace.

clang: /tmp/llvm/lib/IR/Instructions.cpp:2934: static llvm::CastInst *llvm::CastInst::Create(Instruction::CastOps, llvm::Value *, llvm::Type *, const llvm::Twine &, llvm::Instruction *): Assertion `castIsValid(op, S, Ty) && "Invalid cast!"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /tmp/build/bin/clang -cc1 -internal-isystem /tmp/build/lib/clang/13.0.0/include -nostdsysteminc -fenable-matrix -triple x86_64-apple-darwin /tmp/clang/test/CodeGen/matrix-cast.c -emit-llvm -disable-llvm-passes -o -
1.	<eof> parser at end of file
2.	/tmp/clang/test/CodeGen/matrix-cast.c:15:6: LLVM IR generation of declaration 'cast_char_matrix_to_int_same_size'
3.	/tmp/clang/test/CodeGen/matrix-cast.c:15:6: Generating code for declaration 'cast_char_matrix_to_int_same_size'
 #0 0x000000000972648a llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /tmp/llvm/lib/Support/Unix/Signals.inc:565:11
 #1 0x000000000972665b PrintStackTraceSignalHandler(void*) /tmp/llvm/lib/Support/Unix/Signals.inc:632:1
 #2 0x0000000009724c4b llvm::sys::RunSignalHandlers() /tmp/llvm/lib/Support/Signals.cpp:70:5
 #3 0x0000000009726dd1 SignalHandler(int) /tmp/llvm/lib/Support/Unix/Signals.inc:407:1
 #4 0x00007ff3d17353c0 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x153c0)
 #5 0x00007ff3d11e618b raise /build/glibc-eX1tMB/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #6 0x00007ff3d11c5859 abort /build/glibc-eX1tMB/glibc-2.31/stdlib/abort.c:81:7
 #7 0x00007ff3d11c5729 get_sysdep_segment_value /build/glibc-eX1tMB/glibc-2.31/intl/loadmsgcat.c:509:8
 #8 0x00007ff3d11c5729 _nl_load_domain /build/glibc-eX1tMB/glibc-2.31/intl/loadmsgcat.c:970:34
 #9 0x00007ff3d11d6f36 (/lib/x86_64-linux-gnu/libc.so.6+0x36f36)
#10 0x0000000008a5c1bf llvm::CastInst::Create(llvm::Instruction::CastOps, llvm::Value*, llvm::Type*, llvm::Twine const&, llvm::Instruction*) /tmp/llvm/lib/IR/Instructions.cpp:2936:11
#11 0x0000000006205834 llvm::IRBuilderBase::CreateCast(llvm::Instruction::CastOps, llvm::Value*, llvm::Type*, llvm::Twine const&) /tmp/llvm/include/llvm/IR/IRBuilder.h:2106:52
#12 0x00000000061ef472 llvm::IRBuilderBase::CreateBitCast(llvm::Value*, llvm::Type*, llvm::Twine const&) /tmp/llvm/include/llvm/IR/IRBuilder.h:2065:5
#13 0x0000000009fb1140 (anonymous namespace)::ScalarExprEmitter::VisitCastExpr(clang::CastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:2069:5
#14 0x0000000009fb002e (anonymous namespace)::ScalarExprEmitter::VisitExplicitCastExpr(clang::ExplicitCastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:563:5
#15 0x0000000009fa8493 clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::VisitCStyleCastExpr(clang::CStyleCastExpr*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:879:1
#16 0x0000000009fa2747 clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:879:1
#17 0x0000000009f976fb (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:410:3
#18 0x0000000009fa4f82 (anonymous namespace)::ScalarExprEmitter::VisitBinAssign(clang::BinaryOperator const*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4168:9
#19 0x0000000009fa157d clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/clang/include/clang/AST/StmtVisitor.h:72:26
#20 0x0000000009f976fb (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:410:3
#21 0x0000000009f97656 clang::CodeGen::CodeGenFunction::EmitScalarExpr(clang::Expr const*, bool) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4757:3
#22 0x0000000009e5638c clang::CodeGen::CodeGenFunction::EmitAnyExpr(clang::Expr const*, clang::CodeGen::AggValueSlot, bool) /tmp/clang/lib/CodeGen/CGExpr.cpp:218:12
#23 0x0000000009e562bd clang::CodeGen::CodeGenFunction::EmitIgnoredExpr(clang::Expr const*) /tmp/clang/lib/CodeGen/CGExpr.cpp:203:19
#24 0x0000000009fc3616 clang::CodeGen::CodeGenFunction::EmitStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) /tmp/clang/lib/CodeGen/CGStmt.cpp:118:5
#25 0x0000000009fcc7ab clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(clang::CompoundStmt const&, bool, clang::CodeGen::AggValueSlot) /tmp/clang/lib/CodeGen/CGStmt.cpp:447:3
#26 0x0000000009e2ebd1 clang::CodeGen::CodeGenFunction::EmitFunctionBody(clang::Stmt const*) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1187:5
#27 0x0000000009e2f675 clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl, llvm::Function*, clang::CodeGen::CGFunctionInfo const&) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1345:3
#28 0x0000000009ce448e clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:4786:3
#29 0x0000000009cdae4c clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:3172:12
#30 0x0000000009cdfec4 clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:2925:5
#31 0x0000000009ce7d10 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:5627:38
#32 0x000000000a83b2c2 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/ModuleBuilder.cpp:169:73
#33 0x000000000a8356b4 clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/CodeGenAction.cpp:215:12
#34 0x000000000cf8fab5 clang::ParseAST(clang::Sema&, bool, bool) /tmp/clang/lib/Parse/ParseAST.cpp:162:20
#35 0x000000000a65b742 clang::ASTFrontendAction::ExecuteAction() /tmp/clang/lib/Frontend/FrontendAction.cpp:1058:1
#36 0x000000000a831709 clang::CodeGenAction::ExecuteAction() /tmp/clang/lib/CodeGen/CodeGenAction.cpp:1039:5
#37 0x000000000a65b108 clang::FrontendAction::Execute() /tmp/clang/lib/Frontend/FrontendAction.cpp:953:7
#38 0x000000000a52fa45 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /tmp/clang/lib/Frontend/CompilerInstance.cpp:955:23
#39 0x000000000a81df96 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /tmp/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:278:8
#40 0x0000000006103d0d cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /tmp/clang/tools/driver/cc1_main.cpp:246:13
#41 0x00000000060f6759 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /tmp/clang/tools/driver/driver.cpp:335:5
#42 0x00000000060f58ee main /tmp/clang/tools/driver/driver.cpp:412:5
#43 0x00007ff3d11c70b3 __libc_start_main /build/glibc-eX1tMB/glibc-2.31/csu/../csu/libc-start.c:342:3
#44 0x00000000060f509e _start (/tmp/build/bin/clang+0x60f509e)

This cast is failing. And my suspicion is that's because we are not handling matrix types here. It seems like we need to define a matrix type in llvm/include/llvm/IR/Type.h and use that to handle castIsValid.

Do you think this is the right approach?

[fhahn]

In D99037#2649065, @SaurabhJha wrote:

Hey @fhahn ,

I realise, as you pointed out before, that we need to do some changes in CodeGen too. I think its going to be more involved so before starting on that, it would be great if you can confirm whether I am on the right path. I will describe what I did, what happened, and what I inferred from that.

I ran this simple cast.

typedef char cx4x4 __attribute__((matrix_type(4, 4)));
typedef int ix4x4 __attribute__((matrix_type(4, 4)));
cx4x4 c = (cx4x4) i;

This crashed the compiler with this stack trace.

clang: /tmp/llvm/lib/IR/Instructions.cpp:2934: static llvm::CastInst *llvm::CastInst::Create(Instruction::CastOps, llvm::Value *, llvm::Type *, const llvm::Twine &, llvm::Instruction *): Assertion `castIsValid(op, S, Ty) && "Invalid cast!"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /tmp/build/bin/clang -cc1 -internal-isystem /tmp/build/lib/clang/13.0.0/include -nostdsysteminc -fenable-matrix -triple x86_64-apple-darwin /tmp/clang/test/CodeGen/matrix-cast.c -emit-llvm -disable-llvm-passes -o -
1.	<eof> parser at end of file
2.	/tmp/clang/test/CodeGen/matrix-cast.c:15:6: LLVM IR generation of declaration 'cast_char_matrix_to_int_same_size'
3.	/tmp/clang/test/CodeGen/matrix-cast.c:15:6: Generating code for declaration 'cast_char_matrix_to_int_same_size'
 #0 0x000000000972648a llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /tmp/llvm/lib/Support/Unix/Signals.inc:565:11
 #1 0x000000000972665b PrintStackTraceSignalHandler(void*) /tmp/llvm/lib/Support/Unix/Signals.inc:632:1
 #2 0x0000000009724c4b llvm::sys::RunSignalHandlers() /tmp/llvm/lib/Support/Signals.cpp:70:5
 #3 0x0000000009726dd1 SignalHandler(int) /tmp/llvm/lib/Support/Unix/Signals.inc:407:1
 #4 0x00007ff3d17353c0 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x153c0)
 #5 0x00007ff3d11e618b raise /build/glibc-eX1tMB/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #6 0x00007ff3d11c5859 abort /build/glibc-eX1tMB/glibc-2.31/stdlib/abort.c:81:7
 #7 0x00007ff3d11c5729 get_sysdep_segment_value /build/glibc-eX1tMB/glibc-2.31/intl/loadmsgcat.c:509:8
 #8 0x00007ff3d11c5729 _nl_load_domain /build/glibc-eX1tMB/glibc-2.31/intl/loadmsgcat.c:970:34
 #9 0x00007ff3d11d6f36 (/lib/x86_64-linux-gnu/libc.so.6+0x36f36)
#10 0x0000000008a5c1bf llvm::CastInst::Create(llvm::Instruction::CastOps, llvm::Value*, llvm::Type*, llvm::Twine const&, llvm::Instruction*) /tmp/llvm/lib/IR/Instructions.cpp:2936:11
#11 0x0000000006205834 llvm::IRBuilderBase::CreateCast(llvm::Instruction::CastOps, llvm::Value*, llvm::Type*, llvm::Twine const&) /tmp/llvm/include/llvm/IR/IRBuilder.h:2106:52
#12 0x00000000061ef472 llvm::IRBuilderBase::CreateBitCast(llvm::Value*, llvm::Type*, llvm::Twine const&) /tmp/llvm/include/llvm/IR/IRBuilder.h:2065:5
#13 0x0000000009fb1140 (anonymous namespace)::ScalarExprEmitter::VisitCastExpr(clang::CastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:2069:5
#14 0x0000000009fb002e (anonymous namespace)::ScalarExprEmitter::VisitExplicitCastExpr(clang::ExplicitCastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:563:5
#15 0x0000000009fa8493 clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::VisitCStyleCastExpr(clang::CStyleCastExpr*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:879:1
#16 0x0000000009fa2747 clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:879:1
#17 0x0000000009f976fb (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:410:3
#18 0x0000000009fa4f82 (anonymous namespace)::ScalarExprEmitter::VisitBinAssign(clang::BinaryOperator const*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4168:9
#19 0x0000000009fa157d clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/clang/include/clang/AST/StmtVisitor.h:72:26
#20 0x0000000009f976fb (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:410:3
#21 0x0000000009f97656 clang::CodeGen::CodeGenFunction::EmitScalarExpr(clang::Expr const*, bool) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4757:3
#22 0x0000000009e5638c clang::CodeGen::CodeGenFunction::EmitAnyExpr(clang::Expr const*, clang::CodeGen::AggValueSlot, bool) /tmp/clang/lib/CodeGen/CGExpr.cpp:218:12
#23 0x0000000009e562bd clang::CodeGen::CodeGenFunction::EmitIgnoredExpr(clang::Expr const*) /tmp/clang/lib/CodeGen/CGExpr.cpp:203:19
#24 0x0000000009fc3616 clang::CodeGen::CodeGenFunction::EmitStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) /tmp/clang/lib/CodeGen/CGStmt.cpp:118:5
#25 0x0000000009fcc7ab clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(clang::CompoundStmt const&, bool, clang::CodeGen::AggValueSlot) /tmp/clang/lib/CodeGen/CGStmt.cpp:447:3
#26 0x0000000009e2ebd1 clang::CodeGen::CodeGenFunction::EmitFunctionBody(clang::Stmt const*) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1187:5
#27 0x0000000009e2f675 clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl, llvm::Function*, clang::CodeGen::CGFunctionInfo const&) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1345:3
#28 0x0000000009ce448e clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:4786:3
#29 0x0000000009cdae4c clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:3172:12
#30 0x0000000009cdfec4 clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:2925:5
#31 0x0000000009ce7d10 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:5627:38
#32 0x000000000a83b2c2 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/ModuleBuilder.cpp:169:73
#33 0x000000000a8356b4 clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/CodeGenAction.cpp:215:12
#34 0x000000000cf8fab5 clang::ParseAST(clang::Sema&, bool, bool) /tmp/clang/lib/Parse/ParseAST.cpp:162:20
#35 0x000000000a65b742 clang::ASTFrontendAction::ExecuteAction() /tmp/clang/lib/Frontend/FrontendAction.cpp:1058:1
#36 0x000000000a831709 clang::CodeGenAction::ExecuteAction() /tmp/clang/lib/CodeGen/CodeGenAction.cpp:1039:5
#37 0x000000000a65b108 clang::FrontendAction::Execute() /tmp/clang/lib/Frontend/FrontendAction.cpp:953:7
#38 0x000000000a52fa45 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /tmp/clang/lib/Frontend/CompilerInstance.cpp:955:23
#39 0x000000000a81df96 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /tmp/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:278:8
#40 0x0000000006103d0d cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /tmp/clang/tools/driver/cc1_main.cpp:246:13
#41 0x00000000060f6759 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /tmp/clang/tools/driver/driver.cpp:335:5
#42 0x00000000060f58ee main /tmp/clang/tools/driver/driver.cpp:412:5
#43 0x00007ff3d11c70b3 __libc_start_main /build/glibc-eX1tMB/glibc-2.31/csu/../csu/libc-start.c:342:3
#44 0x00000000060f509e _start (/tmp/build/bin/clang+0x60f509e)

This cast is failing. And my suspicion is that's because we are not handling matrix types here. It seems like we need to define a matrix type in llvm/include/llvm/IR/Type.h and use that to handle castIsValid.

Do you think this is the right approach?

There deliberately are no matrix types directly in LLVM. Instead, matrix values are embedded in vectors. The problem probably is that Clang does not handle matrix types and generates cast instructions between wrong types. You could try and confirm that using a debugger and printing the type of the value & the target type. The cast instructions (zext for casts between unsigned, sext between signed & fpext between floats, and the different truncate instructions) support casting vector types, but Clang needs updating to emit the correct casts (e.g. something like trunc <16 x i32> %m to <16 x i8> for your example).

To get an idea what instructions are used to convert between different types, you should be able to just take a look at the code generated for casts between the scalar types.

[rjmccall]

clang/lib/Sema/SemaCast.cpp

2325

The expected semantics for this conversion are not the ordinary bitwise-reinterpretation semantics of reinterpret_cast, so this really should not be allowed as a reinterpret_cast. Allowing it as a static_cast seems appropriate.

clang/lib/Sema/SemaExpr.cpp

7354

"Compatible" has a specific meaning in the C standard, so if you aren't intending to invoke that concept of compatibility, you should find a new word.

It looks like this kind of cast is supposed to be doing an elementwise conversion. I guess all the types you can have matrices of are interconvertible, so there are no restrictions on the element types. But you definitely need this to produce a new CastKind for elementwise conversion instead of using CK_BitCast, which does a bitwise reinterpretation, which is not what you want.

Matrix element types already have to be scalar types, so those checks aren't doing anything.

[SaurabhJha]

clang/lib/Sema/SemaExpr.cpp

7354

I see, so we need a new CK_MatrixCast, right?

[SaurabhJha]

Hey @fhahn @rjmccall ,

Thank you so much for your reviews. Apart from the rest of your comments, here are the two principle things I am going to do next:

1. Replace the reinterpret_castwith static_cast. Do you think I should focus this revision to C-style casts and do static_casts in another patch?
2. Create a new CK_MatrixCast and implement its handling.

Is there any existing code I can look at that can help me implement the handler code for CK_MatrixCast? I could look at vectors because I was doing CK_Bitcast but I don't think I can rely on that now. If there's no such existing code at the moment, that's not an issue. I think I should be able figure it out after I spend some more time on it.

Cheers,
Saurabh

[rjmccall]

In D99037#2659290, @SaurabhJha wrote:

Hey @fhahn @rjmccall ,

Thank you so much for your reviews. Apart from the rest of your comments, here are the two principle things I am going to do next:

1. Replace the reinterpret_castwith static_cast. Do you think I should focus this revision to C-style casts and do static_casts in another patch?

IIRC, making C-style casts work correctly in C++ will actually be easier if you make one of the specialized casts do it; I'd say go ahead and do it in static_cast.

Casts in C use basically a completely different code path.

2. Create a new CK_MatrixCast and implement its handling.

Is there any existing code I can look at that can help me implement the handler code for CK_MatrixCast? I could look at vectors because I was doing CK_Bitcast but I don't think I can rely on that now.

Right, vector casts are their own unfortunate thing which we don't want to semantically emulate.

What code do you want to get out of this? Are there e.g. vectorized float->double conversions we can use, or is the operation basically doomed to break the matrix apart and put it back together again?

[SaurabhJha]

Hey, I should mention that I am new to clang/llvm. My below thoughts could be wrong.

IIRC, making C-style casts work correctly in C++ will actually be easier if you make one of the specialized casts do it; I'd say go ahead and do it in static_cast.

Casts in C use basically a completely different code path.

Okay, then I think I will focus on static casts and C style casts for later. They use different functions, CheckStaticCast and CheckCStyleCast respectively and implementing static casts in matrix must involve change in CheckStaticCast and the function it calls.

Right, vector casts are their own unfortunate thing which we don't want to semantically emulate.

What code do you want to get out of this? Are there e.g. vectorized float->double conversions we can use, or is the operation basically doomed to break the matrix apart and put it back together again?

I think because matrices are vectors underneath, we should try vectorised conversions.

Thoughts?

Saurabh

[fhahn]

In D99037#2659477, @SaurabhJha wrote:

What code do you want to get out of this? Are there e.g. vectorized float->double conversions we can use, or is the operation basically doomed to break the matrix apart and put it back together again?

I think because matrices are vectors underneath, we should try vectorised conversions.

I think there should be vector versions of common conversions in most modern vector instruction sets, e.g. both ARM64 and X86 (with varying levels of support, depending on the supported vector extensions) have vector instructions for sign extend i32 -> i64 and floating point extension float -> double: https://godbolt.org/z/jx4Ya4PP5. John, please let me know if you were referring to something else, but IIUC then it would be best to emit vector conversion for the full vector (that should also be the easiest in terms of codegen).

More recent instruction set versions also have specialized instructions for things like dot-products, that also extend/truncate some of their operands and/or results., which we could also make use of easily if we have the vector conversions.

[rjmccall]

In D99037#2662414, @fhahn wrote:

In D99037#2659477, @SaurabhJha wrote:

What code do you want to get out of this? Are there e.g. vectorized float->double conversions we can use, or is the operation basically doomed to break the matrix apart and put it back together again?

I think because matrices are vectors underneath, we should try vectorised conversions.

I think there should be vector versions of common conversions in most modern vector instruction sets, e.g. both ARM64 and X86 (with varying levels of support, depending on the supported vector extensions) have vector instructions for sign extend i32 -> i64 and floating point extension float -> double: https://godbolt.org/z/jx4Ya4PP5. John, please let me know if you were referring to something else, but IIUC then it would be best to emit vector conversion for the full vector (that should also be the easiest in terms of codegen).

Okay. In that caae, this may be somewhat verbose because you'll have to analyze the element types in IRGen and ask the matrix-lowering code to do the appropriate conversion. Not tricky, just verbose.

[SaurabhJha]

Hey, elementary question about arcanist. I followed the steps here https://llvm.org/docs/Contributing.html#how-to-submit-a-patch and did

arc diff --edit --verbatim

on my current branch. Probably one mistake I did was to do a git reset HEAD~1 and create a new commit. Now its trying to create a new revision. Is that okay to create a new revision and abandoning this one?

[fhahn]

In D99037#2665030, @SaurabhJha wrote:

Hey, elementary question about arcanist. I followed the steps here https://llvm.org/docs/Contributing.html#how-to-submit-a-patch and did

arc diff --edit --verbatim

on my current branch. Probably one mistake I did was to do a git reset HEAD~1 and create a new commit. Now its trying to create a new revision. Is that okay to create a new revision and abandoning this one?

You can't add multiple commits to the same review on Phabricator. If you have multiple commits that you want to update this review with, you can squash them into the commit you used to create this patch and then upload the updated commit. If you have multiple commit but only want to upload the latest, you can use arc diff HEAD^

[SaurabhJha]

Hi Florian and John,

Thanks for the comments so far. I figure it would be easier for further discussion if I have something concrete. Here's what I have right now:

• A new CK_MatrixCast.
• Sema code for C-style cast along with its tests.
• My guess on places CK_MatrixCast will go in CodeGen. I have added a TODO in CGExprScalar.cpp indicating where I think we should implement the code gen for this conversion. There's a failing CodeGen test too.
• I am not sure yet if we need to anything with StaticAnalyzer/Core/ExprEngineC.cpp. I got a warning that CK_MatrixCast needs handling there.

My next step is to make it work for C style cast. Once that works, I can use that learning to implement static_cast.

[fhahn]

In D99037#2665082, @SaurabhJha wrote:

Hi Florian and John,

Thanks for the comments so far. I figure it would be easier for further discussion if I have something concrete. Here's what I have right now:

• A new CK_MatrixCast.
• Sema code for C-style cast along with its tests.
• My guess on places CK_MatrixCast will go in CodeGen. I have added a TODO in CGExprScalar.cpp indicating where I think we should implement the code gen for this conversion. There's a failing CodeGen test too.
• I am not sure yet if we need to anything with StaticAnalyzer/Core/ExprEngineC.cpp. I got a warning that CK_MatrixCast needs handling there.

My next step is to make it work for C style cast. Once that works, I can use that learning to implement static_cast.

Depending on how much work implementing the other casts is, but you may want to start with getting everything work for a single type (e.g. C-style casts) and then submit that first (with codegen support). Once that is done, adding the additional checks for the other casts should be much less work. It's also easier to review if the patch is not too big & doing too much.

[SaurabhJha]

Updating D99037: [Matrix] Implement explicit type conversions for matrix types

Latest update includes code gen for c style casts along with some lit tests

[SaurabhJha]

I pushed some unwanted changes that I used for debugging..fixing/removing them now.

[SaurabhJha]

Updating D99037: [Matrix] Implement explicit type conversions for matrix types
Removed unused variables and includes and fix codegen lit tests

[SaurabhJha]

Added some inline comments on where I have some doubts.

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

547

I thought doing changes here is is outside the scope of casting so I just left a TODO here. Please let me know if we want to do something else here.

clang/test/CodeGen/matrix-cast.c

40

I tried adding a float -> int conversion too but it failed because of this assertion https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGExprScalar.cpp#L1339-L1344 Hopefully that's intended.

[fhahn]

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

547

I think that's fair, but you should probably add continue; rather than falling through.

clang/test/CodeGen/matrix-cast.c

16

This doesn't seem right. We are casting between 2 signed types, so the sign should get preserved, right? Shouldn't this be sext? See https://godbolt.org/z/zWznYdnKW for the scalar case.

I think you also need tests for casts with different bitwidths with unsigned, unsigned -> signed & signed -> unsigned.

40

Clang should never run into an assertion. If that should not be allowed, then Clang should emit an error during Sema. I'm not sure why there is such a restriction for vector types, but I am not sure that this shouldn't be allowed for matrixes. Perhaps @rjmccall has more thoughts on this, but conversion between scalar ints to floats is allowed AFAIKT.

[fhahn]

clang/lib/Sema/SemaCast.cpp

2915–2916

... or a matrix?

clang/test/Sema/matrix-cast.c

4

I think it would be good to add additional test coverage casting between matrix types and other types, e.g. vector types, pointer types and struct types.

It would also be good to have C++ tests that test casting with matrix types where some of the dimensions are template arguments.

[fhahn]

clang/lib/Sema/SemaExpr.cpp

7433

When we get here, SrcTy may not necessarily be a scalar I think (see my earlier note about adding more invalid cast tests for some additional cases that might reach this code)

[SaurabhJha]

Update commit message to more accurately reflect the patch

[fhahn]

In D99037#2666230, @SaurabhJha wrote:

Update commit message to more accurately reflect the patch

Just FYI, arc diff does not update the patch description on Phabricator. I think you have to edit it via the web-interface.

[SaurabhJha]

clang/test/CodeGen/matrix-cast.c

16

This is happening because we are always passing inSigned argument to Builder.CreateIntCast as false here https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGExprScalar.cpp#L1348. IfI change it to true, it generates sext instructions.

I am figuring out how can I determine sign of src and dest type. Because SrcTy and DestTy are vectors here, they are unsigned and SrcElementTy and DestElementTy have no method like isSignedIntegerOrEnumerationType. Once that's solved, this should be fixed.

40

I can probably try removing that assert and see if some other unit or lit tests are failing. We can then make a decision.

[fhahn]

clang/test/CodeGen/matrix-cast.c

16

Oh right, I think I see what's going on. I think the code you are referring to is specifically for the vector types in Clang, but it is checking the LLVM type and we also use LLVM IR vector types for matrix values, so the code accidentally also covers matrix values at the moment.

I *think* we should probably handled matrix values separately in this function. @rjmccall what do you think?

[rjmccall]

clang/test/CodeGen/matrix-cast.c

16

Yes, I would recommend that you recognize matrix values by their Clang type and then call something in the matrix IR-generation library.

[SaurabhJha]

Addressed most of the comments. I couldn't understand "..would also be good to have C++ tests that test casting with matrix types where some of the dimensions are template arguments...". When I tried this

"""
cx4x4 m1;

(void)(ix4x4)m1
"""

it gave me the error
"""
C-style cast from 'cx4x4' (aka 'char attribute((matrix_type(4, 4)))') to 'ix4x4' (aka 'int attribute((matrix_type(4, 4)))') is not allowed
"""
should I address it as part of this patch?

[SaurabhJha]

Update one inline comment in SemaCast.cpp

[SaurabhJha]

One other problem is somehow this test is failing https://github.com/llvm/llvm-project/blob/main/clang/test/SemaOpenCL/sampler_t_overload.cl#L6 with this error.

/tmp/clang/test/SemaOpenCL/sampler_t_overload.cl:6:30: error: initializer element is not a compile-time constant
constant sampler_t glb_smp = 5;
                             ^
1 error generated.

Not sure what's going on but will continue to debug. Let me know if there's something simple that I am missing here.

[SaurabhJha]

In D99037#2668295, @SaurabhJha wrote:

One other problem is somehow this test is failing https://github.com/llvm/llvm-project/blob/main/clang/test/SemaOpenCL/sampler_t_overload.cl#L6 with this error.

/tmp/clang/test/SemaOpenCL/sampler_t_overload.cl:6:30: error: initializer element is not a compile-time constant
constant sampler_t glb_smp = 5;
                             ^
1 error generated.

Not sure what's going on but will continue to debug. Let me know if there's something simple that I am missing here.

I think I got it. If I remove the definition of CAST_OPERATION(MatrixCast) from OperationKinds.def, it works. So probably a matter of defining it the correct way.

[SaurabhJha]

Move the definition of MatrixCast to the bottom in OperationKinds.def

[SaurabhJha]

Move back CK_MatrixCast definition to to just above CK_VectorSplat. The Matrix CodeGen is passing again but SemaOpenCL/sampler tests are failing again

[fhahn]

In D99037#2667484, @SaurabhJha wrote:

Addressed most of the comments. I couldn't understand "..would also be good to have C++ tests that test casting with matrix types where some of the dimensions are template arguments...". When I tried this

"""
cx4x4 m1;

(void)(ix4x4)m1
"""

it gave me the error
"""
C-style cast from 'cx4x4' (aka 'char attribute((matrix_type(4, 4)))') to 'ix4x4' (aka 'int attribute((matrix_type(4, 4)))') is not allowed
"""

Oh, that's interesting, I was assuming the code-paths would be the same. I was thinking about C++ specific test cases like

template <typename X>
using matrix_t = X __attribute__((matrix_type(4, 4)));

matrix_t<int> foo(matrix_t<float> x) {
  return (matrix_t<int>)x;
}

should I address it as part of this patch?

I don't think we necessarily need to implement them in this patch, unless @rjmccall could think of any issues. IMO it would still be good to add tests to Sema to ensure we do not crash. We can then just update them once support for C++ is added.

clang/include/clang/Basic/DiagnosticSemaKinds.td

8583

I think in other places we are already using matrixes. Would be good to be consistent with the existing spelling I think (but I am no English expert)

8588

I think for other messages we say ... is not allowed. Perhaps this message should be similar? Also I'm not sure about reefing to non-matrix types. We might allow at least for conversion between arithmetic types and matrixes (broadcast). It might be OK to just drop the non matrix part?

clang/include/clang/Sema/Sema.h

11714

nit: for matrix casts?

clang/lib/CodeGen/CGExprScalar.cpp

1371

You could move the code generation part to MatrixBuilder.h?

clang/lib/Sema/SemaCast.cpp

2915–2916

nit: missing comma after a scalar.

clang/lib/Sema/SemaExpr.cpp

7348

From the comment here it sounds like this function checks if the arguments are matrix types, but it asserts. Does the comment need updating?

It looks like the part after i.e. needs rewording also, as there's some duplication?

[fhahn]

clang/lib/CodeGen/CGExprScalar.cpp

1379

I think we should support all floating point type here (isFloatingPointTy). Basically we want the same rules as for integer types (around line 1418). Perhaps it would be possible to generalize this code in a separate function that takes the LLVM types & the element type/scalar types?

[SaurabhJha]

clang/lib/CodeGen/CGExprScalar.cpp

1379

I think we should move this code to MatrixBuilder but then generalising floating point after that would be problematic since the code is splitted across this function and in MatrixBuilder, right?

[fhahn]

clang/lib/CodeGen/CGExprScalar.cpp

1379

That's a good point. Sharing the logic with the scalar case in Clang directly seems much more valuable than having it in the MatrixBuilder IMO.

[SaurabhJha]

clang/lib/CodeGen/CGExprScalar.cpp

1379

Whoops, I just moved the code to MatrixBuilder. Will revert it back and generalise it :)

[SaurabhJha]

clang/include/clang/AST/OperationKinds.def

185

This line is causing me issues that I don't know how to solve. If we leave it in the current place on line 185. The new tests Sema and CodeGen tests are passing but Clang.SemaOpenCL::sampler_t.cl and Clang.SemaOpenCL::sampler_t_overload.cl (along with other sampler tests) are failing.

And if I move it to the bottom, right after CAST_OPERATION(IntToOCLSampler), the sampler tests pass but the new matrix conversion tests are failing. Am I missing something here? My understanding was implementing new cast kind is just the matter of defining a CAST_OPERATION in this file.

[SaurabhJha]

Changes in latest revision:

• Updated definition of areMatrixTypesOfTheSameDimension to reflect the comment
• Refactored casting between types into EmitCastBetweenScalarTypes
• Removed mentions of "non matrix"
• Replaced matrices with matrixes
• Update error messages to "..is not allowed"

[SaurabhJha]

I reverted the int <-> float conversion to previous code to make the tests pass. That way, we atleast have something working and we can go from there.

[SaurabhJha]

Fix the bug with int <-> float conversion by explicitly passing llvm types to EmitCastBetweenScalarTypes

[SaurabhJha]

Hey Florian and John,

Thanks for your reviews so far. Just checked the build. Addressed all previous comments and the build is looking good too except for one thing. For open cl tests, it is failing with this curious error: initializer element is not a compile-time constant which I am still not sure how to debug. I tried to debug Clang.SemaOpenCL::sampler_t_overload.cl by moving the definition of MatrixCast in OperationKinds.def to below the definition of IntToOCLSampler. That made it work for sampler_overload but then the new matrix cast tests started failing.

Will give it another shot today. If you have any thoughts on this, let me know.

Saurabh

[SaurabhJha]

Okay interesting I should have posted before. Seems like when I move MatrixCast to the bottom of OperationKinds.def, and do nothing else, the matrix-cast CodeGen fails with this error. It is somehow not able to assign correct cast type.

+ /tmp/build/bin/clang -cc1 -internal-isystem /tmp/build/lib/clang/13.0.0/include -nostdsysteminc -fenable-matrix -triple x86_64-apple-darwin /tmp/clang/test/CodeGen/matrix-cast.c -emit-llvm -disable-llvm-passes -o -
+ /tmp/build/bin/FileCheck /tmp/clang/test/CodeGen/matrix-cast.c
dependent cast kind in IR gen!
UNREACHABLE executed at /tmp/clang/lib/CodeGen/CGExprScalar.cpp:1985!
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /tmp/build/bin/clang -cc1 -internal-isystem /tmp/build/lib/clang/13.0.0/include -nostdsysteminc -fenable-matrix -triple x86_64-apple-darwin /tmp/clang/test/CodeGen/matrix-cast.c -emit-llvm -disable-llvm-passes -o -
1.	/tmp/clang/test/CodeGen/matrix-cast.c:22:1: current parser token 'void'
2.	/tmp/clang/test/CodeGen/matrix-cast.c:12:6: LLVM IR generation of declaration 'cast_char_matrix_to_int'
3.	/tmp/clang/test/CodeGen/matrix-cast.c:12:6: Generating code for declaration 'cast_char_matrix_to_int'
 #0 0x000000000974250a llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /tmp/llvm/lib/Support/Unix/Signals.inc:565:11
 #1 0x00000000097426db PrintStackTraceSignalHandler(void*) /tmp/llvm/lib/Support/Unix/Signals.inc:632:1
 #2 0x0000000009740cab llvm::sys::RunSignalHandlers() /tmp/llvm/lib/Support/Signals.cpp:70:5
 #3 0x0000000009742e51 SignalHandler(int) /tmp/llvm/lib/Support/Unix/Signals.inc:407:1
 #4 0x00007f503b2923c0 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x153c0)
 #5 0x00007f503ad4318b raise /build/glibc-eX1tMB/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #6 0x00007f503ad22859 abort /build/glibc-eX1tMB/glibc-2.31/stdlib/abort.c:81:7
 #7 0x0000000009661fe4 /tmp/llvm/lib/Support/ErrorHandling.cpp:213:3
 #8 0x0000000009fd93fb (anonymous namespace)::ScalarExprEmitter::VisitCastExpr(clang::CastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:1987:5
 #9 0x0000000009fd934e (anonymous namespace)::ScalarExprEmitter::VisitExplicitCastExpr(clang::ExplicitCastExpr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:568:5
#10 0x0000000009fd17b3 clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::VisitCStyleCastExpr(clang::CStyleCastExpr*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:891:1
#11 0x0000000009fcb9ff clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/build/tools/clang/include/clang/AST/StmtNodes.inc:891:1
#12 0x0000000009fc0d0b (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:415:3
#13 0x0000000009fce242 (anonymous namespace)::ScalarExprEmitter::VisitBinAssign(clang::BinaryOperator const*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4218:9
#14 0x0000000009fca7fd clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*) /tmp/clang/include/clang/AST/StmtVisitor.h:72:26
#15 0x0000000009fc0d0b (anonymous namespace)::ScalarExprEmitter::Visit(clang::Expr*) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:415:3
#16 0x0000000009fc0c66 clang::CodeGen::CodeGenFunction::EmitScalarExpr(clang::Expr const*, bool) /tmp/clang/lib/CodeGen/CGExprScalar.cpp:4807:3
#17 0x0000000009e7edec clang::CodeGen::CodeGenFunction::EmitAnyExpr(clang::Expr const*, clang::CodeGen::AggValueSlot, bool) /tmp/clang/lib/CodeGen/CGExpr.cpp:218:12
#18 0x0000000009e7ed1d clang::CodeGen::CodeGenFunction::EmitIgnoredExpr(clang::Expr const*) /tmp/clang/lib/CodeGen/CGExpr.cpp:203:19
#19 0x0000000009fed236 clang::CodeGen::CodeGenFunction::EmitStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) /tmp/clang/lib/CodeGen/CGStmt.cpp:118:5
#20 0x0000000009ff664b clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(clang::CompoundStmt const&, bool, clang::CodeGen::AggValueSlot) /tmp/clang/lib/CodeGen/CGStmt.cpp:453:3
#21 0x0000000009e573c1 clang::CodeGen::CodeGenFunction::EmitFunctionBody(clang::Stmt const*) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1194:5
#22 0x0000000009e57e91 clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl, llvm::Function*, clang::CodeGen::CGFunctionInfo const&) /tmp/clang/lib/CodeGen/CodeGenFunction.cpp:1358:3
#23 0x0000000009d0b7de clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:4780:3
#24 0x0000000009d0215c clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl, llvm::GlobalValue*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:3166:12
#25 0x0000000009d071e4 clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:2919:5
#26 0x0000000009d0f040 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) /tmp/clang/lib/CodeGen/CodeGenModule.cpp:5621:38
#27 0x000000000a86b0f2 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/ModuleBuilder.cpp:169:73
#28 0x000000000a8654e4 clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) /tmp/clang/lib/CodeGen/CodeGenAction.cpp:215:12
#29 0x000000000cfe2475 clang::ParseAST(clang::Sema&, bool, bool) /tmp/clang/lib/Parse/ParseAST.cpp:162:20
#30 0x000000000a688572 clang::ASTFrontendAction::ExecuteAction() /tmp/clang/lib/Frontend/FrontendAction.cpp:1058:1
#31 0x000000000a861539 clang::CodeGenAction::ExecuteAction() /tmp/clang/lib/CodeGen/CodeGenAction.cpp:1039:5
#32 0x000000000a687f38 clang::FrontendAction::Execute() /tmp/clang/lib/Frontend/FrontendAction.cpp:953:7
#33 0x000000000a55a2f5 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /tmp/clang/lib/Frontend/CompilerInstance.cpp:958:23
#34 0x000000000a84ddc6 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /tmp/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:278:8
#35 0x000000000610c23d cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /tmp/clang/tools/driver/cc1_main.cpp:246:13
#36 0x00000000060fec59 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /tmp/clang/tools/driver/driver.cpp:338:5
#37 0x00000000060fddee main /tmp/clang/tools/driver/driver.cpp:415:5
#38 0x00007f503ad240b3 __libc_start_main /build/glibc-eX1tMB/glibc-2.31/csu/../csu/libc-start.c:342:3
#39 0x00000000060fd59e _start (/tmp/build/bin/clang+0x60fd59e)
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /tmp/build/bin/FileCheck /tmp/clang/test/CodeGen/matrix-cast.c

--

********************
********************
Failed Tests (1):
  Clang :: CodeGen/matrix-cast.c


Testing Time: 21.71s
  Failed: 1

[fhahn]

In D99037#2673367, @SaurabhJha wrote:

Hey Florian and John,

Thanks for your reviews so far. Just checked the build. Addressed all previous comments and the build is looking good too except for one thing. For open cl tests, it is failing with this curious error: initializer element is not a compile-time constant which I am still not sure how to debug. I tried to debug Clang.SemaOpenCL::sampler_t_overload.cl by moving the definition of MatrixCast in OperationKinds.def to below the definition of IntToOCLSampler. That made it work for sampler_overload but then the new matrix cast tests started failing.

Will give it another shot today. If you have any thoughts on this, let me know.

I think the issue might be that adding this additional cast-kind caused the value to exceed the maximum supported by the CastExprBitfields; the bitfield can only store 64 values, but after adding MatrixCast, CK_IntToOCLSampler will have value 64, so assigning to the bitfield results in 0 being assigned. I *think* you have to bump the bitfield size to 7 or perhaps 8 (which may result in slightly better codegen). https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/Stmt.h#L521

clang/lib/CodeGen/CGExprScalar.cpp

1197

Can you put up a patch that just moves the existing code to the function, without adding the matrix specifics? Hopefully that would reduce the diff and make it easy to see that the non-matrix code paths are unchanged?

[SaurabhJha]

I think the issue might be that adding this additional cast-kind caused the value to exceed the maximum supported by the CastExprBitfields; the bitfield can only store 64 values, but after adding MatrixCast, CK_IntToOCLSampler will have value 64, so assigning to the bitfield results in 0 being assigned. I *think* you have to bump the bitfield size to 7 or perhaps 8 (which may result in slightly better codegen). https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/Stmt.h#L521

This worked. Setting it to 7 made the tests pass.

I have created a separate patch for codegen refactoring here https://reviews.llvm.org/D100051. Once that's merged, I can rebase this patch/branch against that.

[SaurabhJha]

Rebased with latest main

[SaurabhJha]

clang/lib/CodeGen/CGExprScalar.cpp

1453

Not sure why this was changed. Perhaps clang-clean.

[SaurabhJha]

Hopefully this will work. My IDE is a bit wonky and it will take hours to rebuild for me after rebase. So pushed here with the hope that this could be validated using web build.

[fhahn]

clang/lib/CodeGen/CGExprScalar.cpp

1219

We should be able to assert here that both types are not matrix types, I think?

1376

nit: no braces required here

1453

Not sure, but please remove the change from the diff.

[SaurabhJha]

Address comments

[SaurabhJha]

clang/lib/CodeGen/CGExprScalar.cpp

1219

I did !SrcType->isMatrixType() && !DstType->isMatrixType() instead of !SrcType->isMatrixType() || !DstType->isMatrixType() which I hope was the correct thing to do.

[fhahn]

Thanks for the latest update! This basically looks good to me, with a few final nits!

clang/include/clang/Basic/DiagnosticSemaKinds.td

8584

nit: matrix types?

8586

nit: _and_incompatible_type?

clang/include/clang/Sema/Sema.h

11718

Can the name for Tr be improved? Perhaps ToTy or TargetTy?

clang/lib/CodeGen/CGExprScalar.cpp

1219

Thanks! Can you also add a message to the assert , like && "cannot cast between matrix and non-matrix types")

clang/lib/Sema/SemaCast.cpp

2932

nit: no braces.

clang/lib/Sema/SemaExpr.cpp

7357

nit: No ( ...... ) required here.

clang/test/CodeGen/matrix-cast.c

83

I think this is still missing a test from unsigned to signed?

[SaurabhJha]

Addressed latest round of comments.
Also rebased with latest main as the windows build failed for some reason

[SaurabhJha]

clang/test/CodeGen/matrix-cast.c

83

I added a new cast_unsigned_long_int_matrix_to_short

[SaurabhJha]

The windows build failure is solved by itself and its all passing now!

[fhahn]

LGTM, thanks for working on this!

clang/include/clang/Sema/Sema.h

11715

Nit: matrixes for consistency

clang/lib/CodeGen/CGExprScalar.cpp

1201–1226

I think the comment here could be a bit shorter and to the point. Perhaps something like The *Element* types are used to determine the kind of cast to perform.

The assignments are just below and probably are clear from the code.

1210

nit: matrixes for consistency

[SaurabhJha]

LGTM, thanks for working on this!

Thanks so much Florian. Can you please also commit this on my behalf as I don't have commit access? Cheers.

[SaurabhJha]

In D99037#2678779, @fhahn wrote:

Will create a new patch to address your last comments

[fhahn]

In D99037#2678848, @SaurabhJha wrote:

In D99037#2678779, @fhahn wrote:

Will create a new patch to address your last comments

Can you directly update this one? I'll commit it after the update.

[SaurabhJha]

Replace matrices with matrixes in comments and rewrite the comment about element types

[SaurabhJha]

In D99037#2679131, @fhahn wrote:

In D99037#2678848, @SaurabhJha wrote:

In D99037#2678779, @fhahn wrote:

Will create a new patch to address your last comments

Can you directly update this one? I'll commit it after the update.

Sure, done. I did not know I could change the patch after its accepted.

[SaurabhJha]

Seems like the new build is passing. Can you please commit it on my behalf
if it looks okay to you?

Thanks a lot for your help in this patch.

Saurabh

clang/include/clang/AST/OperationKinds.def

 /// CK_PointerToBoolean - Pointer to boolean conversion.  A check
 /// against null.  Applies to normal, ObjC, and block pointers.
 CAST_OPERATION(PointerToBoolean)
 
 /// CK_ToVoid - Cast to void, discarding the computed value.
 ///    (void) malloc(2048)
 CAST_OPERATION(ToVoid)
 
+/// CK_MatrixCast - A cast between matrix types of the same dimensions.
+CAST_OPERATION(MatrixCast)
+
 /// CK_VectorSplat - A conversion from an arithmetic type to a
 /// vector of that element type.  Fills all elements ("splats") with
 /// the source value.
 ///    __attribute__((ext_vector_type(4))) int v = 5;
 CAST_OPERATION(VectorSplat)
 
 /// CK_IntegralCast - A cast between integral types (other than to
 /// boolean).  Variously a bitcast, a truncation, a sign-extension,

clang/include/clang/AST/Stmt.h

protected:
   };
 
   class CastExprBitfields {
     friend class CastExpr;
     friend class ImplicitCastExpr;
 
     unsigned : NumExprBits;
 
-    unsigned Kind : 6;
+    unsigned Kind : 7;
     unsigned PartOfExplicitCast : 1; // Only set for ImplicitCastExpr.
 
     /// True if the call expression has some floating-point features.
     unsigned HasFPFeatures : 1;
 
     /// The number of CXXBaseSpecifiers in the cast. 14 bits would be enough
     /// here. ([implimits] Direct and indirect base classes [16384]).
     unsigned BasePathSize;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 }
 
   def error_inoutput_conflict_with_clobber : Error<
     "asm-specifier for input or output variable conflicts with asm"
     " clobber list">;
 
 let CategoryName = "Semantic Issue" in {
 
+def err_invalid_conversion_between_matrixes : Error<
+  "conversion between matrix types%diff{ $ and $|}0,1 of different size is not allowed">;
+
+def err_invalid_conversion_between_matrix_and_type : Error<
+  "conversion between matrix type %0 and incompatible type %1 is not allowed">;
+
 def err_invalid_conversion_between_vectors : Error<
   "invalid conversion between vector type%diff{ $ and $|}0,1 of different "
   "size">;
 def err_invalid_conversion_between_vector_and_integer : Error<
   "invalid conversion between vector type %0 and integer type %1 "
   "of different size">;
 
 def err_opencl_function_pointer : Error<

clang/include/clang/Sema/Sema.h

   QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
                                           SourceLocation Loc,
                                           bool IsCompAssign);
   QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
                                        SourceLocation Loc, bool IsCompAssign);
 
   bool isValidSveBitcast(QualType srcType, QualType destType);
 
+  bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy);
+
   bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
   bool isLaxVectorConversion(QualType srcType, QualType destType);
 
   /// type checking declaration initializers (C99 6.7.8)
   bool CheckForConstantInitializer(Expr *e, QualType t);
 
   // type checking C++ declaration initializers (C++ [dcl.init]).
 

   /// given type.
   ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
 
   /// Type-check an expression that's being passed to an
   /// __unknown_anytype parameter.
   ExprResult checkUnknownAnyArg(SourceLocation callLoc,
                                 Expr *result, QualType &paramType);
 
+  // CheckMatrixCast - Check type constraints for matrix casts.
+  // We allow casting between matrixes of the same dimensions i.e. when they
+  // have the same number of rows and column. Returns true if the cast is
+  // invalid.
+  bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
+                       CastKind &Kind);
+
   // CheckVectorCast - check type constraints for vectors.
   // Since vectors are an extension, there are no C standard reference for this.
   // We allow casting between vectors and integer datatypes of the same size.
   // returns true if the cast is invalid
   bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
                        CastKind &Kind);
 
   /// Prepare `SplattedExpr` for a vector splat operation, adding

clang/lib/AST/Expr.cpp

bool CastExpr::CastConsistency() const {
   case CK_ARCExtendBlockObject:
   case CK_ZeroToOCLOpaqueType:
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
+  case CK_MatrixCast:
     assert(!getType()->isBooleanType() && "unheralded conversion to bool");
     goto CheckNoBasePath;
 
   case CK_Dependent:
   case CK_LValueToRValue:
   case CK_NoOp:
   case CK_AtomicToNonAtomic:
   case CK_NonAtomicToAtomic:

clang/lib/AST/ExprConstant.cpp

bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_ZeroToOCLOpaqueType:
   case CK_NonAtomicToAtomic:
   case CK_AddressSpaceConversion:
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_IntegralToFixedPoint:
+  case CK_MatrixCast:
     llvm_unreachable("invalid cast kind for integral value");
 
   case CK_BitCast:
   case CK_Dependent:
   case CK_LValueBitCast:
   case CK_ARCProduceObject:
   case CK_ARCConsumeObject:
   case CK_ARCReclaimReturnedObject:
bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_AddressSpaceConversion:
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_FixedPointToBoolean:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
+  case CK_MatrixCast:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_LValueToRValue:
   case CK_AtomicToNonAtomic:
   case CK_NoOp:
   case CK_LValueToRValueBitCast:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   case CK_CopyAndAutoreleaseBlockObject:
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_FixedPointToBoolean:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
+  case CK_MatrixCast:
     return EmitUnsupportedLValue(E, "unexpected cast lvalue");
 
   case CK_Dependent:
     llvm_unreachable("dependent cast kind in IR gen!");
 
   case CK_BuiltinFnToFnPtr:
     llvm_unreachable("builtin functions are handled elsewhere");
 

clang/lib/CodeGen/CGExprAgg.cpp

void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   case CK_IntegralComplexToFloatingComplex:
   case CK_ARCProduceObject:
   case CK_ARCConsumeObject:
   case CK_ARCReclaimReturnedObject:
   case CK_ARCExtendBlockObject:
   case CK_CopyAndAutoreleaseBlockObject:
   case CK_BuiltinFnToFnPtr:
   case CK_ZeroToOCLOpaqueType:
+  case CK_MatrixCast:
 
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_FixedPointToBoolean:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
static bool castPreservesZero(const CastExpr *CE) {
   case CK_IntegralRealToComplex:
   case CK_IntegralToBoolean:
   case CK_IntegralToFloating:
     // Reinterpreting integers as pointers and vice versa.
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
     // Language extensions.
   case CK_VectorSplat:
+  case CK_MatrixCast:
   case CK_NonAtomicToAtomic:
   case CK_AtomicToNonAtomic:
     return true;
 
   case CK_BaseToDerivedMemberPointer:
   case CK_DerivedToBaseMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_NullToMemberPointer:

clang/lib/CodeGen/CGExprComplex.cpp

ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
   case CK_AddressSpaceConversion:
   case CK_IntToOCLSampler:
   case CK_FloatingToFixedPoint:
   case CK_FixedPointToFloating:
   case CK_FixedPointCast:
   case CK_FixedPointToBoolean:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
+  case CK_MatrixCast:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_FloatingRealToComplex:
   case CK_IntegralRealToComplex: {
     CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
     return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(),
                                    DestTy, Op->getExprLoc());
   }

clang/lib/CodeGen/CGExprConstant.cpp

llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
     case CK_FloatingCast:
     case CK_FloatingToFixedPoint:
     case CK_FixedPointToFloating:
     case CK_FixedPointCast:
     case CK_FixedPointToBoolean:
     case CK_FixedPointToIntegral:
     case CK_IntegralToFixedPoint:
     case CK_ZeroToOCLOpaqueType:
+    case CK_MatrixCast:
       return nullptr;
     }
     llvm_unreachable("Invalid CastKind");
   }
 
   llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
     // No need for a DefaultInitExprScope: we don't handle 'this' in a
     // constant expression.

clang/lib/CodeGen/CGExprScalar.cpp

llvm::Constant *StaticArgs[] = {
       CGF.EmitCheckSourceLocation(Loc), CGF.EmitCheckTypeDescriptor(SrcType),
       CGF.EmitCheckTypeDescriptor(DstType),
       llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
   // EmitCheck() will 'and' all the checks together.
   CGF.EmitCheck(Checks, SanitizerHandler::ImplicitConversion, StaticArgs,
                 {Src, Dst});
 }
 
 Value *ScalarExprEmitter::EmitScalarCast(Value *Src, QualType SrcType,
                                          QualType DstType, llvm::Type *SrcTy,
                                          llvm::Type *DstTy,
                                          ScalarConversionOpts Opts) {
-  if (isa<llvm::IntegerType>(SrcTy)) {
-    bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
-    if (SrcType->isBooleanType() && Opts.TreatBooleanAsSigned) {
+  // The Element types determine the type of cast to perform.
+  llvm::Type *SrcElementTy;
+  llvm::Type *DstElementTy;
+  QualType SrcElementType;
+  QualType DstElementType;
+  if (SrcType->isMatrixType() && DstType->isMatrixType()) {
+    // Allow bitcast between matrixes of the same size.
+    if (SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits())
+      return Builder.CreateBitCast(Src, DstTy, "conv");
+
+    SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
+    DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
+    SrcElementType = SrcType->castAs<MatrixType>()->getElementType();
+    DstElementType = DstType->castAs<MatrixType>()->getElementType();
+  } else {
+    assert(!SrcType->isMatrixType() && !DstType->isMatrixType() &&
+           "cannot cast between matrix and non-matrix types");
+    SrcElementTy = SrcTy;
+    DstElementTy = DstTy;
+    SrcElementType = SrcType;
+    DstElementType = DstType;
+  }
+
+  if (isa<llvm::IntegerType>(SrcElementTy)) {
+    bool InputSigned = SrcElementType->isSignedIntegerOrEnumerationType();
+    if (SrcElementType->isBooleanType() && Opts.TreatBooleanAsSigned) {
       InputSigned = true;
     }
 
-    if (isa<llvm::IntegerType>(DstTy))
+    if (isa<llvm::IntegerType>(DstElementTy))
       return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
     if (InputSigned)
       return Builder.CreateSIToFP(Src, DstTy, "conv");
     return Builder.CreateUIToFP(Src, DstTy, "conv");
   }
 
-  if (isa<llvm::IntegerType>(DstTy)) {
-    assert(SrcTy->isFloatingPointTy() && "Unknown real conversion");
-    if (DstType->isSignedIntegerOrEnumerationType())
+  if (isa<llvm::IntegerType>(DstElementTy)) {
+    assert(SrcElementTy->isFloatingPointTy() && "Unknown real conversion");
+    if (DstElementType->isSignedIntegerOrEnumerationType())
       return Builder.CreateFPToSI(Src, DstTy, "conv");
     return Builder.CreateFPToUI(Src, DstTy, "conv");
   }
 
-  if (DstTy->getTypeID() < SrcTy->getTypeID())
+  if (DstElementTy->getTypeID() < SrcElementTy->getTypeID())
     return Builder.CreateFPTrunc(Src, DstTy, "conv");
   return Builder.CreateFPExt(Src, DstTy, "conv");
 }
 
 /// Emit a conversion from the specified type to the specified destination type,
 /// both of which are LLVM scalar types.
 Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
                                                QualType DstType,
Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
   // A scalar can be splatted to an extended vector of the same element type
   if (DstType->isExtVectorType() && !SrcType->isVectorType()) {
     // Sema should add casts to make sure that the source expression's type is
     // the same as the vector's element type (sans qualifiers)
     assert(DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() ==
                SrcType.getTypePtr() &&
            "Splatted expr doesn't match with vector element type?");
 
     // Splat the element across to all elements
     unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
     return Builder.CreateVectorSplat(NumElements, Src, "splat");
   }
 
+  if (SrcType->isMatrixType() && DstType->isMatrixType())
+    return EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
+
   if (isa<llvm::VectorType>(SrcTy) || isa<llvm::VectorType>(DstTy)) {
     // Allow bitcast from vector to integer/fp of the same size.
     unsigned SrcSize = SrcTy->getPrimitiveSizeInBits();
     unsigned DstSize = DstTy->getPrimitiveSizeInBits();
     if (SrcSize == DstSize)
       return Builder.CreateBitCast(Src, DstTy, "conv");
 
     // Conversions between vectors of different sizes are not allowed except
     // when vectors of half are involved. Operations on storage-only half
Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
   Res = EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
 
   if (DstTy != ResTy) {
     if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
       assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion");
       Res = Builder.CreateCall(
         CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
         Res);
     } else {
       Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
     }
   }
 
   if (Opts.EmitImplicitIntegerTruncationChecks)
     EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
                                NoncanonicalDstType, Loc);
 
case CK_PointerToIntegral: {
     }
 
     return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
   }
   case CK_ToVoid: {
     CGF.EmitIgnoredExpr(E);
     return nullptr;
   }
+  case CK_MatrixCast: {
+    return EmitScalarConversion(Visit(E), E->getType(), DestTy,
+                                CE->getExprLoc());
+  }
   case CK_VectorSplat: {
     llvm::Type *DstTy = ConvertType(DestTy);
     Value *Elt = Visit(const_cast<Expr*>(E));
     // Splat the element across to all elements
     unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
     return Builder.CreateVectorSplat(NumElements, Elt, "splat");
   }
 

clang/lib/Edit/RewriteObjCFoundationAPI.cpp

if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
     case CK_ARCConsumeObject:
     case CK_ARCReclaimReturnedObject:
     case CK_ARCExtendBlockObject:
     case CK_NonAtomicToAtomic:
     case CK_CopyAndAutoreleaseBlockObject:
     case CK_BuiltinFnToFnPtr:
     case CK_ZeroToOCLOpaqueType:
     case CK_IntToOCLSampler:
+    case CK_MatrixCast:
       return false;
 
     case CK_BooleanToSignedIntegral:
       llvm_unreachable("OpenCL-specific cast in Objective-C?");
 
     case CK_FloatingToFixedPoint:
     case CK_FixedPointToFloating:
     case CK_FixedPointCast:

clang/lib/Sema/SemaCast.cpp

if (srcIsVector || destIsVector) {
     // The non-vector type, if any, must have integral type.  This is
     // the same rule that C vector casts use; note, however, that enum
     // types are not integral in C++.
     if ((!destIsVector && !DestType->isIntegralType(Self.Context)) ||
         (!srcIsVector && !SrcType->isIntegralType(Self.Context)))
       return TC_NotApplicable;
 
     // The size we want to consider is eltCount * eltSize.
     // That's exactly what the lax-conversion rules will check.
     if (Self.areLaxCompatibleVectorTypes(SrcType, DestType)) {
       Kind = CK_BitCast;
       return TC_Success;
     }
 
     // Otherwise, pick a reasonable diagnostic.
     if (!destIsVector)
       msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
void CastOperation::CheckCStyleCast() {
 
   // Allow bitcasting between compatible SVE vector types.
   if ((SrcType->isVectorType() || DestType->isVectorType()) &&
       Self.isValidSveBitcast(SrcType, DestType)) {
     Kind = CK_BitCast;
     return;
   }
 
-  if (!DestType->isScalarType() && !DestType->isVectorType()) {
+  if (!DestType->isScalarType() && !DestType->isVectorType() &&
+      !DestType->isMatrixType()) {
     const RecordType *DestRecordTy = DestType->getAs<RecordType>();
 
     if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){
       // GCC struct/union extension: allow cast to self.
       Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar)
         << DestType << SrcExpr.get()->getSourceRange();
       Kind = CK_NoOp;
       return;
if (!DestType->isScalarType() && !DestType->isVectorType() &&
 
     // Reject any other conversions to non-scalar types.
     Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar)
       << DestType << SrcExpr.get()->getSourceRange();
     SrcExpr = ExprError();
     return;
   }
 
-  // The type we're casting to is known to be a scalar or vector.
+  // The type we're casting to is known to be a scalar, a vector, or a matrix.
 
-  // Require the operand to be a scalar or vector.
-  if (!SrcType->isScalarType() && !SrcType->isVectorType()) {
+  // Require the operand to be a scalar, a vector, or a matrix.
+  if (!SrcType->isScalarType() && !SrcType->isVectorType() &&
+      !SrcType->isMatrixType()) {
     Self.Diag(SrcExpr.get()->getExprLoc(),
               diag::err_typecheck_expect_scalar_operand)
       << SrcType << SrcExpr.get()->getSourceRange();
     SrcExpr = ExprError();
     return;
   }
 
   if (DestType->isExtVectorType()) {
     SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind);
     return;
   }
 
+  if (DestType->getAs<MatrixType>() || SrcType->getAs<MatrixType>()) {
+    if (Self.CheckMatrixCast(OpRange, DestType, SrcType, Kind))
+      SrcExpr = ExprError();
+    return;
+  }
+
   if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) {
     if (DestVecTy->getVectorKind() == VectorType::AltiVecVector &&
           (SrcType->isIntegerType() || SrcType->isFloatingType())) {
       Kind = CK_VectorSplat;
       SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
     } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) {
       SrcExpr = ExprError();
     }

clang/lib/Sema/SemaExpr.cpp

auto ValidScalableConversion = [](QualType FirstType, QualType SecondType) {
     return VecTy &&
            VecTy->getVectorKind() == VectorType::SveFixedLengthDataVector;
   };
 
   return ValidScalableConversion(srcTy, destTy) ||
          ValidScalableConversion(destTy, srcTy);
 }
 
+/// Are the two types matrix types and do they have the same dimensions i.e.
+/// do they have the same number of rows and the same number of columns?
+bool Sema::areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy) {
+  if (!destTy->isMatrixType() || !srcTy->isMatrixType())
+    return false;
+
+  const ConstantMatrixType *matSrcType = srcTy->getAs<ConstantMatrixType>();
+  const ConstantMatrixType *matDestType = destTy->getAs<ConstantMatrixType>();
+
+  return matSrcType->getNumRows() == matDestType->getNumRows() &&
+         matSrcType->getNumColumns() == matDestType->getNumColumns();
+}
+
 /// Are the two types lax-compatible vector types?  That is, given
 /// that one of them is a vector, do they have equal storage sizes,
 /// where the storage size is the number of elements times the element
 /// size?
 ///
 /// This will also return false if either of the types is neither a
 /// vector nor a real type.
 bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
case LangOptions::LaxVectorConversionKind::Integer:
 
     case LangOptions::LaxVectorConversionKind::All:
     break;
   }
 
   return areLaxCompatibleVectorTypes(srcTy, destTy);
 }
 
+bool Sema::CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
+                           CastKind &Kind) {
+  if (SrcTy->isMatrixType() && DestTy->isMatrixType()) {
+    if (!areMatrixTypesOfTheSameDimension(SrcTy, DestTy)) {
+      return Diag(R.getBegin(), diag::err_invalid_conversion_between_matrixes)
+             << DestTy << SrcTy << R;
+    }
+  } else if (SrcTy->isMatrixType()) {
+    return Diag(R.getBegin(),
+                diag::err_invalid_conversion_between_matrix_and_type)
+           << SrcTy << DestTy << R;
+  } else if (DestTy->isMatrixType()) {
+    return Diag(R.getBegin(),
+                diag::err_invalid_conversion_between_matrix_and_type)
+           << DestTy << SrcTy << R;
+  }
+
+  Kind = CK_MatrixCast;
+  return false;
+}
+
 bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
                            CastKind &Kind) {
   assert(VectorTy->isVectorType() && "Not a vector type!");
 
   if (Ty->isVectorType() || Ty->isIntegralType(Context)) {
     if (!areLaxCompatibleVectorTypes(Ty, VectorTy))
       return Diag(R.getBegin(),
                   Ty->isVectorType() ?

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

switch (CastE->getCastKind()) {
         continue;
       }
       // Various C++ casts that are not handled yet.
       case CK_ToUnion:
       case CK_VectorSplat: {
         state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
         continue;
       }
+      case CK_MatrixCast: {
+        // TODO: Handle MatrixCast here.
+        continue;
+      }
     }
   }
 }
 
 void ExprEngine::VisitCompoundLiteralExpr(const CompoundLiteralExpr *CL,
                                           ExplodedNode *Pred,
                                           ExplodedNodeSet &Dst) {
   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);

clang/test/CodeGen/matrix-cast.c

+// RUN: %clang_cc1 -fenable-matrix -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+
+typedef char cx5x5 __attribute__((matrix_type(5, 5)));
+typedef int ix5x5 __attribute__((matrix_type(5, 5)));
+typedef short sx5x5 __attribute__((matrix_type(5, 5)));
+typedef float fx5x5 __attribute__((matrix_type(5, 5)));
+typedef double dx5x5 __attribute__((matrix_type(5, 5)));
+typedef unsigned short unsigned_short_int_5x5 __attribute__((matrix_type(5, 5)));
+typedef unsigned int unsigned_int_5x5 __attribute__((matrix_type(5, 5)));
+typedef unsigned long unsigned_long_int_5x5 __attribute__((matrix_type(5, 5)));
+
+void cast_char_matrix_to_int(cx5x5 c, ix5x5 i) {
+  // CHECK-LABEL: define{{.*}} void @cast_char_matrix_to_int(<25 x i8> %c, <25 x i32> %i)
+  // CHECK:       [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
+  // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  i = (ix5x5)c;
+}
+
+void cast_char_matrix_to_unsigned_int(cx5x5 c, unsigned_int_5x5 u) {
+  // CHECK-LABEL: define{{.*}} void @cast_char_matrix_to_unsigned_int(<25 x i8> %c, <25 x i32> %u)
+  // CHECK:       [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
+  // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  u = (unsigned_int_5x5)c;
+}
+
+void cast_unsigned_long_int_matrix_to_short(unsigned_long_int_5x5 u, sx5x5 s) {
+  // CHECK-LABEL: define{{.*}} void @cast_unsigned_long_int_matrix_to_short(<25 x i64> %u, <25 x i16> %s)
+  // CHECK:       [[U:%.*]] = load <25 x i64>, <25 x i64>* {{.*}}, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i64> [[U]] to <25 x i16>
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  ret void
+
+  s = (sx5x5)u;
+}
+
+void cast_int_matrix_to_short(ix5x5 i, sx5x5 s) {
+  // CHECK-LABEL: define{{.*}} void @cast_int_matrix_to_short(<25 x i32> %i, <25 x i16> %s)
+  // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i32> [[I]] to <25 x i16>
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  ret void
+
+  s = (sx5x5)i;
+}
+
+void cast_int_matrix_to_float(ix5x5 i, fx5x5 f) {
+  // CHECK-LABEL: define{{.*}} void @cast_int_matrix_to_float(<25 x i32> %i, <25 x float> %f)
+  // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = bitcast <25 x i32> [[I]] to <25 x float>
+  // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  f = (fx5x5)i;
+}
+
+void cast_double_matrix_to_int(dx5x5 d, ix5x5 i) {
+  // CHECK-LABEL: define{{.*}} void @cast_double_matrix_to_int(<25 x double> %d, <25 x i32> %i)
+  // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = fptosi <25 x double> [[D]] to <25 x i32>
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  i = (ix5x5)d;
+}
+
+void cast_float_matrix_to_unsigned_short_int(fx5x5 f, unsigned_short_int_5x5 i) {
+  // CHECK-LABEL: define{{.*}} void @cast_float_matrix_to_unsigned_short_int(<25 x float> %f, <25 x i16> %i)
+  // CHECK:       [[F:%.*]] = load <25 x float>, <25 x float>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = fptoui <25 x float> [[F]] to <25 x i16>
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* %1, align 2
+  // CHECK-NEXT:  ret void
+
+  i = (unsigned_short_int_5x5)f;
+}
+
+void cast_double_matrix_to_float(dx5x5 d, fx5x5 f) {
+  // CHECK-LABEL: define{{.*}} void @cast_double_matrix_to_float(<25 x double> %d, <25 x float> %f)
+  // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = fptrunc <25 x double> [[D]] to <25 x float>
+  // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  f = (fx5x5)d;
+}
+
+void cast_unsigned_short_int_to_unsigned_int(unsigned_short_int_5x5 s, unsigned_int_5x5 i) {
+  // CHECK-LABEL: define{{.*}} void @cast_unsigned_short_int_to_unsigned_int(<25 x i16> %s, <25 x i32> %i)
+  // CHECK:       [[S:%.*]] = load <25 x i16>, <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  [[CONV:%.*]] = zext <25 x i16> [[S]] to <25 x i32>
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  i = (unsigned_int_5x5)s;
+}
+
+void cast_unsigned_long_int_to_unsigned_short_int(unsigned_long_int_5x5 l, unsigned_short_int_5x5 s) {
+  // CHECK-LABEL: define{{.*}} void @cast_unsigned_long_int_to_unsigned_short_int(<25 x i64> %l, <25 x i16> %s)
+  // CHECK:       [[L:%.*]] = load <25 x i64>, <25 x i64>* %0, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i64> [[L]] to <25 x i16>
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  ret void
+
+  s = (unsigned_short_int_5x5)l;
+}

clang/test/Sema/matrix-cast.c

+// RUN: %clang_cc1 -fenable-matrix -fsyntax-only %s -verify
+
+typedef char cx4x4 __attribute__((matrix_type(4, 4)));
+typedef int ix4x4 __attribute__((matrix_type(4, 4)));
+typedef short sx4x4 __attribute__((matrix_type(4, 4)));
+typedef int ix5x5 __attribute__((matrix_type(5, 5)));
+typedef float fx5x5 __attribute__((matrix_type(5, 5)));
+typedef int vec __attribute__((vector_size(4)));
+typedef struct test_struct {
+} test_struct;
+
+void f1() {
+  cx4x4 m1;
+  ix4x4 m2;
+  sx4x4 m3;
+  ix5x5 m4;
+  fx5x5 m5;
+  int i;
+  vec v;
+  test_struct *s;
+
+  m2 = (ix4x4)m1;
+  m3 = (sx4x4)m2;
+  m4 = (ix5x5)m3;        // expected-error {{conversion between matrix types 'ix5x5' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and 'sx4x4' (aka 'short __attribute__((matrix_type(4, 4)))') of different size \
+is not allowed}}
+  m5 = (ix5x5)m4;        // expected-error {{assigning to 'fx5x5' (aka \
+'float __attribute__((matrix_type(5, 5)))') from incompatible type 'ix5x5' (aka 'int __attribute__((matrix_type(5, 5)))')}}
+  i = (int)m4;           // expected-error {{conversion between matrix type 'ix5x5' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and incompatible type 'int' is not allowed}}
+  m4 = (ix5x5)i;         // expected-error {{conversion between matrix type 'ix5x5' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and incompatible type 'int' is not allowed}}
+  v = (vec)m4;           // expected-error {{conversion between matrix type 'ix5x5' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and incompatible type 'vec' (vector of 1 'int' value) is not allowed}}
+  m4 = (ix5x5)v;         // expected-error {{conversion between matrix type 'ix5x5' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and incompatible type 'vec' (vector of 1 'int' value) is not allowed}}
+  s = (test_struct *)m3; // expected-error {{conversion between matrix type 'sx4x4' (aka 'short \
+__attribute__((matrix_type(4, 4)))') and incompatible type 'test_struct *' (aka 'struct test_struct *') is not allowed}}
+  m3 = (sx4x4)s;         // expected-error {{conversion between matrix type 'sx4x4' (aka 'short \
+__attribute__((matrix_type(4, 4)))') and incompatible type 'test_struct *' (aka 'struct test_struct *') is not allowed}}
+
+  m4 = (ix5x5)m5;
+}
+
+typedef float float2_8x8 __attribute__((matrix_type(8, 8)));
+typedef double double_10x10 __attribute__((matrix_type(10, 10)));
+typedef double double_8x8 __attribute__((matrix_type(8, 8)));
+typedef signed int signed_int_12x12 __attribute__((matrix_type(12, 12)));
+typedef unsigned int unsigned_int_12x12 __attribute__((matrix_type(12, 12)));
+typedef unsigned int unsigned_int_10x10 __attribute__((matrix_type(10, 10)));
+
+void f2() {
+  float2_8x8 m1;
+  double_10x10 m2;
+  double_8x8 m3;
+  signed_int_12x12 m4;
+  unsigned_int_12x12 m5;
+  unsigned_int_10x10 m6;
+  float f;
+
+  m2 = (double_10x10)m1; // expected-error {{conversion between matrix types 'double_10x10' \
+(aka 'double __attribute__((matrix_type(10, 10)))') and 'float2_8x8' (aka 'float __attribute__\
+((matrix_type(8, 8)))') of different size is not allowed}}
+  m3 = (double_8x8)m1;
+
+  m5 = (unsigned_int_12x12)m4;
+  m4 = (signed_int_12x12)m5;
+  m6 = (unsigned_int_10x10)m4; // expected-error {{conversion between matrix types 'unsigned_int_10x10' \
+(aka 'unsigned int __attribute__((matrix_type(10, 10)))') and 'signed_int_12x12' (aka 'int __attribute__\
+((matrix_type(12, 12)))') of different size is not allowed}}
+  f = (float)m4;               // expected-error {{conversion between matrix type 'signed_int_12x12' \
+(aka 'int __attribute__((matrix_type(12, 12)))') and incompatible type 'float' is not allowed}}
+  m4 = (signed_int_12x12)f;    // expected-error {{conversion between matrix type 'signed_int_12x12' \
+(aka 'int __attribute__((matrix_type(12, 12)))') and incompatible type 'float' is not allowed}}
+}
 No newline at end of file

clang/test/SemaCXX/matrix-casts.cpp

+// RUN: %clang_cc1 -std=c++11 -fenable-matrix -fsyntax-only -verify %s
+
+template <typename X>
+
+using matrix_4_4 = X __attribute__((matrix_type(4, 4)));
+
+template <typename Y>
+
+using matrix_5_5 = Y __attribute__((matrix_type(5, 5)));
+
+typedef struct test_struct {
+} test_struct;
+
+typedef int vec __attribute__((vector_size(4)));
+
+void f1() {
+  // TODO: Update this test once the support of C-style casts for C++ is implemented.
+  matrix_4_4<char> m1;
+  matrix_4_4<int> m2;
+  matrix_4_4<short> m3;
+  matrix_5_5<int> m4;
+  int i;
+  vec v;
+  test_struct *s;
+
+  (matrix_4_4<int>)m1;   // expected-error {{C-style cast from 'matrix_4_4<char>' (aka 'char __attribute__((matrix_type(4, \
+4)))') to 'matrix_4_4<int>' (aka 'int __attribute__((matrix_type(4, 4)))') is not allowed}}
+  (matrix_4_4<short>)m2; // expected-error {{C-style cast from 'matrix_4_4<int>' (aka 'int __attribute__((matrix_type(4, \
+4)))') to 'matrix_4_4<short>' (aka 'short __attribute__((matrix_type(4, 4)))') is not allowed}}
+  (matrix_5_5<int>)m3;   // expected-error {{C-style cast from 'matrix_4_4<short>' (aka 'short __attribute__((matrix_type(4, \
+4)))') to 'matrix_5_5<int>' (aka 'int __attribute__((matrix_type(5, 5)))') is not allowed}}
+
+  (int)m3;            // expected-error {{C-style cast from 'matrix_4_4<short>' (aka 'short __attribute__((matrix_type(4, \
+4)))') to 'int'}}
+  (matrix_4_4<int>)i; // expected-error {{C-style cast from 'int' to 'matrix_4_4<int>' (aka 'int __attribute__((\
+matrix_type(4, 4)))') is not allowed}}
+
+  (vec) m2;            // expected-error {{C-style cast from 'matrix_4_4<int>' (aka 'int __attribute__((matrix_type(4, 4)))') \
+to 'vec' (vector of 1 'int' value) is not allowed}}
+  (matrix_4_4<char>)v; // expected-error {{C-style cast from 'vec' (vector of 1 'int' value) to 'matrix_4_4<char>' \
+(aka 'char __attribute__((matrix_type(4, 4)))') is not allowed}}
+
+  (test_struct *)m1;    // expected-error {{cannot cast from type 'matrix_4_4<char>' (aka 'char __attribute__\
+((matrix_type(4, 4)))') to pointer type 'test_struct *}}'
+  (matrix_5_5<float>)s; // expected-error {{C-style cast from 'test_struct *' to 'matrix_5_5<float>' (aka 'float __attribute__\
+((matrix_type(5, 5)))') is not allowed}}'
+}
+
+void f2() {
+  // TODO: Update this test once the support of C-style casts for C++ is implemented.
+  matrix_4_4<float> m1;
+  matrix_5_5<double> m2;
+  matrix_5_5<signed int> m3;
+  matrix_4_4<unsigned int> m4;
+  float f;
+
+  (matrix_4_4<double>)m1;       // expected-error {{C-style cast from 'matrix_4_4<float>' (aka 'float __attribute__\
+((matrix_type(4, 4)))') to 'matrix_4_4<double>' (aka 'double __attribute__((matrix_type(4, 4)))') is not allowed}}
+  (matrix_5_5<float>)m2;        // expected-error {{C-style cast from 'matrix_5_5<double>' (aka 'double __attribute__\
+((matrix_type(5, 5)))') to 'matrix_5_5<float>' (aka 'float __attribute__((matrix_type(5, 5)))') is not allowed}}
+  (matrix_5_5<unsigned int>)m3; // expected-error {{C-style cast from 'matrix_5_5<int>' (aka 'int __attribute__\
+((matrix_type(5, 5)))') to 'matrix_5_5<unsigned int>' (aka 'unsigned int __attribute__((matrix_type(5, 5)))') \
+is not allowed}}
+  (matrix_4_4<int>)m4;          // expected-error {{C-style cast from 'matrix_4_4<unsigned int>' (aka 'unsigned int \
+__attribute__((matrix_type(4, 4)))') to 'matrix_4_4<int>' (aka 'int __attribute__((matrix_type(4, 4)))') is not \
+allowed}}
+}