ZEBinary: support implicit arguments const_base and global_base

Allow accessing global and constant variables through implicit arguments
const_base and global_base, for kernel only.

Before this change, global and constant must be accessed through relocations
in ZEBinary path. This prevent them from promoting to BTI at
StatelessToSateful pass.

ZEBinary spec update:
- add new payload_argument types: const_base and global_base
- add bit_value to payload_argument for representing const and global buffers'
  bti index if promoted.

Author: pkwasnie-intel

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -1660,18 +1660,31 @@ namespace IGC
                 payloadPosition, kernelArg->getAllocateSize());
             break;
 
+        case KernelArg::ArgType::IMPLICIT_CONSTANT_BASE:
+        case KernelArg::ArgType::IMPLICIT_GLOBAL_BASE: {
+          auto zeArgType =
+              kernelArg->getArgType() ==
+                      KernelArg::ArgType::IMPLICIT_CONSTANT_BASE
+                  ? zebin::PreDefinedAttrGetter::ArgType::const_base
+                  : zebin::PreDefinedAttrGetter::ArgType::global_base;
+          zebin::zeInfoPayloadArgument &arg =
+              zebin::ZEInfoBuilder::addPayloadArgumentImplicit(
+                  m_kernelInfo.m_zePayloadArgs, zeArgType, payloadPosition,
+                  kernelArg->getAllocateSize());
+          SOpenCLKernelInfo::SResourceInfo resInfo =
+              getResourceInfo(kernelArg->getAssociatedArgNo());
+          unsigned btiValue = getBTI(resInfo);
+          if (btiValue != 0xffffffff)
+            arg.bti_value = btiValue;
+          break;
+        }
+
         // We don't need these in ZEBinary, can safely skip them
         case KernelArg::ArgType::IMPLICIT_R0:
         case KernelArg::ArgType::R1:
         case KernelArg::ArgType::STRUCT:
             break;
 
-        // FIXME: should these be supported?
-        // CONSTANT_BASE and GLOBAL_BASE are not required that we should export
-        // all globals and constants and let the runtime relocate them when enabling
-        // ZEBinary
-        case KernelArg::ArgType::IMPLICIT_CONSTANT_BASE:
-        case KernelArg::ArgType::IMPLICIT_GLOBAL_BASE:
         case KernelArg::ArgType::IMPLICIT_STAGE_IN_GRID_ORIGIN:
         case KernelArg::ArgType::IMPLICIT_STAGE_IN_GRID_SIZE:
         default:

IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp

@@ -248,26 +248,26 @@ bool ProgramScopeConstantAnalysis::runOnModule(Module& M)
         IGC::appendToUsed(M, globalArray);
     }
 
-    // Check if zebin is enabled
-    bool zebinEnable = Ctx->enableZEBinary();
-
-    // patch-token-path:
-    //     Just add the implicit argument to each function if a constant
-    //     buffer has been created.  This will technically burn a patch
-    //     token on kernels that don't actually use the buffer but it saves
-    //     us having to walk the def-use chain (we can't just check if a
-    //     constant is used in the kernel; for example, a global buffer
-    //     may contain pointers that in turn point into the constant
-    //     address space).
-    // zebinary path:
-    //     Don't add the implicit arguments and rely solely on relocations
-    //     for global variable reference since the implicit arguments were
-    //     removed from zebinary.
-    if (!zebinEnable && hasInlineConstantBuffer)
+    // Kernels and Subroutines:
+    //  Add the implicit arg to the function argument list if a constant buffer is created and there
+    //  is no stack calls
+    //
+    // Stackcalls:
+    //  Stackcall ABI does not allow implicit args, so rely on relocation for global variable access
+
+    // Workaround: When there is stringConstants in the module, do not insert
+    // implicit arguments to prevent const vars getting promoted
+    // at statelessToStateful pass. In zebin path, stateful promotion
+    // of const vars can't work well with printf strings.
+    bool skipConstBuffer =
+        Ctx->enableZEBinary() && !m_pModuleMd->stringConstants.empty();
+
+    if (!skipConstBuffer && hasInlineConstantBuffer)
     {
         for (auto& pFunc : M)
         {
             if (pFunc.isDeclaration()) continue;
+
             // Skip functions called from function marked with stackcall attribute
             if (AddImplicitArgs::hasStackCallInCG(&pFunc, *Ctx)) continue;
 
@@ -278,7 +278,7 @@ bool ProgramScopeConstantAnalysis::runOnModule(Module& M)
         }
     }
 
