Ignore:
Timestamp:
Feb 6, 2018, 8:23:38 PM (19 months ago)
Author:
matszpk
Message:

CLRadeonExtender: DisasmROCm: always print argument name.
AsmROCm: Tentative and untested version of the stuff to handle ROCm metadata (with kernel arguments).

File:
1 edited

Legend:

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

    r3727 r3728  
    5252    "md_group_segment_fixed_size", "md_kernarg_segment_align",
    5353    "md_kernarg_segment_size", "md_language","md_private_segment_fixed_size",
    54     "md_spilledsgprs", "md_spilledvgprs", "md_sgprsnum",
     54    "md_sgprsnum", "md_spilledsgprs", "md_spilledvgprs",
    5555    "md_symname", "md_version", "md_vgprsnum", "md_wavefront_size",
    5656    "metadata", "newbinfmt", "pgmrsrc1", "pgmrsrc2", "printf", "priority",
     
    9191    ROCMOP_MD_KERNARG_SEGMENT_SIZE, ROCMOP_MD_LANGUAGE,
    9292    ROCMOP_MD_PRIVATE_SEGMENT_FIXED_SIZE,
    93     ROCMOP_MD_SPILLEDSGPRS, ROCMOP_MD_SPILLEDVGPRS, ROCMOP_MD_SGPRSNUM,
     93    ROCMOP_MD_SGPRSNUM, ROCMOP_MD_SPILLEDSGPRS, ROCMOP_MD_SPILLEDVGPRS,
    9494    ROCMOP_MD_SYMNAME, ROCMOP_MD_VERSION, ROCMOP_MD_VGPRSNUM, ROCMOP_MD_WAVEFRONT_SIZE,
    9595    ROCMOP_METADATA, ROCMOP_NEWBINFMT, ROCMOP_PGMRSRC1, ROCMOP_PGMRSRC2, ROCMOP_PRINTF,
     
    525525    // parse metadata major version
    526526    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);
     527    bool good = true;
     528    if (getAbsoluteValueArg(asmr, mdVerMajor, linePtr, true))
     529        asmr.printWarningForRange(sizeof(cxuint)<<3, mdVerMajor,
     530                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     531    else
     532        good = false;
    530533    if (!skipRequiredComma(asmr, linePtr))
    531534        return;
     
    534537    skipSpacesToEnd(linePtr, end);
    535538    valuePlace = linePtr;
    536     good &= getAbsoluteValueArg(asmr, mdVerMinor, linePtr, true);
    537     asmr.printWarningForRange(sizeof(cxuint)<<3, mdVerMinor,
    538                 asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     539    if (getAbsoluteValueArg(asmr, mdVerMinor, linePtr, true))
     540        asmr.printWarningForRange(sizeof(cxuint)<<3, mdVerMinor,
     541                    asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     542    else
     543        good = false;
    539544    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    540545        return;
     
    698703        // parse language major version
    699704        const char* valuePlace = linePtr;
    700         good &= getAbsoluteValueArg(asmr, langVerMajor, linePtr, true);
    701         asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMajor,
    702                     asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     705        if (getAbsoluteValueArg(asmr, langVerMajor, linePtr, true))
     706            asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMajor,
     707                        asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     708        else
     709            good = false;
    703710        if (!skipRequiredComma(asmr, linePtr))
    704711            return;
     
    707714        skipSpacesToEnd(linePtr, end);
    708715        valuePlace = linePtr;
    709         good &= getAbsoluteValueArg(asmr, langVerMinor, linePtr, true);
    710         asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMinor,
    711                     asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     716        if (getAbsoluteValueArg(asmr, langVerMinor, linePtr, true))
     717            asmr.printWarningForRange(sizeof(cxuint)<<3, langVerMinor,
     718                        asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     719        else
     720            good = false;
    712721    }
    713722   
     
    740749    // parse printf id
    741750    const char* valuePlace = linePtr;
    742     bool good = getAbsoluteValueArg(asmr, printfId, linePtr);
    743     asmr.printWarningForRange(sizeof(cxuint)<<3, printfId,
    744                     asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     751    bool good = true;
     752    if (getAbsoluteValueArg(asmr, printfId, linePtr))
     753        asmr.printWarningForRange(sizeof(cxuint)<<3, printfId,
     754                            asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     755    else
     756        good = false;
    745757    printfInfo.id = printfId;
    746758   
     
    754766    {
    755767        uint64_t argSize = 0;
    756         good &= getAbsoluteValueArg(asmr, argSize, linePtr);
    757768        valuePlace = linePtr;
    758         // warning
    759         asmr.printWarningForRange(sizeof(cxuint)<<3, argSize,
    760                         asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     769        if (getAbsoluteValueArg(asmr, argSize, linePtr))
     770            asmr.printWarningForRange(sizeof(cxuint)<<3, argSize,
     771                            asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     772        else
     773            good = false;
    761774        argSizes.push_back(uint32_t(argSize));
    762775       
     
    779792    // just add new printf
    780793    handler.output.metadataInfo.printfInfos.push_back(printfInfo);
     794}
     795
     796static const std::pair<const char*, cxuint> rocmValueKindNamesTbl[] =
     797{
     798    { "complact", cxuint(ROCmValueKind::HIDDEN_COMPLETION_ACTION) },
     799    { "dynshptr", cxuint(ROCmValueKind::DYN_SHARED_PTR) },
     800    { "defqueue", cxuint(ROCmValueKind::HIDDEN_DEFAULT_QUEUE) },
     801    { "globalbuf", cxuint(ROCmValueKind::GLOBAL_BUFFER) },
     802    { "globaloffsetx", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X) },
     803    { "globaloffsety", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X) },
     804    { "globaloffsetz", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X) },
     805    { "gox", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X) },
     806    { "goy", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y) },
     807    { "goz", cxuint(ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z) },
     808    { "image", cxuint(ROCmValueKind::IMAGE) },
     809    { "none", cxuint(ROCmValueKind::HIDDEN_NONE) },
     810    { "printfbuf", cxuint(ROCmValueKind::HIDDEN_PRINTF_BUFFER) },
     811    { "pipe", cxuint(ROCmValueKind::PIPE) },
     812    { "queue", cxuint(ROCmValueKind::QUEUE) },
     813    { "sampler", cxuint(ROCmValueKind::SAMPLER) },
     814    { "value", cxuint(ROCmValueKind::BY_VALUE) }
     815};
     816
     817static const size_t rocmValueKindNamesTblSize =
     818        sizeof(rocmValueKindNamesTbl) / sizeof(std::pair<const char*, cxuint>);
     819
     820static const std::pair<const char*, cxuint> rocmValueTypeNamesTbl[] =
     821{
     822    { "char", cxuint(ROCmValueType::INT8) },
     823    { "double", cxuint(ROCmValueType::FLOAT64) },
     824    { "f16", cxuint(ROCmValueType::FLOAT16) },
     825    { "f32", cxuint(ROCmValueType::FLOAT32) },
     826    { "f64", cxuint(ROCmValueType::FLOAT64) },
     827    { "float", cxuint(ROCmValueType::FLOAT32) },
     828    { "half", cxuint(ROCmValueType::FLOAT16) },
     829    { "i16", cxuint(ROCmValueType::INT16) },
     830    { "i32", cxuint(ROCmValueType::INT32) },
     831    { "i64", cxuint(ROCmValueType::INT64) },
     832    { "i8", cxuint(ROCmValueType::INT8) },
     833    { "int", cxuint(ROCmValueType::INT32) },
     834    { "long", cxuint(ROCmValueType::INT64) },
     835    { "short", cxuint(ROCmValueType::INT16) },
     836    { "struct", cxuint(ROCmValueType::STRUCTURE) },
     837    { "u16", cxuint(ROCmValueType::UINT16) },
     838    { "u32", cxuint(ROCmValueType::UINT32) },
     839    { "u64", cxuint(ROCmValueType::UINT64) },
     840    { "u8", cxuint(ROCmValueType::UINT8) },
     841    { "uchar", cxuint(ROCmValueType::UINT8) },
     842    { "uint", cxuint(ROCmValueType::UINT32) },
     843    { "ulong", cxuint(ROCmValueType::UINT64) },
     844    { "ushort", cxuint(ROCmValueType::INT16) }
     845};
     846
     847static const size_t rocmValueTypeNamesTblSize =
     848        sizeof(rocmValueTypeNamesTbl) / sizeof(std::pair<const char*, cxuint>);
     849
     850static const std::pair<const char*, cxuint> rocmAddressSpaceNamesTbl[] =
     851{
     852    { "constant", cxuint(ROCmAddressSpace::CONSTANT) },
     853    { "generic", cxuint(ROCmAddressSpace::GENERIC) },
     854    { "global", cxuint(ROCmAddressSpace::GLOBAL) },
     855    { "local", cxuint(ROCmAddressSpace::LOCAL) },
     856    { "private", cxuint(ROCmAddressSpace::PRIVATE) },
     857    { "region", cxuint(ROCmAddressSpace::REGION) }
     858};
     859
     860static const std::pair<const char*, cxuint> rocmAccessQualNamesTbl[] =
     861{
     862    { "default", cxuint(ROCmAccessQual::DEFAULT) },
     863    { "read_only", cxuint(ROCmAccessQual::READ_ONLY) },
     864    { "read_write", cxuint(ROCmAccessQual::READ_WRITE) },
     865    { "write_inly", cxuint(ROCmAccessQual::WRITE_ONLY) }
     866};
     867
     868// add kernel argument (to metadata)
     869void AsmROCmPseudoOps::addKernelArg(AsmROCmHandler& handler, const char* pseudoOpPlace,
     870                    const char* linePtr)
     871{
     872    Assembler& asmr = handler.assembler;
     873    const char* end = asmr.line + asmr.lineSize;
     874    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     875        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     876        PSEUDOOP_RETURN_BY_ERROR("Illegal place of configuration pseudo-op")
     877   
     878    if (handler.metadataSection != ASMSECT_NONE)
     879        PSEUDOOP_RETURN_BY_ERROR("Metadata config can't be defined if "
     880                    "metadata section exists")
     881   
     882    bool good = true;
     883    skipSpacesToEnd(linePtr, end);
     884    CString argName;
     885    if (linePtr!=end && *linePtr!=',')
     886    {
     887        // parse name
     888        good &= getNameArg(asmr, argName, linePtr, "argument name", true);
     889        if (!skipRequiredComma(asmr, linePtr))
     890            return;
     891    }
     892    std::string typeName;
     893    if (linePtr!=end && *linePtr=='"')
     894    {
     895        // parse arg type
     896        good &= asmr.parseString(typeName, linePtr);
     897       
     898        if (!skipRequiredComma(asmr, linePtr))
     899            return;
     900    }
     901    // parse argument size
     902    uint64_t argSize = 0;
     903    const char* sizePlace = linePtr;
     904    if (getAbsoluteValueArg(asmr, argSize, linePtr, true))
     905    {
     906        if (argSize == 0)
     907            ASM_NOTGOOD_BY_ERROR(sizePlace, "Argument size is zero")
     908    }
     909    else
     910        good = false;
     911    if (!skipRequiredComma(asmr, linePtr))
     912        return;
     913   
     914    skipSpacesToEnd(linePtr, end);
     915    // parse argument alignment
     916    uint64_t argAlign = 0;
     917    if (linePtr!=end && *linePtr!=',')
     918    {
     919        const char* valuePlace = linePtr;
     920        if (getAbsoluteValueArg(asmr, argAlign, linePtr, true))
     921        {
     922            if (argAlign==0 || argAlign != (1ULL<<(63-CLZ64(argAlign))))
     923                ASM_NOTGOOD_BY_ERROR(valuePlace, "Argument alignment is not power of 2")
     924        }
     925        else
     926            good = false;
     927    }
     928    if (argAlign == 0)
     929    {
     930        argAlign = (argSize!=0) ? 1ULL<<(63-CLZ64(argSize)) : 1;
     931        if (argSize > argAlign)
     932            argAlign <<= 1;
     933    }
     934   
     935    if (!skipRequiredComma(asmr, linePtr))
     936        return;
     937   
     938    // get value kind
     939    cxuint valueKindVal = 0;
     940    good &= getEnumeration(asmr, linePtr, "value kind", rocmValueKindNamesTblSize,
     941                rocmValueKindNamesTbl, valueKindVal, nullptr);
     942    if (!skipRequiredComma(asmr, linePtr))
     943        return;
     944   
     945    // get value type
     946    cxuint valueTypeVal = 0;
     947    good &= getEnumeration(asmr, linePtr, "value type", rocmValueTypeNamesTblSize,
     948                rocmValueTypeNamesTbl, valueTypeVal, nullptr);
     949   
     950    uint64_t pointeeAlign = 0;
     951    if (valueKindVal == cxuint(ROCmValueKind::DYN_SHARED_PTR))
     952    {
     953        // parse pointeeAlign
     954        if (!skipRequiredComma(asmr, linePtr))
     955            return;
     956        const char* valuePlace = linePtr;
     957        if (getAbsoluteValueArg(asmr, pointeeAlign, linePtr, true))
     958        {
     959            if (pointeeAlign==0 || pointeeAlign != (1ULL<<(63-CLZ64(pointeeAlign))))
     960                ASM_NOTGOOD_BY_ERROR(valuePlace, "Argument pointee alignment "
     961                            "is not power of 2")
     962        }
     963        else
     964            good = false;
     965    }
     966   
     967    cxuint addressSpaceVal = 0;
     968    if (valueKindVal == cxuint(ROCmValueKind::DYN_SHARED_PTR) ||
     969        valueKindVal == cxuint(ROCmValueKind::GLOBAL_BUFFER))
     970    {
     971        if (!skipRequiredComma(asmr, linePtr))
     972            return;
     973        // parse address space
     974        good &= getEnumeration(asmr, linePtr, "address space",
     975                    6, rocmAddressSpaceNamesTbl, addressSpaceVal, nullptr);
     976    }
     977   
     978    cxuint accessQualVal = 0;
     979    if (valueKindVal == cxuint(ROCmValueKind::IMAGE) ||
     980        valueKindVal == cxuint(ROCmValueKind::PIPE))
     981    {
     982        if (!skipRequiredComma(asmr, linePtr))
     983            return;
     984        // parse address space
     985        good &= getEnumeration(asmr, linePtr, "access qualifier",
     986                    4, rocmAccessQualNamesTbl, accessQualVal, nullptr);
     987    }
     988    cxuint actualAccessQualVal = 0;
     989    if (valueKindVal == cxuint(ROCmValueKind::GLOBAL_BUFFER) ||
     990        valueKindVal == cxuint(ROCmValueKind::IMAGE) ||
     991        valueKindVal == cxuint(ROCmValueKind::PIPE))
     992    {
     993        if (!skipRequiredComma(asmr, linePtr))
     994            return;
     995        // parse address space
     996        good &= getEnumeration(asmr, linePtr, "access qualifier",
     997                    4, rocmAccessQualNamesTbl, actualAccessQualVal, nullptr);
     998    }
     999   
     1000    bool argIsConst = false;
     1001    bool argIsRestrict = false;
     1002    bool argIsVolatile = false;
     1003    bool argIsPipe = false;
     1004    // parse list of flags
     1005    skipSpacesToEnd(linePtr, end);
     1006    while (linePtr != end)
     1007    {
     1008        char name[20];
     1009        const char* fieldPlace = linePtr;
     1010        good &= getNameArg(asmr, 20, name, linePtr, "argument flag", true);
     1011       
     1012        if (::strcmp(name, "const")==0)
     1013            argIsConst = true;
     1014        else if (::strcmp(name, "restrict")==0)
     1015            argIsRestrict= true;
     1016        else if (::strcmp(name, "volatile")==0)
     1017            argIsVolatile = true;
     1018        else if (::strcmp(name, "pip")==0)
     1019            argIsPipe = true;
     1020        else
     1021            ASM_NOTGOOD_BY_ERROR(fieldPlace, "Unknown argument flag")
     1022    }
     1023   
     1024    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     1025        return;
     1026   
     1027    handler.output.useMetadataInfo = true;
     1028    ROCmKernelMetadata& metadata = handler.output.metadataInfo.kernels[asmr.currentKernel];
     1029    // setup kernel arg info
     1030    ROCmKernelArgInfo argInfo{};
     1031    argInfo.name = argName;
     1032    argInfo.typeName = typeName;
     1033    argInfo.size = argSize;
     1034    argInfo.align = argAlign;
     1035    argInfo.pointeeAlign = pointeeAlign;
     1036    argInfo.valueKind = ROCmValueKind(valueKindVal);
     1037    argInfo.valueType = ROCmValueType(valueTypeVal);
     1038    argInfo.addressSpace = ROCmAddressSpace(addressSpaceVal);
     1039    argInfo.accessQual = ROCmAccessQual(accessQualVal);
     1040    argInfo.actualAccessQual = ROCmAccessQual(actualAccessQualVal);
     1041    argInfo.isConst = argIsConst;
     1042    argInfo.isRestrict = argIsRestrict;
     1043    argInfo.isVolatile = argIsVolatile;
     1044    argInfo.isPipe = argIsPipe;
     1045    // just add to kernel arguments
     1046    metadata.argInfos.push_back(argInfo);
    7811047}
    7821048
     
    15961862            break;
    15971863        case ROCMOP_ARG:
     1864            AsmROCmPseudoOps::addKernelArg(*this, stmtPlace, linePtr);
    15981865            break;
    15991866        case ROCMOP_CALL_CONVENTION:
     
    17021969            break;
    17031970        case ROCMOP_MAX_FLAT_WORK_GROUP_SIZE:
     1971            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1972                            ROCMCVAL_MAX_FLAT_WORK_GROUP_SIZE);
    17041973            break;
    17051974        case ROCMOP_MAX_SCRATCH_BACKING_MEMORY:
     
    17111980            break;
    17121981        case ROCMOP_MD_GROUP_SEGMENT_FIXED_SIZE:
     1982            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1983                            ROCMCVAL_MD_GROUP_SEGMENT_FIXED_SIZE);
    17131984            break;
    17141985        case ROCMOP_MD_KERNARG_SEGMENT_ALIGN:
     1986            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1987                            ROCMCVAL_MD_KERNARG_SEGMENT_ALIGN);
    17151988            break;
    17161989        case ROCMOP_MD_KERNARG_SEGMENT_SIZE:
     1990            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1991                            ROCMCVAL_MD_KERNARG_SEGMENT_ALIGN);
    17171992            break;
    17181993        case ROCMOP_MD_LANGUAGE:
     
    17201995            break;
    17211996        case ROCMOP_MD_PRIVATE_SEGMENT_FIXED_SIZE:
     1997            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1998                            ROCMCVAL_MD_PRIVATE_SEGMENT_FIXED_SIZE);
    17221999            break;
    17232000        case ROCMOP_MD_SPILLEDSGPRS:
     2001            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     2002                            ROCMCVAL_MD_SPILLEDSGPRS);
    17242003            break;
    17252004        case ROCMOP_MD_SPILLEDVGPRS:
     2005            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     2006                            ROCMCVAL_MD_SPILLEDVGPRS);
    17262007            break;
    17272008        case ROCMOP_MD_SGPRSNUM:
     2009            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     2010                            ROCMCVAL_MD_SGPRSNUM);
    17282011            break;
    17292012        case ROCMOP_MD_SYMNAME:
     
    17342017            break;
    17352018        case ROCMOP_MD_VGPRSNUM:
     2019            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     2020                            ROCMCVAL_MD_VGPRSNUM);
    17362021            break;
    17372022        case ROCMOP_MD_WAVEFRONT_SIZE:
     2023            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     2024                            ROCMCVAL_MD_WAVEFRONT_SIZE);
    17382025            break;
    17392026        case ROCMOP_NEWBINFMT:
Note: See TracChangeset for help on using the changeset viewer.