Fixing ArgSize calculation for metadata type function argument in OpenCLPasses -> PrivateMemoryResolution and fix of invalid "sret" LegalizeFunctionSignatures void to struct transformation

In such case

```
...
call void @llvm.experimental.noalias.scope.decl(metadata !805)
...

; Function Attrs: nounwind
declare spir_func %structtype @__devicelib_catanf(%structtype sret(%structtype) align 4 %0) #2

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
declare void @llvm.experimental.noalias.scope.decl(metadata %0) #3

!805 = !{!806}
!806 = distinct !{!806, !807, !"catanf: argument 0"}
!807 = distinct !{!807, !"catanf"}
```

When PrivateMemoryResolution was "recursively calculating the max private mem usage of all callees"
Then during processing function argument that is MetadataTy it was failing due to

```
Assertion failed: Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!",
file ...\dump64\llvm-deps-16.0.6\src\llvm\lib\IR\DataLayout.cpp, line 751
````

So I added check for MetadataTy which skips it.

Additionally `LegalizeFunctionSignatures` was transforming the return type of void function that used sret() as its argument.
The LLVM IR verifier didnt like that since the docs state that:
`A function that accepts an sret argument must return void. A return value may not be sret.`

I've decided to perform skip on sret cases in that pass.

Author: bokrzesi

IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp

@@ -294,6 +294,18 @@ void LegalizeFunctionSignatures::FixFunctionSignatures(Module& M)
         // Create the new function signature by replacing the illegal types
         if (FunctionHasPromotableSRetArg(M, pFunc))
         {
+            // According to docs: https://llvm.org/docs/LangRef.html
+            // "A function that accepts an sret argument must return void. A return value may not be sret."
+            // So I'm skipping further modifications of such functions
+            // Because e.g
+            // spir_func void @__devicelib_catanf(%structtype addrspace(4)* sret(%structtype) align 4, (...)
+            // Was changed into
+            // declare spir_func %structtype @__devicelib_catanf(%structtype sret(%structtype) align 4)
+            // Which resulted in:
+            // Invalid struct return type!
+            // % structtype(% structtype)* @__devicelib_catanf
+            continue;
+
             retTypeOption = ReturnOpt::RETURN_STRUCT;
             ai++; // Skip adding the first arg
         }

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp

@@ -374,7 +374,12 @@ bool PrivateMemoryResolution::runOnModule(llvm::Module& M)
                 for (auto AI = childF->arg_begin(), AE = childF->arg_end(); AI != AE; ++AI)
                 {
                     // Argument offsets are also OWORD aligned
-                    argSize += iSTD::Align(static_cast<DWORD>(DL.getTypeAllocSize(AI->getType())), SIZE_OWORD);
+                    auto aiTy = AI->getType();
+
+                    if (aiTy->isMetadataTy())
+                        continue;
+
+                    argSize += iSTD::Align(static_cast<DWORD>(DL.getTypeAllocSize(aiTy)), SIZE_OWORD);
                 }
                 // Also do it for return value
                 if (!childF->getReturnType()->isVoidTy())

IGC/Compiler/tests/LegalizeFunctionSignatures/fix-struct-ret-args.ll

@@ -12,7 +12,6 @@
 ; ------------------------------------------------
 
 ; Pseudo-code:
-; Before:
 ;   void foo()
 ;   {
 ;     st_foo a;
@@ -29,81 +28,37 @@
 ;   {
 ;     *out = {1, 2};
 ;   }
-; After:
-;   void foo()
-;   {
-;     st_foo a;
-;     a = bar_0();
-;     consume(&a);
-;   }
-;
-;   st_foo bar_0()
-;   {
-;     return bar_1();
-;   }
-;
-;   st_foo bar_1(st_foo* in)
-;   {
-;     st_foo out = {1, 2};
-;     return out;
-;   }
 
 %struct._st_foo = type { i32, i32 }
 
 define spir_kernel void @foo() #1 {
 ; CHECK:      define spir_kernel void @foo()
-    %a = alloca %struct._st_foo
 ; CHECK-NEXT:     [[A:%.*]] = alloca %struct._st_foo, align 8
+; CHECK-NEXT:     call void @bar_0(ptr sret(%struct._st_foo) [[A]])
+; CHECK-NEXT:     call void @consume(ptr [[A]])
+; CHECK-NEXT:     ret void
+    %a = alloca %struct._st_foo
     call void @bar_0(ptr sret(%struct._st_foo) %a)
-; CHECK-NEXT:     [[RET_BAR_0:%.*]] = call %struct._st_foo @bar_0()
-; CHECK-NEXT:     [[M_0_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[A]], i32 0, i32 0
-; CHECK-NEXT:     [[M_0:%.*]] = extractvalue %struct._st_foo [[RET_BAR_0]], 0
-; CHECK-NEXT:     store i32 [[M_0]], ptr [[M_0_PTR]], align 4
-; CHECK-NEXT:     [[M_1_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[A]], i32 0, i32 1
-; CHECK-NEXT:     [[M_1:%.*]] = extractvalue %struct._st_foo [[RET_BAR_0]], 1
-; CHECK-NEXT:     store i32 [[M_1]], ptr [[M_1_PTR]], align 4
     call void @consume(ptr %a)
-; CHECK-NEXT:     call void @consume(ptr [[A]])
     ret void
-; CHECK-NEXT:     ret void
 }
 ; CHECK-NEXT: }
 
 define linkonce_odr spir_func void @bar_0(ptr sret(%struct._st_foo) %out) {
-; CHECK:      define linkonce_odr spir_func %struct._st_foo @bar_0()
-; CHECK-NEXT:   [[OUT:%.*]] = alloca %struct._st_foo, align 8
+; CHECK:      define linkonce_odr spir_func void @bar_0(ptr sret(%struct._st_foo) %out) {
+; CHECK-NEXT: call void @bar_1(ptr sret(%struct._st_foo) %out)
+; CHECK-NEXT: ret void
     call void @bar_1(ptr sret(%struct._st_foo) %out)
-; CHECK-NEXT:     [[RET_BAR_1:%.*]] = call %struct._st_foo @bar_1()
-; CHECK-NEXT:     [[M_0_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 0
-; CHECK-NEXT:     [[M_0:%.*]] = extractvalue %struct._st_foo [[RET_BAR_1]], 0
-; CHECK-NEXT:     store i32 [[M_0]], ptr [[M_0_PTR]], align 4
-; CHECK-NEXT:     [[M_1_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 1
-; CHECK-NEXT:     [[M_1:%.*]] = extractvalue %struct._st_foo [[RET_BAR_1]], 1
-; CHECK-NEXT:     store i32 [[M_1]], ptr [[M_1_PTR]], align 4
     ret void
-; CHECK-NEXT:   [[M_0_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 0
-; CHECK-NEXT:   [[M_0:%.*]] = load i32, ptr [[M_0_PTR]], align 4
-; CHECK-NEXT:   [[R_0:%.*]] = insertvalue %struct._st_foo undef, i32 [[M_0]], 0
-; CHECK-NEXT:   [[M_1_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 1
-; CHECK-NEXT:   [[M_1:%.*]] = load i32, ptr [[M_1_PTR]], align 4
-; CHECK-NEXT:   [[R_1:%.*]] = insertvalue %struct._st_foo [[R_0]], i32 [[M_1]], 1
-; CHECK-NEXT:   ret %struct._st_foo [[R_1]]
 }
 ; CHECK-NEXT: }
 
 define linkonce_odr spir_func void @bar_1(ptr sret(%struct._st_foo) %out) {
-; CHECK:      define linkonce_odr spir_func %struct._st_foo @bar_1()
-; CHECK-NEXT:   [[OUT:%.*]] = alloca %struct._st_foo, align 8
+; CHECK:      define linkonce_odr spir_func void @bar_1(ptr sret(%struct._st_foo) %out) {
+; CHECK-NEXT:   store %struct._st_foo { i32 1, i32 2 }, ptr %out, align 4
+; CHECK-NEXT:   ret void
     store %struct._st_foo { i32 1, i32 2 }, ptr %out, align 4
-; CHECK-NEXT:   store %struct._st_foo { i32 1, i32 2 }, ptr [[OUT]], align 4
     ret void
-; CHECK-NEXT:   [[M_0_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 0
-; CHECK-NEXT:   [[M_0:%.*]] = load i32, ptr [[M_0_PTR]], align 4
-; CHECK-NEXT:   [[R_0:%.*]] = insertvalue %struct._st_foo undef, i32 [[M_0]], 0
-; CHECK-NEXT:   [[M_1_PTR:%.*]] = getelementptr inbounds %struct._st_foo, ptr [[OUT]], i32 0, i32 1
-; CHECK-NEXT:   [[M_1:%.*]] = load i32, ptr [[M_1_PTR]], align 4
-; CHECK-NEXT:   [[R_1:%.*]] = insertvalue %struct._st_foo [[R_0]], i32 [[M_1]], 1
-; CHECK-NEXT:   ret %struct._st_foo [[R_1]]
 }
 ; CHECK-NEXT: }