Added support for m8n8k4

Author: TejaX-Alaghari

clang/lib/DPCT/RulesAsm/AsmMigration.cpp

@@ -556,6 +556,9 @@ bool SYCLGenBase::emitVectorType(const InlineAsmVectorType *T) {
     return SYCLGenError();
   OS() << ", ";
   switch (T->getKind()) {
+  case InlineAsmVectorType::v1:
+    OS() << 1;
+    break;
   case InlineAsmVectorType::v2:
     OS() << 2;
     break;
@@ -1342,7 +1345,7 @@ class SYCLGen : public SYCLGenBase {
       return SYCLGenError();
 
     // Register sizes for vector elements of A, B, C & D matrices
-    int NumVecElements[4] = {0};
+    unsigned NumVecElements[4] = {0};
 
     // Data type used to multiply A & B matrices
     std::string MulType;
@@ -1351,8 +1354,8 @@ class SYCLGen : public SYCLGenBase {
       if (AType->getKind() == InlineAsmBuiltinType::f16) {
         // If A matrix type is f16, then C&D matrix types can only be f16
         if (CType->getKind() == AType->getKind()) {
-          NumVecElements[0] = 4; // A
-          NumVecElements[1] = 2; // B
+          NumVecElements[0] = 2; // A
+          NumVecElements[1] = 4; // B
           NumVecElements[2] = 4; // C
           NumVecElements[3] = 4; // D
         } else
@@ -1364,23 +1367,23 @@ class SYCLGen : public SYCLGenBase {
       if (AType->getKind() == InlineAsmBuiltinType::f16) {
         // If A matrix type is f16, then C&D matrix types can only be f16/f32
         if (CType->getKind() == AType->getKind()) {
-          NumVecElements[0] = 4; // A
+          NumVecElements[0] = 2; // A
           NumVecElements[1] = 2; // B
-          NumVecElements[2] = 2; // C
+          NumVecElements[2] = 4; // C
           NumVecElements[3] = 4; // D
         } else if (CType->getKind() == InlineAsmBuiltinType::f32) {
-          NumVecElements[0] = 8; // A
+          NumVecElements[0] = 2; // A
           NumVecElements[1] = 2; // B
-          NumVecElements[2] = 2; // C
+          NumVecElements[2] = 8; // C
           NumVecElements[3] = 8; // D
         } else
           return SYCLGenError();
       } else if (AType->getKind() == InlineAsmBuiltinType::f64) {
         // If A matrix type is f64, then C&D matrix types can only be f64
         if (CType->getKind() == AType->getKind()) {
-          NumVecElements[0] = 2; // A
+          NumVecElements[0] = 1; // A
           NumVecElements[1] = 1; // B
-          NumVecElements[2] = 1; // C
+          NumVecElements[2] = 2; // C
           NumVecElements[3] = 2; // D
         } else
           return SYCLGenError();
@@ -1411,15 +1414,16 @@ class SYCLGen : public SYCLGenBase {
       if (isa<InlineAsmDiscardExpr>(DMatVE->getElement(Inst)))
         continue;
       OS() << "&";
-      if (emitStmt(VE->getElement(Inst)))
+      if (emitStmt(DMatVE->getElement(Inst)))
         return SYCLGenError();
       OS() << ", ";
     }
 
     // Add A, B & C matrix values to compute MAD
     for (unsigned InputOp = 0; InputOp < Inst->getNumInputOperands();
          InputOp++) {
-      if (VE = dyn_cast<InlineAsmVectorExpr>(Inst->getInputOperand(InputOp))) {
+      if (auto VE =
+              dyn_cast<InlineAsmVectorExpr>(Inst->getInputOperand(InputOp))) {
         for (unsigned Inst = 0; Inst != VE->getNumElements(); ++Inst) {
           if (isa<InlineAsmDiscardExpr>(VE->getElement(Inst)))
             continue;

clang/lib/DPCT/RulesAsm/Parser/AsmNodes.h

@@ -116,7 +116,7 @@ class InlineAsmBuiltinType : public InlineAsmType {
 // This class is used for device asm vector types.
 class InlineAsmVectorType : public InlineAsmType {
 public:
-  enum VecKind { v2, v4, v8 };
+  enum VecKind { v1, v2, v4, v8 };
 
 private:
   VecKind Kind;

clang/lib/DPCT/RulesAsm/Parser/AsmParser.cpp

@@ -739,6 +739,9 @@ InlineAsmParser::ActOnVectorExpr(ArrayRef<InlineAsmExpr *> Vec) {
   // Vector size must be 2, 4, or 8.
   InlineAsmVectorType::VecKind Kind;
   switch (Vec.size()) {
+  case 1:
+    Kind = InlineAsmVectorType::v1;
+    break;
   case 2:
     Kind = InlineAsmVectorType::v2;
     break;

clang/lib/DPCT/RulesAsm/Parser/AsmParser.h

@@ -496,7 +496,7 @@ class InlineAsmParser {
   ///           .reg .sreg .const .local .param .shared .tex
   ///
   ///   vector-specifier: one of
-  ///           .v2 .v4 .v8
+  ///           .v1 .v2 .v4 .v8
   ///
   ///   type-specifier: one of
   ///           .b8 .b16 .b32 .b64 .s8 .s16 .s32 .s64

clang/lib/DPCT/RulesAsm/Parser/AsmTokenKinds.def

@@ -270,6 +270,7 @@ BUILTIN_TYPE(s16x2,       ".s16x2")
 BUILTIN_TYPE(u16x2,       ".u16x2")
 
 // Vector modifiers
+MODIFIER(v1, ".v1")
 MODIFIER(v2, ".v2")
 MODIFIER(v4, ".v4")
 MODIFIER(v8, ".v8")

clang/runtime/dpct-rt/include/dpct/math.hpp

@@ -2086,7 +2086,8 @@ void mma(CDType *d0, CDType *d1, CDType *d2, CDType *d3, ABType a0, ABType a1,
 
   short COL_LOAD_OFFSET = 4 * ((lane % 16) / 4);
 
-  ABType recv_a[2] recv_a[0] = a0;
+  ABType recv_a[2];
+  recv_a[0] = a0;
   recv_a[1] = a1;
 
   MulType *ra = reinterpret_cast<MulType *>(recv_a);
@@ -2117,10 +2118,10 @@ void mma(CDType *d0, CDType *d1, CDType *d2, CDType *d3, ABType a0, ABType a1,
     }
   }
 
-  d0 = c0;
-  d1 = c1;
-  d2 = c2;
-  d3 = c3;
+  *d0 = c0;
+  *d1 = c1;
+  *d2 = c2;
+  *d3 = c3;
 }
 
 /// Multiplies 2 8x4 & 4x8 matrices and accumulates the result to a 8x8 b32
@@ -2202,14 +2203,14 @@ void mma(CDType *d0, CDType *d1, CDType *d2, CDType *d3, CDType *d4, CDType *d5,
     c7 += static_cast<CDType>(ra[i + 4]) * static_cast<CDType>(rb[i + 12]);
   }
 
-  d0 = c0;
-  d1 = c1;
-  d2 = c2;
-  d3 = c3;
-  d4 = c4;
-  d5 = c5;
-  d6 = c6;
-  d7 = c7;
+  *d0 = c0;
+  *d1 = c1;
+  *d2 = c2;
+  *d3 = c3;
+  *d4 = c4;
+  *d5 = c5;
+  *d6 = c6;
+  *d7 = c7;
 }
 
 /// Multiplies 2 8x4 & 4x8 matrices and accumulates the result to a 8x8 b32
@@ -2246,8 +2247,8 @@ void mma(CDType *d0, CDType *d1, ABType a0, ABType b0, CDType c0, CDType c1,
     c1 += recv_a * recv_b;
   }
 
-  d0 = c0;
-  d1 = c1;
+  *d0 = c0;
+  *d1 = c1;
 }
 
 /// Multiplies 2 16x16 & 16x8 matrices and accumulates the result to a 16x8 b32