Ignore:
Timestamp:
Jan 31, 2018, 1:54:58 PM (23 months ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCmBin: add parameter singleValue to parsing routines. Skip to newline after parsing value.
Ignore unknown keywords in metadata (by skipping).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r3681 r3682  
    8484}
    8585
    86 static inline void skipSpacesToEnd(const char*& ptr, const char* end)
     86static inline void skipSpacesToLineEnd(const char*& ptr, const char* end)
    8787{
    8888    while (ptr != end && *ptr!='\n' && isSpace(*ptr)) ptr++;
     89}
     90
     91static void skipSpacesToNextLine(const char*& ptr, const char* end, size_t& lineNo)
     92{
     93    skipSpacesToLineEnd(ptr, end);
     94    if (ptr != end && *ptr != '\n' && *ptr!='#')
     95        throw ParseException(lineNo, "Garbages at line");
     96    if (ptr != end && *ptr == '#')
     97        // skip comment at end of line
     98        while (ptr!=end && *ptr!='\n') ptr++;
     99    if (ptr!=end)
     100    {   // newline
     101        ptr++;
     102        lineNo++;
     103    }
    89104}
    90105
     
    102117    ptr++;
    103118    const char* afterColon = ptr;
    104     skipSpacesToEnd(ptr, end);
     119    skipSpacesToLineEnd(ptr, end);
    105120    if (afterColon == ptr)
    106121        throw ParseException("After key and colon must be space");
     
    108123    const size_t index = binaryFind(keywords, keywords+keywordsNum,
    109124                        keyword.c_str(), CStringLess()) - keywords;
    110     if (index == keywordsNum)
    111         throw ParseException(lineNo, "Unknown keyword");
    112125    return index;
    113126}
    114127
    115128template<typename T>
    116 static T parseYAMLIntValue(const char*& ptr, const char* end, size_t lineNo)
    117 {
    118     skipSpacesToEnd(ptr, end);
     129static T parseYAMLIntValue(const char*& ptr, const char* end, size_t& lineNo,
     130                bool singleValue = false)
     131{
     132    skipSpacesToLineEnd(ptr, end);
    119133    if (ptr == end || *ptr=='\n')
    120134        throw ParseException(lineNo, "Expected integer value");
     135    T value = 0;
    121136    try
    122     { return cstrtovCStyle<T>(ptr, end, ptr); }
     137    { value = cstrtovCStyle<T>(ptr, end, ptr); }
    123138    catch(const ParseException& ex)
    124139    { throw ParseException(lineNo, ex.what()); }
    125 }
    126 
    127 static bool parseYAMLBoolValue(const char*& ptr, const char* end, size_t lineNo)
    128 {
    129     skipSpacesToEnd(ptr, end);
     140   
     141    if (singleValue)
     142        skipSpacesToNextLine(ptr, end, lineNo);
     143    return value;
     144}
     145
     146static bool parseYAMLBoolValue(const char*& ptr, const char* end, size_t& lineNo,
     147        bool singleValue = false)
     148{
     149    skipSpacesToLineEnd(ptr, end);
    130150    if (ptr == end || *ptr=='\n')
    131151        throw ParseException(lineNo, "Expected boolean value");
     
    135155    CString word(wordPtr, ptr);
    136156   
     157    bool value = false;
     158    bool isSet = false;
    137159    for (const char* v: { "1", "true", "t", "on", "yes", "y"})
    138160        if (::strcasecmp(word.c_str(), v) == 0)
    139             return true;
     161        {
     162            isSet = true;
     163            value = true;
     164            break;
     165        }
    140166    for (const char* v: { "0", "false", "f", "off", "no", "n"})
    141167        if (::strcasecmp(word.c_str(), v) == 0)
    142             return false;
    143     throw ParseException(lineNo, "Is not boolean value");
     168        {
     169            isSet = true;
     170            value = false;
     171            break;
     172        }
     173    if (!isSet)
     174        throw ParseException(lineNo, "Is not boolean value");
     175   
     176    if (singleValue)
     177        skipSpacesToNextLine(ptr, end, lineNo);
     178    return value;
    144179}
    145180
     
    272307
    273308static std::string parseYAMLStringValue(const char*& ptr, const char* end, size_t& lineNo,
    274                     cxuint prevIndent)
    275 {
    276     skipSpacesToEnd(ptr, end);
     309                    cxuint prevIndent, bool singleValue = false)
     310{
     311    skipSpacesToLineEnd(ptr, end);
    277312    if (ptr == end)
    278313        return "";
    279314    if (*ptr=='"' || *ptr== '\'')
    280         return parseYAMLString(ptr, end, lineNo);
    281    
     315        std::string buf = parseYAMLString(ptr, end, lineNo);
    282316    // otherwise parse stream
    283     if (*ptr == '|' || *ptr == '>')
     317    else if (*ptr == '|' || *ptr == '>')
    284318    {
    285319        // multiline
     
    291325        ptr++; // skip newline
    292326        const char* lineStart = ptr;
    293         skipSpacesToEnd(ptr, end);
     327        skipSpacesToLineEnd(ptr, end);
    294328        size_t indent = ptr - lineStart;
    295329        if (indent <= prevIndent)
     
    305339            lineNo++;
    306340            const char* lineStart = ptr;
    307             skipSpacesToEnd(ptr, end);
     341            skipSpacesToLineEnd(ptr, end);
    308342            if (size_t(ptr - lineStart) < indent)
    309343            {
     
    324358        return buf;
    325359    }
     360    // single line string (unquoted)
    326361    const char* strStart = ptr;
    327     while (ptr != end && *ptr!='\n') ptr++;
    328     return std::string(strStart, ptr);
     362    while (ptr != end && *ptr!='\n' && *ptr!='#') ptr++;
     363    std::string buf(strStart, ptr);
     364   
     365    if (singleValue)
     366        skipSpacesToNextLine(ptr, end, lineNo);
     367    return buf;
    329368}
    330369
     
    333372public:
    334373    virtual void consume(const char*& ptr, const char* end, size_t& lineNo,
    335                 cxuint prevIndent) = 0;
     374                cxuint prevIndent, bool singleValue) = 0;
    336375};
    337376
    338377static void parseYAMLValArray(const char*& ptr, const char* end, size_t& lineNo,
    339             size_t prevIndent, YAMLElemConsumer* elemConsumer)
    340 {
    341     skipSpacesToEnd(ptr, end);
     378            size_t prevIndent, YAMLElemConsumer* elemConsumer, bool singleValue = false)
     379{
     380    skipSpacesToLineEnd(ptr, end);
    342381    if (ptr == end)
    343382        return;
     
    350389        {
    351390            // parse in line
    352             elemConsumer->consume(ptr, end, lineNo, 0);
     391            elemConsumer->consume(ptr, end, lineNo, 0, false);
    353392            if (ptr!=end && *ptr==',')
    354393                throw ParseException(lineNo, "Expected ','");
     
    362401            throw ParseException(lineNo, "Unterminated array");
    363402        ptr++;
     403       
     404        if (singleValue)
     405            skipSpacesToNextLine(ptr, end, lineNo);
    364406        return;
    365407    }
     
    379421        ptr++;
    380422        const char* afterMinus = ptr;
    381         skipSpacesToEnd(ptr, end);
     423        skipSpacesToLineEnd(ptr, end);
    382424        if (afterMinus == ptr)
    383425            throw ParseException(lineNo, "No spaces after '-'");
    384         elemConsumer->consume(ptr, end, lineNo, indent0+1 + afterMinus-ptr);
     426        elemConsumer->consume(ptr, end, lineNo, indent0+1 + afterMinus-ptr, true);
    385427       
    386428        size_t indent = skipSpacesAndComments(ptr, end, lineNo);
     
    410452   
    411453    virtual void consume(const char*& ptr, const char* end, size_t& lineNo,
    412                 cxuint prevIndent)
     454                cxuint prevIndent, bool singleValue)
    413455    {
    414456        if (elemsNum == requiredElemsNum)
     
    419461        { throw ParseException(lineNo, ex.what()); }
    420462        elemsNum++;
     463        if (singleValue)
     464            skipSpacesToNextLine(ptr, end, lineNo);
    421465    }
    422466};
     
    434478   
    435479    virtual void consume(const char*& ptr, const char* end, size_t& lineNo,
    436                 cxuint prevIndent)
    437     {
    438         std::string str = parseYAMLStringValue(ptr, end, lineNo, prevIndent);
     480                cxuint prevIndent, bool singleValue)
     481    {
     482        std::string str = parseYAMLStringValue(ptr, end, lineNo, prevIndent, singleValue);
    439483        // parse printf string
    440484        ROCmPrintfInfo printfInfo{};
     
    442486        const char* ptr2 = str.c_str();
    443487        const char* end2 = str.c_str() + str.size();
    444         skipSpacesToEnd(ptr2, end2);
     488        skipSpacesToLineEnd(ptr2, end2);
    445489        printfInfo.id = cstrtovCStyle<uint32_t>(ptr2, end2, ptr2);
    446         skipSpacesToEnd(ptr2, end2);
     490        skipSpacesToLineEnd(ptr2, end2);
    447491        if (ptr2==end || *ptr2!=':')
    448492            throw ParseException(lineNo, "No colon after printf callId");
    449493        ptr2++;
    450         skipSpacesToEnd(ptr2, end2);
     494        skipSpacesToLineEnd(ptr2, end2);
    451495        uint32_t argsNum = cstrtovCStyle<uint32_t>(ptr2, end2, ptr2);
    452         skipSpacesToEnd(ptr2, end2);
     496        skipSpacesToLineEnd(ptr2, end2);
    453497        if (ptr2==end || *ptr2!=':')
    454498            throw ParseException(lineNo, "No colon after printf argsNum");
     
    460504        for (size_t i = 0; i < argsNum; i++)
    461505        {
    462             skipSpacesToEnd(ptr2, end2);
     506            skipSpacesToLineEnd(ptr2, end2);
    463507            printfInfo.argSizes[i] = cstrtovCStyle<uint32_t>(ptr2, end2, ptr2);
    464             skipSpacesToEnd(ptr2, end2);
     508            skipSpacesToLineEnd(ptr2, end2);
    465509            if (ptr2==end || *ptr2!=':')
    466510                throw ParseException(lineNo, "No colon after printf argsNum");
     
    471515    }
    472516};
     517
     518static void skipYAMLValue(const char* ptr, const char* end, size_t& lineNo,
     519                cxuint prevIndent)
     520{
     521    skipSpacesToLineEnd(ptr, end);
     522    if (ptr == end || *ptr=='\n')
     523        return;
     524    if (ptr==end || (*ptr!='\'' && *ptr!='"' && *ptr!='|' && *ptr!='>' && *ptr !='['))
     525    {
     526        skipSpacesToLineEnd(ptr, end);
     527        if (ptr!=end) ptr++;
     528        return;
     529    }
     530    // string
     531    if (*ptr=='\'' || *ptr=='"')
     532    {
     533        const char delim = *ptr++;
     534        bool escape = false;
     535        while(ptr!=end && (escape || *ptr!=delim))
     536        {
     537            if (!escape && *ptr=='\\')
     538                escape = true;
     539            else if (escape)
     540                escape = false;
     541            if (*ptr=='\n') lineNo++;
     542            ptr++;
     543        }
     544        if (ptr==end)
     545            throw ParseException(lineNo, "Unterminated string");
     546        ptr++;
     547        skipSpacesToNextLine(ptr, end, lineNo);
     548    }
     549    else if (*ptr=='[')
     550    {   // otherwise [array]
     551        ptr++;
     552        skipSpacesAndComments(ptr, end, lineNo);
     553        while (ptr != end)
     554        {
     555            // parse in line
     556            skipYAMLValue(ptr, end, lineNo, 0);
     557            if (ptr!=end && *ptr==',')
     558                throw ParseException(lineNo, "Expected ','");
     559            else if (ptr!=end && *ptr==']')
     560                // just end
     561                break;
     562            ptr++;
     563            skipSpacesAndComments(ptr, end, lineNo);
     564        }
     565        if (ptr == end)
     566            throw ParseException(lineNo, "Unterminated array");
     567        ptr++;
     568        skipSpacesToNextLine(ptr, end, lineNo);
     569    }
     570    else
     571    {   // block value
     572        if (ptr!=end && (*ptr=='|' || *ptr=='>'))
     573            ptr++; // skip '|' or '>'
     574        skipSpacesToLineEnd(ptr, end);
     575        if (ptr!=end && *ptr!='\n')
     576            throw ParseException(lineNo, "Garbages before block or children");
     577        ptr++;
     578        lineNo++;
     579        // skip all lines indented beyound previous level
     580        while (ptr != end)
     581        {
     582            const char* lineStart = ptr;
     583            skipSpacesToLineEnd(ptr, end);
     584            if (ptr == end)
     585            {
     586                ptr++;
     587                lineNo++;
     588                continue;
     589            }
     590            if (ptr-lineStart < prevIndent)
     591            {
     592                ptr = lineStart;
     593                break;
     594            }
     595        }
     596    }
     597}
    473598
    474599enum {
     
    684809                {
    685810                    YAMLPrintfVectorConsumer consumer(metadataInfo.printfInfos);
    686                     parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer);
     811                    parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer, true);
    687812                    break;
    688813                }
     
    690815                {
    691816                    YAMLIntArrayConsumer<uint32_t> consumer(2, metadataInfo.version);
    692                     parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer);
     817                    parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer, true);
    693818                    break;
    694819                }
    695820                default:
     821                    skipYAMLValue(ptr, end, lineNo, level);
    696822                    break;
    697823            }
     
    705831            ptr++;
    706832            const char* afterMinus = ptr;
    707             skipSpacesToEnd(ptr, end);
     833            skipSpacesToLineEnd(ptr, end);
    708834            levels[++curLevel] = level + 1 + ptr-afterMinus;
    709835            level = levels[curLevel];
     
    743869                    break;
    744870                case ROCMMT_KERNEL_LANGUAGE:
    745                     kernel.language = parseYAMLStringValue(ptr, end, lineNo, level);
     871                    kernel.language = parseYAMLStringValue(ptr, end, lineNo, level, true);
    746872                    break;
    747873                case ROCMMT_KERNEL_LANGUAGE_VERSION:
     
    752878                }
    753879                case ROCMMT_KERNEL_NAME:
    754                     kernel.name = parseYAMLStringValue(ptr, end, lineNo, level);
     880                    kernel.name = parseYAMLStringValue(ptr, end, lineNo, level, true);
    755881                    break;
    756882                case ROCMMT_KERNEL_SYMBOLNAME:
    757                     kernel.symbolName = parseYAMLStringValue(ptr, end, lineNo, level);
     883                    kernel.symbolName = parseYAMLStringValue(ptr, end, lineNo, level, true);
    758884                    break;
    759885                default:
     886                    skipYAMLValue(ptr, end, lineNo, level);
    760887                    break;
    761888            }
     
    774901                {
    775902                    YAMLIntArrayConsumer<cxuint> consumer(3, kernel.reqdWorkGroupSize);
    776                     parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer);
     903                    parseYAMLValArray(ptr, end, lineNo, level, &consumer);
    777904                    break;
    778905                }
    779906                case ROCMMT_ATTRS_RUNTIME_HANDLE:
    780                     kernel.runtimeHandle = parseYAMLStringValue(ptr, end, lineNo, level);
     907                    kernel.runtimeHandle = parseYAMLStringValue(
     908                                ptr, end, lineNo, level, true);
    781909                    break;
    782910                case ROCMMT_ATTRS_VECTYPEHINT:
    783                     kernel.vecTypeHint = parseYAMLStringValue(ptr, end, lineNo, level);
     911                    kernel.vecTypeHint = parseYAMLStringValue(
     912                                ptr, end, lineNo, level, true);
    784913                    break;
    785914                case ROCMMT_ATTRS_WORK_GROUP_SIZE_HINT:
    786915                {
    787916                    YAMLIntArrayConsumer<cxuint> consumer(3, kernel.workGroupSizeHint);
    788                     parseYAMLValArray(ptr, end, lineNo, levels[curLevel], &consumer);
     917                    parseYAMLValArray(ptr, end, lineNo, level, &consumer, true);
    789918                    break;
    790919                }
    791920                default:
     921                    skipYAMLValue(ptr, end, lineNo, level);
    792922                    break;
    793923            }
     
    811941                case ROCMMT_CODEPROPS_GROUP_SEGMENT_FIXED_SIZE:
    812942                    kernel.groupSegmentFixedSize =
    813                                 parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     943                                parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    814944                    break;
    815945                case ROCMMT_CODEPROPS_KERNARG_SEGMENT_ALIGN:
    816946                    kernel.kernargSegmentAlign =
    817                                 parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     947                                parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    818948                    break;
    819949                case ROCMMT_CODEPROPS_KERNARG_SEGMENT_SIZE:
    820950                    kernel.kernargSegmentSize =
    821                                 parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     951                                parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    822952                    break;
    823953                case ROCMMT_CODEPROPS_MAX_FLAT_WORK_GROUP_SIZE:
    824954                    kernel.maxFlatWorkGroupSize =
    825                                 parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     955                                parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    826956                    break;
    827957                case ROCMMT_CODEPROPS_NUM_SGPRS:
    828                     kernel.sgprsNum = parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     958                    kernel.sgprsNum = parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    829959                    break;
    830960                case ROCMMT_CODEPROPS_NUM_SPILLED_SGPRS:
    831                     kernel.spilledSgprs = parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     961                    kernel.spilledSgprs =
     962                            parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    832963                    break;
    833964                case ROCMMT_CODEPROPS_NUM_SPILLED_VGPRS:
    834                     kernel.spilledVgprs = parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     965                    kernel.spilledVgprs =
     966                            parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    835967                    break;
    836968                case ROCMMT_CODEPROPS_NUM_VGPRS:
    837                     kernel.vgprsNum = parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     969                    kernel.vgprsNum = parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    838970                    break;
    839971                case ROCMMT_CODEPROPS_PRIVATE_SEGMENT_FIXED_SIZE:
    840972                    kernel.privateSegmentFixedSize =
    841                                 parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     973                                parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    842974                    break;
    843975                case ROCMMT_CODEPROPS_WAVEFRONT_SIZE:
    844                     kernel.wavefrontSize = parseYAMLIntValue<cxuint>(ptr, end, lineNo);
     976                    kernel.wavefrontSize =
     977                            parseYAMLIntValue<cxuint>(ptr, end, lineNo, true);
    845978                    break;
    846979                default:
     980                    skipYAMLValue(ptr, end, lineNo, level);
    847981                    break;
    848982            }
     
    856990            ptr++;
    857991            const char* afterMinus = ptr;
    858             skipSpacesToEnd(ptr, end);
     992            skipSpacesToLineEnd(ptr, end);
    859993            levels[++curLevel] = level + 1 + ptr-afterMinus;
    860994            level = levels[curLevel];
     
    8771011                {
    8781012                    const std::string acc = trimStrSpaces(parseYAMLStringValue(
    879                                     ptr, end, lineNo, level));
     1013                                    ptr, end, lineNo, level, true));
    8801014                    size_t accIndex = 0;
    8811015                    for (; accIndex < 6; accIndex++)
     
    8931027                {
    8941028                    const std::string aspace = trimStrSpaces(parseYAMLStringValue(
    895                                     ptr, end, lineNo, level));
     1029                                    ptr, end, lineNo, level, true));
    8961030                    size_t aspaceIndex = 0;
    8971031                    for (; aspaceIndex < 6; aspaceIndex++)
     
    9051039                }
    9061040                case ROCMMT_ARGS_ALIGN:
    907                     kernelArg.align = parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     1041                    kernelArg.align = parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    9081042                    break;
    9091043                case ROCMMT_ARGS_ISCONST:
    910                     kernelArg.isConst = parseYAMLBoolValue(ptr, end, lineNo);
     1044                    kernelArg.isConst = parseYAMLBoolValue(ptr, end, lineNo, true);
    9111045                    break;
    9121046                case ROCMMT_ARGS_ISPIPE:
    913                     kernelArg.isPipe = parseYAMLBoolValue(ptr, end, lineNo);
     1047                    kernelArg.isPipe = parseYAMLBoolValue(ptr, end, lineNo, true);
    9141048                    break;
    9151049                case ROCMMT_ARGS_ISRESTRICT:
    916                     kernelArg.isRestrict = parseYAMLBoolValue(ptr, end, lineNo);
     1050                    kernelArg.isRestrict = parseYAMLBoolValue(ptr, end, lineNo, true);
    9171051                    break;
    9181052                case ROCMMT_ARGS_ISVOLATILE:
    919                     kernelArg.isVolatile = parseYAMLBoolValue(ptr, end, lineNo);
     1053                    kernelArg.isVolatile = parseYAMLBoolValue(ptr, end, lineNo, true);
    9201054                    break;
    9211055                case ROCMMT_ARGS_NAME:
    922                     kernelArg.name = parseYAMLStringValue(ptr, end, lineNo, level);
     1056                    kernelArg.name = parseYAMLStringValue(ptr, end, lineNo, level, true);
    9231057                    break;
    9241058                case ROCMMT_ARGS_POINTEE_ALIGN:
    925                     kernelArg.pointeeAlign = parseYAMLIntValue<uint64_t>(ptr, end, lineNo);
     1059                    kernelArg.pointeeAlign =
     1060                                parseYAMLIntValue<uint64_t>(ptr, end, lineNo, true);
    9261061                    break;
    9271062                case ROCMMT_ARGS_SIZE:
     
    9291064                    break;
    9301065                case ROCMMT_ARGS_TYPENAME:
    931                     kernelArg.typeName = parseYAMLStringValue(ptr, end, lineNo, level);
     1066                    kernelArg.typeName =
     1067                                parseYAMLStringValue(ptr, end, lineNo, level, true);
    9321068                    break;
    9331069                case ROCMMT_ARGS_VALUEKIND:
    9341070                {
    9351071                    const std::string vkind = trimStrSpaces(parseYAMLStringValue(
    936                                 ptr, end, lineNo, level));
     1072                                ptr, end, lineNo, level, true));
    9371073                    const size_t vkindIndex = binaryMapFind(rocmValueKindNames,
    9381074                            rocmValueKindNames + rocmValueKindNamesNum, vkind.c_str(),
     
    9471083                {
    9481084                    const std::string vtype = trimStrSpaces(parseYAMLStringValue(
    949                                     ptr, end, lineNo, level));
     1085                                    ptr, end, lineNo, level, true));
    9501086                    const size_t vtypeIndex = binaryMapFind(rocmValueTypeNames,
    9511087                            rocmValueTypeNames + rocmValueTypeNamesNum, vtype.c_str(),
     
    9581094                }
    9591095                default:
     1096                    skipYAMLValue(ptr, end, lineNo, level);
    9601097                    break;
    9611098            }
Note: See TracChangeset for help on using the changeset viewer.