Changeset 1673 in CLRX


Ignore:
Timestamp:
Nov 7, 2015, 2:25:05 PM (5 years ago)
Author:
matszpk
Message:

CLRadeonExtender: Allow to using unaligned scalar register range in register's symbols. Added an indexing of register's symbols.

Location:
CLRadeonExtender/trunk/amdasm
Files:
3 edited

Legend:

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

    r1671 r1673  
    6868
    6969bool GCNAsmUtils::parseSymRegRange(Assembler& asmr, const char*& linePtr,
    70                     RegRange& regPair, cxuint regsNum, Flags flags, bool required)
     70            RegRange& regPair, uint16_t arch, cxuint regsNum, Flags flags, bool required)
    7171{
    7272    const char* oldLinePtr = linePtr;
     
    9595            vsflags == (INSTROP_VREGS|INSTROP_SREGS))
    9696        {
     97            skipSpacesToEnd(linePtr, end);
     98            if (*linePtr == '[')
     99            {
     100                uint64_t value1, value2;
     101                skipCharAndSpacesToEnd(linePtr, end);
     102                if (!getAbsoluteValueArg(asmr, value1, linePtr, true))
     103                    return false;
     104                skipSpacesToEnd(linePtr, end);
     105                if (linePtr == end || (*linePtr!=':' && *linePtr!=']'))
     106                {   // error
     107                    asmr.printError(vgprRangePlace, "Unterminated register range");
     108                    return false;
     109                }
     110                if (linePtr!=end && *linePtr==':')
     111                {
     112                    skipCharAndSpacesToEnd(linePtr, end);
     113                    if (!getAbsoluteValueArg(asmr, value2, linePtr, true))
     114                        return false;
     115                }
     116                else
     117                    value2 = value1;
     118                skipSpacesToEnd(linePtr, end);
     119                if (linePtr == end || *linePtr != ']')
     120                {   // error
     121                    asmr.printError(vgprRangePlace, "Unterminated register range");
     122                    return false;
     123                }
     124                ++linePtr;
     125                if (value2 < value1)
     126                {   // error (illegal register range)
     127                    asmr.printError(vgprRangePlace, "Illegal register range");
     128                    return false;
     129                }
     130                if (value2 >= rend-rstart || value1 >= rend-rstart)
     131                {
     132                    asmr.printError(vgprRangePlace, "Register range out of range");
     133                    return false;
     134                }
     135                rend = rstart + value2+1;
     136                rstart += value1;
     137            }
     138           
    97139            if (regsNum!=0 && regsNum != rend-rstart)
    98140            {
     
    100142                return false;
    101143            }
     144            const cxuint maxSGPRsNum = (arch&ARCH_RX3X0) ? 102 : 104;
     145            /// check aligned for scalar registers
     146            if ((flags & INSTROP_UNALIGNED) == 0 && rstart>=0 && rstart<maxSGPRsNum)
     147                if ((rend-rstart==2 && (rstart&1)!=0) || (rend-rstart>2 && (rstart&3)!=0))
     148                {
     149                    asmr.printError(vgprRangePlace, "Unaligned scalar register range");
     150                    return false;
     151                }
    102152            regPair = { rstart, rend };
    103153            return true;
     
    112162
    113163bool GCNAsmUtils::parseVRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    114                     cxuint regsNum, bool required, bool symRegRange)
     164                    cxuint regsNum, bool required, Flags flags)
    115165{
    116166    const char* oldLinePtr = linePtr;
     
    122172    {
    123173        linePtr = oldLinePtr;
    124         if (symRegRange)
    125             return parseSymRegRange(asmr, linePtr, regPair, regsNum,
     174        if ((flags&INSTROP_SYMREGRANGE) != 0)
     175            return parseSymRegRange(asmr, linePtr, regPair, 0, regsNum,
    126176                            INSTROP_VREGS, required);
    127177        if (printRegisterRangeExpected(asmr, vgprRangePlace, "vector", regsNum, required))
     
    148198    else if (*linePtr == '[')
    149199    {   // many registers
    150         ++linePtr;
    151200        uint64_t value1, value2;
    152         skipSpacesToEnd(linePtr, end);
     201        skipCharAndSpacesToEnd(linePtr, end);
    153202        if (!getAbsoluteValueArg(asmr, value1, linePtr, true))
    154203            return false;
     
    209258
    210259bool GCNAsmUtils::parseSRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    211                     uint16_t arch, cxuint regsNum, bool required, bool symRegRange)
     260                    uint16_t arch, cxuint regsNum, bool required, Flags flags)
    212261{
    213262    const char* oldLinePtr = linePtr;
     
    334383        {   // otherwise
    335384            linePtr = oldLinePtr;
    336             if (symRegRange)
    337                 return parseSymRegRange(asmr, linePtr, regPair, regsNum,
     385            if ((flags&INSTROP_SYMREGRANGE) != 0)
     386                return parseSymRegRange(asmr, linePtr, regPair, arch, regsNum,
    338387                                INSTROP_SREGS, required);
    339388            if (printRegisterRangeExpected(asmr, sgprRangePlace, "scalar",
     
    388437    else if (*linePtr == '[')
    389438    {   // many registers
    390         ++linePtr;
    391439        uint64_t value1, value2;
    392         skipSpacesToEnd(linePtr, end);
     440        skipCharAndSpacesToEnd(linePtr, end);
    393441        if (!getAbsoluteValueArg(asmr, value1, linePtr, true))
    394442            return false;
     
    455503        }
    456504        /// check alignment
    457         if (!ttmpReg)
     505        if (!ttmpReg && (flags & INSTROP_UNALIGNED)==0)
    458506            if ((value2-value1==1 && (value1&1)!=0) || (value2-value1>1 && (value1&3)!=0))
    459507            {
     
    730778    }
    731779   
     780    const cxuint alignFlags = (instrOpMask&INSTROP_UNALIGNED);
    732781    // otherwise
    733782    if (instrOpMask & INSTROP_SREGS)
    734783    {
    735         if (!parseSRegRange(asmr, linePtr, operand.range, arch, regsNum, false, false))
     784        if (!parseSRegRange(asmr, linePtr, operand.range, arch, regsNum, false, alignFlags))
    736785            return false;
    737786        if (operand)
     
    740789    if (instrOpMask & INSTROP_VREGS)
    741790    {
    742         if (!parseVRegRange(asmr, linePtr, operand.range, regsNum, false, false))
     791        if (!parseVRegRange(asmr, linePtr, operand.range, regsNum, false, alignFlags))
    743792            return false;
    744793        if (operand)
     
    747796    if (instrOpMask & (INSTROP_SREGS|INSTROP_VREGS))
    748797    {
    749         if (!parseSymRegRange(asmr, linePtr, operand.range, regsNum,
    750                     INSTROP_SREGS|INSTROP_VREGS|(instrOpMask&INSTROP_SSOURCE), false))
     798        if (!parseSymRegRange(asmr, linePtr, operand.range, arch, regsNum, INSTROP_SREGS|
     799                    INSTROP_VREGS|(instrOpMask&INSTROP_SSOURCE)|alignFlags, false))
    751800            return false;
    752801        if (operand)
  • CLRadeonExtender/trunk/amdasm/GCNAsmInternals.h

    r1671 r1673  
    5151    INSTROP_FLOAT = 0x1000, // floating point literal
    5252    INSTROP_F16 = 0x2000,   // half floating point literal
     53    INSTROP_UNALIGNED = 0x8000, // not aligned, use by parseRegisterRange
     54   
     55    // for parseSRregRange/parseVRegRange
     56    INSTROP_SYMREGRANGE = 1
    5357};
    5458
     
    114118               const char* regPoolName, cxuint requiredRegsNum);
    115119   
    116     static bool parseSymRegRange(Assembler& asmr, const char*& linePtr,
    117                     RegRange& regPair, cxuint regsNum, Flags flags, bool required = true);
     120    static bool parseSymRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
     121                 uint16_t arch, cxuint regsNum, Flags flags, bool required = true);
    118122    /* return true if no error */
    119123    static bool parseVRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    120                    cxuint regsNum, bool required = true, bool symRegRange = true);
     124                   cxuint regsNum, bool required = true, Flags flags = INSTROP_SYMREGRANGE);
    121125    /* return true if no error */
    122126    static bool parseSRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    123            uint16_t arch, cxuint regsNum, bool required = true, bool symRegRange = true);
     127                   uint16_t arch, cxuint regsNum, bool required = true,
     128                   Flags flags = INSTROP_SYMREGRANGE);
    124129   
    125130    /* return true if no error */
  • CLRadeonExtender/trunk/amdasm/GCNAssembler.cpp

    r1670 r1673  
    28162816    GCNOperand operand;
    28172817    if (!GCNAsmUtils::parseOperand(assembler, linePtr, operand, nullptr, curArchMask, 0,
    2818                 INSTROP_SREGS|INSTROP_VREGS|INSTROP_SSOURCE))
     2818                INSTROP_SREGS|INSTROP_VREGS|INSTROP_SSOURCE|INSTROP_UNALIGNED))
    28192819        return false;
    28202820    regStart = operand.range.start;
Note: See TracChangeset for help on using the changeset viewer.