Changeset 3727 in CLRX


Ignore:
Timestamp:
Feb 6, 2018, 7:10:25 PM (17 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?: Remove obsolete (stupid) checking spilled GPRs.
AsmROCm: Add first stuff to handling ROCm metadata config. ROCmBin: Checking uniqueness of printf ids.

Location:
CLRadeonExtender/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3575 r3727  
    584584                    char buf[64];
    585585                    snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    586                     ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    587                 }
    588                 break;
    589             }
    590             case GALLIUMCVAL_SPILLEDSGPRS:
    591             {
    592                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    593                             asmr.deviceType);
    594                 cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    595                 if (value > maxSGPRsNum)
    596                 {
    597                     char buf[64];
    598                     snprintf(buf, 64, "Spilled SGPRs number out of range (0-%u)",
    599                              maxSGPRsNum);
    600                     ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    601                 }
    602                 break;
    603             }
    604             case GALLIUMCVAL_SPILLEDVGPRS:
    605             {
    606                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    607                             asmr.deviceType);
    608                 cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
    609                 if (value > maxVGPRsNum)
    610                 {
    611                     char buf[64];
    612                     snprintf(buf, 64, "Spilled VGPRs number out of range (0-%u)",
    613                              maxVGPRsNum);
    614586                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    615587                }
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r3726 r3727  
    2929#include <CLRX/amdasm/Assembler.h>
    3030#include <CLRX/amdasm/AsmFormats.h>
     31#include "AsmAmdInternals.h"
    3132#include "AsmROCmInternals.h"
    3233
     
    8889    ROCMOP_MAX_FLAT_WORK_GROUP_SIZE, ROCMOP_MAX_SCRATCH_BACKING_MEMORY,
    8990    ROCMOP_MD_GROUP_SEGMENT_FIXED_SIZE, ROCMOP_MD_KERNARG_SEGMENT_ALIGN,
    90     ROCMOP_MD_KERNARG_SEGMENT_SIZE, ROCMOP_MD_LANGUAGE, ROCMOP_MD_PRIVATE_SEGMENT_FIXED_SIZE,
     91    ROCMOP_MD_KERNARG_SEGMENT_SIZE, ROCMOP_MD_LANGUAGE,
     92    ROCMOP_MD_PRIVATE_SEGMENT_FIXED_SIZE,
    9193    ROCMOP_MD_SPILLEDSGPRS, ROCMOP_MD_SPILLEDVGPRS, ROCMOP_MD_SGPRSNUM,
    9294    ROCMOP_MD_SYMNAME, ROCMOP_MD_VERSION, ROCMOP_MD_VGPRSNUM, ROCMOP_MD_WAVEFRONT_SIZE,
     
    144146    kernelStates.push_back(
    145147        new Kernel{ thisSection, nullptr, false, ASMSECT_NONE, thisSection });
     148    output.metadataInfo.kernels.push_back(ROCmKernelMetadata());
     149    output.metadataInfo.kernels.back().initialize();
    146150   
    147151    if (assembler.currentKernel == ASMKERN_GLOBAL)
     
    474478    Assembler& asmr = handler.assembler;
    475479   
     480    if (handler.output.useMetadataInfo)
     481        PSEUDOOP_RETURN_BY_ERROR("Metadata can't be defined if metadata config "
     482                    "is already defined")
     483   
    476484    if (!checkGarbagesAtEnd(asmr, linePtr))
    477485        return;
     
    499507    // set fkernel flag for kernel
    500508    handler.kernelStates[asmr.currentKernel]->isFKernel = true;
     509}
     510
     511void AsmROCmPseudoOps::setMetadataVersion(AsmROCmHandler& handler,
     512                const char* pseudoOpPlace, const char* linePtr)
     513{
     514    Assembler& asmr = handler.assembler;
     515    const char* end = asmr.line + asmr.lineSize;
     516    if (asmr.currentKernel!=ASMKERN_GLOBAL)
     517        PSEUDOOP_RETURN_BY_ERROR("Illegal place of md_version pseudo-op")
     518   
     519    if (handler.metadataSection != ASMSECT_NONE)
     520        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     521                    "metadata section exists")
     522   
     523    uint64_t mdVerMajor = 0, mdVerMinor = 0;
     524    skipSpacesToEnd(linePtr, end);
     525    // parse metadata major version
     526    const char* valuePlace = linePtr;
     527    bool good = getAbsoluteValueArg(asmr, mdVerMajor, linePtr, true);
     528    asmr.printWarningForRange(sizeof(cxuint)<<3, mdVerMajor,
     529                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     530    if (!skipRequiredComma(asmr, linePtr))
     531        return;
     532   
     533    // parse metadata minor version
     534    skipSpacesToEnd(linePtr, end);
     535    valuePlace = linePtr;
     536    good &= getAbsoluteValueArg(asmr, mdVerMinor, linePtr, true);
     537    asmr.printWarningForRange(sizeof(cxuint)<<3, mdVerMinor,
     538                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     539    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     540        return;
     541   
     542    handler.output.useMetadataInfo = true;
     543    handler.output.metadataInfo.version[0] = mdVerMajor;
     544    handler.output.metadataInfo.version[1] = mdVerMinor;
     545}
     546
     547void AsmROCmPseudoOps::setCWS(AsmROCmHandler& handler, const char* pseudoOpPlace,
     548                      const char* linePtr)
     549{
     550    Assembler& asmr = handler.assembler;
     551    const char* end = asmr.line + asmr.lineSize;
     552    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     553        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     554        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     555   
     556    if (handler.metadataSection != ASMSECT_NONE)
     557        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     558                    "metadata section exists")
     559   
     560    skipSpacesToEnd(linePtr, end);
     561    uint64_t out[3] = { 0, 0, 0 };
     562    // parse CWS (1-3 values)
     563    if (!AsmAmdPseudoOps::parseCWS(asmr, pseudoOpPlace, linePtr, out))
     564        return;
     565    handler.output.useMetadataInfo = true;
     566    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     567    // reqd_work_group_size
     568    metadata.reqdWorkGroupSize[0] = out[0];
     569    metadata.reqdWorkGroupSize[1] = out[1];
     570    metadata.reqdWorkGroupSize[2] = out[2];
     571}
     572
     573void AsmROCmPseudoOps::setWorkGroupSizeHint(AsmROCmHandler& handler,
     574                    const char* pseudoOpPlace, const char* linePtr)
     575{
     576    Assembler& asmr = handler.assembler;
     577    const char* end = asmr.line + asmr.lineSize;
     578    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     579        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     580        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     581   
     582    if (handler.metadataSection != ASMSECT_NONE)
     583        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     584                    "metadata section exists")
     585   
     586    skipSpacesToEnd(linePtr, end);
     587    uint64_t out[3] = { 0, 0, 0 };
     588    // parse CWS (1-3 values)
     589    if (!AsmAmdPseudoOps::parseCWS(asmr, pseudoOpPlace, linePtr, out))
     590        return;
     591    handler.output.useMetadataInfo = true;
     592    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     593    // work group size hint
     594    metadata.workGroupSizeHint[0] = out[0];
     595    metadata.workGroupSizeHint[1] = out[1];
     596    metadata.workGroupSizeHint[2] = out[2];
     597}
     598
     599void AsmROCmPseudoOps::setFixedWorkGroupSize(AsmROCmHandler& handler,
     600                    const char* pseudoOpPlace, const char* linePtr)
     601{
     602    Assembler& asmr = handler.assembler;
     603    const char* end = asmr.line + asmr.lineSize;
     604    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     605        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     606        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     607   
     608    if (handler.metadataSection != ASMSECT_NONE)
     609        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     610                    "metadata section exists")
     611   
     612    skipSpacesToEnd(linePtr, end);
     613    uint64_t out[3] = { 0, 0, 0 };
     614    // parse CWS (1-3 values)
     615    if (!AsmAmdPseudoOps::parseCWS(asmr, pseudoOpPlace, linePtr, out))
     616        return;
     617    handler.output.useMetadataInfo = true;
     618    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     619    // fixed work group size
     620    metadata.fixedWorkGroupSize[0] = out[0];
     621    metadata.fixedWorkGroupSize[1] = out[1];
     622    metadata.fixedWorkGroupSize[2] = out[2];
     623}
     624
     625void AsmROCmPseudoOps::setVecTypeHint(AsmROCmHandler& handler, const char* pseudoOpPlace,
     626                      const char* linePtr)
     627{
     628    Assembler& asmr = handler.assembler;
     629    const char* end = asmr.line + asmr.lineSize;
     630    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     631        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     632        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     633   
     634    if (handler.metadataSection != ASMSECT_NONE)
     635        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     636                    "metadata section exists")
     637   
     638    CString vecTypeHint;
     639    skipSpacesToEnd(linePtr, end);
     640    bool good = getNameArg(asmr, vecTypeHint, linePtr, "vectypehint", true);
     641    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     642        return;
     643   
     644    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     645    handler.output.useMetadataInfo = true;
     646    metadata.vecTypeHint = vecTypeHint;
     647}
     648
     649void AsmROCmPseudoOps::setKernelSymName(AsmROCmHandler& handler, const char* pseudoOpPlace,
     650                      const char* linePtr)
     651{
     652    Assembler& asmr = handler.assembler;
     653    const char* end = asmr.line + asmr.lineSize;
     654    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     655        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     656        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     657   
     658    if (handler.metadataSection != ASMSECT_NONE)
     659        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     660                    "metadata section exists")
     661   
     662    CString symName;
     663    skipSpacesToEnd(linePtr, end);
     664    bool good = getNameArg(asmr, symName, linePtr, "symbol name", true);
     665    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     666        return;
     667   
     668    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     669    handler.output.useMetadataInfo = true;
     670    metadata.symbolName = symName;
     671}
     672
     673void AsmROCmPseudoOps::setKernelLanguage(AsmROCmHandler& handler, const char* pseudoOpPlace,
     674                      const char* linePtr)
     675{
     676    Assembler& asmr = handler.assembler;
     677    const char* end = asmr.line + asmr.lineSize;
     678    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     679        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     680        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     681   
     682    if (handler.metadataSection != ASMSECT_NONE)
     683        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     684                    "metadata section exists")
     685   
     686    std::string langName;
     687    skipSpacesToEnd(linePtr, end);
     688    bool good = asmr.parseString(langName, linePtr);
     689   
     690    uint64_t langVerMajor = 0, langVerMinor = 0;
     691    skipSpacesToEnd(linePtr, end);
     692    if (linePtr != end)
     693    {
     694        if (!skipRequiredComma(asmr, linePtr))
     695            return;
     696       
     697        skipSpacesToEnd(linePtr, end);
     698        // parse language major version
     699        const char* valuePlace = linePtr;
     700        good &= getAbsoluteValueArg(asmr, langVerMajor, linePtr, true);
     701        asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMajor,
     702                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     703        if (!skipRequiredComma(asmr, linePtr))
     704            return;
     705       
     706        // parse language major version
     707        skipSpacesToEnd(linePtr, end);
     708        valuePlace = linePtr;
     709        good &= getAbsoluteValueArg(asmr, langVerMinor, linePtr, true);
     710        asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMinor,
     711                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     712    }
     713   
     714    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     715        return;
     716   
     717    // just set language
     718    handler.output.useMetadataInfo = true;
     719    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     720    metadata.language = langName;
     721    metadata.langVersion[0] = langVerMajor;
     722    metadata.langVersion[1] = langVerMinor;
     723}
     724
     725void AsmROCmPseudoOps::addPrintf(AsmROCmHandler& handler, const char* pseudoOpPlace,
     726                      const char* linePtr)
     727{
     728    Assembler& asmr = handler.assembler;
     729    const char* end = asmr.line + asmr.lineSize;
     730    if (asmr.currentKernel!=ASMKERN_GLOBAL)
     731        PSEUDOOP_RETURN_BY_ERROR("Illegal place of printf pseudo-op")
     732   
     733    if (handler.metadataSection != ASMSECT_NONE)
     734        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     735                    "metadata section exists")
     736   
     737    ROCmPrintfInfo printfInfo{};
     738    uint64_t printfId = 0;
     739    skipSpacesToEnd(linePtr, end);
     740    // parse printf id
     741    const char* valuePlace = linePtr;
     742    bool good = getAbsoluteValueArg(asmr, printfId, linePtr);
     743    asmr.printWarningForRange(sizeof(cxuint)<<3, printfId,
     744                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     745    printfInfo.id = printfId;
     746   
     747    if (!skipRequiredComma(asmr, linePtr))
     748        return;
     749   
     750    std::vector<uint32_t> argSizes;
     751    skipSpacesToEnd(linePtr, end);
     752    // parse argument sizes
     753    while (linePtr != end && *linePtr!='\"')
     754    {
     755        uint64_t argSize = 0;
     756        good &= getAbsoluteValueArg(asmr, argSize, linePtr);
     757        valuePlace = linePtr;
     758        // warning
     759        asmr.printWarningForRange(sizeof(cxuint)<<3, argSize,
     760                        asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     761        argSizes.push_back(uint32_t(argSize));
     762       
     763        if (!skipRequiredComma(asmr, linePtr))
     764            return;
     765        skipSpacesToEnd(linePtr, end);
     766    }
     767    printfInfo.argSizes.assign(argSizes.begin(), argSizes.end());
     768   
     769    if (linePtr == end)
     770        PSEUDOOP_RETURN_BY_ERROR("Missing format string")
     771    // parse format
     772    std::string formatStr;
     773    good &= asmr.parseString(formatStr, linePtr);
     774    printfInfo.format = formatStr;
     775   
     776    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     777        return;
     778    handler.output.useMetadataInfo = true;
     779    // just add new printf
     780    handler.output.metadataInfo.printfInfos.push_back(printfInfo);
    501781}
    502782
     
    615895}
    616896
     897// check metadata config values
     898bool AsmROCmPseudoOps::checkMDConfigValue(Assembler& asmr, const char* valuePlace,
     899                ROCmConfigValueTarget target, uint64_t value)
     900{
     901    bool good = true;
     902    switch(target)
     903    {
     904        case ROCMCVAL_MD_WAVEFRONT_SIZE:
     905            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
     906                ASM_NOTGOOD_BY_ERROR(valuePlace, "Wavefront size must be power of two")
     907            else if (value > 256)
     908                ASM_NOTGOOD_BY_ERROR(valuePlace,
     909                            "Wavefront size must be not greater than 256")
     910            break;
     911        case ROCMCVAL_MD_KERNARG_SEGMENT_ALIGN:
     912            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
     913                ASM_NOTGOOD_BY_ERROR(valuePlace, "Alignment size must be power of two")
     914            break;
     915        case ROCMCVAL_MD_SGPRSNUM:
     916        {
     917            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     918                        asmr.deviceType);
     919            cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     920            if (value > maxSGPRsNum)
     921            {
     922                char buf[64];
     923                snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
     924                ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
     925            }
     926            break;
     927        }
     928        case ROCMCVAL_MD_VGPRSNUM:
     929        {
     930            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     931                        asmr.deviceType);
     932            cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
     933            if (value > maxVGPRsNum)
     934            {
     935                char buf[64];
     936                snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
     937                ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
     938            }
     939            break;
     940        }
     941        default:
     942            break;
     943    }
     944    return good;
     945}
     946
    617947void AsmROCmPseudoOps::setConfigValueMain(AsmAmdHsaKernelConfig& config,
    618948                ROCmConfigValueTarget target, uint64_t value)
     
    7041034        case ROCMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL:
    7051035            config.runtimeLoaderKernelSymbol = value;
     1036            break;
     1037        default:
     1038            break;
     1039    }
     1040}
     1041
     1042/// set metadata config values
     1043void AsmROCmPseudoOps::setMDConfigValue(ROCmKernelMetadata& metadata,
     1044                        ROCmConfigValueTarget target, uint64_t value)
     1045{
     1046    switch(target)
     1047    {
     1048        case ROCMCVAL_MD_WAVEFRONT_SIZE:
     1049            metadata.wavefrontSize = value;
     1050            break;
     1051        case ROCMCVAL_MD_KERNARG_SEGMENT_ALIGN:
     1052            metadata.kernargSegmentAlign = value;
     1053            break;
     1054        case ROCMCVAL_MD_KERNARG_SEGMENT_SIZE:
     1055            metadata.kernargSegmentSize = value;
     1056            break;
     1057        case ROCMCVAL_MD_GROUP_SEGMENT_FIXED_SIZE:
     1058            metadata.groupSegmentFixedSize = value;
     1059            break;
     1060        case ROCMCVAL_MD_PRIVATE_SEGMENT_FIXED_SIZE:
     1061            metadata.privateSegmentFixedSize = value;
     1062            break;
     1063        case ROCMCVAL_MD_SGPRSNUM:
     1064            metadata.sgprsNum = value;
     1065            break;
     1066        case ROCMCVAL_MD_VGPRSNUM:
     1067            metadata.vgprsNum = value;
     1068            break;
     1069        case ROCMCVAL_MD_SPILLEDSGPRS:
     1070            metadata.spilledSgprs = value;
     1071            break;
     1072        case ROCMCVAL_MD_SPILLEDVGPRS:
     1073            metadata.spilledVgprs = value;
     1074            break;
     1075        case ROCMCVAL_MAX_FLAT_WORK_GROUP_SIZE:
     1076            metadata.maxFlatWorkGroupSize = value;
    7061077            break;
    7071078        default:
     
    7261097    /* ranges checking */
    7271098    if (good)
    728         good = checkConfigValue(asmr, valuePlace, target, value);
     1099    {
     1100        if (target < ROCMCVAL_METADATA_START)
     1101            good = checkConfigValue(asmr, valuePlace, target, value);
     1102        else // metadata values
     1103            good = checkMDConfigValue(asmr, valuePlace, target, value);
     1104    }
    7291105    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    7301106        return;
    7311107   
    732     AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
    7331108    // set value
    734     setConfigValueMain(config, target, value);
     1109    if (target < ROCMCVAL_METADATA_START)
     1110    {
     1111        AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     1112        setConfigValueMain(config, target, value);
     1113    }
     1114    else
     1115    {
     1116        // set metadata value
     1117        handler.output.useMetadataInfo = true;
     1118        ROCmKernelMetadata& metadata =
     1119                    handler.output.metadataInfo.kernels[asmr.currentKernel];
     1120        setMDConfigValue(metadata, target, value);
     1121    }
    7351122}
    7361123
     
    12241611            break;
    12251612        case ROCMOP_CWS:
     1613        case ROCMOP_REQD_WORK_GROUP_SIZE:
     1614            AsmROCmPseudoOps::setCWS(*this, stmtPlace, linePtr);
    12261615            break;
    12271616        case ROCMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     
    12521641            break;
    12531642        case ROCMOP_FIXED_WORK_GROUP_SIZE:
     1643            AsmROCmPseudoOps::setFixedWorkGroupSize(*this, stmtPlace, linePtr);
    12541644            break;
    12551645        case ROCMOP_FKERNEL:
     
    13271717            break;
    13281718        case ROCMOP_MD_LANGUAGE:
     1719            AsmROCmPseudoOps::setKernelLanguage(*this, stmtPlace, linePtr);
    13291720            break;
    13301721        case ROCMOP_MD_PRIVATE_SEGMENT_FIXED_SIZE:
     
    13371728            break;
    13381729        case ROCMOP_MD_SYMNAME:
     1730            AsmROCmPseudoOps::setKernelSymName(*this, stmtPlace, linePtr);
    13391731            break;
    13401732        case ROCMOP_MD_VERSION:
     1733            AsmROCmPseudoOps::setMetadataVersion(*this, stmtPlace, linePtr);
    13411734            break;
    13421735        case ROCMOP_MD_VGPRSNUM:
     
    13541747            break;
    13551748        case ROCMOP_PRINTF:
     1749            AsmROCmPseudoOps::addPrintf(*this, stmtPlace, linePtr);
    13561750            break;
    13571751        case ROCMOP_PRIORITY:
     
    13701764                             ROCMCVAL_PRIVMODE);
    13711765            break;
    1372         case ROCMOP_REQD_WORK_GROUP_SIZE:
    1373             break;
    13741766        case ROCMOP_RESERVED_SGPRS:
    13751767            AsmROCmPseudoOps::setReservedXgprs(*this, stmtPlace, linePtr, false);
     
    14571849                             ROCMCVAL_USERDATANUM);
    14581850            break;
     1851        case ROCMOP_VECTYPEHINT:
     1852            AsmROCmPseudoOps::setVecTypeHint(*this, stmtPlace, linePtr);
     1853            break;
    14591854        case ROCMOP_VGPRSNUM:
    14601855            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_VGPRSNUM);
     
    14731868            break;
    14741869        case ROCM_WORK_GROUP_SIZE_HINT:
     1870            AsmROCmPseudoOps::setWorkGroupSizeHint(*this, stmtPlace, linePtr);
    14751871            break;
    14761872        case ROCMOP_WORKGROUP_FBARRIER_COUNT:
  • CLRadeonExtender/trunk/amdasm/AsmROCmInternals.h

    r3726 r3727  
    8484   
    8585    // metadata info
    86     ROCMCVAL_MD_WAVEFRONT_SIZE,
     86    ROCMCVAL_METADATA_START,
     87    ROCMCVAL_MD_WAVEFRONT_SIZE = ROCMCVAL_METADATA_START,
    8788    ROCMCVAL_MD_KERNARG_SEGMENT_ALIGN,
    8889    ROCMCVAL_MD_KERNARG_SEGMENT_SIZE,
     
    158159    static void setConfigValueMain(AsmAmdHsaKernelConfig& config,
    159160                        ROCmConfigValueTarget target, uint64_t value);
     161    // checkConfigMdValue
     162    static bool checkMDConfigValue(Assembler& asmr, const char* valuePlace,
     163                    ROCmConfigValueTarget target, uint64_t value);
     164    // setConfigMdValue
     165    static void setMDConfigValue(ROCmKernelMetadata& metadata,
     166                ROCmConfigValueTarget target, uint64_t value);
    160167    // set config value
    161168    static void setConfigValue(AsmROCmHandler& handler, const char* pseudoOpPlace,
    162169                      const char* linePtr, ROCmConfigValueTarget target);
    163    
    164170    // setConfigBoolValueMain routines used by other handlers to set AMD HSA config values
    165171    static void setConfigBoolValueMain(AsmAmdHsaKernelConfig& config,
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r3726 r3727  
    2727#include <algorithm>
    2828#include <utility>
     29#include <unordered_set>
    2930#include <CLRX/amdbin/ElfBinaries.h>
    3031#include <CLRX/utils/Utilities.h>
     
    530531class CLRX_INTERNAL YAMLPrintfVectorConsumer: public YAMLElemConsumer
    531532{
     533private:
     534    std::unordered_set<cxuint> printfIds;
    532535public:
    533536    std::vector<ROCmPrintfInfo>& printfInfos;
     
    553556        catch(const ParseException& ex)
    554557        { throw ParseException(oldLineNo, ex.what()); }
     558       
     559        // check printf id uniqueness
     560        if (!printfIds.insert(printfInfo.id).second)
     561            throw ParseException(oldLineNo, "Duplicate of printf id");
     562       
    555563        skipSpacesToLineEnd(ptr2, end2);
    556564        if (ptr2==end || *ptr2!=':')
     
    15621570    if (!mdInfo.printfInfos.empty())
    15631571        output += "Printf:          \n";
     1572    // check print ids uniquness
     1573    {
     1574        std::unordered_set<cxuint> printfIds;
     1575        for (const ROCmPrintfInfo& printfInfo: mdInfo.printfInfos)
     1576            if (!printfIds.insert(printfInfo.id).second)
     1577                throw BinGenException("Duplicate of printf id");
     1578    }
    15641579    // printfs
    15651580    for (const ROCmPrintfInfo& printfInfo: mdInfo.printfInfos)
Note: See TracChangeset for help on using the changeset viewer.