fixed loading of constant structs by ConstantLoader

constant returns are not allowed, and PostLegalization is expected to
insert a proper constant loading sequence. However, if we return a
constant structure, before this patch the generated sequence looked like
this:

```
ret { <4 x i32> } { <4 x i32> <i32 1, i32 1, i32 1, i32 1> })
```
->
```
%const_val = call { <4 x i32> } @llvm.genx.constanti.s1v4i32(
            { <4 x i32> } { <4 x i32> <i32 1, i32 1, i32 1, i32 1> })
ret %const_val
```

Issue: *genx.constanti* is designed to handle proper vector types, not
aggregates!

This commit introduces the following changes:
1. All constant structures are treated as non-simple constants and
always loaded by loadNonSimpleConstants
2. Undef values are left as is
3. ConstantLoader class must not be used with aggregate types (including
structs).

NOTE_1: In theory, restriction #3 can be relaxed by allowing
ConstantLoader to operate on such types. 2 minor issues are prevent us
from  doing that:
I. I haven't observed such cases in practice :).
II. This would require us to handle *undef* values. The resulting code
looks extremely quirky as the constant loader must produce instruction,
not a value.

NOTE_2: This change may not solve all the remaining issues with constant
structures. For example - loadPhiConstants could potentially encounter a
constant struct. If this happens in practice - then we must
relax our restrictions on ConsantLoader (see NOTE_1).

Author: aparshin-intel

IGC/VectorCompiler/lib/GenXCodeGen/GenXConstants.cpp

@@ -113,9 +113,10 @@ using namespace genx;
 /***********************************************************************
  * loadConstantStruct : insert instructions to load a constant struct
  */
-static Value *loadConstantStruct(Constant *C, Instruction *InsertBefore,
-                                 const GenXSubtarget &Subtarget,
-                                 const DataLayout &DL) {
+static Value *loadConstantStruct(
+    Constant *C, Instruction *InsertPt, const GenXSubtarget &Subtarget,
+    const DataLayout &DL,
+    SmallVectorImpl<Instruction *> *AddedInstructions = nullptr) {
   auto ST = cast<StructType>(C->getType());
   Value *Agg = UndefValue::get(ST);
   for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
@@ -124,10 +125,17 @@ static Value *loadConstantStruct(Constant *C, Instruction *InsertBefore,
       continue;
     Value *LoadedEl = nullptr;
     if (isa<StructType>(El->getType()))
-      LoadedEl = loadConstantStruct(El, InsertBefore, Subtarget, DL);
-    else
-      LoadedEl = ConstantLoader(El, Subtarget, DL).load(InsertBefore);
-    Agg = InsertValueInst::Create(Agg, LoadedEl, i, "loadstruct", InsertBefore);
+      LoadedEl =
+          loadConstantStruct(El, InsertPt, Subtarget, DL, AddedInstructions);
+    else {
+      LoadedEl = ConstantLoader(El, Subtarget, DL, nullptr, AddedInstructions)
+                     .loadBig(InsertPt);
+    }
+    auto *InsertInst =
+        InsertValueInst::Create(Agg, LoadedEl, i, "loadstruct", InsertPt);
+    Agg = InsertInst;
+    if (AddedInstructions)
+      AddedInstructions->push_back(InsertInst);
   }
   return Agg;
 }
@@ -170,6 +178,12 @@ bool genx::loadNonSimpleConstants(
         continue;
       if (opMustBeConstant(Inst, i))
         continue;
+      if (C->getType()->isStructTy()) {
+        *U = loadConstantStruct(C, Inst, Subtarget, DL, AddedInstructions);
+        Modified = true;
+        continue;
+      }
+
       ConstantLoader CL(C, Subtarget, DL, Inst, AddedInstructions);
       if (CL.needFixingSimple()) {
         Modified = true;
@@ -307,8 +321,10 @@ bool genx::loadConstants(Instruction *Inst, const GenXSubtarget &Subtarget,
     if (Ret->getNumOperands() && Ret->getParent()->getParent()->getLinkage()
           == GlobalValue::InternalLinkage) {
       if (auto C = dyn_cast<Constant>(Ret->getOperand(0))) {
-        if (!C->getType()->isVoidTy())
+        if (!C->getType()->isVoidTy() && !isa<UndefValue>(C)) {
           Ret->setOperand(0, ConstantLoader(C, Subtarget, DL).load(Ret));
+          Modified = true;
+        }
       }
     }
     return Modified;

IGC/VectorCompiler/lib/GenXCodeGen/GenXConstants.h

@@ -15,6 +15,8 @@ SPDX-License-Identifier: MIT
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 
+#include "Probe/Assertion.h"
+
 namespace llvm {
 namespace genx {
 
@@ -60,6 +62,8 @@ class ConstantLoader {
                  SmallVectorImpl<Instruction *> *AddedInstructions = nullptr)
       : C(C), User(User), Subtarget(InSubtarget), DL(InDL),
         AddedInstructions(AddedInstructions) {
+    IGC_ASSERT_MESSAGE(!C->getType()->isAggregateType(),
+                       "aggregate types are not supported by constant loader");
     analyze();
   }