-    if (!zebinEnable && hasInlineGlobalBuffer)
+    if (hasInlineGlobalBuffer)
     {
         for (auto& pFunc : M)
         {

IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantResolution.cpp

@@ -79,13 +79,6 @@ bool ProgramScopeConstantResolution::runOnModule(Module& M)
         return false;
     }
 
-    if (pCtx->enableZEBinary())
-    {
-        // ZEBinary always relies on relocation, so we can ignore this pass
-        return false;
-    }
-
-
     if (RunCautiously) {
         if (!needRunConservatively(M))
             return false;

IGC/ZEBinWriter/zebin/source/autogen/ZEInfo.hpp

@@ -76,7 +76,7 @@ struct zeInfoPayloadArgument
 {
     bool operator==(const zeInfoPayloadArgument& other) const
     {
-        return arg_type == other.arg_type && offset == other.offset && size == other.size && arg_index == other.arg_index && addrmode == other.addrmode && addrspace == other.addrspace && access_type == other.access_type && sampler_index == other.sampler_index && source_offset == other.source_offset && slm_alignment == other.slm_alignment && image_type == other.image_type && image_transformable == other.image_transformable && sampler_type == other.sampler_type && is_pipe == other.is_pipe && is_ptr == other.is_ptr;
+        return arg_type == other.arg_type && offset == other.offset && size == other.size && arg_index == other.arg_index && addrmode == other.addrmode && addrspace == other.addrspace && access_type == other.access_type && sampler_index == other.sampler_index && source_offset == other.source_offset && slm_alignment == other.slm_alignment && image_type == other.image_type && image_transformable == other.image_transformable && sampler_type == other.sampler_type && is_pipe == other.is_pipe && is_ptr == other.is_ptr && bti_value == other.bti_value;
     }
     zeinfo_str_t arg_type;
     zeinfo_int32_t offset = 0;
@@ -93,6 +93,7 @@ struct zeInfoPayloadArgument
     zeinfo_str_t sampler_type;
     zeinfo_bool_t is_pipe = false;
     zeinfo_bool_t is_ptr = false;
+    zeinfo_int32_t bti_value = -1;
 };
 struct zeInfoPerThreadPayloadArgument
 {
@@ -235,7 +236,7 @@ struct zeInfoContainer
     KernelsMiscInfoTy kernels_misc_info;
 };
 struct PreDefinedAttrGetter{
-    static zeinfo_str_t getVersionNumber() { return "1.26"; }
+    static zeinfo_str_t getVersionNumber() { return "1.28"; }
 
     enum class ArgThreadSchedulingMode {
         age_based,
@@ -275,7 +276,9 @@ struct PreDefinedAttrGetter{
         flat_image_pitch,
         sampler_address,
         sampler_normalized,
-        sampler_snap_wa
+        sampler_snap_wa,
+        const_base,
+        global_base
     };
     enum class ArgAddrMode {
         stateless,
@@ -427,6 +430,10 @@ struct PreDefinedAttrGetter{
             return "sampler_normalized";
         case ArgType::sampler_snap_wa:
             return "sampler_snap_wa";
+        case ArgType::const_base:
+            return "const_base";
+        case ArgType::global_base:
+            return "global_base";
         default:
             break;
         }

IGC/ZEBinWriter/zebin/source/autogen/ZEInfoYAML.cpp

@@ -98,6 +98,7 @@ void MappingTraits<zeInfoPayloadArgument>::mapping(IO& io, zeInfoPayloadArgument
     io.mapOptional("sampler_type", info.sampler_type, std::string());
     io.mapOptional("is_pipe", info.is_pipe, false);
     io.mapOptional("is_ptr", info.is_ptr, false);
+    io.mapOptional("bti_value", info.bti_value, -1);
 }
 void MappingTraits<zeInfoPerThreadPayloadArgument>::mapping(IO& io, zeInfoPerThreadPayloadArgument& info)
 {

IGC/ZEBinWriter/zebin/spec/version.md

@@ -7,14 +7,16 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ==========================-->
 
 # ZEBIN Version
-Version 1.26
+Version 1.28
 
 ## Versioning
 Format: \<_Major number_\>.\<_Minor number_\>
 - Major number: Increase when non-backward-compatible features are added. For example, rename attributes or remove attributes.
 - Minor number: Increase when backward-compatible features are added. For example, add new attributes.
 
 ## Change Note
+- **Version 1.28**: Add const_base and global_base to payload arguments.
+- **Version 1.27**: Add has_sample to execution_env.
 - **Version 1.26**: Add rt_global_buffer to payload arguments.
 - **Version 1.25**: Add is_ptr attribute to payload arguments.
 - **Version 1.24**: Add eu_thread_count to execution_env.

IGC/ZEBinWriter/zebin/spec/zeinfo.md

@@ -175,6 +175,7 @@ If an attribute is **Required**, it must be present in payload arguments. If it'
 | sampler_type | <sampler_type> | Optional | | Present when addrspace is "sampler" |
 | is_pipe | bool | Optional | false | Present when arg_type is "arg_bypointer" and type qualifier is pipe |
 | is_ptr | bool | Optional | false | Present when arg_type is "arg_byvalue" and arg is used as pointer |
+| bti_value | int32 | Optional | -1 | Present when arg_type is "const_base", "global_base" and when the buffer is promoted to BTI |
 <!--- PayloadArgument PayloadArguments -->
 
 ### Supported argument types:
@@ -215,6 +216,8 @@ Supported <argument_type> of payload_arguments or per_thread_payload_arguments.
 | sampler_address | | Sampler descriptor specifying the image addressing mode |
 | sampler_normalized | | Sampler descriptor specifying whether the coordinates are passed in as normalized or unnormalized values |
 | sampler_snap_wa | | Sampler descriptor specifying whether snap coordinate workaround is required |
+| const_base | | The base address of constant buffer |
+| global_base | | The base address of global buffer |
 <!--- <argument_type> ArgType -->
 
 arg_byvalue and arg_bypointer are user arguments that are explicitly passed in from the applications. Other kinds of arguments are implicit arguments that are passed in by runtime.