Changeset 1671 in CLRX


Ignore:
Timestamp:
Nov 6, 2015, 6:16:12 PM (5 years ago)
Author:
matszpk
Message:

CLRadeonExtender: Optimized parsing regsymbols. Fixed determining whether operans is regsymbol or register name.

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

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

    r1668 r1671  
    6767}
    6868
     69bool GCNAsmUtils::parseSymRegRange(Assembler& asmr, const char*& linePtr,
     70                    RegRange& regPair, cxuint regsNum, Flags flags, bool required)
     71{
     72    const char* oldLinePtr = linePtr;
     73    const char* end = asmr.line+asmr.lineSize;
     74    skipSpacesToEnd(linePtr, end);
     75    const char* vgprRangePlace = linePtr;
     76   
     77    AsmSymbolEntry* symEntry = nullptr;
     78    if (linePtr!=end && *linePtr=='@')
     79        skipCharAndSpacesToEnd(linePtr, end);
     80   
     81    const char *regTypeName = (flags&INSTROP_VREGS) ? "vector" : "scalar";
     82   
     83    if (asmr.parseSymbol(linePtr, symEntry, false, true)==
     84        Assembler::ParseState::PARSED && symEntry!=nullptr &&
     85        symEntry->second.regRange)
     86    { // set up regrange
     87        cxuint rstart = symEntry->second.value&UINT_MAX;
     88        cxuint rend = symEntry->second.value>>32;
     89        const cxuint vsflags = flags & (INSTROP_VREGS|INSTROP_SREGS);
     90        if ((vsflags == INSTROP_VREGS && rstart >= 256 && rend >= 256) ||
     91            (vsflags == INSTROP_SREGS && rstart < 256 && rend < 256 &&
     92            /* if ssource and regs is vccz/execz/scc or
     93             *    no ssource and not vccz/execz/scc */
     94            (((flags&INSTROP_SSOURCE)==0) ^ (rstart==251 || rstart==252 || rstart==253))) ||
     95            vsflags == (INSTROP_VREGS|INSTROP_SREGS))
     96        {
     97            if (regsNum!=0 && regsNum != rend-rstart)
     98            {
     99                printXRegistersRequired(asmr, vgprRangePlace, regTypeName, regsNum);
     100                return false;
     101            }
     102            regPair = { rstart, rend };
     103            return true;
     104        }
     105    }
     106    if (printRegisterRangeExpected(asmr, vgprRangePlace, regTypeName, regsNum, required))
     107        return false;
     108    regPair = { 0, 0 }; // no range
     109    linePtr = oldLinePtr; // revert current line pointer
     110    return true;
     111}
     112
    69113bool GCNAsmUtils::parseVRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    70                     cxuint regsNum, bool required)
     114                    cxuint regsNum, bool required, bool symRegRange)
    71115{
    72116    const char* oldLinePtr = linePtr;
     
    77121        (!isDigit(linePtr[1]) && linePtr[1]!='['))
    78122    {
    79         if (linePtr!=end)
    80         {   // check whether is name of symbol with register
    81             AsmSymbolEntry* symEntry = nullptr;
    82             if (*linePtr=='@')
    83                 skipCharAndSpacesToEnd(linePtr, end);
    84             if (asmr.parseSymbol(linePtr, symEntry, false, true)==
    85                 Assembler::ParseState::PARSED && symEntry!=nullptr &&
    86                 symEntry->second.regRange)
    87             { // set up regrange
    88                 cxuint rstart = symEntry->second.value&UINT_MAX;
    89                 cxuint rend = symEntry->second.value>>32;
    90                 if (rstart >= 256 && rend >= 256)
    91                 {
    92                     if (regsNum!=0 && regsNum != rend-rstart)
    93                     {
    94                         printXRegistersRequired(asmr, vgprRangePlace, "vector", regsNum);
    95                         return false;
    96                     }
    97                     regPair = { rstart, rend };
    98                     return true;
    99                 }
    100             }
    101         }
     123        linePtr = oldLinePtr;
     124        if (symRegRange)
     125            return parseSymRegRange(asmr, linePtr, regPair, regsNum,
     126                            INSTROP_VREGS, required);
    102127        if (printRegisterRangeExpected(asmr, vgprRangePlace, "vector", regsNum, required))
    103128            return false;
     
    184209
    185210bool GCNAsmUtils::parseSRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    186                     uint16_t arch, cxuint regsNum, bool required)
     211                    uint16_t arch, cxuint regsNum, bool required, bool symRegRange)
    187212{
    188213    const char* oldLinePtr = linePtr;
     
    308333        else
    309334        {   // otherwise
    310             // check whether is name of symbol with register
    311             AsmSymbolEntry* symEntry = nullptr;
    312335            linePtr = oldLinePtr;
    313             skipSpacesToEnd(linePtr, end);
    314             if (linePtr!=end && *linePtr=='@')
    315                 skipCharAndSpacesToEnd(linePtr, end);
    316             if (asmr.parseSymbol(linePtr, symEntry, false, true)==
    317                 Assembler::ParseState::PARSED && symEntry!=nullptr &&
    318                 symEntry->second.regRange)
    319             { // set up regrange
    320                 cxuint rstart = symEntry->second.value&UINT_MAX;
    321                 cxuint rend = symEntry->second.value>>32;
    322                 if (rstart < 256 && rend <= 256)
    323                 {
    324                     if (regsNum!=0 && regsNum != rend-rstart)
    325                     {
    326                         printXRegistersRequired(asmr, sgprRangePlace, "scalar", regsNum);
    327                         return false;
    328                     }
    329                     regPair = { rstart, rend };
    330                     return true;
    331                 }
    332             }
     336            if (symRegRange)
     337                return parseSymRegRange(asmr, linePtr, regPair, regsNum,
     338                                INSTROP_SREGS, required);
    333339            if (printRegisterRangeExpected(asmr, sgprRangePlace, "scalar",
    334340                            regsNum, required))
     
    727733    if (instrOpMask & INSTROP_SREGS)
    728734    {
    729         if (!parseSRegRange(asmr, linePtr, operand.range, arch, regsNum, false))
     735        if (!parseSRegRange(asmr, linePtr, operand.range, arch, regsNum, false, false))
    730736            return false;
    731737        if (operand)
     
    734740    if (instrOpMask & INSTROP_VREGS)
    735741    {
    736         if (!parseVRegRange(asmr, linePtr, operand.range, regsNum, false))
     742        if (!parseVRegRange(asmr, linePtr, operand.range, regsNum, false, false))
     743            return false;
     744        if (operand)
     745            return true;
     746    }
     747    if (instrOpMask & (INSTROP_SREGS|INSTROP_VREGS))
     748    {
     749        if (!parseSymRegRange(asmr, linePtr, operand.range, regsNum,
     750                    INSTROP_SREGS|INSTROP_VREGS|(instrOpMask&INSTROP_SSOURCE), false))
    737751            return false;
    738752        if (operand)
  • CLRadeonExtender/trunk/amdasm/GCNAsmInternals.h

    r1551 r1671  
    114114               const char* regPoolName, cxuint requiredRegsNum);
    115115   
     116    static bool parseSymRegRange(Assembler& asmr, const char*& linePtr,
     117                    RegRange& regPair, cxuint regsNum, Flags flags, bool required = true);
    116118    /* return true if no error */
    117119    static bool parseVRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    118                    cxuint regsNum, bool required = true);
     120                   cxuint regsNum, bool required = true, bool symRegRange = true);
    119121    /* return true if no error */
    120122    static bool parseSRegRange(Assembler& asmr, const char*& linePtr, RegRange& regPair,
    121                    uint16_t arch, cxuint regsNum, bool required = true);
     123           uint16_t arch, cxuint regsNum, bool required = true, bool symRegRange = true);
    122124   
    123125    /* return true if no error */
Note: See TracChangeset for help on using the changeset viewer.