Changeset 3313 in CLRX


Ignore:
Timestamp:
Sep 6, 2017, 1:17:27 PM (4 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?: Small fix (wrong name of type section CTRL_DIRECTIVE).
AsmAmdCL2: Add HSA configuration pseudo-ops. AmdCL2BinGen: Add hsaConfig mode.
Asm: Small commenting. Commons: AddAmdHsaKernelConfig::toLe - convert to Little endian.
Move code to initialize HSA kernel config to AsmFormats?.

Location:
CLRadeonExtender/trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/AsmFormats.h

    r3300 r3313  
    6262    AMDCL2_METADATA,
    6363    AMDCL2_ISAMETADATA,
     64    AMDCL2_CONFIG_CTRL_DIRECTIVE,
    6465   
    6566    GALLIUM_COMMENT = LAST_COMMON+1,    ///< gallium comment section
     
    275276};
    276277
     278/// Asm AMD HSA kernel configuration
     279struct AsmAmdHsaKernelConfig: AmdHsaKernelConfig
     280{
     281    cxuint dimMask;    ///< mask of dimension (bits: 0 - X, 1 - Y, 2 - Z)
     282    cxuint usedVGPRsNum;  ///< number of used VGPRs
     283    cxuint usedSGPRsNum;  ///< number of used SGPRs
     284    cxbyte userDataNum;   ///< number of user data
     285    bool ieeeMode;  ///< IEEE mode
     286    cxbyte floatMode; ///< float mode
     287    cxbyte priority;    ///< priority
     288    cxbyte exceptions;      ///< enabled exceptions
     289    bool tgSize;        ///< enable TG_SIZE_EN bit
     290    bool debugMode;     ///< debug mode
     291    bool privilegedMode;   ///< prvileged mode
     292    bool dx10Clamp;     ///< DX10 CLAMP mode
     293   
     294    void initialize();
     295};
     296
    277297/// handles AMD OpenCL 2.0 binary format
    278298class AsmAmdCL2Handler: public AsmFormatHandler
     
    305325        cxuint isaMetadataSection;
    306326        cxuint configSection;
     327        cxuint ctrlDirSection;
    307328        cxuint codeSection;
    308329        cxuint savedSection;
     330        bool useHsaConfig; //
     331        std::unique_ptr<AsmAmdHsaKernelConfig> config; // hsaConfig
    309332        std::unordered_set<CString> argNamesSet;
    310333        cxuint allocRegs[MAX_REGTYPES_NUM];
    311334        Flags allocRegFlags;
     335       
     336        void initializeKernelConfig();
    312337    };
    313338    std::vector<Section> sections;
     
    359384};
    360385
    361 /// Asm AMD HSA kernel configuration
    362 struct AsmAmdHsaKernelConfig: AmdHsaKernelConfig
    363 {
    364     cxuint dimMask;    ///< mask of dimension (bits: 0 - X, 1 - Y, 2 - Z)
    365     cxuint usedVGPRsNum;  ///< number of used VGPRs
    366     cxuint usedSGPRsNum;  ///< number of used SGPRs
    367     cxbyte userDataNum;   ///< number of user data
    368     bool ieeeMode;  ///< IEEE mode
    369     cxbyte floatMode; ///< float mode
    370     cxbyte priority;    ///< priority
    371     cxbyte exceptions;      ///< enabled exceptions
    372     bool tgSize;        ///< enable TG_SIZE_EN bit
    373     bool debugMode;     ///< debug mode
    374     bool privilegedMode;   ///< prvileged mode
    375     bool dx10Clamp;     ///< DX10 CLAMP mode
    376 };
    377 
    378386/// handles GalliumCompute format
    379387class AsmGalliumHandler: public AsmFormatHandler
  • CLRadeonExtender/trunk/CLRX/amdbin/AmdCL2BinGen.h

    r3195 r3313  
    104104    const cxbyte* isaMetadata;   ///< kernel's metadata (used if useConfig=false)
    105105    bool useConfig;         ///< true if configuration has been used to generate binary
     106    bool hsaConfig;         ///< true if configuration in setup as HSA config
    106107    AmdCL2KernelConfig config; ///< kernel's configuration
    107108    std::vector<AmdCL2RelInput> relocations;    ///< relocation to kernel code
  • CLRadeonExtender/trunk/CLRX/amdbin/Commons.h

    r3195 r3313  
    2525
    2626#include <CLRX/Config.h>
     27#include <CLRX/utils/MemAccess.h>
    2728
    2829/// main namespace
     
    9899    uint64_t runtimeLoaderKernelSymbol;
    99100    cxbyte controlDirective[128];       ///< control directives area
     101   
     102    void toLE()
     103    {
     104        SLEV(amdCodeVersionMajor, amdCodeVersionMajor);
     105        SLEV(amdCodeVersionMinor, amdCodeVersionMinor);
     106        SLEV(amdMachineKind, amdMachineKind);
     107        SLEV(amdMachineMajor, amdMachineMajor);
     108        SLEV(amdMachineMinor, amdMachineMinor);
     109        SLEV(amdMachineStepping, amdMachineStepping);
     110        SLEV(kernelCodeEntryOffset, kernelCodeEntryOffset);
     111        SLEV(kernelCodePrefetchOffset, kernelCodePrefetchOffset);
     112        SLEV(kernelCodePrefetchSize, kernelCodePrefetchSize);
     113        SLEV(maxScrachBackingMemorySize, maxScrachBackingMemorySize);
     114        SLEV(computePgmRsrc1, computePgmRsrc1);
     115        SLEV(computePgmRsrc2, computePgmRsrc2);
     116        SLEV(enableSgprRegisterFlags, enableSgprRegisterFlags);
     117        SLEV(enableFeatureFlags, enableFeatureFlags);
     118        SLEV(workitemPrivateSegmentSize, workitemPrivateSegmentSize);
     119        SLEV(workgroupGroupSegmentSize, workgroupGroupSegmentSize);
     120        SLEV(gdsSegmentSize, gdsSegmentSize);
     121        SLEV(kernargSegmentSize, kernargSegmentSize);
     122        SLEV(workgroupFbarrierCount, workgroupFbarrierCount);
     123        SLEV(wavefrontSgprCount, wavefrontSgprCount);
     124        SLEV(workitemVgprCount, workitemVgprCount);
     125        SLEV(reservedVgprFirst, reservedVgprFirst);
     126        SLEV(reservedVgprCount, reservedVgprCount);
     127        SLEV(reservedSgprFirst, reservedSgprFirst);
     128        SLEV(reservedSgprCount, reservedSgprCount);
     129        SLEV(debugWavefrontPrivateSegmentOffsetSgpr,
     130             debugWavefrontPrivateSegmentOffsetSgpr);
     131        SLEV(debugPrivateSegmentBufferSgpr, debugPrivateSegmentBufferSgpr);
     132        SLEV(callConvention, callConvention);
     133        SLEV(runtimeLoaderKernelSymbol, runtimeLoaderKernelSymbol);
     134    }
    100135};
    101136
  • CLRadeonExtender/trunk/amdasm/AsmAmdCL2Format.cpp

    r3300 r3313  
    3636{
    3737    "acl_version", "arch_minor", "arch_stepping",
    38     "arg", "bssdata", "compile_options", "config",
    39     "cws", "debugmode", "dims", "driver_version", "dx10clamp", "exceptions",
    40     "floatmode", "gdssize", "get_driver_version",
    41     "globaldata", "ieeemode", "inner",
    42     "isametadata", "localsize", "metadata", "pgmrsrc1", "pgmrsrc2",
    43     "priority", "privmode", "rwdata", "sampler",
     38    "arg", "bssdata", "compile_options",
     39    "call_convention", "codeversion", "config", "control_directive",
     40    "cws", "debug_private_segment_buffer_sgpr",
     41    "debug_wavefront_private_segment_offset_sgpr",
     42    "debugmode", "dims", "driver_version", "dx10clamp", "exceptions",
     43    "floatmode", "gds_segment_size", "gdssize", "get_driver_version",
     44    "globaldata", "group_segment_align", "hsaconfig", "ieeemode", "inner",
     45    "isametadata", "kernarg_segment_align",
     46    "kernarg_segment_size", "kernel_code_entry_offset",
     47    "kernel_code_prefetch_offset", "kernel_code_prefetch_size",
     48    "localsize", "machine", "max_scratch_backing_memory",
     49    "metadata", "pgmrsrc1", "pgmrsrc2", "priority",
     50    "private_elem_size", "private_segment_align",
     51    "privmode", "reserved_sgprs", "reserved_vgprs",
     52    "runtime_loader_kernel_symbol", "rwdata", "sampler",
    4453    "samplerinit", "samplerreloc", "scratchbuffer", "setup",
    45     "setupargs", "sgprsnum", "stub", "tgsize", "useargs",
    46     "useenqueue", "usegeneric", "usesetup", "vgprsnum"
     54    "setupargs", "sgprsnum", "stub", "tgsize",
     55    "use_debug_enabled", "use_dispatch_id",
     56    "use_dispatch_ptr", "use_dynamic_call_stack",
     57    "use_flat_scratch_init", "use_grid_workgroup_count",
     58    "use_kernarg_segment_ptr", "use_ordered_append_gds",
     59    "use_private_segment_buffer", "use_private_segment_size",
     60    "use_ptr64", "use_queue_ptr", "use_xnack_enabled",
     61    "useargs", "useenqueue", "usegeneric", "usesetup", "vgprsnum",
     62    "wavefront_sgpr_count", "wavefront_size",  "workgroup_fbarrier_count",
     63    "workgroup_group_segment_size", "workitem_private_segment_size",
     64    "workitem_vgpr_count"
    4765};
    4866
     
    5169    AMDCL2OP_ACL_VERSION = 0, AMDCL2OP_ARCH_MINOR, AMDCL2OP_ARCH_STEPPING,
    5270    AMDCL2OP_ARG, AMDCL2OP_BSSDATA, AMDCL2OP_COMPILE_OPTIONS,
    53     AMDCL2OP_CONFIG, AMDCL2OP_CWS, AMDCL2OP_DEBUGMODE, AMDCL2OP_DIMS,
     71    AMDCL2OP_CALL_CONVENTION, AMDCL2OP_CODEVERSION,
     72    AMDCL2OP_CONFIG, AMDCL2OP_CONTROL_DIRECTIVE,
     73    AMDCL2OP_CWS, AMDCL2OP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR,
     74    AMDCL2OP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR,
     75    AMDCL2OP_DEBUGMODE, AMDCL2OP_DIMS,
    5476    AMDCL2OP_DRIVER_VERSION, AMDCL2OP_DX10CLAMP, AMDCL2OP_EXCEPTIONS,
    55     AMDCL2OP_FLOATMODE, AMDCL2OP_GDSSIZE, AMDCL2OP_GET_DRIVER_VERSION, AMDCL2OP_GLOBALDATA,
    56     AMDCL2OP_IEEEMODE, AMDCL2OP_INNER, AMDCL2OP_ISAMETADATA, AMDCL2OP_LOCALSIZE,
     77    AMDCL2OP_FLOATMODE, AMDCL2OP_GDS_SEGMENT_SIZE,
     78    AMDCL2OP_GDSSIZE, AMDCL2OP_GET_DRIVER_VERSION,
     79    AMDCL2OP_GLOBALDATA, AMDCL2OP_GROUP_SEGMENT_ALIGN,
     80    AMDCL2OP_HSACONFIG, AMDCL2OP_IEEEMODE, AMDCL2OP_INNER,
     81    AMDCL2OP_ISAMETADATA, AMDCL2OP_KERNARG_SEGMENT_ALIGN,
     82    AMDCL2OP_KERNARG_SEGMENT_SIZE, AMDCL2OP_KERNEL_CODE_ENTRY_OFFSET,
     83    AMDCL2OP_KERNEL_CODE_PREFETCH_OFFSET,
     84    AMDCL2OP_KERNEL_CODE_PREFETCH_SIZE, AMDCL2OP_LOCALSIZE,
     85    AMDCL2OP_MACHINE, AMDCL2OP_MAX_SCRATCH_BACKING_MEMORY,
    5786    AMDCL2OP_METADATA, AMDCL2OP_PGMRSRC1, AMDCL2OP_PGMRSRC2, AMDCL2OP_PRIORITY,
    58     AMDCL2OP_PRIVMODE, AMDCL2OP_RWDATA, AMDCL2OP_SAMPLER, AMDCL2OP_SAMPLERINIT,
     87    AMDCL2OP_PRIVATE_ELEM_SIZE, AMDCL2OP_PRIVATE_SEGMENT_ALIGN,
     88    AMDCL2OP_PRIVMODE, AMDCL2OP_RESERVED_SGPRS, AMDCL2OP_RESERVED_VGPRS,
     89    AMDCL2OP_RUNTIME_LOADER_KERNEL_SYMBOL, AMDCL2OP_RWDATA,
     90    AMDCL2OP_SAMPLER, AMDCL2OP_SAMPLERINIT,
    5991    AMDCL2OP_SAMPLERRELOC, AMDCL2OP_SCRATCHBUFFER, AMDCL2OP_SETUP, AMDCL2OP_SETUPARGS,
    60     AMDCL2OP_SGPRSNUM, AMDCL2OP_STUB, AMDCL2OP_TGSIZE, AMDCL2OP_USEARGS,
    61     AMDCL2OP_USEENQUEUE, AMDCL2OP_USEGENERIC, AMDCL2OP_USESETUP, AMDCL2OP_VGPRSNUM
     92    AMDCL2OP_SGPRSNUM, AMDCL2OP_STUB, AMDCL2OP_TGSIZE,
     93    AMDCL2OP_USE_DEBUG_ENABLED, AMDCL2OP_USE_DISPATCH_ID,
     94    AMDCL2OP_USE_DISPATCH_PTR, AMDCL2OP_USE_DYNAMIC_CALL_STACK,
     95    AMDCL2OP_USE_FLAT_SCRATCH_INIT, AMDCL2OP_USE_GRID_WORKGROUP_COUNT,
     96    AMDCL2OP_USE_KERNARG_SEGMENT_PTR, AMDCL2OP_USE_ORDERED_APPEND_GDS,
     97    AMDCL2OP_USE_PRIVATE_SEGMENT_BUFFER, AMDCL2OP_USE_PRIVATE_SEGMENT_SIZE,
     98    AMDCL2OP_USE_PTR64, AMDCL2OP_USE_QUEUE_PTR, AMDCL2OP_USE_XNACK_ENABLED,
     99    AMDCL2OP_USEARGS, AMDCL2OP_USEENQUEUE, AMDCL2OP_USEGENERIC,
     100    AMDCL2OP_USESETUP, AMDCL2OP_VGPRSNUM,
     101    AMDCL2OP_WAVEFRONT_SGPR_COUNT, AMDCL2OP_WAVEFRONT_SIZE,
     102    AMDCL2OP_WORKGROUP_FBARRIER_COUNT, AMDCL2OP_WORKGROUP_GROUP_SEGMENT_SIZE,
     103    AMDCL2OP_WORKITEM_PRIVATE_SEGMENT_SIZE, AMDCL2OP_WORKITEM_VGPR_COUNT
    62104};
    63105
     106void AsmAmdCL2Handler::Kernel::initializeKernelConfig()
     107{
     108    if (!config)
     109    {
     110        config.reset(new AsmROCmKernelConfig{});
     111        config->initialize();
     112    }
     113}
     114
    64115/*
    65  * AmdCatalyst format handler
     116 * AmdCL2Catalyst format handler
    66117 */
    67118
     
    141192    output.addEmptyKernel(kernelName);
    142193    Kernel kernelState{ ASMSECT_NONE, ASMSECT_NONE, ASMSECT_NONE,
    143             ASMSECT_NONE, ASMSECT_NONE, thisSection, ASMSECT_NONE };
     194            ASMSECT_NONE, ASMSECT_NONE, ASMSECT_NONE, thisSection, ASMSECT_NONE, false };
    144195    /* add new kernel and their section (.text) */
    145196    kernelStates.push_back(new Kernel(std::move(kernelState)));
     
    708759}
    709760
     761void AsmAmdCL2PseudoOps::doControlDirective(AsmAmdCL2Handler& handler,
     762              const char* pseudoOpPlace, const char* linePtr)
     763{
     764    Assembler& asmr = handler.assembler;
     765    if (asmr.currentKernel==ASMKERN_GLOBAL)
     766    {
     767        asmr.printError(pseudoOpPlace, "Kernel control directive can be defined "
     768                    "only inside kernel");
     769        return;
     770    }
     771    AsmAmdCL2Handler::Kernel& kernel = *handler.kernelStates[asmr.currentKernel];
     772    if (kernel.metadataSection!=ASMSECT_NONE || kernel.isaMetadataSection!=ASMSECT_NONE ||
     773        kernel.setupSection!=ASMSECT_NONE || kernel.stubSection!=ASMSECT_NONE)
     774    {
     775        asmr.printError(pseudoOpPlace, "Control directive "
     776            "can't be defined if metadata,header,setup,stub section exists");
     777        return;
     778    }
     779    if (kernel.configSection != ASMSECT_NONE && !kernel.useHsaConfig)
     780    {   // control directive only if hsa config
     781        asmr.printError(pseudoOpPlace, "Config and Control directive can't be mixed");
     782        return;
     783    }
     784   
     785    if (!checkGarbagesAtEnd(asmr, linePtr))
     786        return;
     787   
     788    if (kernel.ctrlDirSection == ASMSECT_NONE)
     789    {
     790        cxuint thisSection = handler.sections.size();
     791        handler.sections.push_back({ asmr.currentKernel,
     792            AsmSectionType::AMDCL2_CONFIG_CTRL_DIRECTIVE,
     793            ELFSECTID_UNDEF, nullptr });
     794        kernel.ctrlDirSection = thisSection;
     795    }
     796    asmr.goToSection(pseudoOpPlace, kernel.ctrlDirSection);
     797    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     798}
     799
     800
    710801void AsmAmdCL2PseudoOps::setConfigValue(AsmAmdCL2Handler& handler,
    711802         const char* pseudoOpPlace, const char* linePtr, AmdCL2ConfigValueTarget target)
     
    718809    {
    719810        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     811        return;
     812    }
     813    const bool useHsaConfig = handler.kernelStates[asmr.currentKernel]->useHsaConfig;
     814    if (!useHsaConfig && target >= AMDCL2CVAL_ONLY_HSA_FIRST_PARAM)
     815    {
     816        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
    720817        return;
    721818    }
     
    728825    if (good)
    729826    {
    730         switch(target)
    731         {
    732             case AMDCL2CVAL_SGPRSNUM:
     827        if (useHsaConfig && target >= AMDCL2CVAL_HSA_FIRST_PARAM)
     828            // hsa config
     829            good = AsmROCmPseudoOps::checkConfigValue(asmr, valuePlace,
     830                    ROCmConfigValueTarget(cxuint(target) - AMDCL2CVAL_HSA_FIRST_PARAM),
     831                    value);
     832        else
     833            switch(target)
    733834            {
    734                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    735                             asmr.deviceType);
    736                 cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    737                 if (value > maxSGPRsNum)
     835                case AMDCL2CVAL_SGPRSNUM:
    738836                {
    739                     char buf[64];
    740                     snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    741                     asmr.printError(valuePlace, buf);
    742                     good = false;
     837                    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     838                                asmr.deviceType);
     839                    cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     840                    if (value > maxSGPRsNum)
     841                    {
     842                        char buf[64];
     843                        snprintf(buf, 64,
     844                                 "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
     845                        asmr.printError(valuePlace, buf);
     846                        good = false;
     847                    }
     848                    break;
    743849                }
    744                 break;
     850                case AMDCL2CVAL_VGPRSNUM:
     851                {
     852                    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     853                                asmr.deviceType);
     854                    cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
     855                    if (value > maxVGPRsNum)
     856                    {
     857                        char buf[64];
     858                        snprintf(buf, 64,
     859                                 "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
     860                        asmr.printError(valuePlace, buf);
     861                        good = false;
     862                    }
     863                    break;
     864                }
     865                case AMDCL2CVAL_EXCEPTIONS:
     866                    asmr.printWarningForRange(7, value,
     867                                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     868                    value &= 0x7f;
     869                    break;
     870                case AMDCL2CVAL_FLOATMODE:
     871                    asmr.printWarningForRange(8, value,
     872                                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     873                    value &= 0xff;
     874                    break;
     875                case AMDCL2CVAL_PRIORITY:
     876                    asmr.printWarningForRange(2, value,
     877                                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     878                    value &= 3;
     879                    break;
     880                case AMDCL2CVAL_LOCALSIZE:
     881                {
     882                    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     883                                asmr.deviceType);
     884                    const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
     885                    if (value > maxLocalSize)
     886                    {
     887                        char buf[64];
     888                        snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
     889                        asmr.printError(valuePlace, buf);
     890                        good = false;
     891                    }
     892                    break;
     893                }
     894                case AMDCL2CVAL_GDSSIZE:
     895                {
     896                    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     897                                asmr.deviceType);
     898                    const cxuint maxGDSSize = getGPUMaxGDSSize(arch);
     899                    if (value > maxGDSSize)
     900                    {
     901                        char buf[64];
     902                        snprintf(buf, 64, "GDSSize out of range (0-%u)", maxGDSSize);
     903                        asmr.printError(valuePlace, buf);
     904                        good = false;
     905                    }
     906                    break;
     907                }
     908                case AMDCL2CVAL_PGMRSRC1:
     909                case AMDCL2CVAL_PGMRSRC2:
     910                    asmr.printWarningForRange(32, value,
     911                                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     912                    break;
     913                default:
     914                    break;
    745915            }
    746             case AMDCL2CVAL_VGPRSNUM:
    747             {
    748                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    749                             asmr.deviceType);
    750                 cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
    751                 if (value > maxVGPRsNum)
    752                 {
    753                     char buf[64];
    754                     snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    755                     asmr.printError(valuePlace, buf);
    756                     good = false;
    757                 }
    758                 break;
    759             }
    760             case AMDCL2CVAL_EXCEPTIONS:
    761                 asmr.printWarningForRange(7, value,
    762                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    763                 value &= 0x7f;
    764                 break;
    765             case AMDCL2CVAL_FLOATMODE:
    766                 asmr.printWarningForRange(8, value,
    767                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    768                 value &= 0xff;
    769                 break;
    770             case AMDCL2CVAL_PRIORITY:
    771                 asmr.printWarningForRange(2, value,
    772                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    773                 value &= 3;
    774                 break;
    775             case AMDCL2CVAL_LOCALSIZE:
    776             {
    777                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    778                             asmr.deviceType);
    779                 const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
    780                 if (value > maxLocalSize)
    781                 {
    782                     char buf[64];
    783                     snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
    784                     asmr.printError(valuePlace, buf);
    785                     good = false;
    786                 }
    787                 break;
    788             }
    789             case AMDCL2CVAL_GDSSIZE:
    790             {
    791                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    792                             asmr.deviceType);
    793                 const cxuint maxGDSSize = getGPUMaxGDSSize(arch);
    794                 if (value > maxGDSSize)
    795                 {
    796                     char buf[64];
    797                     snprintf(buf, 64, "GDSSize out of range (0-%u)", maxGDSSize);
    798                     asmr.printError(valuePlace, buf);
    799                     good = false;
    800                 }
    801                 break;
    802             }
    803             case AMDCL2CVAL_PGMRSRC1:
    804             case AMDCL2CVAL_PGMRSRC2:
    805                 asmr.printWarningForRange(32, value,
    806                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    807                 break;
    808             default:
    809                 break;
    810         }
    811916    }
    812917   
    813918    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    814919        return;
     920   
     921    if (handler.kernelStates[asmr.currentKernel]->useHsaConfig)
     922    {   // hsa config
     923        handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     924        AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     925       
     926        AsmROCmPseudoOps::setConfigValueMain(config, ROCmConfigValueTarget(
     927                cxuint(target) - AMDCL2CVAL_HSA_FIRST_PARAM), value);
     928        return;
     929    }
    815930   
    816931    AmdCL2KernelConfig& config = handler.output.kernels[asmr.currentKernel].config;
     
    834949            break;
    835950        case AMDCL2CVAL_LOCALSIZE:
    836             config.localSize = value;
     951            if (!useHsaConfig)
     952                config.localSize = value;
     953            else
     954            {
     955                handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     956                AsmROCmKernelConfig& hsaConfig = *(handler.
     957                                kernelStates[asmr.currentKernel]->config);
     958                hsaConfig.workgroupGroupSegmentSize = value;
     959            }
    837960            break;
    838961        case AMDCL2CVAL_GDSSIZE:
    839             config.gdsSize = value;
     962            if (!useHsaConfig)
     963                config.gdsSize = value;
     964            else
     965            {
     966                handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     967                AsmROCmKernelConfig& hsaConfig = *(handler.
     968                                kernelStates[asmr.currentKernel]->config);
     969                hsaConfig.gdsSegmentSize = value;
     970            }
    840971            break;
    841972        case AMDCL2CVAL_SCRATCHBUFFER:
    842             config.scratchBufferSize = value;
     973            if (!useHsaConfig)
     974                config.scratchBufferSize = value;
     975            else
     976            {
     977                handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     978                AsmROCmKernelConfig& hsaConfig = *(handler.
     979                                kernelStates[asmr.currentKernel]->config);
     980                hsaConfig.workitemPrivateSegmentSize = value;
     981            }
    843982            break;
    844983        case AMDCL2CVAL_PRIORITY:
     
    8641003        return;
    8651004    }
     1005   
     1006    const bool useHsaConfig = handler.kernelStates[asmr.currentKernel]->useHsaConfig;
     1007    if (useHsaConfig &&
     1008        (target == AMDCL2CVAL_USESETUP || target == AMDCL2CVAL_USEARGS ||
     1009         target == AMDCL2CVAL_USEENQUEUE || target == AMDCL2CVAL_USEGENERIC))
     1010    {
     1011        asmr.printError(pseudoOpPlace, "Illegal config pseudo-op in HSAConfig");
     1012        return;
     1013    }
     1014    if (!useHsaConfig && target >= AMDCL2CVAL_ONLY_HSA_FIRST_PARAM)
     1015    {
     1016        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
     1017        return;
     1018    }
     1019   
    8661020    if (!checkGarbagesAtEnd(asmr, linePtr))
    8671021        return;
     1022   
     1023    if (useHsaConfig)
     1024    {   // hsa config
     1025        handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     1026        AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     1027       
     1028        AsmROCmPseudoOps::setConfigBoolValueMain(config, ROCmConfigValueTarget(
     1029                cxuint(target) - AMDCL2CVAL_HSA_FIRST_PARAM));
     1030        return;
     1031    }
     1032   
    8681033    AmdCL2KernelConfig& config = handler.output.kernels[asmr.currentKernel].config;
    8691034    switch(target)
     
    9171082        return;
    9181083    handler.output.kernels[asmr.currentKernel].config.dimMask = dimMask;
     1084}
     1085
     1086void AsmAmdCL2PseudoOps::setMachine(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
     1087                      const char* linePtr)
     1088{
     1089    Assembler& asmr = handler.assembler;
     1090    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1091        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1092    {
     1093        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1094        return;
     1095    }
     1096    if (!handler.kernelStates[asmr.currentKernel]->useHsaConfig)
     1097    {
     1098        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
     1099        return;
     1100    }
     1101   
     1102    uint16_t kindValue = 0, majorValue = 0;
     1103    uint16_t minorValue = 0, steppingValue = 0;
     1104    if (!AsmROCmPseudoOps::parseMachine(asmr, linePtr, kindValue,
     1105                    majorValue, minorValue, steppingValue))
     1106        return;
     1107   
     1108    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     1109    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1110    config->amdMachineKind = kindValue;
     1111    config->amdMachineMajor = majorValue;
     1112    config->amdMachineMinor = minorValue;
     1113    config->amdMachineStepping = steppingValue;
     1114}
     1115
     1116void AsmAmdCL2PseudoOps::setCodeVersion(AsmAmdCL2Handler& handler,
     1117                const char* pseudoOpPlace, const char* linePtr)
     1118{
     1119    Assembler& asmr = handler.assembler;
     1120    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1121        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1122    {
     1123        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1124        return;
     1125    }
     1126    if (!handler.kernelStates[asmr.currentKernel]->useHsaConfig)
     1127    {
     1128        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
     1129        return;
     1130    }
     1131   
     1132    uint16_t majorValue = 0, minorValue = 0;
     1133    if (!AsmROCmPseudoOps::parseCodeVersion(asmr, linePtr, majorValue, minorValue))
     1134        return;
     1135   
     1136    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     1137    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1138    config->amdCodeVersionMajor = majorValue;
     1139    config->amdCodeVersionMinor = minorValue;
     1140}
     1141
     1142void AsmAmdCL2PseudoOps::setReservedXgprs(AsmAmdCL2Handler& handler,
     1143                const char* pseudoOpPlace, const char* linePtr, bool inVgpr)
     1144{
     1145    Assembler& asmr = handler.assembler;
     1146    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1147        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1148    {
     1149        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1150        return;
     1151    }
     1152    if (!handler.kernelStates[asmr.currentKernel]->useHsaConfig)
     1153    {
     1154        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
     1155        return;
     1156    }
     1157   
     1158    uint16_t gprFirst = 0, gprCount = 0;
     1159    if (!AsmROCmPseudoOps::parseReservedXgprs(asmr, linePtr, inVgpr, gprFirst, gprCount))
     1160        return;
     1161   
     1162    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     1163    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1164    if (inVgpr)
     1165    {
     1166        config->reservedVgprFirst = gprFirst;
     1167        config->reservedVgprCount = gprCount;
     1168    }
     1169    else
     1170    {
     1171        config->reservedSgprFirst = gprFirst;
     1172        config->reservedSgprCount = gprCount;
     1173    }
     1174}
     1175
     1176
     1177void AsmAmdCL2PseudoOps::setUseGridWorkGroupCount(AsmAmdCL2Handler& handler,
     1178                   const char* pseudoOpPlace, const char* linePtr)
     1179{
     1180    Assembler& asmr = handler.assembler;
     1181    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1182        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1183    {
     1184        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1185        return;
     1186    }
     1187    if (!handler.kernelStates[asmr.currentKernel]->useHsaConfig)
     1188    {
     1189        asmr.printError(pseudoOpPlace, "HSAConfig pseudo-op only in HSAConfig");
     1190        return;
     1191    }
     1192   
     1193    cxuint dimMask = 0;
     1194    if (!parseDimensions(asmr, linePtr, dimMask))
     1195        return;
     1196    if (!checkGarbagesAtEnd(asmr, linePtr))
     1197        return;
     1198    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     1199    uint16_t& flags = handler.kernelStates[asmr.currentKernel]->config->
     1200                enableSgprRegisterFlags;
     1201    flags = (flags & ~(7<<ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT)) |
     1202            (dimMask<<ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT);
    9191203}
    9201204
     
    11821466
    11831467void AsmAmdCL2PseudoOps::doConfig(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
    1184                       const char* linePtr)
     1468                      const char* linePtr, bool hsaConfig)
    11851469{
    11861470    Assembler& asmr = handler.assembler;
     
    11921476        return;
    11931477    }
    1194     skipSpacesToEnd(linePtr, end);
    11951478    AsmAmdCL2Handler::Kernel& kernel = *handler.kernelStates[asmr.currentKernel];
    11961479    if (kernel.metadataSection!=ASMSECT_NONE || kernel.isaMetadataSection!=ASMSECT_NONE ||
     
    12011484        return;
    12021485    }
    1203    
     1486    if (kernel.configSection != ASMSECT_NONE && kernel.useHsaConfig != hsaConfig)
     1487    {   // if config defined and doesn't match type of config
     1488        asmr.printError(pseudoOpPlace, "Config and HSAConfig can't be mixed");
     1489        return;
     1490    }
     1491   
     1492    skipSpacesToEnd(linePtr, end);
    12041493    if (!checkGarbagesAtEnd(asmr, linePtr))
    12051494        return;
     
    12131502    }
    12141503    asmr.goToSection(pseudoOpPlace, kernel.configSection);
     1504    kernel.useHsaConfig = hsaConfig;
    12151505    handler.output.kernels[asmr.currentKernel].useConfig = true;
    12161506}
     
    12421532            AsmAmdCL2PseudoOps::doBssData(*this, stmtPlace, linePtr);
    12431533            break;
     1534        case AMDCL2OP_CODEVERSION:
     1535            AsmAmdCL2PseudoOps::setCodeVersion(*this, stmtPlace, linePtr);
     1536            break;
    12441537        case AMDCL2OP_COMPILE_OPTIONS:
    12451538            AsmAmdCL2PseudoOps::setCompileOptions(*this, linePtr);
    12461539            break;
    12471540        case AMDCL2OP_CONFIG:
    1248             AsmAmdCL2PseudoOps::doConfig(*this, stmtPlace, linePtr);
     1541            AsmAmdCL2PseudoOps::doConfig(*this, stmtPlace, linePtr, false);
     1542            break;
     1543        case AMDCL2OP_CONTROL_DIRECTIVE:
     1544            AsmAmdCL2PseudoOps::doControlDirective(*this, stmtPlace, linePtr);
    12491545            break;
    12501546        case AMDCL2OP_CWS:
    12511547            AsmAmdCL2PseudoOps::setCWS(*this, stmtPlace, linePtr);
     1548            break;
     1549        case AMDCL2OP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     1550            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1551                             AMDCL2CVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR);
     1552            break;
     1553        case AMDCL2OP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
     1554            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1555                         AMDCL2CVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR);
    12521556            break;
    12531557        case AMDCL2OP_DEBUGMODE:
     
    12731577                       AMDCL2CVAL_FLOATMODE);
    12741578            break;
     1579        case AMDCL2OP_GDS_SEGMENT_SIZE:
     1580            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1581                             AMDCL2CVAL_GDS_SEGMENT_SIZE);
     1582            break;
     1583        case AMDCL2OP_GROUP_SEGMENT_ALIGN:
     1584            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1585                             AMDCL2CVAL_GROUP_SEGMENT_ALIGN);
     1586            break;
    12751587        case AMDCL2OP_GDSSIZE:
    12761588            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     
    12821594        case AMDCL2OP_GLOBALDATA:
    12831595            AsmAmdCL2PseudoOps::doGlobalData(*this, stmtPlace, linePtr);
     1596            break;
     1597        case AMDCL2OP_HSACONFIG:
     1598            AsmAmdCL2PseudoOps::doConfig(*this, stmtPlace, linePtr, true);
    12841599            break;
    12851600        case AMDCL2OP_IEEEMODE:
     
    12931608            AsmAmdCL2PseudoOps::addISAMetadata(*this, stmtPlace, linePtr);
    12941609            break;
     1610        case AMDCL2OP_KERNARG_SEGMENT_ALIGN:
     1611            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1612                             AMDCL2CVAL_KERNARG_SEGMENT_ALIGN);
     1613            break;
     1614        case AMDCL2OP_KERNARG_SEGMENT_SIZE:
     1615            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1616                             AMDCL2CVAL_KERNARG_SEGMENT_SIZE);
     1617            break;
     1618        case AMDCL2OP_KERNEL_CODE_ENTRY_OFFSET:
     1619            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1620                             AMDCL2CVAL_KERNEL_CODE_ENTRY_OFFSET);
     1621            break;
     1622        case AMDCL2OP_KERNEL_CODE_PREFETCH_OFFSET:
     1623            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1624                             AMDCL2CVAL_KERNEL_CODE_PREFETCH_OFFSET);
     1625            break;
     1626        case AMDCL2OP_KERNEL_CODE_PREFETCH_SIZE:
     1627            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1628                             AMDCL2CVAL_KERNEL_CODE_PREFETCH_SIZE);
     1629            break;
    12951630        case AMDCL2OP_LOCALSIZE:
    12961631            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    12971632                       AMDCL2CVAL_LOCALSIZE);
     1633            break;
     1634        case AMDCL2OP_MACHINE:
     1635            AsmAmdCL2PseudoOps::setMachine(*this, stmtPlace, linePtr);
     1636            break;
     1637        case AMDCL2OP_MAX_SCRATCH_BACKING_MEMORY:
     1638            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1639                             AMDCL2CVAL_MAX_SCRATCH_BACKING_MEMORY);
    12981640            break;
    12991641        case AMDCL2OP_METADATA:
    13001642            AsmAmdCL2PseudoOps::addMetadata(*this, stmtPlace, linePtr);
     1643            break;
     1644        case AMDCL2OP_PRIVATE_ELEM_SIZE:
     1645            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1646                             AMDCL2CVAL_PRIVATE_ELEM_SIZE);
     1647            break;
     1648        case AMDCL2OP_PRIVATE_SEGMENT_ALIGN:
     1649            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1650                             AMDCL2CVAL_PRIVATE_SEGMENT_ALIGN);
    13011651            break;
    13021652        case AMDCL2OP_PRIVMODE:
     
    13161666                       AMDCL2CVAL_PRIORITY);
    13171667            break;
     1668        case AMDCL2OP_RESERVED_SGPRS:
     1669            AsmAmdCL2PseudoOps::setReservedXgprs(*this, stmtPlace, linePtr, false);
     1670            break;
     1671        case AMDCL2OP_RESERVED_VGPRS:
     1672            AsmAmdCL2PseudoOps::setReservedXgprs(*this, stmtPlace, linePtr, true);
     1673            break;
     1674        case AMDCL2OP_RUNTIME_LOADER_KERNEL_SYMBOL:
     1675            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1676                             AMDCL2CVAL_RUNTIME_LOADER_KERNEL_SYMBOL);
     1677            break;
    13181678        case AMDCL2OP_RWDATA:
    13191679            AsmAmdCL2PseudoOps::doRwData(*this, stmtPlace, linePtr);
     
    13491709                       AMDCL2CVAL_TGSIZE);
    13501710            break;
     1711        case AMDCL2OP_USE_DEBUG_ENABLED:
     1712            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1713                             AMDCL2CVAL_USE_DEBUG_ENABLED);
     1714            break;
     1715        case AMDCL2OP_USE_DISPATCH_ID:
     1716            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1717                             AMDCL2CVAL_USE_DISPATCH_ID);
     1718            break;
     1719        case AMDCL2OP_USE_DISPATCH_PTR:
     1720            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1721                             AMDCL2CVAL_USE_DISPATCH_PTR);
     1722            break;
     1723        case AMDCL2OP_USE_DYNAMIC_CALL_STACK:
     1724            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1725                             AMDCL2CVAL_USE_DYNAMIC_CALL_STACK);
     1726            break;
     1727        case AMDCL2OP_USE_FLAT_SCRATCH_INIT:
     1728            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1729                             AMDCL2CVAL_USE_FLAT_SCRATCH_INIT);
     1730            break;
     1731        case AMDCL2OP_USE_GRID_WORKGROUP_COUNT:
     1732            AsmAmdCL2PseudoOps::setUseGridWorkGroupCount(*this, stmtPlace, linePtr);
     1733            break;
     1734        case AMDCL2OP_USE_KERNARG_SEGMENT_PTR:
     1735            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1736                             AMDCL2CVAL_USE_KERNARG_SEGMENT_PTR);
     1737            break;
     1738        case AMDCL2OP_USE_ORDERED_APPEND_GDS:
     1739            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1740                             AMDCL2CVAL_USE_ORDERED_APPEND_GDS);
     1741            break;
     1742        case AMDCL2OP_USE_PRIVATE_SEGMENT_SIZE:
     1743            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1744                             AMDCL2CVAL_USE_PRIVATE_SEGMENT_SIZE);
     1745            break;
     1746        case AMDCL2OP_USE_PTR64:
     1747            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1748                             AMDCL2CVAL_USE_PTR64);
     1749            break;
     1750        case AMDCL2OP_USE_QUEUE_PTR:
     1751            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1752                             AMDCL2CVAL_USE_QUEUE_PTR);
     1753            break;
     1754        case AMDCL2OP_USE_PRIVATE_SEGMENT_BUFFER:
     1755            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1756                             AMDCL2CVAL_USE_PRIVATE_SEGMENT_BUFFER);
     1757            break;
     1758        case AMDCL2OP_USE_XNACK_ENABLED:
     1759            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1760                             AMDCL2CVAL_USE_XNACK_ENABLED);
     1761            break;
    13511762        case AMDCL2OP_USEARGS:
    13521763            AsmAmdCL2PseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     
    13681779            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    13691780                       AMDCL2CVAL_VGPRSNUM);
     1781            break;
     1782        case AMDCL2OP_WAVEFRONT_SGPR_COUNT:
     1783            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1784                             AMDCL2CVAL_WAVEFRONT_SGPR_COUNT);
     1785            break;
     1786        case AMDCL2OP_WAVEFRONT_SIZE:
     1787            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1788                             AMDCL2CVAL_WAVEFRONT_SIZE);
     1789            break;
     1790        case AMDCL2OP_WORKITEM_VGPR_COUNT:
     1791            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1792                             AMDCL2CVAL_WORKITEM_VGPR_COUNT);
     1793            break;
     1794        case AMDCL2OP_WORKGROUP_FBARRIER_COUNT:
     1795            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1796                             AMDCL2CVAL_WORKGROUP_FBARRIER_COUNT);
     1797            break;
     1798        case AMDCL2OP_WORKGROUP_GROUP_SEGMENT_SIZE:
     1799            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1800                             AMDCL2CVAL_WORKGROUP_GROUP_SEGMENT_SIZE);
     1801            break;
     1802        case AMDCL2OP_WORKITEM_PRIVATE_SEGMENT_SIZE:
     1803            AsmAmdCL2PseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1804                             AMDCL2CVAL_WORKITEM_PRIVATE_SEGMENT_SIZE);
    13701805            break;
    13711806        default:
     
    14331868                kernel->stubSize = sectionSize;
    14341869                kernel->stub = sectionData;
     1870                break;
     1871            case AsmSectionType::AMDCL2_CONFIG_CTRL_DIRECTIVE:
     1872                if (sectionSize != 128)
     1873                    assembler.printError(AsmSourcePos(),
     1874                         (std::string("Section '.control_directive' for kernel '")+
     1875                          assembler.kernels[section.kernelId].name+
     1876                          "' have wrong size").c_str());
    14351877                break;
    14361878            case AsmSectionType::EXTRA_PROGBITS:
  • CLRadeonExtender/trunk/amdasm/AsmFormats.cpp

    r2720 r3313  
    3232AsmFormatException::AsmFormatException(const std::string& message) : Exception(message)
    3333{ }
     34
     35void AsmAmdHsaKernelConfig::initialize()
     36{
     37    // set default values to kernel config
     38    ::memset(this, 0xff, 128);
     39    ::memset(controlDirective, 0, 128);
     40    computePgmRsrc1 = computePgmRsrc2 = 0;
     41    enableSgprRegisterFlags = 0;
     42    enableFeatureFlags = 0;
     43    reserved1[0] = reserved1[1] = reserved1[2] = 0;
     44    dimMask = 0;
     45    usedVGPRsNum = BINGEN_DEFAULT;
     46    usedSGPRsNum = BINGEN_DEFAULT;
     47    userDataNum = BINGEN8_DEFAULT;
     48    ieeeMode = false;
     49    floatMode = 0xc0;
     50    priority = 0;
     51    exceptions = 0;
     52    tgSize = false;
     53    debugMode = false;
     54    privilegedMode = false;
     55    dx10Clamp = false;
     56}
    3457
    3558AsmFormatHandler::AsmFormatHandler(Assembler& _assembler) : assembler(_assembler)
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3309 r3313  
    128128    {
    129129        config.reset(new AsmROCmKernelConfig{});
    130         // set default values to kernel config
    131         ::memset(config.get(), 0xff, 128);
    132         ::memset(config->controlDirective, 0, 128);
    133         config->computePgmRsrc1 = config->computePgmRsrc2 = 0;
    134         config->enableSgprRegisterFlags = 0;
    135         config->enableFeatureFlags = 0;
    136         config->reserved1[0] = config->reserved1[1] = config->reserved1[2] = 0;
    137         config->dimMask = 0;
    138         config->usedVGPRsNum = BINGEN_DEFAULT;
    139         config->usedSGPRsNum = BINGEN_DEFAULT;
    140         config->userDataNum = BINGEN8_DEFAULT;
    141         config->ieeeMode = false;
    142         config->floatMode = 0xc0;
    143         config->priority = 0;
    144         config->exceptions = 0;
    145         config->tgSize = false;
    146         config->debugMode = false;
    147         config->privilegedMode = false;
    148         config->dx10Clamp = false;
     130        config->initialize();
    149131    }
    150132}
     
    536518        cxuint thisSection = handler.sections.size();
    537519        handler.sections.push_back({ asmr.currentKernel,
    538             AsmSectionType::ROCM_CONFIG_CTRL_DIRECTIVE,
     520            AsmSectionType::GALLIUM_CONFIG_CTRL_DIRECTIVE,
    539521            ELFSECTID_UNDEF, nullptr });
    540522        kernel.ctrlDirSection = thisSection;
     
    859841}
    860842
     843// set machine - four numbers - kind, major, minor, stepping
    861844void AsmGalliumPseudoOps::setMachine(AsmGalliumHandler& handler, const char* pseudoOpPlace,
    862845                      const char* linePtr)
     
    889872}
    890873
     874// two numbers - major and minor
    891875void AsmGalliumPseudoOps::setCodeVersion(AsmGalliumHandler& handler,
    892876                const char* pseudoOpPlace, const char* linePtr)
     
    915899}
    916900
    917 void AsmGalliumPseudoOps::setReservedXgprs(AsmGalliumHandler& handler, const char* pseudoOpPlace,
    918                       const char* linePtr, bool inVgpr)
     901/// set reserved S/VGRPS - first number is first register, second is last register
     902void AsmGalliumPseudoOps::setReservedXgprs(AsmGalliumHandler& handler,
     903                    const char* pseudoOpPlace, const char* linePtr, bool inVgpr)
    919904{
    920905    Assembler& asmr = handler.assembler;
     
    949934}
    950935
    951 
     936// set UseGridWorkGroupCount - 3 bits for dimensions
    952937void AsmGalliumPseudoOps::setUseGridWorkGroupCount(AsmGalliumHandler& handler,
    953938                   const char* pseudoOpPlace, const char* linePtr)
     
    20942079           
    20952080            // to little endian
    2096             SLEV(outConfig.amdCodeVersionMajor, outConfig.amdCodeVersionMajor);
    2097             SLEV(outConfig.amdCodeVersionMinor, outConfig.amdCodeVersionMinor);
    2098             SLEV(outConfig.amdMachineKind, outConfig.amdMachineKind);
    2099             SLEV(outConfig.amdMachineMajor, outConfig.amdMachineMajor);
    2100             SLEV(outConfig.amdMachineMinor, outConfig.amdMachineMinor);
    2101             SLEV(outConfig.amdMachineStepping, outConfig.amdMachineStepping);
    2102             SLEV(outConfig.kernelCodeEntryOffset, outConfig.kernelCodeEntryOffset);
    2103             SLEV(outConfig.kernelCodePrefetchOffset, outConfig.kernelCodePrefetchOffset);
    2104             SLEV(outConfig.kernelCodePrefetchSize, outConfig.kernelCodePrefetchSize);
    2105             SLEV(outConfig.maxScrachBackingMemorySize,
    2106                  outConfig.maxScrachBackingMemorySize);
    2107             SLEV(outConfig.computePgmRsrc1, outConfig.computePgmRsrc1);
    2108             SLEV(outConfig.computePgmRsrc2, outConfig.computePgmRsrc2);
    2109             SLEV(outConfig.enableSgprRegisterFlags, outConfig.enableSgprRegisterFlags);
    2110             SLEV(outConfig.enableFeatureFlags, outConfig.enableFeatureFlags);
    2111             SLEV(outConfig.workitemPrivateSegmentSize,
    2112                  outConfig.workitemPrivateSegmentSize);
    2113             SLEV(outConfig.workgroupGroupSegmentSize,
    2114                  outConfig.workgroupGroupSegmentSize);
    2115             SLEV(outConfig.gdsSegmentSize, outConfig.gdsSegmentSize);
    2116             SLEV(outConfig.kernargSegmentSize, outConfig.kernargSegmentSize);
    2117             SLEV(outConfig.workgroupFbarrierCount, outConfig.workgroupFbarrierCount);
    2118             SLEV(outConfig.wavefrontSgprCount, outConfig.wavefrontSgprCount);
    2119             SLEV(outConfig.workitemVgprCount, outConfig.workitemVgprCount);
    2120             SLEV(outConfig.reservedVgprFirst, outConfig.reservedVgprFirst);
    2121             SLEV(outConfig.reservedVgprCount, outConfig.reservedVgprCount);
    2122             SLEV(outConfig.reservedSgprFirst, outConfig.reservedSgprFirst);
    2123             SLEV(outConfig.reservedSgprCount, outConfig.reservedSgprCount);
    2124             SLEV(outConfig.debugWavefrontPrivateSegmentOffsetSgpr,
    2125                 outConfig.debugWavefrontPrivateSegmentOffsetSgpr);
    2126             SLEV(outConfig.debugPrivateSegmentBufferSgpr,
    2127                  outConfig.debugPrivateSegmentBufferSgpr);
    2128             SLEV(outConfig.callConvention, outConfig.callConvention);
    2129             SLEV(outConfig.runtimeLoaderKernelSymbol,
    2130                  outConfig.runtimeLoaderKernelSymbol);
     2081            outConfig.toLE(); // to little-endian
    21312082            // put control directive section to config
    21322083            if (kernel.ctrlDirSection!=ASMSECT_NONE &&
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3309 r3313  
    527527enum AmdCL2ConfigValueTarget
    528528{
    529     AMDCL2CVAL_SGPRSNUM,
    530     AMDCL2CVAL_VGPRSNUM,
    531     AMDCL2CVAL_PGMRSRC1,
    532     AMDCL2CVAL_PGMRSRC2,
    533     AMDCL2CVAL_IEEEMODE,
    534     AMDCL2CVAL_FLOATMODE,
    535529    AMDCL2CVAL_LOCALSIZE,
    536530    AMDCL2CVAL_GDSSIZE,
    537531    AMDCL2CVAL_SCRATCHBUFFER,
    538     AMDCL2CVAL_PRIORITY,
    539     AMDCL2CVAL_TGSIZE,
    540     AMDCL2CVAL_DEBUGMODE,
    541     AMDCL2CVAL_DX10CLAMP,
    542     AMDCL2CVAL_PRIVMODE,
    543     AMDCL2CVAL_EXCEPTIONS,
    544532    AMDCL2CVAL_USESETUP,
    545533    AMDCL2CVAL_USEARGS,
    546534    AMDCL2CVAL_USEENQUEUE,
    547     AMDCL2CVAL_USEGENERIC
     535    AMDCL2CVAL_USEGENERIC,
     536    AMDCL2CVAL_HSA_SGPRSNUM,
     537    AMDCL2CVAL_HSA_VGPRSNUM,
     538    AMDCL2CVAL_HSA_PRIVMODE,
     539    AMDCL2CVAL_HSA_DEBUGMODE,
     540    AMDCL2CVAL_HSA_DX10CLAMP,
     541    AMDCL2CVAL_HSA_IEEEMODE,
     542    AMDCL2CVAL_HSA_TGSIZE,
     543    AMDCL2CVAL_HSA_FLOATMODE,
     544    AMDCL2CVAL_HSA_PRIORITY,
     545    AMDCL2CVAL_HSA_EXCEPTIONS,
     546    AMDCL2CVAL_HSA_USERDATANUM,
     547    AMDCL2CVAL_HSA_PGMRSRC1,
     548    AMDCL2CVAL_HSA_PGMRSRC2,
     549    AMDCL2CVAL_KERNEL_CODE_ENTRY_OFFSET,
     550    AMDCL2CVAL_KERNEL_CODE_PREFETCH_OFFSET,
     551    AMDCL2CVAL_KERNEL_CODE_PREFETCH_SIZE,
     552    AMDCL2CVAL_MAX_SCRATCH_BACKING_MEMORY,
     553    AMDCL2CVAL_USE_PRIVATE_SEGMENT_BUFFER,
     554    AMDCL2CVAL_USE_DISPATCH_PTR,
     555    AMDCL2CVAL_USE_QUEUE_PTR,
     556    AMDCL2CVAL_USE_KERNARG_SEGMENT_PTR,
     557    AMDCL2CVAL_USE_DISPATCH_ID,
     558    AMDCL2CVAL_USE_FLAT_SCRATCH_INIT,
     559    AMDCL2CVAL_USE_PRIVATE_SEGMENT_SIZE,
     560    AMDCL2CVAL_USE_ORDERED_APPEND_GDS,
     561    AMDCL2CVAL_PRIVATE_ELEM_SIZE,
     562    AMDCL2CVAL_USE_PTR64,
     563    AMDCL2CVAL_USE_DYNAMIC_CALL_STACK,
     564    AMDCL2CVAL_USE_DEBUG_ENABLED,
     565    AMDCL2CVAL_USE_XNACK_ENABLED,
     566    AMDCL2CVAL_WORKITEM_PRIVATE_SEGMENT_SIZE,
     567    AMDCL2CVAL_WORKGROUP_GROUP_SEGMENT_SIZE,
     568    AMDCL2CVAL_GDS_SEGMENT_SIZE,
     569    AMDCL2CVAL_KERNARG_SEGMENT_SIZE,
     570    AMDCL2CVAL_WORKGROUP_FBARRIER_COUNT,
     571    AMDCL2CVAL_WAVEFRONT_SGPR_COUNT,
     572    AMDCL2CVAL_WORKITEM_VGPR_COUNT,
     573    AMDCL2CVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR,
     574    AMDCL2CVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR,
     575    AMDCL2CVAL_KERNARG_SEGMENT_ALIGN,
     576    AMDCL2CVAL_GROUP_SEGMENT_ALIGN,
     577    AMDCL2CVAL_PRIVATE_SEGMENT_ALIGN,
     578    AMDCL2CVAL_WAVEFRONT_SIZE,
     579    AMDCL2CVAL_CALL_CONVENTION,
     580    AMDCL2CVAL_RUNTIME_LOADER_KERNEL_SYMBOL,
     581    AMDCL2CVAL_HSA_FIRST_PARAM = AMDCL2CVAL_HSA_SGPRSNUM,
     582    AMDCL2CVAL_ONLY_HSA_FIRST_PARAM = AMDCL2CVAL_KERNEL_CODE_ENTRY_OFFSET,
     583   
     584    AMDCL2CVAL_SGPRSNUM = AMDCL2CVAL_HSA_SGPRSNUM,
     585    AMDCL2CVAL_VGPRSNUM = AMDCL2CVAL_HSA_VGPRSNUM,
     586    AMDCL2CVAL_PRIVMODE = AMDCL2CVAL_HSA_PRIVMODE,
     587    AMDCL2CVAL_DEBUGMODE = AMDCL2CVAL_HSA_DEBUGMODE,
     588    AMDCL2CVAL_DX10CLAMP = AMDCL2CVAL_HSA_DX10CLAMP,
     589    AMDCL2CVAL_IEEEMODE = AMDCL2CVAL_HSA_IEEEMODE,
     590    AMDCL2CVAL_TGSIZE = AMDCL2CVAL_HSA_TGSIZE,
     591    AMDCL2CVAL_FLOATMODE = AMDCL2CVAL_HSA_FLOATMODE,
     592    AMDCL2CVAL_PRIORITY = AMDCL2CVAL_HSA_PRIORITY,
     593    AMDCL2CVAL_EXCEPTIONS = AMDCL2CVAL_HSA_EXCEPTIONS,
     594    AMDCL2CVAL_USERDATANUM = AMDCL2CVAL_HSA_USERDATANUM,
     595    AMDCL2CVAL_PGMRSRC1 = AMDCL2CVAL_HSA_PGMRSRC1,
     596    AMDCL2CVAL_PGMRSRC2 = AMDCL2CVAL_HSA_PGMRSRC2
    548597};
    549598
     
    563612   
    564613    static void doInner(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
     614                      const char* linePtr);
     615   
     616    static void doControlDirective(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
    565617                      const char* linePtr);
    566618   
     
    587639                      const char* linePtr);
    588640   
     641    static void setMachine(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
     642                      const char* linePtr);
     643   
     644    static void setCodeVersion(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
     645                      const char* linePtr);
     646   
     647    static void setReservedXgprs(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
     648                      const char* linePtr, bool inVgpr);
     649   
     650    static void setUseGridWorkGroupCount(AsmAmdCL2Handler& handler,
     651                      const char* pseudoOpPlace, const char* linePtr);
     652   
    589653    static void setCWS(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
    590654                      const char* linePtr);
     
    604668                      const char* linePtr);
    605669    static void doConfig(AsmAmdCL2Handler& handler, const char* pseudoOpPlace,
    606                       const char* linePtr);
     670                      const char* linePtr, bool hsaConfig);
    607671};
    608672
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r3306 r3313  
    293293    {
    294294        config.reset(new AsmROCmKernelConfig{});
    295         // set default values to kernel config
    296         ::memset(config.get(), 0xff, 128);
    297         ::memset(config->controlDirective, 0, 128);
    298         config->computePgmRsrc1 = config->computePgmRsrc2 = 0;
    299         config->enableSgprRegisterFlags = 0;
    300         config->enableFeatureFlags = 0;
    301         config->reserved1[0] = config->reserved1[1] = config->reserved1[2] = 0;
    302         config->dimMask = 0;
    303         config->usedVGPRsNum = BINGEN_DEFAULT;
    304         config->usedSGPRsNum = BINGEN_DEFAULT;
    305         config->userDataNum = BINGEN8_DEFAULT;
    306         config->ieeeMode = false;
    307         config->floatMode = 0xc0;
    308         config->priority = 0;
    309         config->exceptions = 0;
    310         config->tgSize = false;
    311         config->debugMode = false;
    312         config->privilegedMode = false;
    313         config->dx10Clamp = false;
     295        config->initialize();
    314296    }
    315297}
     
    789771
    790772// parse machine version - used also in AsmGalliumFormat
     773// four numbers - kind, major, minor, stepping
    791774bool AsmROCmPseudoOps::parseMachine(Assembler& asmr, const char* linePtr,
    792775        uint16_t& machineKind, uint16_t& machineMajor, uint16_t& machineMinor,
     
    833816}
    834817
     818// set machine - four numbers - kind, major, minor, stepping
    835819void AsmROCmPseudoOps::setMachine(AsmROCmHandler& handler, const char* pseudoOpPlace,
    836820                      const char* linePtr)
     
    858842
    859843// parse code version (amd code version) - used also in AsmGalliumFormat
     844// two numbers - major and minor
    860845bool AsmROCmPseudoOps::parseCodeVersion(Assembler& asmr, const char* linePtr,
    861846                uint16_t& codeMajor, uint16_t& codeMinor)
     
    884869}
    885870
     871// two numbers - major and minor
    886872void AsmROCmPseudoOps::setCodeVersion(AsmROCmHandler& handler, const char* pseudoOpPlace,
    887873                  const char* linePtr)
     
    906892
    907893// parse reserved gprs - used also in AsmGalliumFormat
     894// parsereserved S/VGRPS - first number is first register, second is last register
    908895bool AsmROCmPseudoOps::parseReservedXgprs(Assembler& asmr, const char* linePtr,
    909896                bool inVgpr, uint16_t& gprFirst, uint16_t& gprCount)
     
    957944}
    958945
     946/// set reserved S/VGRPS - first number is first register, second is last register
    959947void AsmROCmPseudoOps::setReservedXgprs(AsmROCmHandler& handler, const char* pseudoOpPlace,
    960948                      const char* linePtr, bool inVgpr)
     
    986974}
    987975
    988 
     976// set UseGridWorkGroupCount - 3 bits for dimensions
    989977void AsmROCmPseudoOps::setUseGridWorkGroupCount(AsmROCmHandler& handler,
    990978                   const char* pseudoOpPlace, const char* linePtr)
     
    16411629            config.runtimeLoaderKernelSymbol = 0;
    16421630       
    1643         // to little endian
    1644         SLEV(config.amdCodeVersionMajor, config.amdCodeVersionMajor);
    1645         SLEV(config.amdCodeVersionMinor, config.amdCodeVersionMinor);
    1646         SLEV(config.amdMachineKind, config.amdMachineKind);
    1647         SLEV(config.amdMachineMajor, config.amdMachineMajor);
    1648         SLEV(config.amdMachineMinor, config.amdMachineMinor);
    1649         SLEV(config.amdMachineStepping, config.amdMachineStepping);
    1650         SLEV(config.kernelCodeEntryOffset, config.kernelCodeEntryOffset);
    1651         SLEV(config.kernelCodePrefetchOffset, config.kernelCodePrefetchOffset);
    1652         SLEV(config.kernelCodePrefetchSize, config.kernelCodePrefetchSize);
    1653         SLEV(config.maxScrachBackingMemorySize, config.maxScrachBackingMemorySize);
    1654         SLEV(config.computePgmRsrc1, config.computePgmRsrc1);
    1655         SLEV(config.computePgmRsrc2, config.computePgmRsrc2);
    1656         SLEV(config.enableSgprRegisterFlags, config.enableSgprRegisterFlags);
    1657         SLEV(config.enableFeatureFlags, config.enableFeatureFlags);
    1658         SLEV(config.workitemPrivateSegmentSize, config.workitemPrivateSegmentSize);
    1659         SLEV(config.workgroupGroupSegmentSize, config.workgroupGroupSegmentSize);
    1660         SLEV(config.gdsSegmentSize, config.gdsSegmentSize);
    1661         SLEV(config.kernargSegmentSize, config.kernargSegmentSize);
    1662         SLEV(config.workgroupFbarrierCount, config.workgroupFbarrierCount);
    1663         SLEV(config.wavefrontSgprCount, config.wavefrontSgprCount);
    1664         SLEV(config.workitemVgprCount, config.workitemVgprCount);
    1665         SLEV(config.reservedVgprFirst, config.reservedVgprFirst);
    1666         SLEV(config.reservedVgprCount, config.reservedVgprCount);
    1667         SLEV(config.reservedSgprFirst, config.reservedSgprFirst);
    1668         SLEV(config.reservedSgprCount, config.reservedSgprCount);
    1669         SLEV(config.debugWavefrontPrivateSegmentOffsetSgpr,
    1670              config.debugWavefrontPrivateSegmentOffsetSgpr);
    1671         SLEV(config.debugPrivateSegmentBufferSgpr, config.debugPrivateSegmentBufferSgpr);
    1672         SLEV(config.callConvention, config.callConvention);
    1673         SLEV(config.runtimeLoaderKernelSymbol, config.runtimeLoaderKernelSymbol);
     1631        config.toLE(); // to little-endian
    16741632        // put control directive section to config
    16751633        if (kernel.ctrlDirSection!=ASMSECT_NONE &&
  • CLRadeonExtender/trunk/amdbin/AmdCL2BinGen.cpp

    r3307 r3313  
    15791579                const TempAmdCL2KernelData& tempData = tempDatas[i];
    15801580                if (!kernel.useConfig)
    1581                 {   // no configuration, get from kernel data
     1581                    // no configuration, get from kernel data
    15821582                    fob.writeArray(tempData.stubSize, kernel.stub);
    1583                     fob.writeArray(tempData.setupSize, kernel.setup);
    1584                 }
    1585                 else // generate stub, setup from kernel config
    1586                 {
     1583                else // generate stub, from kernel config
    15871584                    generateKernelStub(arch, kernel.config, fob, tempData.codeSize,
    15881585                               kernel.code, tempData.useLocals, tempData.pipesUsed!=0);
     1586               
     1587                if (!kernel.useConfig || kernel.hsaConfig)
     1588                    // no configuration, get from kernel data
     1589                    fob.writeArray(tempData.setupSize, kernel.setup);
     1590                else // generate stub, setup from kernel config
    15891591                    generateKernelSetup(arch, kernel.config, fob, false,
    15901592                                tempData.useLocals, tempData.pipesUsed!=0, input->is64Bit,
    15911593                                input->driverVersion);
    1592                 }
    15931594                fob.writeArray(kernel.codeSize, kernel.code);
    15941595            }
     
    16341635                outSize += toFill;
    16351636            }
    1636             if (!kernel.useConfig)
     1637            if (!kernel.useConfig || kernel.hsaConfig)
    16371638                fob.writeArray(tempData.setupSize, kernel.setup);
    16381639            else
  • CLRadeonExtender/trunk/tests/amdbin/AmdCL2BinGen.cpp

    r3048 r3313  
    590590        kernel.isaMetadata = nullptr;
    591591        kernel.useConfig = useConfig;
     592        kernel.hsaConfig = false;
    592593        if (!isNewBinary)
    593594        {
Note: See TracChangeset for help on using the changeset viewer.