Hash mov fix

insert mov after EOT or at the entry. For example,

(W)     send.gtwy (1|M0)   null     r127    null:0  0x0      0x02000010           {EOT,F@1}
        nop
(W)     mov (16|M0)        null<1>:ud    0x2D1D3FFE:ud
(W)     mov (16|M0)        null<1>:ud    0xF6824120:ud
(W)     mov (16|M0)        null<1>:ud    0x0:ud
(W)     mov (16|M0)        null<1>:ud    0x4:ud

This change:
  1. make sure the hash mov order is as below:
         mov       hashmovs's hi
         mov       hashmovs's lo
        [mov       hashmovs1's hi
         mov       hashmovs1's lo]

      hashmovs1 is optional.  Previously, visa did "mov lo" first before "mov hi".
      This change makes sure hi goes before lo to be consistent with flag.

      Also, scalar IGC generates "hashmovs/hashmovs1  lo hi", which has the wrong order
      of hi and lo. This change also fixed that.

  2. For OCL, use kernel dump id as hashmovs1's lo, and set its hi to zero.
     For example,
       a dump kernel: OCL_asmf68241202d1d3ffe_simd16_entry_0005.asm,
     it has:
       hashmovs1's lo = 5.
       hashmovs1's hi = 0.

Author: jgu222

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -3832,22 +3832,29 @@ namespace IGC
                 params.push_back(param_uptr(OptName, literal_deleter));
                 std::string Low = std::to_string((DWORD)Hash);
                 std::string High = std::to_string((DWORD)(Hash >> 32));
-                params.push_back(param_uptr(_strdup(Low.c_str()), dup_deleter));
                 params.push_back(param_uptr(_strdup(High.c_str()), dup_deleter));
+                params.push_back(param_uptr(_strdup(Low.c_str()), dup_deleter));
             };
 
             QWORD AssemblyHash = context->hash.getAsmHash();
 
 
             addHash("-hashmovs", AssemblyHash);
+            if (context->type == ShaderType::OPENCL_SHADER)
+            {
+                uint32_t kernelId = context->getFunctionID(m_program->entry);
+                addHash("-hashmovs1", (QWORD)kernelId);
+            }
+            else {
 
-            QWORD NosHash = context->hash.getNosHash();
-            QWORD PsoHash = context->hash.getPsoHash();
-            QWORD hashToUse = NosHash != 0 ? NosHash : PsoHash;
-            if (hashToUse)
-                addHash("-hashmovs1", hashToUse);
-            else if (context->hash.getPerShaderPsoHash() != 0)
-                addHash("-hashmovs1", context->hash.getPerShaderPsoHash());
+                QWORD NosHash = context->hash.getNosHash();
+                QWORD PsoHash = context->hash.getPsoHash();
+                QWORD hashToUse = NosHash != 0 ? NosHash : PsoHash;
+                if (hashToUse)
+                    addHash("-hashmovs1", hashToUse);
+                else if (context->hash.getPerShaderPsoHash() != 0)
+                    addHash("-hashmovs1", context->hash.getPerShaderPsoHash());
+            }
         }
     }
 

visa/Optimizer.cpp

@@ -326,13 +326,13 @@ void Optimizer::insertHashMovs() {
     for (auto it = bb->begin(); it != bb->end(); ++it) {
       auto inst = (*it);
       if (inst->isEOT() || hashAtPrologue) {
+        auto insertBefore = it;
+        if (inst->isLabel())
+          ++insertBefore;
         // We have to insert new instructions after EOT.
         // Lexically, EOT could even be in the middle
         // of the program.
         auto insertHashMovInsts = [&](uint64_t hashVal) {
-          if (hashVal == 0)
-            return;
-
           G4_INST *lo;
           G4_INST *hi;
           lo = kernel.fg.builder->createMov(
@@ -346,29 +346,26 @@ void Optimizer::insertHashMovs() {
               kernel.fg.builder->createImm(
                   (unsigned int)((hashVal >> 32) & 0xffffffff), Type_UD),
               InstOpt_WriteEnable, false);
-
+          // Option: -hashmovs hi lo
+          //   To be consistent, 'mov hi' goes before 'mov lo'
           if (hashAtPrologue) {
-            if (inst->isLabel()) {
-              bb->insertAfter(it, hi);
-              bb->insertAfter(it, lo);
-            } else {
-              bb->insertBefore(it, hi);
-              bb->insertBefore(it, lo);
-            }
+            bb->insertBefore(insertBefore, hi);
+            bb->insertBefore(insertBefore, lo);
           } else {
-            bb->push_back(lo);
             bb->push_back(hi);
+            bb->push_back(lo);
           }
         };
-        uint64_t hashVal1 = builder.getOptions()->getuInt64Option(vISA_HashVal);
-        uint64_t hashVal2 =
+
+        // This func is called when vISA_HashVal is set by user;
+        // but vISA_HashVal1 is still optional.
+        uint64_t hashVal = builder.getOptions()->getuInt64Option(vISA_HashVal);
+        insertHashMovInsts(hashVal);
+        if (builder.getOptions()->isOptionSetByUser(vISA_HashVal1)) {
+          uint64_t hashVal1 =
             builder.getOptions()->getuInt64Option(vISA_HashVal1);
-        // Ensure same order (hashVal1 then hashVal2) by swapping if
-        // we're going to insertAfter().
-        if (hashAtPrologue && inst->isLabel())
-          std::swap(hashVal1, hashVal2);
-        insertHashMovInsts(hashVal1);
-        insertHashMovInsts(hashVal2);
+          insertHashMovInsts(hashVal1);
+        }
         return;
       }
     }