Improve struct support in EmitPass

* Emit LifetimeStart on insertvalue to improve codegen.
* Implement emitting select for structs
* Improve struct symbol elision on insertvalue

Author: jaladreips

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -2118,7 +2118,8 @@ CVariable* CShader::GetStructVariable(llvm::Value* v)
         isa<InsertValueInst>(v) ||
         isa<CallInst>(v) ||
         isa<Argument>(v) ||
-        isa<PHINode>(v),
+        isa<PHINode>(v) ||
+        isa<SelectInst>(v),
         "Invalid instruction using struct type!");
 
     if (isa<InsertValueInst>(v))
@@ -2176,6 +2177,29 @@ CVariable* CShader::GetStructVariable(llvm::Value* v)
             }
         }
     }
+    else if (auto* SI = dyn_cast<SelectInst>(v))
+    {
+        if (IGC_IS_FLAG_ENABLED(EnableDeSSA) && m_deSSA)
+        {
+            e_alignment pAlign = EALIGN_GRF;
+            Value* rVal = m_deSSA->getRootValue(v, &pAlign);
+
+            // If a struct type is coalesced with another non-struct type,
+            // need to call createAliasIfNeeded().  Otherwise, all coalesced
+            // structs are of the same type (Byte).
+            if (rVal && !rVal->getType()->isStructTy()) {
+                CVariable* rootV = GetSymbol(rVal);
+                return createAliasIfNeeded(v, rootV);
+            }
+
+            v = rVal ? rVal : v;
+            auto it = symbolMapping.find(v);
+            if (it != symbolMapping.end())
+            {
+                return it->second;
+            }
+        }
+    }
     else if (isa<CallInst>(v) || isa<Argument>(v))
     {
         // For now, special handling of bitcasttostruct intrinsic

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -2993,6 +2993,7 @@ void EmitPass::EmitInsertValueToStruct(InsertValueInst* inst)
         CVariable* SrcV = GetSymbol(src0);
         if (DstV != SrcV)
         {
+            m_encoder->Lifetime(VISAVarLifetime::LIFETIME_START, DstV);
             // Only copy SrcV's elements that have been initialized already.
             // For the example, DstV = %13, SrcV = %9;
             // 'toBeCopied' will be field {0, 1}, not {0,1,2,3}.
@@ -3278,6 +3279,60 @@ void EmitPass::EmitExtractValueFromLayoutStruct(ExtractValueInst* EVI)
     }
 }
 
+void EmitPass::EmitSelectStruct(SelectInst* SI)
+{
+    StructType* sTy = dyn_cast<StructType>(SI->getType());
+    IGC_ASSERT_MESSAGE(sTy, "This method is only for structs");
+
+    const uint32_t nLanes = numLanes(m_currShader->m_SIMDSize);
+
+    auto* srcTrueV = SI->getTrueValue();
+    auto* srcFalseV = SI->getFalseValue();
+
+    auto* srcTrueS = GetSymbol(srcTrueV);
+    auto* srcFalseS = GetSymbol(srcFalseV);
+    auto* destS = GetSymbol(SI);
+    auto* cond = GetSymbol(SI->getCondition());
+
+    if (srcTrueS != destS && srcFalseS != destS)
+        // if we aren't coalescing with any of the operands, emit lifetime start for the struct
+        m_encoder->Lifetime(VISAVarLifetime::LIFETIME_START, destS);
+
+    auto iterator = {
+        std::make_tuple(srcTrueV, srcTrueS, false),
+        std::make_tuple(srcFalseV, srcFalseS, true)
+    };
+
+    for (auto [srcV, srcS, inv] : iterator)
+    {
+        // For now, do not support uniform dst and non-uniform src
+        IGC_ASSERT_MESSAGE(!srcS->IsUniform() || srcS->IsUniform() == destS->IsUniform(),
+            "Can't select non-uniform value into a uniform struct!");
+
+        if (srcS == destS)
+            continue;
+
+        SmallVector<std::vector<unsigned>> toBeCopied;
+        getAllDefinedMembers(srcV, toBeCopied);
+        for (const auto& II : toBeCopied)
+        {
+
+            Type* ty;
+            uint32_t byteOffset;
+            getStructMemberByteOffsetAndType_1(m_DL, sTy, II, ty, byteOffset);
+
+            uint32_t d_off =
+                byteOffset * (destS->IsUniform() ? 1 : nLanes);
+            uint32_t s_off =
+                byteOffset * (srcS->IsUniform() ? 1 : nLanes);
+
+            m_encoder->SetPredicate(cond);
+            m_encoder->SetInversePredicate(inv);
+            emitMayUnalignedVectorCopy(destS, d_off, srcS, s_off, ty);
+        }
+    }
+}
+
 void EmitPass::EmitAddPair(GenIntrinsicInst* GII, const SSource Sources[4], const DstModifier& DstMod) {
     auto [L, H] = getPairOutput(GII);
     CVariable* Lo = L ? GetSymbol(L) : nullptr;
@@ -5135,7 +5190,6 @@ void EmitPass::Select(const SSource sources[3], const DstModifier& modifier)
 
     m_encoder->Select(flag, m_destination, src0, src1);
     m_encoder->Push();
-
 }
 
 void EmitPass::PredAdd(const SSource& pred, bool invert, const SSource sources[2], const DstModifier& modifier)
@@ -11706,6 +11760,9 @@ void EmitPass::EmitNoModifier(llvm::Instruction* inst)
     case Instruction::ExtractValue:
         EmitExtractValueFromStruct(cast<ExtractValueInst>(inst));
         break;
+    case Instruction::Select:
+        EmitSelectStruct(cast<SelectInst>(inst));
+        break;
     case Instruction::Unreachable:
         break;
     default:

IGC/Compiler/CISACodeGen/EmitVISAPass.hpp

@@ -158,6 +158,7 @@ class EmitPass : public llvm::FunctionPass
     void EmitExtractValueFromStruct(llvm::ExtractValueInst* EI);
     void EmitInsertValueToLayoutStruct(llvm::InsertValueInst* IVI);
     void EmitExtractValueFromLayoutStruct(llvm::ExtractValueInst* EVI);
+    void EmitSelectStruct(llvm::SelectInst* SI);
     void emitVectorCopyToAOS(uint32_t AOSBytes,
         CVariable* Dst, CVariable* Src, uint32_t nElts,
         uint32_t DstSubRegOffset = 0, uint32_t SrcSubRegOffset = 0) {

IGC/Compiler/CISACodeGen/PatternMatchPass.cpp

@@ -3811,6 +3811,9 @@ namespace IGC
 
     bool CodeGenPatternMatch::MatchSelectModifier(llvm::SelectInst& I)
     {
+        if (I.getType()->isAggregateType())
+            return MatchSingleInstruction(I);
+
         struct SelectPattern : Pattern
         {
             SSource sources[3];