Changeset 4124 in CLRX


Ignore:
Timestamp:
May 9, 2018, 12:11:25 PM (2 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Rename VVars, lvIndices and ssaIdIndices to VIdx(es).

Location:
CLRadeonExtender/trunk
Files:
4 edited

Legend:

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

    r4117 r4124  
    356356    };
    357357   
    358     struct VVarSetEntry
    359     {
    360         std::unordered_set<size_t> vvars[MAX_REGTYPES_NUM];
     358    struct VIdxSetEntry
     359    {
     360        std::unordered_set<size_t> vs[MAX_REGTYPES_NUM];
    361361    };
    362362private:
     
    373373    std::unordered_map<size_t, LinearDep> linearDepMaps[MAX_REGTYPES_NUM];
    374374    // key - routine block, value - set of svvregs (lv indexes) used in routine
    375     std::unordered_map<size_t, VVarSetEntry> varRoutineMap;
     375    std::unordered_map<size_t, VIdxSetEntry> vidxRoutineMap;
    376376    // key - call block, value - set of svvregs (lv indexes) used between this call point
    377     std::unordered_map<size_t, VVarSetEntry> varCallMap;
     377    std::unordered_map<size_t, VIdxSetEntry> vidxCallMap;
    378378   
    379379public:
     
    406406    { return vregIndexMaps; }
    407407   
    408     const std::unordered_map<size_t, VVarSetEntry>& getVarRoutineMap() const
    409     { return varRoutineMap; }
    410     const std::unordered_map<size_t, VVarSetEntry>& getVarCallMap() const
    411     { return varCallMap; }
     408    const std::unordered_map<size_t, VIdxSetEntry>& getVIdxRoutineMap() const
     409    { return vidxRoutineMap; }
     410    const std::unordered_map<size_t, VIdxSetEntry>& getVIdxCallMap() const
     411    { return vidxCallMap; }
    412412};
    413413
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r4121 r4124  
    702702}
    703703
    704 static void getLivenessIndex(const AsmSingleVReg& svreg, size_t ssaIdIdx,
     704static void getVIdx(const AsmSingleVReg& svreg, size_t ssaIdIdx,
    705705        const AsmRegAllocator::SSAInfo& ssaInfo,
    706706        const VarIndexMap* vregIndexMaps, size_t regTypesNum, const cxuint* regRanges,
    707         cxuint& regType, size_t& lvIndex)
     707        cxuint& regType, size_t& vidx)
    708708{
    709709    size_t ssaId;
     
    721721    regType = getRegType(regTypesNum, regRanges, svreg); // regtype
    722722    const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    723     const std::vector<size_t>& ssaIdIndices = vregIndexMap.find(svreg)->second;
    724     /*ARDOut << "lvn[" << regType << "][" << ssaIdIndices[ssaId] << "]. ssaIdIdx: " <<
     723    const std::vector<size_t>& vidxes = vregIndexMap.find(svreg)->second;
     724    /*ARDOut << "lvn[" << regType << "][" << vidxes[ssaId] << "]. ssaIdIdx: " <<
    725725            ssaIdIdx << ". ssaId: " << ssaId << ". svreg: " << svreg.regVar << ":" <<
    726726            svreg.index << "\n";*/
    727727    //return livenesses[regType][ssaIdIndices[ssaId]];
    728     lvIndex = ssaIdIndices[ssaId];
     728    vidx = vidxes[ssaId];
    729729}
    730730
     
    734734{
    735735    cxuint regType;
    736     size_t lvIndex;
    737     getLivenessIndex(svreg, ssaIdIdx, ssaInfo, vregIndexMaps, regTypesNum, regRanges,
    738             regType, lvIndex);
    739     return livenesses[regType][lvIndex];
    740 }
    741 
    742 static void getLiveness2Index(const AsmSingleVReg& svreg, size_t ssaId,
     736    size_t vidx;
     737    getVIdx(svreg, ssaIdIdx, ssaInfo, vregIndexMaps, regTypesNum, regRanges,
     738            regType, vidx);
     739    return livenesses[regType][vidx];
     740}
     741
     742static void getVIdx2(const AsmSingleVReg& svreg, size_t ssaId,
    743743        const VarIndexMap* vregIndexMaps, size_t regTypesNum, const cxuint* regRanges,
    744         cxuint& regType, size_t& lvIndex)
     744        cxuint& regType, size_t& vidx)
    745745{
    746746    regType = getRegType(regTypesNum, regRanges, svreg); // regtype
    747747    const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    748     const std::vector<size_t>& ssaIdIndices = vregIndexMap.find(svreg)->second;
    749     /*ARDOut << "lvn[" << regType << "][" << ssaIdIndices[ssaId] << "]. ssaId: " <<
     748    const std::vector<size_t>& vidxes = vregIndexMap.find(svreg)->second;
     749    /*ARDOut << "lvn[" << regType << "][" << vidxes[ssaId] << "]. ssaId: " <<
    750750            ssaId << ". svreg: " << svreg.regVar << ":" << svreg.index << "\n";*/
    751     lvIndex = ssaIdIndices[ssaId];
    752 }
    753 
    754 
    755 static void addVVRegsToCallEntry(size_t blockIndex, cxuint regType, size_t lvIndex,
     751    vidx = vidxes[ssaId];
     752}
     753
     754
     755static void addVIdxToCallEntry(size_t blockIndex, cxuint regType, size_t vidx,
    756756            const std::vector<CodeBlock>& codeBlocks,
    757             std::unordered_map<size_t, VVarSetEntry>& varCallMap,
    758             const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap)
     757            std::unordered_map<size_t, VIdxSetEntry>& vidxCallMap,
     758            const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap)
    759759{
    760760    const CodeBlock& cblock = codeBlocks[blockIndex];
    761761    if (cblock.haveCalls)
    762762    {
    763         VVarSetEntry& varCallEntry = varCallMap[blockIndex];
     763        VIdxSetEntry& varCallEntry = vidxCallMap[blockIndex];
    764764        for (const NextBlock& next: cblock.nexts)
    765765            if (next.isCall)
    766766            {
    767                 const auto& allLvs = varRoutineMap.find(next.block)->second;
    768                 if (allLvs.vvars[regType].find(lvIndex) == allLvs.vvars[regType].end())
     767                const auto& allLvs = vidxRoutineMap.find(next.block)->second;
     768                if (allLvs.vs[regType].find(vidx) == allLvs.vs[regType].end())
    769769                    // add callLiveTime only if vreg not present in routine
    770                     varCallEntry.vvars[regType].insert(lvIndex);
     770                    varCallEntry.vs[regType].insert(vidx);
    771771            }
    772772    }
     
    775775static void fillUpInsideRoutine(std::vector<bool>& visited,
    776776            const std::vector<CodeBlock>& codeBlocks,
    777             std::unordered_map<size_t, VVarSetEntry>& varCallMap,
    778             const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap,
     777            std::unordered_map<size_t, VIdxSetEntry>& vidxCallMap,
     778            const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
    779779            size_t startBlock, const AsmSingleVReg& svreg, Liveness& lv,
    780             cxuint lvRType /* lv register type */, size_t lvIndex)
     780            cxuint lvRType /* lv register type */, size_t vidx)
    781781{
    782782    std::deque<FlowStackEntry3> flowStack;
     
    808808                lv.insert(cbStart, cblock.end);
    809809               
    810                 addVVRegsToCallEntry(entry.blockIndex, lvRType, lvIndex,
    811                         codeBlocks, varCallMap, varRoutineMap);
     810                addVIdxToCallEntry(entry.blockIndex, lvRType, vidx,
     811                        codeBlocks, vidxCallMap, vidxRoutineMap);
    812812            }
    813813            else
     
    838838static void joinVRegRecur(const std::deque<FlowStackEntry3>& flowStack,
    839839            const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    840             std::unordered_map<size_t, VVarSetEntry>& varCallMap,
    841             const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap,
     840            std::unordered_map<size_t, VIdxSetEntry>& vidxCallMap,
     841            const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
    842842            LastVRegStackPos flowStkStart, const AsmSingleVReg& svreg, size_t ssaId,
    843843            const VarIndexMap* vregIndexMaps, std::vector<Liveness>* livenesses,
     
    856856        --flitEnd; // before last element
    857857    cxuint lvRegType;
    858     size_t lvIndex;
    859     getLiveness2Index(svreg, ssaId, vregIndexMaps, regTypesNum, regRanges,
    860                       lvRegType, lvIndex);
    861     Liveness& lv = livenesses[lvRegType][lvIndex];
     858    size_t vidx;
     859    getVIdx2(svreg, ssaId, vregIndexMaps, regTypesNum, regRanges, lvRegType, vidx);
     860    Liveness& lv = livenesses[lvRegType][vidx];
    862861   
    863862    if (flitEnd != flowStack.begin())
     
    922921             * (that with subroutines calls) will be skipped */
    923922            if (rjStack.size() > 1)
    924                 fillUpInsideRoutine(visited, codeBlocks, varCallMap, varRoutineMap,
     923                fillUpInsideRoutine(visited, codeBlocks, vidxCallMap, vidxRoutineMap,
    925924                        entry.blockIndex + (entry.inSubroutines), svreg,
    926                         lv, lvRegType, lvIndex);
     925                        lv, lvRegType, vidx);
    927926            rjStack.pop();
    928927        }
     
    940939            if (flit->nextIndex > lastBlk.nexts.size())
    941940                // only if pass this routine
    942                 addVVRegsToCallEntry(flit->blockIndex, lvRegType, lvIndex,
    943                         codeBlocks, varCallMap, varRoutineMap);
     941                addVIdxToCallEntry(flit->blockIndex, lvRegType, vidx,
     942                        codeBlocks, vidxCallMap, vidxRoutineMap);
    944943            // if begin at some point at last block
    945944            lastPos = sinfoIt->second.lastPos;
     
    954953        if (flit->nextIndex > cblock.nexts.size())
    955954            // only if pass this routine
    956             addVVRegsToCallEntry(flit->blockIndex, lvRegType, lvIndex, codeBlocks,
    957                         varCallMap, varRoutineMap);
     955            addVIdxToCallEntry(flit->blockIndex, lvRegType, vidx, codeBlocks,
     956                        vidxCallMap, vidxRoutineMap);
    958957        lv.insert(cblock.start, cblock.end);
    959958    }
     
    967966static void putCrossBlockLivenesses(const std::deque<FlowStackEntry3>& flowStack,
    968967        const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    969         std::unordered_map<size_t, VVarSetEntry>& varCallMap,
    970         const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap,
     968        std::unordered_map<size_t, VIdxSetEntry>& vidxCallMap,
     969        const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
    971970        const LastVRegMap& lastVRegMap, std::vector<Liveness>* livenesses,
    972971        const VarIndexMap* vregIndexMaps, size_t regTypesNum, const cxuint* regRanges)
     
    982981                lvrit->second.back() : LastVRegStackPos{ 0, false };
    983982           
    984             joinVRegRecur(flowStack, codeBlocks, routineMap, varCallMap, varRoutineMap,
     983            joinVRegRecur(flowStack, codeBlocks, routineMap, vidxCallMap, vidxRoutineMap,
    985984                    flowStackStart, entry.first, entry.second.ssaIdBefore,
    986985                    vregIndexMaps, livenesses, regTypesNum, regRanges, true);
     
    11391138static void joinRegVarLivenesses(const std::deque<FlowStackEntry3>& prevFlowStack,
    11401139        const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    1141         std::unordered_map<size_t, VVarSetEntry>& varCallMap,
    1142         const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap,
     1140        std::unordered_map<size_t, VIdxSetEntry>& vidxCallMap,
     1141        const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
    11431142        const PrevWaysIndexMap& prevWaysIndexMap,
    11441143        const std::vector<bool>& waysToCache, ResSecondPointsToCache& cblocksToCache,
     
    12511250                           
    12521251                            joinVRegRecur(prevFlowStack, codeBlocks, routineMap,
    1253                                 varCallMap, varRoutineMap,
     1252                                vidxCallMap, vidxRoutineMap,
    12541253                                stackPos, sentry.first, sentry.second.ssaIdBefore,
    12551254                                vregIndexMaps, livenesses, regTypesNum, regRanges, true);
     
    12751274                           
    12761275                            joinVRegRecur(prevFlowStack, codeBlocks, routineMap,
    1277                                 varCallMap, varRoutineMap,
     1276                                vidxCallMap, vidxRoutineMap,
    12781277                                stackPos, rsentry.first, rsentry.second, vregIndexMaps,
    12791278                                livenesses, regTypesNum, regRanges, true);
     
    14391438}
    14401439
    1441 static void joinRoutineDataLv(RoutineDataLv& dest, VVarSetEntry& destVars,
     1440static void joinRoutineDataLv(RoutineDataLv& dest, VIdxSetEntry& destVars,
    14421441            RoutineCurAccessMap& curSVRegMap, FlowStackEntry4& entry,
    1443             const RoutineDataLv& src, const VVarSetEntry& srcVars)
     1442            const RoutineDataLv& src, const VIdxSetEntry& srcVars)
    14441443{
    14451444    dest.rbwSSAIdMap.insert(src.rbwSSAIdMap.begin(), src.rbwSSAIdMap.end());
    14461445    for (size_t i = 0; i < MAX_REGTYPES_NUM; i++)
    1447         destVars.vvars[i].insert(srcVars.vvars[i].begin(), srcVars.vvars[i].end());
     1446        destVars.vs[i].insert(srcVars.vs[i].begin(), srcVars.vs[i].end());
    14481447   
    14491448    // join source lastAccessMap with curSVRegMap
     
    14671466static void createRoutineDataLv(const std::vector<CodeBlock>& codeBlocks,
    14681467        const RoutineLvMap& routineMap,
    1469         const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap,
    1470         RoutineDataLv& rdata, VVarSetEntry& routineVars,
     1468        const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
     1469        RoutineDataLv& rdata, VIdxSetEntry& routineVIdxes,
    14711470        size_t routineBlock, const VarIndexMap* vregIndexMaps,
    14721471        size_t regTypesNum, const cxuint* regRanges)
     
    15181517                    cxuint regType = getRegType(regTypesNum, regRanges, svreg);
    15191518                    const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    1520                     const std::vector<size_t>& ssaIdIndices =
     1519                    const std::vector<size_t>& vidxes =
    15211520                                vregIndexMap.find(svreg)->second;
    15221521                   
    15231522                    // add SSA indices to allSSAs
    15241523                    if (sinfo.readBeforeWrite)
    1525                         routineVars.vvars[regType].insert(ssaIdIndices[sinfo.ssaIdBefore]);
     1524                        routineVIdxes.vs[regType].insert(vidxes[sinfo.ssaIdBefore]);
    15261525                    if (sinfo.ssaIdChange != 0)
    15271526                    {
    1528                         routineVars.vvars[regType].insert(ssaIdIndices[sinfo.ssaIdFirst]);
     1527                        routineVIdxes.vs[regType].insert(vidxes[sinfo.ssaIdFirst]);
    15291528                        for (size_t i = 1; i < sinfo.ssaIdChange; i++)
    1530                             routineVars.vvars[regType].insert(ssaIdIndices[sinfo.ssaId+i]);
    1531                         routineVars.vvars[regType].insert(ssaIdIndices[sinfo.ssaIdLast]);
     1529                            routineVIdxes.vs[regType].insert(vidxes[sinfo.ssaId+i]);
     1530                        routineVIdxes.vs[regType].insert(vidxes[sinfo.ssaIdLast]);
    15321531                    }
    15331532                }
     
    15521551           
    15531552            for (size_t srcRoutBlock: calledRoutines)
    1554                 joinRoutineDataLv(rdata, routineVars, curSVRegMap, entry,
     1553                joinRoutineDataLv(rdata, routineVIdxes, curSVRegMap, entry,
    15551554                        routineMap.find(srcRoutBlock)->second,
    1556                         varRoutineMap.find(srcRoutBlock)->second);
     1555                        vidxRoutineMap.find(srcRoutBlock)->second);
    15571556        }
    15581557       
     
    16391638            VarIndexMap& vregIndices = vregIndexMaps[regType];
    16401639            size_t& graphVregsCount = graphVregsCounts[regType];
    1641             std::vector<size_t>& ssaIdIndices = vregIndices[entry.first];
     1640            std::vector<size_t>& vidxes = vregIndices[entry.first];
    16421641            size_t ssaIdCount = 0;
    16431642            if (sinfo.readBeforeWrite)
     
    16541653                ssaIdCount = 1;
    16551654           
    1656             if (ssaIdIndices.size() < ssaIdCount)
    1657                 ssaIdIndices.resize(ssaIdCount, SIZE_MAX);
    1658            
    1659             // set liveness index to ssaIdIndices
     1655            if (vidxes.size() < ssaIdCount)
     1656                vidxes.resize(ssaIdCount, SIZE_MAX);
     1657           
     1658            // set liveness index to vidxes
    16601659            if (sinfo.readBeforeWrite)
    16611660            {
    1662                 if (ssaIdIndices[sinfo.ssaIdBefore] == SIZE_MAX)
    1663                     ssaIdIndices[sinfo.ssaIdBefore] = graphVregsCount++;
     1661                if (vidxes[sinfo.ssaIdBefore] == SIZE_MAX)
     1662                    vidxes[sinfo.ssaIdBefore] = graphVregsCount++;
    16641663            }
    16651664            if (sinfo.ssaIdChange!=0)
    16661665            {
    1667                 // fill up ssaIdIndices (with graph Ids)
    1668                 if (ssaIdIndices[sinfo.ssaIdFirst] == SIZE_MAX)
    1669                     ssaIdIndices[sinfo.ssaIdFirst] = graphVregsCount++;
     1666                // fill up vidxes (with graph Ids)
     1667                if (vidxes[sinfo.ssaIdFirst] == SIZE_MAX)
     1668                    vidxes[sinfo.ssaIdFirst] = graphVregsCount++;
    16701669                for (size_t ssaId = sinfo.ssaId+1;
    16711670                        ssaId < sinfo.ssaId+sinfo.ssaIdChange-1; ssaId++)
    1672                     ssaIdIndices[ssaId] = graphVregsCount++;
    1673                 if (ssaIdIndices[sinfo.ssaIdLast] == SIZE_MAX)
    1674                     ssaIdIndices[sinfo.ssaIdLast] = graphVregsCount++;
     1671                    vidxes[ssaId] = graphVregsCount++;
     1672                if (vidxes[sinfo.ssaIdLast] == SIZE_MAX)
     1673                    vidxes[sinfo.ssaIdLast] = graphVregsCount++;
    16751674            }
    16761675            // if not readBeforeWrite and neither ssaIdChanges but it is write to
    16771676            // normal register
    1678             if (entry.first.regVar==nullptr && ssaIdIndices[0] == SIZE_MAX)
    1679                 ssaIdIndices[0] = graphVregsCount++;
     1677            if (entry.first.regVar==nullptr && vidxes[0] == SIZE_MAX)
     1678                vidxes[0] = graphVregsCount++;
    16801679        }
    16811680   
     
    17241723                if (flowStack.size() > 1)
    17251724                    putCrossBlockLivenesses(flowStack, codeBlocks, routineMap,
    1726                             varCallMap, varRoutineMap, lastVRegMap,
     1725                            vidxCallMap, vidxRoutineMap, lastVRegMap,
    17271726                            livenesses, vregIndexMaps, regTypesNum, regRanges);
    17281727                // update last vreg position
     
    18591858            if (res.second)
    18601859            {
    1861                 auto varRes = varRoutineMap.insert({ routineBlock, VVarSetEntry{} });
    1862                 createRoutineDataLv(codeBlocks, routineMap, varRoutineMap,
     1860                auto varRes = vidxRoutineMap.insert({ routineBlock, VIdxSetEntry{} });
     1861                createRoutineDataLv(codeBlocks, routineMap, vidxRoutineMap,
    18631862                        res.first->second, varRes.first->second,
    18641863                        routineBlock, vregIndexMaps, regTypesNum, regRanges);
     
    18751874                   
    18761875                    joinVRegRecur(flowStack, codeBlocks, routineMap,
    1877                             varCallMap, varRoutineMap,
     1876                                  vidxCallMap, vidxRoutineMap,
    18781877                            flowStackStart, entry.first, entry.second, vregIndexMaps,
    18791878                            livenesses, regTypesNum, regRanges, false);
     
    19791978            {
    19801979                joinRegVarLivenesses(flowStack, codeBlocks, routineMap,
    1981                         varCallMap, varRoutineMap,
     1980                        vidxCallMap, vidxRoutineMap,
    19821981                        prevWaysIndexMap, waysToCache, cblocksToCache,
    19831982                        joinFirstPointsCache, joinSecondPointsCache,
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4120 r4124  
    3838#define ASMREGALLOC_DEBUGDUMP 0
    3939
     40/* svreg - single regvar register
     41 * ssaId - SSA id for svreg
     42 * vidx - virtual variable index, refer to some ssaId for some svreg
     43 */
     44
    4045namespace CLRX
    4146{
     
    4550typedef AsmRegAllocator::SSAInfo SSAInfo;
    4651typedef std::pair<const AsmSingleVReg, SSAInfo> SSAEntry;
    47 typedef AsmRegAllocator::VVarSetEntry VVarSetEntry;
     52typedef AsmRegAllocator::VIdxSetEntry VIdxSetEntry;
    4853
    4954//  BlockIndex
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4123 r4124  
    3737typedef AsmRegAllocator::LinearDep LinearDep;
    3838typedef AsmRegAllocator::VarIndexMap VarIndexMap;
    39 typedef AsmRegAllocator::VVarSetEntry VVarSetEntry;
     39typedef AsmRegAllocator::VIdxSetEntry VIdxSetEntry;
    4040
    4141struct LinearDep2
     
    4646};
    4747
    48 struct VVarSetEntry2
     48struct VIdxSetEntry2
    4949{
    50     Array<size_t> vvars[4];
     50    Array<size_t> vs[4];
    5151};
    5252
     
    5656    Array<OutLiveness> livenesses[MAX_REGTYPES_NUM];
    5757    Array<std::pair<size_t, LinearDep2> > linearDepMaps[MAX_REGTYPES_NUM];
    58     Array<std::pair<size_t, VVarSetEntry2> > varRoutineMap;
    59     Array<std::pair<size_t, VVarSetEntry2> > varCallMap;
     58    Array<std::pair<size_t, VIdxSetEntry2> > vidxRoutineMap;
     59    Array<std::pair<size_t, VIdxSetEntry2> > vidxCallMap;
    6060    bool good;
    6161    const char* errorMessages;
     
    8686        },
    8787        { },  // linearDepMaps
    88         { },  // varRoutineMap
    89         { },  // varCallMap
     88        { },  // vidxRoutineMap
     89        { },  // vidxCallMap
    9090        true, ""
    9191    },
     
    113113        },
    114114        { },  // linearDepMaps
    115         { },  // varRoutineMap
    116         { },  // varCallMap
     115        { },  // vidxRoutineMap
     116        { },  // vidxCallMap
    117117        true, ""
    118118    },
     
    185185            { }
    186186        },
    187         { },  // varRoutineMap
    188         { },  // varCallMap
     187        { },  // vidxRoutineMap
     188        { },  // vidxCallMap
    189189        true, ""
    190190    },
     
    225225        },
    226226        { }, // linearDepMaps
    227         { },  // varRoutineMap
    228         { },  // varCallMap
     227        { },  // vidxRoutineMap
     228        { },  // vidxCallMap
    229229        true, ""
    230230    },
     
    276276        },
    277277        { }, // linearDepMaps
    278         { },  // varRoutineMap
    279         { },  // varCallMap
     278        { },  // vidxRoutineMap
     279        { },  // vidxCallMap
    280280        true, ""
    281281    },
     
    332332            { }
    333333        },
    334         { },  // varRoutineMap
    335         { },  // varCallMap
     334        { },  // vidxRoutineMap
     335        { },  // vidxCallMap
    336336        true, ""
    337337    },
     
    412412            { }
    413413        },
    414         { },  // varRoutineMap
    415         { },  // varCallMap
     414        { },  // vidxRoutineMap
     415        { },  // vidxCallMap
    416416        true, ""
    417417    },
     
    521521        },
    522522        { },  // linearDepMaps
    523         { },  // varRoutineMap
    524         { },  // varCallMap
     523        { },  // vidxRoutineMap
     524        { },  // vidxCallMap
    525525        true, ""
    526526    },
     
    596596        },
    597597        { },  // linearDepMaps
    598         { },  // varRoutineMap
    599         { },  // varCallMap
     598        { },  // vidxRoutineMap
     599        { },  // vidxCallMap
    600600        true, ""
    601601    },
     
    640640        },
    641641        { },  // linearDepMaps
    642         { },  // varRoutineMap
    643         { },  // varCallMap
     642        { },  // vidxRoutineMap
     643        { },  // vidxCallMap
    644644        true, ""
    645645    },
     
    698698        },
    699699        { },  // linearDepMaps
    700         { },  // varRoutineMap
    701         { },  // varCallMap
     700        { },  // vidxRoutineMap
     701        { },  // vidxCallMap
    702702        true, ""
    703703    },
     
    754754        },
    755755        { },  // linearDepMaps
    756         { },  // varRoutineMap
    757         { },  // varCallMap
     756        { },  // vidxRoutineMap
     757        { },  // vidxCallMap
    758758        true, ""
    759759    },
     
    782782        },
    783783        { },  // linearDepMaps
    784         { },  // varRoutineMap
    785         { },  // varCallMap
     784        { },  // vidxRoutineMap
     785        { },  // vidxCallMap
    786786        true, ""
    787787    },
     
    811811        },
    812812        { },  // linearDepMaps
    813         { },  // varRoutineMap
    814         { },  // varCallMap
     813        { },  // vidxRoutineMap
     814        { },  // vidxCallMap
    815815        true, ""
    816816    },
     
    904904            { }
    905905        },
    906         { },  // varRoutineMap
    907         { },  // varCallMap
     906        { },  // vidxRoutineMap
     907        { },  // vidxCallMap
    908908        true, ""
    909909    },
     
    938938        },
    939939        { },  // linearDepMaps
    940         { },  // varRoutineMap
    941         { },  // varCallMap
     940        { },  // vidxRoutineMap
     941        { },  // vidxCallMap
    942942        true, ""
    943943    },
     
    970970        },
    971971        { },  // linearDepMaps
    972         { },  // varRoutineMap
    973         { },  // varCallMap
     972        { },  // vidxRoutineMap
     973        { },  // vidxCallMap
    974974        true, ""
    975975    },
     
    10161016        },
    10171017        { }, //
    1018         {   // varRoutineMap
     1018        {   // vidxRoutineMap
    10191019            { 2, { { { 0, 1, 6, 7, 9, 10, 12 }, { }, { }, { } } } }
    10201020        },
    1021         { },  // varCallMap
     1021        { },  // vidxCallMap
    10221022        true, ""
    10231023    },
     
    10791079        },
    10801080        { },
    1081         {   // varRoutineMap
     1081        {   // vidxRoutineMap
    10821082            { 2, { { { 0, 1, 6, 7, 8, 10, 11, 12, 14 }, { }, { }, { } } } }
    10831083        },
    1084         {   // varCallMap
     1084        {   // vidxCallMap
    10851085            { 0, { { { 15 }, { }, { }, { } } } }
    10861086        },
     
    11381138        },
    11391139        { },
    1140         {   // varRoutineMap
     1140        {   // vidxRoutineMap
    11411141            { 2, { { { 0, 1, 6, 7, 8, 10, 12 }, { }, { }, { } } } }
    11421142        },
    1143         {   // varCallMap
     1143        {   // vidxCallMap
    11441144            { 0, { { { 13 }, { }, { }, { } } } }
    11451145        },
     
    11601160}
    11611161
    1162 static void checkVVarSetEntries(const std::string& testCaseName, const char* vvarSetName,
    1163         const Array<std::pair<size_t, VVarSetEntry2> >& expVarRoutineMap,
    1164         const std::unordered_map<size_t,VVarSetEntry>& varRoutineMap,
     1162static void checkVIdxSetEntries(const std::string& testCaseName, const char* vvarSetName,
     1163        const Array<std::pair<size_t, VIdxSetEntry2> >& expVIdxRoutineMap,
     1164        const std::unordered_map<size_t,VIdxSetEntry>& vidxRoutineMap,
    11651165        const std::vector<size_t>* revLvIndexCvtTables)
    11661166{
    11671167    assertValue("testAsmLivenesses", testCaseName + vvarSetName + ".size",
    1168             varRoutineMap.size(), expVarRoutineMap.size());
     1168            vidxRoutineMap.size(), expVIdxRoutineMap.size());
    11691169   
    1170     for (size_t j = 0; j < varRoutineMap.size(); j++)
     1170    for (size_t j = 0; j < vidxRoutineMap.size(); j++)
    11711171    {
    11721172        std::ostringstream vOss;
     
    11751175        std::string vcname(vOss.str());
    11761176       
    1177         auto vcit = varRoutineMap.find(expVarRoutineMap[j].first);
     1177        auto vcit = vidxRoutineMap.find(expVIdxRoutineMap[j].first);
    11781178        std::ostringstream kOss;
    1179         kOss << expVarRoutineMap[j].first;
     1179        kOss << expVIdxRoutineMap[j].first;
    11801180        kOss.flush();
    11811181        assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
    1182                     vcit != varRoutineMap.end());
    1183        
    1184         const Array<size_t>* expEntry = expVarRoutineMap[j].second.vvars;
    1185         const VVarSetEntry& resEntry = vcit->second;
     1182                    vcit != vidxRoutineMap.end());
     1183       
     1184        const Array<size_t>* expEntry = expVIdxRoutineMap[j].second.vs;
     1185        const VIdxSetEntry& resEntry = vcit->second;
    11861186        for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
    11871187        {
     
    11921192           
    11931193            assertValue("testAsmLivenesses", testCaseName + vsname +".size",
    1194                     expEntry[r].size(), resEntry.vvars[r].size());
     1194                    expEntry[r].size(), resEntry.vs[r].size());
    11951195           
    11961196            std::vector<size_t> resVVars;
    1197             std::transform(resEntry.vvars[r].begin(), resEntry.vvars[r].end(),
     1197            std::transform(resEntry.vs[r].begin(), resEntry.vs[r].end(),
    11981198                    std::back_inserter(resVVars),
    11991199                    [&r,&revLvIndexCvtTables](size_t v)
     
    13691369    }
    13701370   
    1371     // checking varRoutineMap
    1372     checkVVarSetEntries(testCaseName, "varRoutineMap", testCase.varRoutineMap,
    1373                 regAlloc.getVarRoutineMap(), revLvIndexCvtTables);
     1371    // checking vidxRoutineMap
     1372    checkVIdxSetEntries(testCaseName, "vidxRoutineMap", testCase.vidxRoutineMap,
     1373                regAlloc.getVIdxRoutineMap(), revLvIndexCvtTables);
    13741374   
    1375     // checking varCallMap
    1376     checkVVarSetEntries(testCaseName, "varCallMap", testCase.varCallMap,
    1377                 regAlloc.getVarCallMap(), revLvIndexCvtTables);
     1375    // checking vidxCallMap
     1376    checkVIdxSetEntries(testCaseName, "vidxCallMap", testCase.vidxCallMap,
     1377                regAlloc.getVIdxCallMap(), revLvIndexCvtTables);
    13781378}
    13791379
Note: See TracChangeset for help on using the changeset viewer.