Changeset 4032 in CLRX


Ignore:
Timestamp:
Apr 20, 2018, 3:04:10 PM (5 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: GCNAsm: Do not permit regvars and SGPRs to be equal in VOP2/VOP3/VOPC instructions (rule: only 1 SGPR can be read).
AsmRegAlloc?: Remove obsolete equalTo dependencies (obsolete, when SGPRs and regvars can not be same if this same live time).
Fixed some GCNRegVarUsage testcases. Remove obsolete equalTo stuff from AsmRegalloc3 testsuite.

Location:
CLRadeonExtender/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/Assembler.h

    r4027 r4032  
    152152    /// get usage dependencies around single instruction
    153153    virtual void getUsageDependencies(cxuint rvusNum, const AsmRegVarUsage* rvus,
    154                     cxbyte* linearDeps, cxbyte* equalToDeps) const = 0;
     154                    cxbyte* linearDeps) const = 0;
    155155};
    156156
     
    172172    std::pair<uint16_t,uint16_t> getRegPair(AsmRegField regField, cxbyte rwFlags) const;
    173173    void getUsageDependencies(cxuint rvusNum, const AsmRegVarUsage* rvus,
    174                     cxbyte* linearDeps, cxbyte* equalToDeps) const;
     174                    cxbyte* linearDeps) const;
    175175};
    176176
     
    351351        std::vector<size_t> nextVidxes;
    352352    };
    353     struct EqualToDep
    354     {
    355         std::vector<size_t> prevVidxes;
    356         std::vector<size_t> nextVidxes;
    357     };
    358353private:
    359354    Assembler& assembler;
     
    368363    Array<cxuint> graphColorMaps[MAX_REGTYPES_NUM];
    369364    std::unordered_map<size_t, LinearDep> linearDepMaps[MAX_REGTYPES_NUM];
    370     std::unordered_map<size_t, EqualToDep> equalToDepMaps[MAX_REGTYPES_NUM];
    371     std::unordered_map<size_t, size_t> equalSetMaps[MAX_REGTYPES_NUM];
    372     std::vector<std::vector<size_t> > equalSetLists[MAX_REGTYPES_NUM];
    373365   
    374366public:
     
    398390    const std::unordered_map<size_t, LinearDep>* getLinearDepMaps() const
    399391    { return linearDepMaps; }
    400     const std::unordered_map<size_t, EqualToDep>* getEqualToDepMaps() const
    401     { return equalToDepMaps; }
    402392   
    403393    const VarIndexMap* getVregIndexMaps() const
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r4030 r4032  
    857857}
    858858
    859 static void addUsageDeps(const cxbyte* ldeps, const cxbyte* edeps, cxuint rvusNum,
     859static void addUsageDeps(const cxbyte* ldeps, cxuint rvusNum,
    860860            const AsmRegVarUsage* rvus, LinearDepMap* ldepsOut,
    861             EqualToDepMap* edepsOut, const VarIndexMap* vregIndexMaps,
     861            const VarIndexMap* vregIndexMaps,
    862862            const std::unordered_map<AsmSingleVReg, size_t>& ssaIdIdxMap,
    863863            size_t regTypesNum, const cxuint* regRanges)
     
    925925            }
    926926        }
    927    
    928     /* equalTo dependencies */
    929     count = edeps[0];
    930     pos = 1;
    931     for (cxuint i = 0; i < count; i++)
    932     {
    933         cxuint ccount = edeps[pos++];
    934         std::vector<size_t> vidxes;
    935         cxuint regType = UINT_MAX;
    936         for (cxuint j = 0; j < ccount; j++)
    937         {
    938             const AsmRegVarUsage& rvu = rvus[edeps[pos++]];
    939             // only one register should be set for equalTo depencencies
    940             // other registers in range will be resolved by linear dependencies
    941             AsmSingleVReg svreg = {rvu.regVar, rvu.rstart};
    942             auto sit = ssaIdIdxMap.find(svreg);
    943             if (regType==UINT_MAX)
    944                 regType = getRegType(regTypesNum, regRanges, svreg);
    945             const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    946             const std::vector<size_t>& ssaIdIndices =
    947                         vregIndexMap.find(svreg)->second;
    948             // push variable index
    949             vidxes.push_back(ssaIdIndices[sit->second]);
    950         }
    951         for (size_t j = 1; j < vidxes.size(); j++)
    952         {
    953             edepsOut[regType][vidxes[j-1]].nextVidxes.push_back(vidxes[j]);
    954             edepsOut[regType][vidxes[j]].prevVidxes.push_back(vidxes[j-1]);
    955         }
    956     }
    957927}
    958928
     
    11201090                        // get linear deps and equal to
    11211091                        cxbyte lDeps[16];
    1122                         cxbyte eDeps[16];
    1123                         usageHandler.getUsageDependencies(instrRVUsCount, instrRVUs,
    1124                                         lDeps, eDeps);
     1092                        usageHandler.getUsageDependencies(instrRVUsCount, instrRVUs, lDeps);
    11251093                       
    1126                         addUsageDeps(lDeps, eDeps, instrRVUsCount, instrRVUs,
    1127                                 linearDepMaps, equalToDepMaps, vregIndexMaps, ssaIdIdxMap,
     1094                        addUsageDeps(lDeps, instrRVUsCount, instrRVUs,
     1095                                linearDepMaps, vregIndexMaps, ssaIdIdxMap,
    11281096                                regTypesNum, regRanges);
    11291097                       
     
    12651233        }
    12661234    }
    1267    
    1268     /*
    1269      * resolve equalSets
    1270      */
    1271     for (cxuint regType = 0; regType < regTypesNum; regType++)
    1272     {
    1273         InterGraph& interGraph = interGraphs[regType];
    1274         const size_t nodesNum = interGraph.size();
    1275         const std::unordered_map<size_t, EqualToDep>& etoDepMap = equalToDepMaps[regType];
    1276         std::vector<bool> visited(nodesNum, false);
    1277         std::vector<std::vector<size_t> >& equalSetList = equalSetLists[regType];
    1278        
    1279         for (size_t v = 0; v < nodesNum;)
    1280         {
    1281             auto it = etoDepMap.find(v);
    1282             if (it == etoDepMap.end())
    1283             {
    1284                 // is not regvar in equalTo dependencies
    1285                 v++;
    1286                 continue;
    1287             }
    1288            
    1289             std::stack<EqualStackEntry> etoStack;
    1290             etoStack.push(EqualStackEntry{ it, 0 });
    1291            
    1292             std::unordered_map<size_t, size_t>& equalSetMap =  equalSetMaps[regType];
    1293             const size_t equalSetIndex = equalSetList.size();
    1294             equalSetList.push_back(std::vector<size_t>());
    1295             std::vector<size_t>& equalSet = equalSetList.back();
    1296            
    1297             // traverse by this
    1298             while (!etoStack.empty())
    1299             {
    1300                 EqualStackEntry& entry = etoStack.top();
    1301                 size_t vidx = entry.etoDepIt->first; // node index, vreg index
    1302                 const EqualToDep& eToDep = entry.etoDepIt->second;
    1303                 if (entry.nextIdx == 0)
    1304                 {
    1305                     if (!visited[vidx])
    1306                     {
    1307                         // push to this equalSet
    1308                         equalSetMap.insert({ vidx, equalSetIndex });
    1309                         equalSet.push_back(vidx);
    1310                     }
    1311                     else
    1312                     {
    1313                         // already visited
    1314                         etoStack.pop();
    1315                         continue;
    1316                     }
    1317                 }
    1318                
    1319                 if (entry.nextIdx < eToDep.nextVidxes.size())
    1320                 {
    1321                     auto nextIt = etoDepMap.find(eToDep.nextVidxes[entry.nextIdx]);
    1322                     etoStack.push(EqualStackEntry{ nextIt, 0 });
    1323                     entry.nextIdx++;
    1324                 }
    1325                 else if (entry.nextIdx < eToDep.nextVidxes.size()+eToDep.prevVidxes.size())
    1326                 {
    1327                     auto nextIt = etoDepMap.find(eToDep.prevVidxes[
    1328                                 entry.nextIdx - eToDep.nextVidxes.size()]);
    1329                     etoStack.push(EqualStackEntry{ nextIt, 0 });
    1330                     entry.nextIdx++;
    1331                 }
    1332                 else
    1333                     etoStack.pop();
    1334             }
    1335            
    1336             // to first already added node (var)
    1337             while (v < nodesNum && !visited[v]) v++;
    1338         }
    1339     }
    13401235}
    13411236
     
    13601255        const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    13611256        Array<cxuint>& gcMap = graphColorMaps[regType];
    1362         const std::vector<std::vector<size_t> >& equalSetList = equalSetLists[regType];
    1363         const std::unordered_map<size_t, size_t>& equalSetMap =  equalSetMaps[regType];
    13641257       
    13651258        const size_t nodesNum = interGraph.size();
     
    13861279                continue; // already colored
    13871280            size_t color = 0;
    1388             std::vector<size_t> equalNodes;
    1389             equalNodes.push_back(node); // only one node, if equalSet not found
    1390             auto equalSetMapIt = equalSetMap.find(node);
    1391             if (equalSetMapIt != equalSetMap.end())
    1392                 // found, get equal set from equalSetList
    1393                 equalNodes = equalSetList[equalSetMapIt->second];
    13941281           
    13951282            for (color = 0; color <= colorsNum; color++)
     
    14131300            }
    14141301           
    1415             for (size_t nextNode: equalNodes)
    1416                 gcMap[nextNode] = color;
     1302            gcMap[node] = color;
    14171303            // update SDO for node
    14181304            bool colorExists = false;
    1419             for (size_t node: equalNodes)
    1420             {
    1421                 for (size_t nb: interGraph[node])
    1422                     if (gcMap[nb] == color)
     1305            for (size_t nb: interGraph[node])
     1306                if (gcMap[nb] == color)
     1307                {
     1308                    colorExists = true;
     1309                    break;
     1310                }
     1311            if (!colorExists)
     1312                sdoCounts[node]++;
     1313            // update SDO for neighbors
     1314            for (size_t nb: interGraph[node])
     1315            {
     1316                colorExists = false;
     1317                for (size_t nb2: interGraph[nb])
     1318                    if (gcMap[nb2] == color)
    14231319                    {
    14241320                        colorExists = true;
     
    14261322                    }
    14271323                if (!colorExists)
    1428                     sdoCounts[node]++;
    1429             }
    1430             // update SDO for neighbors
    1431             for (size_t node: equalNodes)
    1432                 for (size_t nb: interGraph[node])
    14331324                {
    1434                     colorExists = false;
    1435                     for (size_t nb2: interGraph[nb])
    1436                         if (gcMap[nb2] == color)
    1437                         {
    1438                             colorExists = true;
    1439                             break;
    1440                         }
    1441                     if (!colorExists)
    1442                     {
    1443                         if (gcMap[nb] == UINT_MAX)
    1444                             nodeSet.erase(nb);  // before update we erase from nodeSet
    1445                         sdoCounts[nb]++;
    1446                         if (gcMap[nb] == UINT_MAX)
    1447                             nodeSet.insert(nb); // after update, insert again
    1448                     }
     1325                    if (gcMap[nb] == UINT_MAX)
     1326                        nodeSet.erase(nb);  // before update we erase from nodeSet
     1327                    sdoCounts[nb]++;
     1328                    if (gcMap[nb] == UINT_MAX)
     1329                        nodeSet.insert(nb); // after update, insert again
    14491330                }
    1450            
    1451             for (size_t nextNode: equalNodes)
    1452                 gcMap[nextNode] = color;
     1331            }
     1332           
     1333            gcMap[node] = color;
    14531334        }
    14541335    }
     
    14651346        interGraphs[i].clear();
    14661347        linearDepMaps[i].clear();
    1467         equalToDepMaps[i].clear();
    14681348        graphColorMaps[i].clear();
    1469         equalSetMaps[i].clear();
    1470         equalSetLists[i].clear();
    14711349    }
    14721350    ssaReplacesMap.clear();
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4026 r4032  
    351351
    352352typedef AsmRegAllocator::LinearDep LinearDep;
    353 typedef AsmRegAllocator::EqualToDep EqualToDep;
    354353typedef std::unordered_map<size_t, LinearDep> LinearDepMap;
    355 typedef std::unordered_map<size_t, EqualToDep> EqualToDepMap;
    356 
    357 typedef std::unordered_map<size_t, EqualToDep>::const_iterator EqualToDepMapCIter;
    358 
    359 struct CLRX_INTERNAL EqualStackEntry
    360 {
    361     EqualToDepMapCIter etoDepIt;
    362     size_t nextIdx; // over nextVidxes size, then prevVidxes[nextIdx-nextVidxes.size()]
    363 };
    364354
    365355typedef AsmRegAllocator::InterGraph InterGraph;
  • CLRadeonExtender/trunk/amdasm/GCNAssembler.cpp

    r4031 r4032  
    310310
    311311/// get usage dependencies
    312 /* linearDeps - lists of linked register fields (linked fields)
    313  * equalToDeps - lists of register fields should be equal */
     312/* linearDeps - lists of linked register fields (linked fields) */
    314313void GCNUsageHandler::getUsageDependencies(cxuint rvusNum, const AsmRegVarUsage* rvus,
    315                 cxbyte* linearDeps, cxbyte* equalToDeps) const
     314                cxbyte* linearDeps) const
    316315{
    317316    cxuint count = 0;
    318     equalToDeps[0] = 0;
    319     if (rvus[0].regField>=GCNFIELD_VOP_SRC0 && rvus[0].regField<=GCNFIELD_VOP3_SDST1)
    320     {
    321         // if VOPx instructions, equalTo deps for rule (only one SGPR in source)
    322         for (cxuint i = 0; i < rvusNum; i++)
    323         {
    324             const AsmRegField rf = rvus[i].regField;
    325             if (rf == GCNFIELD_VOP_SRC0 || rf == GCNFIELD_VOP_VSRC1 ||
    326                 rf == GCNFIELD_VOP_SSRC1 || rf == GCNFIELD_VOP3_SRC0 ||
    327                 rf == GCNFIELD_VOP3_SRC1 || rf == GCNFIELD_VOP3_SRC2 ||
    328                 rf == GCNFIELD_VOP3_SSRC || rf == GCNFIELD_DPPSDWA_SRC0)
    329             {
    330                 // if SGPR
    331                 if ((rvus[i].regVar==nullptr && rvus[i].rstart<108) ||
    332                      (rvus[i].regVar!=nullptr && rvus[i].regVar->type == REGTYPE_SGPR))
    333                     equalToDeps[2 + count++] = i;
    334             }
    335         }
    336         equalToDeps[1] = (count >= 2) ? count : 0;
    337         equalToDeps[0] = (equalToDeps[1] != 0);
    338     }
    339317    // linear dependencies (join fields)
    340318    count = 0;
     
    397375static inline bool regRangeCanEqual(const RegRange& r1, const RegRange& r2)
    398376{
    399     if (r1.isRegVar() != r2.isRegVar() && r1.isSGPR()==r2.isSGPR())
    400         return true; // can be equal: regvar -> reg
    401377    return r1.regVar==r2.regVar && r1.start==r2.start;
    402378}
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4031 r4032  
    3535typedef AsmRegAllocator::OutLiveness OutLiveness;
    3636typedef AsmRegAllocator::LinearDep LinearDep;
    37 typedef AsmRegAllocator::EqualToDep EqualToDep;
    3837typedef AsmRegAllocator::VarIndexMap VarIndexMap;
    3938
     
    4443    Array<size_t> nextVidxes;
    4544};
    46 struct EqualToDep2
    47 {
    48     Array<size_t> prevVidxes;
    49     Array<size_t> nextVidxes;
    50 };
    5145
    5246struct AsmLivenessesCase
     
    5549    Array<OutLiveness> livenesses[MAX_REGTYPES_NUM];
    5650    Array<std::pair<size_t, LinearDep2> > linearDepMaps[MAX_REGTYPES_NUM];
    57     Array<std::pair<size_t, EqualToDep2> > equalToDepMaps[MAX_REGTYPES_NUM];
    5851    bool good;
    5952    const char* errorMessages;
     
    8477        },
    8578        { },  // linearDepMaps
    86         { },  // equalToDepMaps
    8779        true, ""
    8880    },
     
    110102        },
    111103        { },  // linearDepMaps
    112         { },  // equalToDepMaps
    113104        true, ""
    114105    },
    115106    {   // 2 - simple case (linear dep)
    116         R"ffDXD(.regvar sa:s:10, va:v:10
     107        R"ffDXD(.regvar sa:s:8, va:v:10
    117108        .regvar sbuf:s:4, rbx4:v:6
    118109        s_mov_b64 sa[4:5], sa[2:3]  # 0
     
    120111        v_add_f64 va[4:5], va[2:3], v[3:4]
    121112        buffer_load_dwordx4 rbx4[1:5], va[6], sbuf[0:3], sa[7] idxen offset:603 tfe
    122         v_mad_f32 va[7], sa[8], va[8], s10
    123113)ffDXD",
    124114        {   // livenesses
     
    126116                { { 0, 5 } }, // S4
    127117                { { 0, 5 } }, // S5
    128                 { { 0, 25 } }, // S10
    129118                { { 0, 0 } }, // sa[2]'0
    130119                { { 0, 0 } }, // sa[3]'0
     
    134123                { { 8, 9 } }, // sa[5]'1
    135124                { { 0, 17 } }, // sa[7]'0
    136                 { { 0, 25 } }, // sa[8]'0
    137125                { { 0, 17 } }, // sbuf[0]'0
    138126                { { 0, 17 } }, // sbuf[1]'0
    139127                { { 0, 17 } }, // sbuf[2]'0
    140                 { { 0, 17 } }  // sbuf[3]'0
     128                { { 0, 17 } }, // sbuf[3]'0
    141129            },
    142130            {   // for VGPRs
    143131                { { 0, 9 } }, // V3
    144132                { { 0, 9 } }, // V4
    145                 { { 24, 25 } }, // rbx4[1]'0
    146                 { { 24, 25 } }, // rbx4[2]'0
    147                 { { 24, 25 } }, // rbx4[3]'0
    148                 { { 24, 25 } }, // rbx4[4]'0
     133                { }, // rbx4[1]'0
     134                { }, // rbx4[2]'0
     135                { }, // rbx4[3]'0
     136                { }, // rbx4[4]'0
    149137                { { 0, 17 } }, // rbx4[5]'0: tfe - read before write
    150138                { { 0, 9 } }, // va[2]'0
     
    152140                { { 16, 17 } }, // va[4]'0 : out of range code block
    153141                { { 16, 17 } }, // va[5]'0 : out of range code block
    154                 { { 0, 17 } }, // va[6]'0
    155                 { }, // va[7]'0
    156                 { { 0, 25 } }  // va[8]'0
     142                { { 0, 17 } } // va[6]'0
    157143            },
    158144            { },
     
    163149                { 0, { 0, { }, { 1 } } },  // S4
    164150                { 1, { 0, { 0 }, { } } },  // S5
    165                 { 3, { 2, { }, { 4 } } },  // sa[2]'0
    166                 { 4, { 0, { 3 }, { } } },  // sa[3]'0
    167                 { 5, { 2, { }, { 7 } } },  // sa[4]'0
    168                 { 6, { 2, { }, { 8, 8 } } },  // sa[4]'1
    169                 { 7, { 0, { 5 }, { } } },  // sa[5]'0
    170                 { 8, { 0, { 6, 6 }, { } } },   // sa[5]'1
    171                 { 11, { 4, { }, { 12 } } }, // sbuf[0]'0
    172                 { 12, { 0, { 11 }, { 13 } } }, // sbuf[1]'0
    173                 { 13, { 0, { 12 }, { 14 } } }, // sbuf[2]'0
    174                 { 14, { 0, { 13 }, { } } }  // sbuf[3]'0
     151                { 2, { 2, { }, { 3 } } },  // sa[2]'0
     152                { 3, { 0, { 2 }, { } } },  // sa[3]'0
     153                { 4, { 2, { }, { 6 } } },  // sa[4]'0
     154                { 5, { 2, { }, { 7, 7 } } },  // sa[4]'1
     155                { 6, { 0, { 4 }, { } } },  // sa[5]'0
     156                { 7, { 0, { 5, 5 }, { } } },   // sa[5]'1
     157                { 9, { 4, { }, { 10 } } }, // sbuf[0]'0
     158                { 10, { 0, { 9 }, { 11 } } }, // sbuf[1]'0
     159                { 11, { 0, { 10 }, { 12 } } }, // sbuf[2]'0
     160                { 12, { 0, { 11 }, { } } }  // sbuf[3]'0
    175161            },
    176162            {   // for VGPRs
     
    187173                { 10, { 0, { 9 }, { } } }  // va[5]'0
    188174            },
    189             { },
    190             { }
    191         },
    192         {   // equalToDepMaps
    193             {   // for SGPRs
    194                 { 2, { { 10 }, { } } },  // S10
    195                 { 10, { { }, { 2 } } }   // sa[8]'0
    196             },
    197             { },
    198175            { },
    199176            { }
     
    375352        }
    376353    }
    377    
    378     const std::unordered_map<size_t, EqualToDep>* resEqualToDepMaps =
    379                 regAlloc.getEqualToDepMaps();
    380     for (size_t r = 0; r < MAX_REGTYPES_NUM; r++)
    381     {
    382         std::ostringstream rOss;
    383         rOss << "eqtodep.regtype#" << r;
    384         rOss.flush();
    385         std::string rtname(rOss.str());
    386        
    387         assertValue("testAsmLivenesses", testCaseName + rtname + ".size",
    388                     testCase.equalToDepMaps[r].size(), resEqualToDepMaps[r].size());
    389        
    390         for (size_t di = 0; di < testCase.equalToDepMaps[r].size(); di++)
    391         {
    392             std::ostringstream lOss;
    393             lOss << ".eqtodep#" << di;
    394             lOss.flush();
    395             std::string ldname(rtname + lOss.str());
    396             const auto& expEqualToDepEntry = testCase.equalToDepMaps[r][di];
    397             auto reit = resEqualToDepMaps[r].find(
    398                             lvIndexCvtTables[r][expEqualToDepEntry.first]);
    399            
    400             std::ostringstream vOss;
    401             vOss << expEqualToDepEntry.first;
    402             vOss.flush();
    403             assertTrue("testAsmLivenesses", testCaseName + ldname + ".key=" + vOss.str(),
    404                         reit != resEqualToDepMaps[r].end());
    405             const EqualToDep2& expEqualToDep = expEqualToDepEntry.second;
    406             const EqualToDep& resEqualToDep = reit->second;
    407            
    408             Array<size_t> resPrevVidxes(resEqualToDep.prevVidxes.size());
    409             // convert to res ssaIdIndices
    410             for (size_t k = 0; k < resEqualToDep.prevVidxes.size(); k++)
    411                 resPrevVidxes[k] = revLvIndexCvtTables[r][resEqualToDep.prevVidxes[k]];
    412            
    413             assertArray("testAsmLivenesses", testCaseName + ldname + ".prevVidxes",
    414                         expEqualToDep.prevVidxes, resPrevVidxes);
    415            
    416             Array<size_t> resNextVidxes(resEqualToDep.nextVidxes.size());
    417             // convert to res ssaIdIndices
    418             for (size_t k = 0; k < resEqualToDep.nextVidxes.size(); k++)
    419                 resNextVidxes[k] = revLvIndexCvtTables[r][resEqualToDep.nextVidxes[k]];
    420            
    421             assertArray("testAsmLivenesses", testCaseName + ldname + ".nextVidxes",
    422                         expEqualToDep.nextVidxes, resNextVidxes);
    423         }
    424     }
    425354}
    426355
  • CLRadeonExtender/trunk/tests/amdasm/GCNRegVarUsage.cpp

    r3578 r4032  
    389389        "v_mac_f32  v46, v42, v22\n"
    390390        "v_sub_f32  rex, 87.0, rbx\n"
    391         "v_sub_f32  v46, -61.5, v22\n"
    392         "v_add_f32 v10, srex, s21\n",
     391        "v_sub_f32  v46, -61.5, v22\n",
    393392        {
    394393            // v_sub_f32  rex, rax, rbx
     
    483482            // v_sub_f32  v46, -61.5, v22
    484483            { 116, nullptr, 256+46, 256+47, GCNFIELD_VOP_VDST, ASMRVU_WRITE, 0 },
    485             { 116, nullptr, 256+22, 256+23, GCNFIELD_VOP_VSRC1, ASMRVU_READ, 0 },
    486             // v_add_f32 v10, srex, s21
    487             { 124, nullptr, 266, 267, GCNFIELD_VOP3_VDST, ASMRVU_WRITE, 0 },
    488             { 124, "srex", 0, 1, GCNFIELD_VOP3_SRC0, ASMRVU_READ, 1 },
    489             { 124, nullptr, 21, 22, GCNFIELD_VOP3_SRC1, ASMRVU_READ, 0 }
     484            { 116, nullptr, 256+22, 256+23, GCNFIELD_VOP_VSRC1, ASMRVU_READ, 0 }
    490485        },
    491486        true, ""
     
    15871582        { },
    15881583        false, "test.s:3:1: Error: More than one SGPR to read in instruction\n"
     1584        "test.s:4:1: Error: More than one SGPR to read in instruction\n"
    15891585        "test.s:5:1: Error: More than one SGPR to read in instruction\n"
    15901586        "test.s:6:1: Error: More than one SGPR to read in instruction\n"
Note: See TracChangeset for help on using the changeset viewer.