Utils to create read/write_variable_region

Utils to create read/write_variable_region intrinsics were added.

Author: dmitryryintel

IGC/VectorCompiler/include/vc/Utils/GenX/IRBuilder.h

@@ -9,12 +9,16 @@ SPDX-License-Identifier: MIT
 #ifndef VC_UTILS_GENX_IRBUILDER_H
 #define VC_UTILS_GENX_IRBUILDER_H
 
+#include "vc/Utils/GenX/Region.h"
+
 #include "Probe/Assertion.h"
 
+#include <llvm/ADT/Twine.h>
 #include <llvm/IR/IRBuilder.h>
 
 namespace llvm {
 class Value;
+class CallInst;
 } // namespace llvm
 
 namespace vc {
@@ -23,6 +27,35 @@ namespace vc {
 // The produced IR is valid only for target that have payload in memory (PIM).
 llvm::Value *getGroupThreadIDForPIM(llvm::IRBuilder<> &IRB);
 
+// Produces IR that reads a region \p R from a vISA variable \p Variable.
+llvm::CallInst *
+createReadVariableRegion(llvm::GlobalVariable &Variable,
+                         const llvm::CMRegion &R, llvm::IRBuilder<> &IRB,
+                         const llvm::Twine &Name = "rd.var.rgn");
+
+// Produces IR that reads a whole vISA variable \p Variable.
+inline llvm::CallInst *
+createReadVariableRegion(llvm::GlobalVariable &Variable, llvm::IRBuilder<> &IRB,
+                         const llvm::Twine &Name = "rd.var.rgn") {
+  return createReadVariableRegion(Variable, {Variable.getValueType()}, IRB,
+                                  Name);
+}
+
+// Produces IR that writes \p Input to a region \p R of a vISA variable
+// \p Variable.
+llvm::CallInst *createWriteVariableRegion(llvm::GlobalVariable &Variable,
+                                          llvm::Value &Input,
+                                          const llvm::CMRegion &R,
+                                          llvm::IRBuilder<> &IRB);
+
+// Produces IR that writes \p Input to a whole vISA variable \p Variable.
+inline llvm::CallInst *createWriteVariableRegion(llvm::GlobalVariable &Variable,
+                                                 llvm::Value &Input,
+                                                 llvm::IRBuilder<> &IRB) {
+  return createWriteVariableRegion(Variable, Input, {Variable.getValueType()},
+                                   IRB);
+}
+
 } // namespace vc
 
 #endif // VC_UTILS_GENX_IRBUILDER_H

IGC/VectorCompiler/include/vc/Utils/General/Types.h

@@ -67,6 +67,16 @@ llvm::Type &fixDegenerateVectorType(llvm::Type &Ty);
 // To some extend this function is the opposite of vc::fixDegenerateVectorType.
 IGCLLVM::FixedVectorType &getVectorType(llvm::Type &Ty);
 
+// Takes \p OrigTy, replaces its scalar type with \p ScalarTy. The produced type
+// is returned.
+// \p OrigTy must be an integer, floating point, pointer type or vector of those
+// types. \p ScalarTy must be an integer, floating point or pointer type.
+// Examples:
+//    (<3 x i32>, i1) -> <3 x i1>
+//    (float, i16) -> i16
+//    (<4 x double>, double) -> <4 x double>
+llvm::Type *setScalarType(llvm::Type &OrigTy, llvm::Type &ScalarTy);
+
 } // namespace vc
 
 #endif // VC_UTILS_GENERAL_TYPES_H

IGC/VectorCompiler/lib/Utils/GenX/IRBuilder.cpp

@@ -8,7 +8,10 @@ SPDX-License-Identifier: MIT
 
 #include "vc/Utils/GenX/IRBuilder.h"
 
+#include "vc/InternalIntrinsics/InternalIntrinsics.h"
+#include "vc/Utils/GenX/Intrinsics.h"
 #include "vc/Utils/GenX/TypeSize.h"
+#include "vc/Utils/General/Types.h"
 
 #include "Probe/Assertion.h"
 #include "llvmWrapper/IR/DerivedTypes.h"
@@ -38,3 +41,34 @@ Value *vc::getGroupThreadIDForPIM(IRBuilder<> &IRB) {
       "r0.bytes");
   return IRB.CreateExtractElement(R0InBytes, TIDIndexInBytes, "r0.tid");
 }
+
+CallInst *vc::createReadVariableRegion(GlobalVariable &Variable,
+                                       const CMRegion &R, IRBuilder<> &IRB,
+                                       const Twine &Name) {
+  IGC_ASSERT_MESSAGE(R.ElementTy == Variable.getValueType()->getScalarType(),
+                     "wrong arguments: region and variable types don't match");
+  Value *Args[] = {&Variable, IRB.getInt32(R.VStride), IRB.getInt32(R.Width),
+                   IRB.getInt32(R.Stride),
+                   IRB.getInt32(R.getOffsetInElements())};
+  Function *Decl = vc::getInternalDeclarationForIdFromArgs(
+      R.getRegionType(), Args, vc::InternalIntrinsic::read_variable_region,
+      *IRB.GetInsertPoint()->getModule());
+  return IRB.CreateCall(Decl, Args, Name);
+}
+
+CallInst *vc::createWriteVariableRegion(GlobalVariable &Variable, Value &Input,
+                                        const CMRegion &R, IRBuilder<> &IRB) {
+  IGC_ASSERT_MESSAGE(R.ElementTy == Variable.getValueType()->getScalarType(),
+                     "wrong arguments: region and variable types don't match");
+  IGC_ASSERT_MESSAGE(R.getRegionType() == Input.getType(),
+                     "wrong arguments: region and input types don't match");
+  IGC_ASSERT_MESSAGE(R.is1D(), "wrong arguments: region must be 1D");
+  auto *Mask = Constant::getAllOnesValue(
+      vc::setScalarType(*Input.getType(), *IRB.getInt1Ty()));
+  Value *Args[] = {&Variable, &Input, IRB.getInt32(R.getDstStride()),
+                   IRB.getInt32(R.getOffsetInElements()), Mask};
+  Function *Decl = vc::getInternalDeclarationForIdFromArgs(
+      IRB.getVoidTy(), Args, vc::InternalIntrinsic::write_variable_region,
+      *IRB.GetInsertPoint()->getModule());
+  return IRB.CreateCall(Decl, Args);
+}

IGC/VectorCompiler/lib/Utils/General/Types.cpp

@@ -130,3 +130,18 @@ IGCLLVM::FixedVectorType &vc::getVectorType(Type &Ty) {
     return cast<IGCLLVM::FixedVectorType>(Ty);
   return *IGCLLVM::FixedVectorType::get(&Ty, 1);
 }
+
+Type *vc::setScalarType(Type &OrigTy, Type &ScalarTy) {
+  IGC_ASSERT_MESSAGE(OrigTy.isFPOrFPVectorTy() || OrigTy.isIntOrIntVectorTy() ||
+                         OrigTy.isPtrOrPtrVectorTy(),
+                     "wrong argument: OrigType must be an int, float, pointer "
+                     "or vector of those");
+  IGC_ASSERT_MESSAGE(
+      ScalarTy.isFloatingPointTy() || ScalarTy.isIntegerTy() ||
+          ScalarTy.isPointerTy(),
+      "wrong argument: ScalarTy must be an int, float or pointer");
+  if (!isa<IGCLLVM::FixedVectorType>(OrigTy))
+    return &ScalarTy;
+  return IGCLLVM::FixedVectorType::get(
+      &ScalarTy, cast<IGCLLVM::FixedVectorType>(OrigTy).getNumElements());
+}