Changeset 3280 in CLRX


Ignore:
Timestamp:
Sep 1, 2017, 5:47:44 PM (10 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?: Add almost pseudo-ops to handle AMDHSA config parameters.

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

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

    r3279 r3280  
    6464   
    6565    GALLIUM_COMMENT = LAST_COMMON+1,    ///< gallium comment section
     66    GALLIUM_CONFIG_CTRL_DIRECTIVE,
    6667   
    6768    ROCM_COMMENT = LAST_COMMON+1,        ///< ROCm comment section
     
    397398        cxuint defaultSection;
    398399        std::unique_ptr<AsmAmdHsaKernelConfig> config;
     400        cxuint ctrlDirSection;
    399401        bool hasProgInfo;
    400402        cxbyte progInfoEntries;
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3279 r3280  
    3535static const char* galliumPseudoOpNamesTbl[] =
    3636{
    37     "arg", "args", "config",
     37    "arg", "args", "call_convention", "codeversion",
     38    "config", "control_directive",
     39    "debug_private_segment_buffer_sgpr",
     40    "debug_wavefront_private_segment_offset_sgpr",
    3841    "debugmode", "dims", "driver_version", "dx10clamp",
    39     "entry", "exceptions", "floatmode",
    40     "get_driver_version", "get_llvm_version",
    41     "globaldata", "ieeemode",
    42     "kcode", "kcodeend",
     42    "entry", "exceptions", "floatmode", "gds_segment_size",
     43    "get_driver_version", "get_llvm_version", "globaldata",
     44    "group_segment_align",
     45    "hsa_debugmode", "hsa_dims", "hsa_dx10clamp", "hsa_exceptions",
     46    "hsa_floatmode", "hsa_ieeemode",
     47    "hsa_localsize", "hsa_pgmrsrc1",
     48    "hsa_pgmrsrc2", "hsa_priority", "hsa_privmode",
     49    "hsa_sgprsnum", "hsa_tgsize", "hsa_userdatanum", "hsa_vgprsnum",
     50    "ieeemode", "kcode", "kcodeend",
     51    "kernarg_segment_align", "kernarg_segment_size",
     52    "kernel_code_entry_offset", "kernel_code_prefetch_offset",
     53    "kernel_code_prefetch_size",
    4354    "llvm_version", "localsize",
     55    "machine", "max_scratch_backing_memory",
    4456    "pgmrsrc1", "pgmrsrc2", "priority",
    45     "privmode", "proginfo",
    46     "scratchbuffer", "sgprsnum", "spilledsgprs", "spilledvgprs",
    47     "tgsize", "userdatanum", "vgprsnum"
     57    "private_elem_size", "private_segment_align",
     58    "privmode", "proginfo", "reserved_sgprs", "reserved_vgprs",
     59    "runtime_loader_kernel_symbol",
     60    "scratchbuffer", "sgprsnum",
     61    "spilledsgprs", "spilledvgprs", "tgsize",
     62    "use_debug_enabled", "use_dispatch_id",
     63    "use_dispatch_ptr", "use_dynamic_call_stack",
     64    "use_flat_scratch_init", "use_grid_workgroup_count",
     65    "use_kernarg_segment_ptr",
     66    "use_ordered_append_gds", "use_private_segment_buffer",
     67    "use_private_segment_size", "use_ptr64",
     68    "use_queue_ptr", "use_xnack_enabled",
     69    "userdatanum", "vgprsnum",
     70    "wavefront_sgpr_count", "wavefront_size",
     71    "workgroup_fbarrier_count", "workgroup_group_segment_size",
     72    "workitem_private_segment_size", "workitem_vgpr_count"
    4873};
    4974
    5075enum
    5176{
    52     GALLIUMOP_ARG = 0, GALLIUMOP_ARGS, GALLIUMOP_CONFIG,
     77    GALLIUMOP_ARG = 0, GALLIUMOP_ARGS, GALLIUMOP_CALL_CONVENTION, GALLIUMOP_CODEVERSION,
     78    GALLIUMOP_CONFIG, GALLIUMOP_CONTROL_DIRECTIVE,
     79    GALLIUMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR,
     80    GALLIUMOP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR,
    5381    GALLIUMOP_DEBUGMODE, GALLIUMOP_DIMS, GALLIUMOP_DRIVER_VERSION, GALLIUMOP_DX10CLAMP,
    54     GALLIUMOP_ENTRY, GALLIUMOP_EXCEPTIONS, GALLIUMOP_FLOATMODE,
    55     GALLIUMOP_GET_DRIVER_VERSION, GALLIUMOP_GET_LLVM_VERSION,
    56     GALLIUMOP_GLOBALDATA, GALLIUMOP_IEEEMODE,
    57     GALLIUMOP_KCODE, GALLIUMOP_KCODEEND,
     82    GALLIUMOP_ENTRY, GALLIUMOP_EXCEPTIONS, GALLIUMOP_FLOATMODE, GALLIUMOP_GDS_SEGMENT_SIZE,
     83    GALLIUMOP_GET_DRIVER_VERSION, GALLIUMOP_GET_LLVM_VERSION, GALLIUMOP_GLOBALDATA,
     84    GALLIUMOP_GROUP_SEGMENT_ALIGN,
     85    GALLIUMOP_HSA_DEBUGMODE, GALLIUMOP_HSA_DIMS,
     86    GALLIUMOP_HSA_DX10CLAMP, GALLIUMOP_HSA_EXCEPTIONS,
     87    GALLIUMOP_HSA_FLOATMODE, GALLIUMOP_HSA_IEEEMODE,
     88    GALLIUMOP_HSA_LOCALSIZE, GALLIUMOP_HSA_PGMRSRC1,
     89    GALLIUMOP_HSA_PGMRSRC2, GALLIUMOP_HSA_PRIORITY, GALLIUMOP_HSA_PRIVMODE,
     90    GALLIUMOP_HSA_SGPRSNUM, GALLIUMOP_HSA_TGSIZE,
     91    GALLIUMOP_HSA_USERDATANUM, GALLIUMOP_HSA_VGPRSNUM,
     92    GALLIUMOP_IEEEMODE, GALLIUMOP_KCODE, GALLIUMOP_KCODEEND,
     93    GALLIUMOP_KERNARG_SEGMENT_ALIGN, GALLIUMOP_KERNARG_SEGMENT_SIZE,
     94    GALLIUMOP_KERNEL_CODE_ENTRY_OFFSET, GALLIUMOP_KERNEL_CODE_PREFETCH_OFFSET,
     95    GALLIUMOP_KERNEL_CODE_PREFETCH_SIZE,
    5896    GALLIUMOP_LLVM_VERSION, GALLIUMOP_LOCALSIZE,
     97    GALLIUMOP_MACHINE, GALLIUMOP_MAX_SCRATCH_BACKING_MEMORY,
    5998    GALLIUMOP_PGMRSRC1, GALLIUMOP_PGMRSRC2, GALLIUMOP_PRIORITY,
     99    GALLIUMOP_PRIVATE_ELEM_SIZE, GALLIUMOP_PRIVATE_SEGMENT_ALIGN,
    60100    GALLIUMOP_PRIVMODE, GALLIUMOP_PROGINFO,
     101    GALLIUMOP_RESERVED_SGPRS, GALLIUMOP_RESERVED_VGPRS,
     102    GALLIUMOP_RUNTIME_LOADER_KERNEL_SYMBOL,
    61103    GALLIUMOP_SCRATCHBUFFER, GALLIUMOP_SGPRSNUM,
    62     GALLIUMOP_SPILLEDSGPRS, GALLIUMOP_SPILLEDVGPRS,
    63     GALLIUMOP_TGSIZE, GALLIUMOP_USERDATANUM, GALLIUMOP_VGPRSNUM
     104    GALLIUMOP_SPILLEDSGPRS, GALLIUMOP_SPILLEDVGPRS, GALLIUMOP_TGSIZE,
     105    GALLIUMOP_USE_DEBUG_ENABLED, GALLIUMOP_USE_DISPATCH_ID,
     106    GALLIUMOP_USE_DISPATCH_PTR, GALLIUMOP_USE_DYNAMIC_CALL_STACK,
     107    GALLIUMOP_USE_FLAT_SCRATCH_INIT, GALLIUMOP_USE_GRID_WORKGROUP_COUNT,
     108    GALLIUMOP_USE_KERNARG_SEGMENT_PTR,
     109    GALLIUMOP_USE_ORDERED_APPEND_GDS, GALLIUMOP_USE_PRIVATE_SEGMENT_BUFFER,
     110    GALLIUMOP_USE_PRIVATE_SEGMENT_SIZE, GALLIUMOP_USE_PTR64,
     111    GALLIUMOP_USE_QUEUE_PTR, GALLIUMOP_USE_XNACK_ENABLED,
     112    GALLIUMOP_USERDATANUM, GALLIUMOP_VGPRSNUM,
     113    GALLIUMOP_WAVEFRONT_SGPR_COUNT, GALLIUMOP_WAVEFRONT_SIZE,
     114    GALLIUMOP_WORKGROUP_FBARRIER_COUNT, GALLIUMOP_WORKGROUP_GROUP_SEGMENT_SIZE,
     115    GALLIUMOP_WORKITEM_PRIVATE_SEGMENT_SIZE, GALLIUMOP_WORKITEM_VGPR_COUNT
    64116};
    65117
     
    139191    /// add kernel config section
    140192    sections.push_back({ thisKernel, AsmSectionType::CONFIG, ELFSECTID_UNDEF, nullptr });
    141     kernelStates.push_back(new Kernel{ thisSection, nullptr, false, 0 });
     193    kernelStates.push_back(new Kernel{ thisSection, nullptr, ASMSECT_NONE, false, 0 });
    142194   
    143195    if (assembler.currentKernel == ASMKERN_GLOBAL)
     
    419471}
    420472
     473void AsmGalliumPseudoOps::doControlDirective(AsmGalliumHandler& handler,
     474              const char* pseudoOpPlace, const char* linePtr)
     475{
     476    Assembler& asmr = handler.assembler;
     477    if (asmr.currentKernel==ASMKERN_GLOBAL)
     478    {
     479        asmr.printError(pseudoOpPlace, "Kernel control directive can be defined "
     480                    "only inside kernel");
     481        return;
     482    }
     483    if (handler.determineLLVMVersion() < 40000U)
     484    {
     485        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     486        return;
     487    }
     488    if (!checkGarbagesAtEnd(asmr, linePtr))
     489        return;
     490   
     491    AsmGalliumHandler::Kernel& kernel = *handler.kernelStates[asmr.currentKernel];
     492    if (kernel.ctrlDirSection == ASMSECT_NONE)
     493    {
     494        cxuint thisSection = handler.sections.size();
     495        handler.sections.push_back({ asmr.currentKernel,
     496            AsmSectionType::ROCM_CONFIG_CTRL_DIRECTIVE,
     497            ELFSECTID_UNDEF, nullptr });
     498        kernel.ctrlDirSection = thisSection;
     499    }
     500    asmr.goToSection(pseudoOpPlace, kernel.ctrlDirSection);
     501    handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     502}
     503
    421504void AsmGalliumPseudoOps::doGlobalData(AsmGalliumHandler& handler,
    422505                   const char* pseudoOpPlace, const char* linePtr)
     
    432515
    433516void AsmGalliumPseudoOps::setDimensions(AsmGalliumHandler& handler,
    434                     const char* pseudoOpPlace, const char* linePtr)
     517            const char* pseudoOpPlace, const char* linePtr, bool amdHsa)
    435518{
    436519    Assembler& asmr = handler.assembler;
     
    441524        return;
    442525    }
     526    if (amdHsa && handler.determineLLVMVersion() < 40000U)
     527    {
     528        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     529        return;
     530    }
     531       
    443532    cxuint dimMask = 0;
    444533    if (!parseDimensions(asmr, linePtr, dimMask))
     
    446535    if (!checkGarbagesAtEnd(asmr, linePtr))
    447536        return;
    448     handler.output.kernels[asmr.currentKernel].config.dimMask = dimMask;
     537    if (!amdHsa)
     538        handler.output.kernels[asmr.currentKernel].config.dimMask = dimMask;
     539    else
     540    {    // AMD HSA
     541        handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     542        AsmAmdHsaKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     543        config.dimMask = dimMask;
     544    }
    449545}
    450546
     
    464560    if (target >= GALLIUMCVAL_HSA_FIRST_PARAM && handler.determineLLVMVersion() < 40000U)
    465561    {
    466         asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM<=4.0.0");
     562        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
    467563        return;
    468564    }
     
    697793            break;
    698794    }
     795   
     796    if (target >= GALLIUMCVAL_HSA_FIRST_PARAM)
     797    {
     798        handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     799        AsmAmdHsaKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     800       
     801        // set value
     802        switch(target)
     803        {
     804            case GALLIUMCVAL_HSA_SGPRSNUM:
     805                config.usedSGPRsNum = value;
     806                break;
     807            case GALLIUMCVAL_HSA_VGPRSNUM:
     808                config.usedVGPRsNum = value;
     809                break;
     810            case GALLIUMCVAL_HSA_PGMRSRC1:
     811                config.computePgmRsrc1 = value;
     812                break;
     813            case GALLIUMCVAL_HSA_PGMRSRC2:
     814                config.computePgmRsrc2 = value;
     815                break;
     816            case GALLIUMCVAL_HSA_FLOATMODE:
     817                config.floatMode = value;
     818                break;
     819            case GALLIUMCVAL_HSA_PRIORITY:
     820                config.priority = value;
     821                break;
     822            case GALLIUMCVAL_HSA_USERDATANUM:
     823                config.userDataNum = value;
     824                break;
     825            case GALLIUMCVAL_HSA_EXCEPTIONS:
     826                config.exceptions = value;
     827                break;
     828            case GALLIUMCVAL_KERNEL_CODE_ENTRY_OFFSET:
     829                config.kernelCodeEntryOffset = value;
     830                break;
     831            case GALLIUMCVAL_KERNEL_CODE_PREFETCH_OFFSET:
     832                config.kernelCodePrefetchOffset = value;
     833                break;
     834            case GALLIUMCVAL_KERNEL_CODE_PREFETCH_SIZE:
     835                config.kernelCodePrefetchSize = value;
     836                break;
     837            case GALLIUMCVAL_MAX_SCRATCH_BACKING_MEMORY:
     838                config.maxScrachBackingMemorySize = value;
     839                break;
     840            case GALLIUMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
     841                config.workitemPrivateSegmentSize = value;
     842                break;
     843            case GALLIUMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE:
     844                config.workgroupGroupSegmentSize = value;
     845                break;
     846            case GALLIUMCVAL_GDS_SEGMENT_SIZE:
     847                config.gdsSegmentSize = value;
     848                break;
     849            case GALLIUMCVAL_KERNARG_SEGMENT_SIZE:
     850                config.kernargSegmentSize = value;
     851                break;
     852            case GALLIUMCVAL_WORKGROUP_FBARRIER_COUNT:
     853                config.workgroupFbarrierCount = value;
     854                break;
     855            case GALLIUMCVAL_WAVEFRONT_SGPR_COUNT:
     856                config.wavefrontSgprCount = value;
     857                break;
     858            case GALLIUMCVAL_WORKITEM_VGPR_COUNT:
     859                config.workitemVgprCount = value;
     860                break;
     861            case GALLIUMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
     862                config.debugWavefrontPrivateSegmentOffsetSgpr = value;
     863                break;
     864            case GALLIUMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     865                config.debugPrivateSegmentBufferSgpr = value;
     866                break;
     867            case GALLIUMCVAL_PRIVATE_ELEM_SIZE:
     868                config.enableFeatureFlags = (config.enableFeatureFlags & ~6) |
     869                        ((63-CLZ64(value)-1)<<1);
     870                break;
     871            case GALLIUMCVAL_KERNARG_SEGMENT_ALIGN:
     872                config.kernargSegmentAlignment = 63-CLZ64(value);
     873                break;
     874            case GALLIUMCVAL_GROUP_SEGMENT_ALIGN:
     875                config.groupSegmentAlignment = 63-CLZ64(value);
     876                break;
     877            case GALLIUMCVAL_PRIVATE_SEGMENT_ALIGN:
     878                config.privateSegmentAlignment = 63-CLZ64(value);
     879                break;
     880            case GALLIUMCVAL_WAVEFRONT_SIZE:
     881                config.wavefrontSize = 63-CLZ64(value);
     882                break;
     883            case GALLIUMCVAL_CALL_CONVENTION:
     884                config.callConvention = value;
     885                break;
     886            case GALLIUMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL:
     887                config.runtimeLoaderKernelSymbol = value;
     888                break;
     889            default:
     890                break;
     891        }
     892    }
    699893}
    700894
     
    710904        return;
    711905    }
     906   
     907    if (target >= GALLIUMCVAL_HSA_FIRST_PARAM && handler.determineLLVMVersion() < 40000U)
     908    {
     909        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     910        return;
     911    }
     912   
    712913    if (!checkGarbagesAtEnd(asmr, linePtr))
    713914        return;
     
    733934            break;
    734935    }
     936   
     937    if (target >= GALLIUMCVAL_HSA_FIRST_PARAM)
     938    {
     939        handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     940        AsmAmdHsaKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     941       
     942        // set value
     943        switch(target)
     944        {
     945            case GALLIUMCVAL_HSA_PRIVMODE:
     946                config.privilegedMode = true;
     947                break;
     948            case GALLIUMCVAL_HSA_DEBUGMODE:
     949                config.debugMode = true;
     950                break;
     951            case GALLIUMCVAL_HSA_DX10CLAMP:
     952                config.dx10Clamp = true;
     953                break;
     954            case GALLIUMCVAL_HSA_IEEEMODE:
     955                config.ieeeMode = true;
     956                break;
     957            case GALLIUMCVAL_HSA_TGSIZE:
     958                config.tgSize = true;
     959                break;
     960            case GALLIUMCVAL_USE_PRIVATE_SEGMENT_BUFFER:
     961                config.enableSgprRegisterFlags |= ROCMFLAG_USE_PRIVATE_SEGMENT_BUFFER;
     962                break;
     963            case GALLIUMCVAL_USE_DISPATCH_PTR:
     964                config.enableSgprRegisterFlags |= ROCMFLAG_USE_DISPATCH_PTR;
     965                break;
     966            case GALLIUMCVAL_USE_QUEUE_PTR:
     967                config.enableSgprRegisterFlags |= ROCMFLAG_USE_QUEUE_PTR;
     968                break;
     969            case GALLIUMCVAL_USE_KERNARG_SEGMENT_PTR:
     970                config.enableSgprRegisterFlags |= ROCMFLAG_USE_KERNARG_SEGMENT_PTR;
     971                break;
     972            case GALLIUMCVAL_USE_DISPATCH_ID:
     973                config.enableSgprRegisterFlags |= ROCMFLAG_USE_DISPATCH_ID;
     974                break;
     975            case GALLIUMCVAL_USE_FLAT_SCRATCH_INIT:
     976                config.enableSgprRegisterFlags |= ROCMFLAG_USE_FLAT_SCRATCH_INIT;
     977                break;
     978            case GALLIUMCVAL_USE_PRIVATE_SEGMENT_SIZE:
     979                config.enableSgprRegisterFlags |= ROCMFLAG_USE_PRIVATE_SEGMENT_SIZE;
     980                break;
     981            case GALLIUMCVAL_USE_ORDERED_APPEND_GDS:
     982                config.enableFeatureFlags |= ROCMFLAG_USE_ORDERED_APPEND_GDS;
     983                break;
     984            case GALLIUMCVAL_USE_PTR64:
     985                config.enableFeatureFlags |= ROCMFLAG_USE_PTR64;
     986                break;
     987            case GALLIUMCVAL_USE_DYNAMIC_CALL_STACK:
     988                config.enableFeatureFlags |= ROCMFLAG_USE_DYNAMIC_CALL_STACK;
     989                break;
     990            case GALLIUMCVAL_USE_DEBUG_ENABLED:
     991                config.enableFeatureFlags |= ROCMFLAG_USE_DEBUG_ENABLED;
     992                break;
     993            case GALLIUMCVAL_USE_XNACK_ENABLED:
     994                config.enableFeatureFlags |= ROCMFLAG_USE_XNACK_ENABLED;
     995                break;
     996            default:
     997                break;
     998        }
     999    }
     1000}
     1001
     1002void AsmGalliumPseudoOps::setMachine(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     1003                      const char* linePtr)
     1004{
     1005    Assembler& asmr = handler.assembler;
     1006    const char* end = asmr.line + asmr.lineSize;
     1007    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1008        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1009    {
     1010        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1011        return;
     1012    }
     1013    if (handler.determineLLVMVersion() < 40000U)
     1014    {
     1015        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     1016        return;
     1017    }
     1018   
     1019    skipSpacesToEnd(linePtr, end);
     1020    uint64_t kindValue = BINGEN_NOTSUPPLIED;
     1021    uint64_t majorValue = BINGEN_NOTSUPPLIED;
     1022    uint64_t minorValue = BINGEN_NOTSUPPLIED;
     1023    uint64_t steppingValue = BINGEN_NOTSUPPLIED;
     1024    const char* valuePlace = linePtr;
     1025    bool good = getAbsoluteValueArg(asmr, kindValue, linePtr, true);
     1026    asmr.printWarningForRange(16, kindValue, asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1027    if (!skipRequiredComma(asmr, linePtr))
     1028        return;
     1029   
     1030    valuePlace = linePtr;
     1031    good &= getAbsoluteValueArg(asmr, majorValue, linePtr, true);
     1032    asmr.printWarningForRange(16, majorValue, asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1033    if (!skipRequiredComma(asmr, linePtr))
     1034        return;
     1035   
     1036    valuePlace = linePtr;
     1037    good &= getAbsoluteValueArg(asmr, minorValue, linePtr, true);
     1038    asmr.printWarningForRange(16, minorValue, asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1039    if (!skipRequiredComma(asmr, linePtr))
     1040        return;
     1041   
     1042    valuePlace = linePtr;
     1043    good &= getAbsoluteValueArg(asmr, steppingValue, linePtr, true);
     1044    asmr.printWarningForRange(16, steppingValue,
     1045                      asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1046   
     1047    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     1048        return;
     1049   
     1050    handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     1051    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1052    config->amdMachineKind = kindValue;
     1053    config->amdMachineMajor = majorValue;
     1054    config->amdMachineMinor = minorValue;
     1055    config->amdMachineStepping = steppingValue;
     1056}
     1057
     1058void AsmGalliumPseudoOps::setCodeVersion(AsmGalliumHandler& handler,
     1059                const char* pseudoOpPlace, const char* linePtr)
     1060{
     1061    Assembler& asmr = handler.assembler;
     1062    const char* end = asmr.line + asmr.lineSize;
     1063    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1064        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1065    {
     1066        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1067        return;
     1068    }
     1069    if (handler.determineLLVMVersion() < 40000U)
     1070    {
     1071        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     1072        return;
     1073    }
     1074   
     1075    skipSpacesToEnd(linePtr, end);
     1076    uint64_t majorValue = BINGEN_NOTSUPPLIED;
     1077    uint64_t minorValue = BINGEN_NOTSUPPLIED;
     1078    const char* valuePlace = linePtr;
     1079    bool good = getAbsoluteValueArg(asmr, majorValue, linePtr, true);
     1080    asmr.printWarningForRange(32, majorValue, asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1081    if (!skipRequiredComma(asmr, linePtr))
     1082        return;
     1083   
     1084    valuePlace = linePtr;
     1085    good &= getAbsoluteValueArg(asmr, minorValue, linePtr, true);
     1086    asmr.printWarningForRange(32, minorValue, asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     1087   
     1088    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     1089        return;
     1090   
     1091    handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     1092    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1093    config->amdCodeVersionMajor = majorValue;
     1094    config->amdCodeVersionMinor = minorValue;
     1095}
     1096
     1097void AsmGalliumPseudoOps::setReservedXgprs(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     1098                      const char* linePtr, bool inVgpr)
     1099{
     1100    Assembler& asmr = handler.assembler;
     1101    const char* end = asmr.line + asmr.lineSize;
     1102    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1103        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1104    {
     1105        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1106        return;
     1107    }
     1108    if (handler.determineLLVMVersion() < 40000U)
     1109    {
     1110        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     1111        return;
     1112    }
     1113   
     1114    skipSpacesToEnd(linePtr, end);
     1115    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(asmr.deviceType);
     1116    cxuint maxGPRsNum = getGPUMaxRegistersNum(arch,
     1117                       inVgpr ? REGTYPE_VGPR : REGTYPE_SGPR, 0);
     1118   
     1119    uint64_t firstReg = BINGEN_NOTSUPPLIED;
     1120    uint64_t lastReg = BINGEN_NOTSUPPLIED;
     1121    const char* valuePlace = linePtr;
     1122    bool haveFirstReg;
     1123    bool good = getAbsoluteValueArg(asmr, firstReg, linePtr, true);
     1124    haveFirstReg = good;
     1125    if (haveFirstReg && firstReg > maxGPRsNum-1)
     1126    {
     1127        char buf[64];
     1128        snprintf(buf, 64, "First reserved %s register out of range (0-%u)",
     1129                 inVgpr ? "VGPR" : "SGPR",  maxGPRsNum-1);
     1130        asmr.printError(valuePlace, buf);
     1131        good = false;
     1132    }
     1133    if (!skipRequiredComma(asmr, linePtr))
     1134        return;
     1135   
     1136    valuePlace = linePtr;
     1137    bool haveLastReg = getAbsoluteValueArg(asmr, lastReg, linePtr, true);
     1138    good &= haveLastReg;
     1139    if (haveLastReg && lastReg > maxGPRsNum-1)
     1140    {
     1141        char buf[64];
     1142        snprintf(buf, 64, "Last reserved %s register out of range (0-%u)",
     1143                 inVgpr ? "VGPR" : "SGPR", maxGPRsNum-1);
     1144        asmr.printError(valuePlace, buf);
     1145        good = false;
     1146    }
     1147    if (haveFirstReg && haveLastReg && firstReg > lastReg)
     1148    {
     1149        asmr.printError(valuePlace, "Wrong regsister range");
     1150        good = false;
     1151    }
     1152       
     1153   
     1154    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     1155        return;
     1156   
     1157    handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     1158    AsmAmdHsaKernelConfig* config = handler.kernelStates[asmr.currentKernel]->config.get();
     1159    if (inVgpr)
     1160    {
     1161        config->reservedVgprFirst = firstReg;
     1162        config->reservedVgprCount = lastReg-firstReg+1;
     1163    }
     1164    else
     1165    {
     1166        config->reservedSgprFirst = firstReg;
     1167        config->reservedSgprCount = lastReg-firstReg+1;
     1168    }
     1169}
     1170
     1171
     1172void AsmGalliumPseudoOps::setUseGridWorkGroupCount(AsmGalliumHandler& handler,
     1173                   const char* pseudoOpPlace, const char* linePtr)
     1174{
     1175    Assembler& asmr = handler.assembler;
     1176    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     1177        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     1178    {
     1179        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     1180        return;
     1181    }
     1182    if (handler.determineLLVMVersion() < 40000U)
     1183    {
     1184        asmr.printError(pseudoOpPlace, "HSA configuration pseudo-op only for LLVM>=4.0.0");
     1185        return;
     1186    }
     1187   
     1188    cxuint dimMask = 0;
     1189    if (!parseDimensions(asmr, linePtr, dimMask))
     1190        return;
     1191    if (!checkGarbagesAtEnd(asmr, linePtr))
     1192        return;
     1193    handler.kernelStates[asmr.currentKernel]->initializeAmdHsaKernelConfig();
     1194    uint16_t& flags = handler.kernelStates[asmr.currentKernel]->config->
     1195                enableSgprRegisterFlags;
     1196    flags = (flags & ~(7<<ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT)) |
     1197            (dimMask<<ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT);
    7351198}
    7361199
     
    11641627            AsmGalliumPseudoOps::doArgs(*this, stmtPlace, linePtr);
    11651628            break;
     1629        case GALLIUMOP_CALL_CONVENTION:
     1630            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1631                             GALLIUMCVAL_CALL_CONVENTION);
     1632            break;
     1633        case GALLIUMOP_CODEVERSION:
     1634            AsmGalliumPseudoOps::setCodeVersion(*this, stmtPlace, linePtr);
     1635            break;
    11661636        case GALLIUMOP_CONFIG:
    11671637            AsmGalliumPseudoOps::doConfig(*this, stmtPlace, linePtr);
     1638            break;
     1639        case GALLIUMOP_CONTROL_DIRECTIVE:
     1640            AsmGalliumPseudoOps::doControlDirective(*this, stmtPlace, linePtr);
     1641            break;
     1642        case GALLIUMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     1643            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1644                             GALLIUMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR);
     1645            break;
     1646        case GALLIUMOP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
     1647            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1648                         GALLIUMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR);
    11681649            break;
    11691650        case GALLIUMOP_DEBUGMODE:
     
    11721653            break;
    11731654        case GALLIUMOP_DIMS:
    1174             AsmGalliumPseudoOps::setDimensions(*this, stmtPlace, linePtr);
     1655            AsmGalliumPseudoOps::setDimensions(*this, stmtPlace, linePtr, false);
    11751656            break;
    11761657        case GALLIUMOP_DRIVER_VERSION:
     
    11921673                                    GALLIUMCVAL_FLOATMODE);
    11931674            break;
     1675        case GALLIUMOP_GDS_SEGMENT_SIZE:
     1676            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1677                             GALLIUMCVAL_GDS_SEGMENT_SIZE);
     1678            break;
    11941679        case GALLIUMOP_GET_DRIVER_VERSION:
    11951680            AsmGalliumPseudoOps::getXXXVersion(*this, linePtr, false);
     
    12001685        case GALLIUMOP_GLOBALDATA:
    12011686            AsmGalliumPseudoOps::doGlobalData(*this, stmtPlace, linePtr);
     1687            break;
     1688        case GALLIUMOP_GROUP_SEGMENT_ALIGN:
     1689            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1690                             GALLIUMCVAL_GROUP_SEGMENT_ALIGN);
     1691            break;
     1692        case GALLIUMOP_HSA_DEBUGMODE:
     1693            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1694                                GALLIUMCVAL_HSA_DEBUGMODE);
     1695            break;
     1696        case GALLIUMOP_HSA_DIMS:
     1697            AsmGalliumPseudoOps::setDimensions(*this, stmtPlace, linePtr, true);
     1698            break;
     1699        case GALLIUMOP_HSA_DX10CLAMP:
     1700            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1701                                GALLIUMCVAL_HSA_DX10CLAMP);
     1702            break;
     1703        case GALLIUMOP_HSA_EXCEPTIONS:
     1704            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1705                                    GALLIUMCVAL_HSA_EXCEPTIONS);
     1706            break;
     1707        case GALLIUMOP_HSA_FLOATMODE:
     1708            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1709                                    GALLIUMCVAL_HSA_FLOATMODE);
     1710            break;
     1711        case GALLIUMOP_HSA_IEEEMODE:
     1712            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1713                                GALLIUMCVAL_HSA_IEEEMODE);
     1714            break;
     1715        case GALLIUMOP_HSA_LOCALSIZE:
     1716            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1717                             GALLIUMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE);
     1718            break;
     1719        case GALLIUMOP_HSA_PGMRSRC1:
     1720            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1721                                    GALLIUMCVAL_HSA_PGMRSRC1);
     1722            break;
     1723        case GALLIUMOP_HSA_PGMRSRC2:
     1724            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1725                                    GALLIUMCVAL_HSA_PGMRSRC2);
     1726            break;
     1727        case GALLIUMOP_HSA_PRIORITY:
     1728            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1729                                    GALLIUMCVAL_HSA_PRIORITY);
     1730            break;
     1731        case GALLIUMOP_HSA_PRIVMODE:
     1732            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1733                                GALLIUMCVAL_HSA_PRIVMODE);
     1734            break;
     1735        case GALLIUMOP_HSA_SGPRSNUM:
     1736            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1737                                    GALLIUMCVAL_HSA_SGPRSNUM);
     1738            break;
     1739        case GALLIUMOP_HSA_TGSIZE:
     1740            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1741                                GALLIUMCVAL_HSA_TGSIZE);
     1742            break;
     1743        case GALLIUMOP_HSA_USERDATANUM:
     1744            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1745                                    GALLIUMCVAL_HSA_USERDATANUM);
     1746            break;
     1747        case GALLIUMOP_HSA_VGPRSNUM:
     1748            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1749                                    GALLIUMCVAL_HSA_VGPRSNUM);
    12021750            break;
    12031751        case GALLIUMOP_IEEEMODE:
     
    12111759            AsmGalliumPseudoOps::doKCodeEnd(*this, stmtPlace, linePtr);
    12121760            break;
     1761        case GALLIUMOP_KERNARG_SEGMENT_ALIGN:
     1762            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1763                             GALLIUMCVAL_KERNARG_SEGMENT_ALIGN);
     1764            break;
     1765        case GALLIUMOP_KERNARG_SEGMENT_SIZE:
     1766            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1767                             GALLIUMCVAL_KERNARG_SEGMENT_SIZE);
     1768            break;
     1769        case GALLIUMOP_KERNEL_CODE_ENTRY_OFFSET:
     1770            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1771                             GALLIUMCVAL_KERNEL_CODE_ENTRY_OFFSET);
     1772            break;
     1773        case GALLIUMOP_KERNEL_CODE_PREFETCH_OFFSET:
     1774            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1775                             GALLIUMCVAL_KERNEL_CODE_PREFETCH_OFFSET);
     1776            break;
     1777        case GALLIUMOP_KERNEL_CODE_PREFETCH_SIZE:
     1778            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1779                             GALLIUMCVAL_KERNEL_CODE_PREFETCH_SIZE);
     1780            break;
    12131781        case GALLIUMOP_LLVM_VERSION:
    12141782            AsmGalliumPseudoOps::setLLVMVersion(*this, linePtr);
     
    12181786                                    GALLIUMCVAL_LOCALSIZE);
    12191787            break;
     1788        case GALLIUMOP_MACHINE:
     1789            AsmGalliumPseudoOps::setMachine(*this, stmtPlace, linePtr);
     1790            break;
     1791        case GALLIUMOP_MAX_SCRATCH_BACKING_MEMORY:
     1792            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1793                             GALLIUMCVAL_MAX_SCRATCH_BACKING_MEMORY);
     1794            break;
    12201795        case GALLIUMOP_PRIORITY:
    12211796            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    12221797                                    GALLIUMCVAL_PRIORITY);
     1798            break;
     1799        case GALLIUMOP_PRIVATE_ELEM_SIZE:
     1800            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1801                             GALLIUMCVAL_PRIVATE_ELEM_SIZE);
     1802            break;
     1803        case GALLIUMOP_PRIVATE_SEGMENT_ALIGN:
     1804            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1805                             GALLIUMCVAL_PRIVATE_SEGMENT_ALIGN);
    12231806            break;
    12241807        case GALLIUMOP_PRIVMODE:
     
    12371820            AsmGalliumPseudoOps::doProgInfo(*this, stmtPlace, linePtr);
    12381821            break;
     1822        case GALLIUMOP_RESERVED_SGPRS:
     1823            AsmGalliumPseudoOps::setReservedXgprs(*this, stmtPlace, linePtr, false);
     1824            break;
     1825        case GALLIUMOP_RESERVED_VGPRS:
     1826            AsmGalliumPseudoOps::setReservedXgprs(*this, stmtPlace, linePtr, true);
     1827            break;
     1828        case GALLIUMOP_RUNTIME_LOADER_KERNEL_SYMBOL:
     1829            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1830                             GALLIUMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL);
     1831            break;
    12391832        case GALLIUMOP_SCRATCHBUFFER:
    12401833            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     
    12521845            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    12531846                                    GALLIUMCVAL_SPILLEDVGPRS);
     1847            break;
     1848        case GALLIUMOP_USE_DEBUG_ENABLED:
     1849            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1850                             GALLIUMCVAL_USE_DEBUG_ENABLED);
     1851            break;
     1852        case GALLIUMOP_USE_DISPATCH_ID:
     1853            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1854                             GALLIUMCVAL_USE_DISPATCH_ID);
     1855            break;
     1856        case GALLIUMOP_USE_DISPATCH_PTR:
     1857            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1858                             GALLIUMCVAL_USE_DISPATCH_PTR);
     1859            break;
     1860        case GALLIUMOP_USE_DYNAMIC_CALL_STACK:
     1861            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1862                             GALLIUMCVAL_USE_DYNAMIC_CALL_STACK);
     1863            break;
     1864        case GALLIUMOP_USE_FLAT_SCRATCH_INIT:
     1865            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1866                             GALLIUMCVAL_USE_FLAT_SCRATCH_INIT);
     1867            break;
     1868        case GALLIUMOP_USE_GRID_WORKGROUP_COUNT:
     1869            AsmGalliumPseudoOps::setUseGridWorkGroupCount(*this, stmtPlace, linePtr);
     1870            break;
     1871        case GALLIUMOP_USE_KERNARG_SEGMENT_PTR:
     1872            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1873                             GALLIUMCVAL_USE_KERNARG_SEGMENT_PTR);
     1874            break;
     1875        case GALLIUMOP_USE_ORDERED_APPEND_GDS:
     1876            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1877                             GALLIUMCVAL_USE_ORDERED_APPEND_GDS);
     1878            break;
     1879        case GALLIUMOP_USE_PRIVATE_SEGMENT_SIZE:
     1880            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1881                             GALLIUMCVAL_USE_PRIVATE_SEGMENT_SIZE);
     1882            break;
     1883        case GALLIUMOP_USE_PTR64:
     1884            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1885                             GALLIUMCVAL_USE_PTR64);
     1886            break;
     1887        case GALLIUMOP_USE_QUEUE_PTR:
     1888            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1889                             GALLIUMCVAL_USE_QUEUE_PTR);
     1890            break;
     1891        case GALLIUMOP_USE_PRIVATE_SEGMENT_BUFFER:
     1892            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1893                             GALLIUMCVAL_USE_PRIVATE_SEGMENT_BUFFER);
     1894            break;
     1895        case GALLIUMOP_USE_XNACK_ENABLED:
     1896            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     1897                             GALLIUMCVAL_USE_XNACK_ENABLED);
    12541898            break;
    12551899        case GALLIUMOP_TGSIZE:
     
    12641908            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    12651909                                    GALLIUMCVAL_VGPRSNUM);
     1910            break;
     1911        case GALLIUMOP_WAVEFRONT_SGPR_COUNT:
     1912            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1913                             GALLIUMCVAL_WAVEFRONT_SGPR_COUNT);
     1914            break;
     1915        case GALLIUMOP_WAVEFRONT_SIZE:
     1916            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1917                             GALLIUMCVAL_WAVEFRONT_SIZE);
     1918            break;
     1919        case GALLIUMOP_WORKITEM_VGPR_COUNT:
     1920            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1921                             GALLIUMCVAL_WORKITEM_VGPR_COUNT);
     1922            break;
     1923        case GALLIUMOP_WORKGROUP_FBARRIER_COUNT:
     1924            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1925                             GALLIUMCVAL_WORKGROUP_FBARRIER_COUNT);
     1926            break;
     1927        case GALLIUMOP_WORKGROUP_GROUP_SEGMENT_SIZE:
     1928            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1929                             GALLIUMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE);
     1930            break;
     1931        case GALLIUMOP_WORKITEM_PRIVATE_SEGMENT_SIZE:
     1932            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1933                             GALLIUMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE);
    12661934            break;
    12671935        default:
     
    13572025                output.commentSize = sectionSize;
    13582026                output.comment = (const char*)sectionData;
     2027                break;
     2028            case AsmSectionType::GALLIUM_CONFIG_CTRL_DIRECTIVE:
     2029                if (sectionSize != 128)
     2030                    assembler.printError(AsmSourcePos(),
     2031                         (std::string("Section '.control_directive' for kernel '")+
     2032                          assembler.kernels[section.kernelId].name+
     2033                          "' have wrong size").c_str());
    13592034                break;
    13602035            default: // ignore other sections
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3277 r3280  
    370370    static bool checkPseudoOpName(const CString& string);
    371371   
     372    static void doControlDirective(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     373                      const char* linePtr);
     374   
    372375    static void setDriverVersion(AsmGalliumHandler& handler, const char* linePtr);
    373376   
     
    388391   
    389392    static void setDimensions(AsmGalliumHandler& handler, const char* pseudoOpPlace,
    390                       const char* linePtr);
     393                      const char* linePtr, bool amdHsa);
     394   
     395    static void setMachine(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     396                      const char* linePtr);
     397   
     398    static void setCodeVersion(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     399                      const char* linePtr);
     400   
     401    static void setReservedXgprs(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     402                      const char* linePtr, bool inVgpr);
     403   
     404    static void setUseGridWorkGroupCount(AsmGalliumHandler& handler,
     405                      const char* pseudoOpPlace, const char* linePtr);
    391406   
    392407    static void doGlobalData(AsmGalliumHandler& handler, const char* pseudoOpPlace,
     
    462477    static void doConfig(AsmAmdHandler& handler, const char* pseudoOpPlace,
    463478                      const char* linePtr);
     479   
    464480    /// add any entry with two 32-bit integers
    465481    static void doEntry(AsmAmdHandler& handler, const char* pseudoOpPlace,
Note: See TracChangeset for help on using the changeset viewer.