Changeset 3098 in CLRX


Ignore:
Timestamp:
May 29, 2017, 2:06:51 PM (2 years ago)
Author:
matszpk
Message:

CLRadeonExtender: GCNAsm: Add support for syntax of binary array "[bit0,bit1,...]" for neg,abs,sext modifiers.

Location:
CLRadeonExtender/trunk
Files:
6 edited

Legend:

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

    r3097 r3098  
    15061506}
    15071507
     1508bool GCNAsmUtils::parseImmWithBoolArray(Assembler& asmr, const char*& linePtr,
     1509            uint32_t& value, cxuint bits, cxbyte signess)
     1510{
     1511    const char* end = asmr.line + asmr.lineSize;
     1512    skipSpacesToEnd(linePtr, end);
     1513    if (linePtr == end || *linePtr != '[')
     1514        return parseImm(asmr, linePtr, value, nullptr, bits, signess);
     1515    // array of boolean values
     1516    linePtr++;
     1517    bool good = true;
     1518    uint32_t inVal = 0;
     1519    for (cxuint i = 0; i < bits; i++)
     1520    {
     1521        uint32_t v = 0;
     1522        good &= parseImm(asmr, linePtr, v, nullptr, 1, WS_UNSIGNED);
     1523        inVal |= v<<i;
     1524        skipSpacesToEnd(linePtr, end);
     1525        if (i+1 < bits)
     1526        {
     1527            if (linePtr==end || *linePtr!=',')
     1528            {
     1529                asmr.printError(linePtr, "Expected ',' before bit value");
     1530                good = false;
     1531                break;
     1532            }
     1533            else
     1534                ++linePtr;
     1535        }
     1536        else
     1537        {
     1538            if (linePtr == end || *linePtr!=']')
     1539            {
     1540                asmr.printError(linePtr, "Unterminated bit array");
     1541                good = false;
     1542            }
     1543            else
     1544                ++linePtr;
     1545        }
     1546    }
     1547    if (good)
     1548        value = inVal;
     1549    return good;
     1550}
     1551
    15081552static const std::pair<const char*, cxuint> vopSDWADSTSelNamesMap[] =
    15091553{
     
    15361580 * withSDWAOperands - specify number of operand for that modifier will be parsed */
    15371581bool GCNAsmUtils::parseVOPModifiers(Assembler& asmr, const char*& linePtr,
    1538                 uint16_t arch, cxbyte& mods, VOPOpModifiers& opMods,
     1582                uint16_t arch, cxbyte& mods, VOPOpModifiers& opMods, cxuint modOperands,
    15391583                VOPExtraModifiers* extraMods, bool withClamp, cxuint withSDWAOperands,
    15401584                bool withSext)
     
    16541698                    }
    16551699                }
    1656                 else if (::strcmp(mod, "abs")==0)
    1657                 {
    1658                     cxbyte absVal = 0;
     1700                else if (modOperands>1 && ::strcmp(mod, "abs")==0)
     1701                {
     1702                    uint32_t absVal = 0;
    16591703                    if (linePtr!=end && *linePtr==':')
    16601704                    {
    16611705                        linePtr++;
    1662                         if (parseImm(asmr, linePtr, absVal, nullptr, 3, WS_UNSIGNED))
     1706                        if (parseImmWithBoolArray(asmr, linePtr, absVal, modOperands-1,
     1707                                    WS_UNSIGNED))
    16631708                        {
    16641709                            opMods.absMod = absVal;
     
    16711716                        good = false;
    16721717                }
    1673                 else if (::strcmp(mod, "neg")==0)
    1674                 {
    1675                     cxbyte negVal = 0;
     1718                else if (modOperands>1 && ::strcmp(mod, "neg")==0)
     1719                {
     1720                    uint32_t negVal = 0;
    16761721                    if (linePtr!=end && *linePtr==':')
    16771722                    {
    16781723                        linePtr++;
    1679                         if (parseImm(asmr, linePtr, negVal, nullptr, 3, WS_UNSIGNED))
     1724                        if (parseImmWithBoolArray(asmr, linePtr, negVal, modOperands-1,
     1725                                        WS_UNSIGNED))
    16801726                        {
    16811727                            opMods.negMod = negVal;
     
    16881734                        good = false;
    16891735                }
    1690                 else if ((arch & ARCH_GCN_1_2_4) && withSext && ::strcmp(mod, "sext")==0)
    1691                 {
    1692                     cxbyte sextVal = 0;
     1736                else if ((arch & ARCH_GCN_1_2_4) && withSext &&
     1737                         modOperands>1 && ::strcmp(mod, "sext")==0)
     1738                {
     1739                    uint32_t sextVal = 0;
    16931740                    if (linePtr!=end && *linePtr==':')
    16941741                    {
    16951742                        linePtr++;
    1696                         if (parseImm(asmr, linePtr, sextVal, nullptr, 2, WS_UNSIGNED))
     1743                        if (parseImmWithBoolArray(asmr, linePtr, sextVal, modOperands-1,
     1744                                    WS_UNSIGNED))
    16971745                        {
    16981746                            opMods.sextMod = sextVal;
     
    19211969                            {
    19221970                                skipSpacesToEnd(linePtr, end);
    1923                                 try
    1924                                 {
    1925                                     cxbyte qpv = 0;
    1926                                     good &= parseImm(asmr, linePtr, qpv, nullptr,
    1927                                             2, WS_UNSIGNED);
    1928                                     quadPerm |= qpv<<(k<<1);
    1929                                 }
    1930                                 catch(const ParseException& ex)
    1931                                 {
    1932                                     asmr.printError(linePtr, ex.what());
    1933                                     goodMod = good = false;
    1934                                 }
     1971                                cxbyte qpv = 0;
     1972                                good &= parseImm(asmr, linePtr, qpv, nullptr,
     1973                                        2, WS_UNSIGNED);
     1974                                quadPerm |= qpv<<(k<<1);
    19351975                                skipSpacesToEnd(linePtr, end);
    19361976                                if (k!=3)
  • CLRadeonExtender/trunk/amdasm/GCNAsmInternals.h

    r3097 r3098  
    205205    }
    206206   
     207    static bool parseImmWithBoolArray(Assembler& asmr, const char*& linePtr,
     208            uint32_t& value, cxuint bits = 0, cxbyte signess = WS_BOTH);
     209   
    207210    static bool parseLiteralImm(Assembler& asmr, const char*& linePtr, uint32_t& value,
    208211            std::unique_ptr<AsmExpression>* outTargetExpr, Flags instropMask = 0);
    209212   
    210213    /* withSDWAOperands - number operand that will be handled by SDWA modifer parser,
     214     * modOperands - number of operands for abs,neg,sext
    211215     * (includes destination at begin) */
    212216    static bool parseVOPModifiers(Assembler& asmr, const char*& linePtr, uint16_t arch,
    213                        cxbyte& mods, VOPOpModifiers& opMods,
     217                       cxbyte& mods, VOPOpModifiers& opMods, cxuint modOperands,
    214218                       VOPExtraModifiers* extraMods = nullptr, bool withClamp = true,
    215219                       cxuint withSDWAOperands = 3, bool withSext = true);
  • CLRadeonExtender/trunk/amdasm/GCNAssembler.cpp

    r3097 r3098  
    15181518    VOPExtraModifiers extraMods{};
    15191519    VOPOpModifiers opMods{};
    1520     good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods,
     1520    good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods, 3,
    15211521                    (isGCN12) ? &extraMods : nullptr, !haveDstCC || isGCN12);
    15221522    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     
    17611761    VOPOpModifiers opMods{};
    17621762    good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods,
     1763                  (mode1!=GCN_VOP_ARG_NONE) ? 2 : 0,
    17631764                  (isGCN12)?&extraMods:nullptr, true, (mode1!=GCN_VOP_ARG_NONE) ? 2 : 0);
    17641765    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     
    19201921    VOPExtraModifiers extraMods{};
    19211922    VOPOpModifiers opMods{};
    1922     good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods,
     1923    good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods, 3,
    19231924                        (isGCN12)?&extraMods:nullptr, true);
    19241925    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     
    20932094            INSTROP_VOP3NEG : INSTROP_VOP3MODS | INSTROP_NOSEXT;
    20942095   
     2096    cxuint operands = 1;
    20952097    if (mode1 != GCN_VOP_ARG_NONE)
    20962098    {
     
    21302132                    INSTROP_ONLYINLINECONSTS|INSTROP_NOLITERALERROR|INSTROP_READ,
    21312133                    GCNFIELD_VOP3_SRC0);
     2134            operands++;
    21322135        }
    21332136       
     
    22002203                    INSTROP_ONLYINLINECONSTS|INSTROP_NOLITERALERROR|INSTROP_READ,
    22012204                    GCNFIELD_VOP3_SRC1);
    2202          
     2205            operands++;
     2206           
    22032207            if (mode1 != GCN_SRC2_NONE && mode1 != GCN_DST_VCC)
    22042208            {
     
    22132217                        vop3Mods|INSTROP_ONLYINLINECONSTS|INSTROP_NOLITERALERROR,
    22142218                        GCNFIELD_VOP3_SRC2);
     2219                operands++;
    22152220            }
    22162221        }
     
    22192224    VOPOpModifiers opMods{};
    22202225    if (mode2 != GCN_VOP3_VINTRP)
    2221         good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods, nullptr,
    2222                               isGCN12 || gcnInsn.encoding!=GCNENC_VOP3B, 3, false);
     2226        good &= parseVOPModifiers(asmr, linePtr, arch, modifiers, opMods, operands,
     2227                    nullptr, isGCN12 || gcnInsn.encoding!=GCNENC_VOP3B, 3, false);
    22232228    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    22242229        return false;
  • CLRadeonExtender/trunk/doc/GcnOperands.md

    r3096 r3098  
    168168`bound_ctrl:0:expr` or `bound_ctrl:1:expr`.
    169169The `abs`, `neg` and `sext` modifiers with parameter (expression) allow to set what
    170 source operand will have operand modifier. Number of bit of value refer to number of source operand.
     170source operand will have operand modifier. Number of bit of value refer to number of source operand. The `abs`, `neg` and `sext` modifiers accepts binary array of expressions like
     171`[bit0,bit1,...]`.
    171172
    172173The HW registers and send message parameters (message and GSOP) is parametrizable if
  • CLRadeonExtender/trunk/tests/amdasm/GCNAsmOpc11.cpp

    r3096 r3098  
    612612    { "    v_add_f32  v154, v21, -v107", 0xd206009aU, 0x4002d715U, true, true, "" },
    613613    { "    v_add_f32  v154, v21, v107 neg:2", 0xd206009aU, 0x4002d715U, true, true, "" },
     614    { "    v_add_f32  v154, v21, v107 neg:[0,1]",
     615        0xd206009aU, 0x4002d715U, true, true, "" },
     616    { "    v_add_f32  v154, v21, v107 neg: [ 0  , 1  ] ",
     617        0xd206009aU, 0x4002d715U, true, true, "" },
    614618    { "    v_add_f32  v154, -v21, -v107", 0xd206009aU, 0x6002d715U, true, true, "" },
    615619    { "    v_add_f32  v154, -abs(v21), -abs(v107)",
    616620        0xd206039aU, 0x6002d715U, true, true, "" },
    617621    { "    v_add_f32  v154, v21, v107 neg:3 abs:3",
     622        0xd206039aU, 0x6002d715U, true, true, "" },
     623    { "    v_add_f32  v154, v21, v107 neg:[1,1] abs:[1,1]",
    618624        0xd206039aU, 0x6002d715U, true, true, "" },
    619625    { "    v_add_f32  v154, v21, v107 mul:2", 0xd206009aU, 0x0802d715U, true, true, "" },
     
    16571663    { "   v_mad_legacy_f32 v55, v79, v166, v229 neg:4",
    16581664        0xd2800037U, 0x87974d4fU, true, true, "" },
     1665    { "   v_mad_legacy_f32 v55, v79, v166, v229 neg:[0,0,1]",
     1666        0xd2800037U, 0x87974d4fU, true, true, "" },
    16591667    { "   v_mad_legacy_f32 v55, v79, v166, v229 clamp",
    16601668        0xd2800837U, 0x07974d4fU, true, true, "" },
  • CLRadeonExtender/trunk/tests/amdasm/GCNAsmOpc12.cpp

    r3097 r3098  
    342342        0x0134d6f9U, 0x1e060541U, true, true, "" },
    343343    { "   v_cndmask_b32   v154, v65, v107, vcc dst_sel:word1 sext:2 neg:2",
     344        0x0134d6f9U, 0x1e060541U, true, true, "" },
     345    { "   v_cndmask_b32   v154, v65, v107, vcc dst_sel:word1 sext:[0,1] neg:[0,1]",
    344346        0x0134d6f9U, 0x1e060541U, true, true, "" },
    345347    { "   v_cndmask_b32   v154, abs(v65), v107, vcc clamp dst_sel:word1",
Note: See TracChangeset for help on using the changeset viewer.