[Matrix] Add asserts for mismatched element types.

[braedy]

Summary

This patch clarifies the failing point of having input or output vectors
of differing types. Before, lowering would fail elsewhere (e.g. in
fmul creation) which may have been not immediately clear.

As a side effect, the getElementType and getVectoryTy functions
required the const qualifier to be added.

[fhahn]

LGTM, thanks!

I *think* thanks to @SjoerdMeijer 's recent improvements to the IR verifier, some of those cases should be caught directly by the verifier. But those assertions are helpful in any case, to explicitly state the assumption in the code.

[SjoerdMeijer]

Yep, think so too that this should be caught by the Verifier, but like you said, doesn't hurt to have them here too.

[braedy]

I was unaware of these changes to the verifier but like you've said, it's still reasonable. The side effect of adding the const qualifier is also useful to me in a future patch.

@fhahn Can you push this?

[fhahn]

In D84374#2169301, @braedy wrote:

I was unaware of these changes to the verifier but like you've, it's still reasonable. The side effect of adding the const qualifier is also useful to me in a future patch.

@fhahn Can you push this?

Sure, could let me know the name & email I should use to set the author of the commit?

[braedy]

Braedy Kuzma
[e-mail]

[fhahn]

Great, thanks!

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

public:
     }
     Value *getRow(unsigned i) const {
       assert(!isColumnMajor() && "only supported for row-major matrixes");
       return Vectors[i];
     }
 
     void setVector(unsigned i, Value *V) { Vectors[i] = V; }
 
-    Type *getElementType() { return getVectorTy()->getElementType(); }
+    Type *getElementType() const { return getVectorTy()->getElementType(); }
 
     unsigned getNumVectors() const {
       if (isColumnMajor())
         return getNumColumns();
       return getNumRows();
     }
 
     unsigned getNumColumns() const {
public:
     }
 
     void addVector(Value *V) { Vectors.push_back(V); }
     VectorType *getColumnTy() {
       assert(isColumnMajor() && "only supported for column-major matrixes");
       return getVectorTy();
     }
 
-    VectorType *getVectorTy() {
+    VectorType *getVectorTy() const {
       return cast<VectorType>(Vectors[0]->getType());
     }
 
     iterator_range<SmallVector<Value *, 8>::iterator> columns() {
       assert(isColumnMajor() &&
              "columns() only supported for column-major matrixes");
       return make_range(Vectors.begin(), Vectors.end());
     }
public:
   void LowerMultiply(CallInst *MatMul) {
     IRBuilder<> Builder(MatMul);
     auto *EltType = cast<VectorType>(MatMul->getType())->getElementType();
     ShapeInfo LShape(MatMul->getArgOperand(2), MatMul->getArgOperand(3));
     ShapeInfo RShape(MatMul->getArgOperand(3), MatMul->getArgOperand(4));
 
     const MatrixTy &Lhs = getMatrix(MatMul->getArgOperand(0), LShape, Builder);
     const MatrixTy &Rhs = getMatrix(MatMul->getArgOperand(1), RShape, Builder);
+    assert(Lhs.getElementType() == Rhs.getElementType() &&
+           "Matrix multiply argument element types do not match.");
 
     const unsigned R = LShape.NumRows;
     const unsigned C = RShape.NumColumns;
     assert(LShape.NumColumns == RShape.NumRows);
 
     // Initialize the output
     MatrixTy Result(R, C, EltType);
+    assert(Lhs.getElementType() == Result.getElementType() &&
+           "Matrix multiply result element type does not match arguments.");
 
     bool AllowContract = AllowContractEnabled || (isa<FPMathOperator>(MatMul) &&
                                                   MatMul->hasAllowContract());
     emitMatrixMultiply(Result, Lhs, Rhs, AllowContract, Builder, false);
     finalizeLowering(MatMul, Result, Builder);
   }
 
   /// Lowers llvm.matrix.transpose.