Revert " ZEBinary: support implicit arguments const_base and global_base"

This reverts commit 08fca25.

Author: Artem Gindinson

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -1660,31 +1660,18 @@ 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);
     }
 
-    // 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)
+    // 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)
     {
         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 (hasInlineGlobalBuffer)
+    if (!zebinEnable && hasInlineGlobalBuffer)
     {
         for (auto& pFunc : M)
         {

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

@@ -79,6 +79,13 @@ 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 && bti_value == other.bti_value;
+        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;
     }
     zeinfo_str_t arg_type;
     zeinfo_int32_t offset = 0;
@@ -93,7 +93,6 @@ 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
 {
@@ -236,7 +235,7 @@ struct zeInfoContainer
     KernelsMiscInfoTy kernels_misc_info;
 };
 struct PreDefinedAttrGetter{
-    static zeinfo_str_t getVersionNumber() { return "1.28"; }
+    static zeinfo_str_t getVersionNumber() { return "1.26"; }
 
     enum class ArgThreadSchedulingMode {
         age_based,
@@ -276,9 +275,7 @@ struct PreDefinedAttrGetter{
         flat_image_pitch,
         sampler_address,
         sampler_normalized,
-        sampler_snap_wa,
-        const_base,
-        global_base
+        sampler_snap_wa
     };
     enum class ArgAddrMode {
         stateless,
@@ -430,10 +427,6 @@ 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,7 +98,6 @@ 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,16 +7,14 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ==========================-->
 
 # ZEBIN Version
-Version 1.28
+Version 1.26
 
 ## 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,7 +175,6 @@ 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:
@@ -216,8 +215,6 @@ 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.