Changeset 4163 in CLRX


Ignore:
Timestamp:
May 14, 2018, 9:05:43 PM (3 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Fixing createLivenesses for second testcase with recursion. Adapt passing recursion twice in main loop to createLivenesses.
Remov obsolete CallStackEntry2.

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4151 r4163  
    240240    LastAccessMap lastAccessMap;
    241241    std::unordered_set<size_t> haveReturnBlocks;
     242    bool inSecondPass;
    242243};
    243244
     
    263264struct CLRX_INTERNAL FlowStackEntry3
    264265{
    265     size_t blockIndex;
     266    BlockIndex blockIndex;
    266267    size_t nextIndex;
    267268    bool isCall;
     
    283284    size_t callNextIndex; // index of call next
    284285    BlockIndex routineBlock;    // routine block
    285 };
    286 
    287 struct CLRX_INTERNAL CallStackEntry2
    288 {
    289     size_t callBlock; // index
    290     size_t callNextIndex; // index of call next
    291     size_t routineBlock;    // routine block
    292286};
    293287
  • CLRadeonExtender/trunk/amdasm/AsmRegAllocLive.cpp

    r4162 r4163  
    175175    {
    176176        FlowStackEntry3& entry = flowStack.back();
    177         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     177        const CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    178178       
    179179        bool endOfPath = false;
    180180        if (entry.nextIndex == 0)
    181181        {
    182             if (visited.insert(entry.blockIndex).second &&
    183                 haveReturnBlocks.find(entry.blockIndex) != haveReturnBlocks.end())
     182            if (visited.insert(entry.blockIndex.index).second &&
     183                haveReturnBlocks.find(entry.blockIndex.index) != haveReturnBlocks.end())
    184184            {
    185185                auto sinfoIt = cblock.ssaInfoMap.find(svreg);
     
    199199            else
    200200            {
    201                 const bool prevPath = havePathBlocks.find(entry.blockIndex) !=
     201                const bool prevPath = havePathBlocks.find(entry.blockIndex.index) !=
    202202                        havePathBlocks.end();
    203203                flowStack.pop_back();
     
    206206                {
    207207                    flowStack.back().havePath = true;
    208                     havePathBlocks.insert(flowStack.back().blockIndex);
     208                    havePathBlocks.insert(flowStack.back().blockIndex.index);
    209209                }
    210210                continue;
     
    235235            if (endOfPath || cblock.haveReturn)
    236236            {
    237                 havePathBlocks.insert(entry.blockIndex);
     237                havePathBlocks.insert(entry.blockIndex.index);
    238238                // we have path only if have return and if have path
    239239                entry.havePath = true;
     
    257257                lv.insert(cbStart, cbEnd);
    258258                if (cblock.end == cbEnd)
    259                     addVIdxToCallEntry(entry.blockIndex, lvRType, vidx,
     259                    addVIdxToCallEntry(entry.blockIndex.index, lvRType, vidx,
    260260                            codeBlocks, vidxCallMap, vidxRoutineMap);
    261261            }
     
    267267            {
    268268                if (curHavePath)
    269                     havePathBlocks.insert(flowStack.back().blockIndex);
     269                    havePathBlocks.insert(flowStack.back().blockIndex.index);
    270270                flowStack.back().havePath |= curHavePath;
    271271            }
     
    304304    std::stack<JoinEntry> rjStack; // routine join stack
    305305    if (flowStkStart.inSubroutines)
    306         rjStack.push({ flowStack[flowStkStart.stackPos].blockIndex,
     306        rjStack.push({ flowStack[flowStkStart.stackPos].blockIndex.index,
    307307                            0, 0, true, SIZE_MAX, nullptr });
    308308   
     
    365365    if (flitEnd != flowStack.begin())
    366366    {
    367         const CodeBlock& cbLast = codeBlocks[(flitEnd-1)->blockIndex];
     367        const CodeBlock& cbLast = codeBlocks[(flitEnd-1)->blockIndex.index];
    368368        if (lv.contain(cbLast.end-1))
    369369            // if already filled up
     
    374374    // applyVIdx to call entry (if needed, and if some join inside subroutines)
    375375    // resolve this vidx before these call point and if nexts>1
    376     if (flowStkStart.inSubroutines && lv.contain(codeBlocks[flit->blockIndex].end-1) &&
    377         codeBlocks[flit->blockIndex].nexts.size() > 1)
     376    if (flowStkStart.inSubroutines &&
     377        lv.contain(codeBlocks[flit->blockIndex.index].end-1) &&
     378        codeBlocks[flit->blockIndex.index].nexts.size() > 1)
    378379        // just apply, only if join before call
    379         addVIdxToCallEntry(flit->blockIndex, lvRegType, vidx,
     380        addVIdxToCallEntry(flit->blockIndex.index, lvRegType, vidx,
    380381                    codeBlocks, vidxCallMap, vidxRoutineMap);
    381382   
     
    383384        ++flit; // skip this codeblock before call
    384385   
    385     const CodeBlock& lastBlk = codeBlocks[flit->blockIndex];
     386    const CodeBlock& lastBlk = codeBlocks[flit->blockIndex.index];
    386387    if (flit != flitEnd)
    387388    {
     
    392393            if (flit->nextIndex > lastBlk.nexts.size())
    393394                // only if pass this routine
    394                 addVIdxToCallEntry(flit->blockIndex, lvRegType, vidx,
     395                addVIdxToCallEntry(flit->blockIndex.index, lvRegType, vidx,
    395396                        codeBlocks, vidxCallMap, vidxRoutineMap);
    396397            // if begin at some point at last block
     
    403404    for (; flit != flitEnd; ++flit)
    404405    {
    405         const CodeBlock& cblock = codeBlocks[flit->blockIndex];
     406        const CodeBlock& cblock = codeBlocks[flit->blockIndex.index];
    406407        if (flit->nextIndex > cblock.nexts.size())
    407408            // only if pass this routine
    408             addVIdxToCallEntry(flit->blockIndex, lvRegType, vidx, codeBlocks,
     409            addVIdxToCallEntry(flit->blockIndex.index, lvRegType, vidx, codeBlocks,
    409410                        vidxCallMap, vidxRoutineMap);
    410411        lv.insert(cblock.start, cblock.end);
     
    425426{
    426427    ARDOut << "putCrossBlockLv block: " << flowStack.back().blockIndex << "\n";
    427     const CodeBlock& cblock = codeBlocks[flowStack.back().blockIndex];
     428    const CodeBlock& cblock = codeBlocks[flowStack.back().blockIndex.index];
    428429    for (const auto& entry: cblock.ssaInfoMap)
    429430        if (entry.second.readBeforeWrite)
     
    459460    {
    460461        FlowStackEntry3& entry = flowStack.back();
    461         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     462        const CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    462463       
    463464        if (entry.nextIndex == 0)
    464465        {
    465466            // process current block
    466             if (visited.insert(entry.blockIndex).second)
     467            if (visited.insert(entry.blockIndex.index).second)
    467468            {
    468469                ARDOut << "  resolv (cache): " << entry.blockIndex << "\n";
    469470               
    470471                const SVRegMap* resSecondPoints =
    471                             joinSecondPointsCache.use(entry.blockIndex);
     472                            joinSecondPointsCache.use(entry.blockIndex.index);
    472473                if (resSecondPoints == nullptr)
    473474                {
     
    599600        std::vector<Liveness>* livenesses, size_t regTypesNum, const cxuint* regRanges)
    600601{
    601     size_t nextBlock = prevFlowStack.back().blockIndex;
     602    size_t nextBlock = prevFlowStack.back().blockIndex.index;
    602603    auto pfEnd = prevFlowStack.end();
    603604    --pfEnd;
     
    610611        auto pfPrev = pfEnd;
    611612        --pfPrev;
    612         auto it = prevWaysIndexMap.find(pfPrev->blockIndex);
     613        auto it = prevWaysIndexMap.find(pfPrev->blockIndex.index);
    613614        if (it != prevWaysIndexMap.end())
    614615        {
     
    635636    {
    636637        const FlowStackEntry3& entry = *pfit;
    637         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     638        const CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    638639        for (const auto& sentry: cblock.ssaInfoMap)
    639640        {
     
    648649       
    649650        // put to first point cache
    650         if (waysToCache[pfit->blockIndex] &&
    651             !joinFirstPointsCache.hasKey(pfit->blockIndex))
     651        if (waysToCache[pfit->blockIndex.index] &&
     652            !joinFirstPointsCache.hasKey(pfit->blockIndex.index))
    652653        {
    653654            ARDOut << "put pfcache " << pfit->blockIndex << "\n";
    654             joinFirstPointsCache.put(pfit->blockIndex, stackVarMap);
     655            joinFirstPointsCache.put(pfit->blockIndex.index, stackVarMap);
    655656        }
    656657    }
     
    672673    {
    673674        FlowStackEntry3& entry = flowStack.back();
    674         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     675        const CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    675676       
    676677        if (entry.nextIndex == 0)
    677678        {
    678679            // process current block
    679             if (!visited[entry.blockIndex])
    680             {
    681                 visited[entry.blockIndex] = true;
     680            if (!visited[entry.blockIndex.index])
     681            {
     682                visited[entry.blockIndex.index] = true;
    682683                ARDOut << "  lvjoin: " << entry.blockIndex << "\n";
    683684               
    684685                const SVRegMap* joinSecondPoints =
    685                         joinSecondPointsCache.use(entry.blockIndex);
     686                        joinSecondPointsCache.use(entry.blockIndex.index);
    686687               
    687688                if (joinSecondPoints == nullptr)
     
    690691                        const SSAInfo& sinfo = sentry.second;
    691692                        auto res = alreadyReadMap.insert(
    692                                     { sentry.first, entry.blockIndex });
     693                                    { sentry.first, entry.blockIndex.index });
    693694                       
    694695                        if (toCache)
     
    763764                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
    764765                    for (const auto& v: rdata.rbwSSAIdMap)
    765                         alreadyReadMap.insert({v.first, entry.blockIndex });
     766                        alreadyReadMap.insert({v.first, entry.blockIndex.index });
    766767                    for (const auto& v: rdata.lastAccessMap)
    767                         alreadyReadMap.insert({v.first, entry.blockIndex });
     768                        alreadyReadMap.insert({v.first, entry.blockIndex.index });
    768769                }
    769770           
     
    782783                    {
    783784                        auto it = alreadyReadMap.find(v.first);
    784                         if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     785                        if (it != alreadyReadMap.end() &&
     786                            it->second == entry.blockIndex.index)
    785787                            alreadyReadMap.erase(it);
    786788                    }
     
    788790                    {
    789791                        auto it = alreadyReadMap.find(v.first);
    790                         if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     792                        if (it != alreadyReadMap.end() &&
     793                            it->second == entry.blockIndex.index)
    791794                            alreadyReadMap.erase(it);
    792795                    }
     
    796799            {
    797800                auto it = alreadyReadMap.find(sentry.first);
    798                 if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     801                if (it != alreadyReadMap.end() && it->second == entry.blockIndex.index)
    799802                    // remove old to resolve in leaved way to allow collecting next ssaId
    800803                    // before write (can be different due to earlier visit)
     
    804807           
    805808            if (cblocksToCache.count(entry.blockIndex)==2 &&
    806                 !joinSecondPointsCache.hasKey(entry.blockIndex))
     809                !joinSecondPointsCache.hasKey(entry.blockIndex.index))
    807810                // add to cache
    808811                addJoinSecCacheEntry(routineMap, codeBlocks, joinSecondPointsCache,
    809                             entry.blockIndex);
     812                            entry.blockIndex.index);
    810813           
    811814            flowStack.pop_back();
     
    11981201   
    11991202    // construct vreg liveness
    1200     std::deque<CallStackEntry2> callStack;
     1203    std::deque<CallStackEntry> callStack;
    12011204    std::deque<FlowStackEntry3> flowStack;
    1202     std::vector<bool> visited(codeBlocks.size(), false);
     1205    CBlockBitPool visited(codeBlocks.size(), false);
    12031206    // hold last vreg ssaId and position
    12041207    LastVRegMap lastVRegMap;
     
    12101213    std::vector<bool> waysToCache(codeBlocks.size(), false);
    12111214    ResSecondPointsToCache cblocksToCache(codeBlocks.size());
    1212     std::unordered_set<size_t> callBlocks;
     1215    std::unordered_set<BlockIndex> callBlocks;
    12131216    std::unordered_set<size_t> recurseBlocks;
    12141217   
     
    12281231    flowStack.push_back({ 0, 0 });
    12291232   
     1233    bool doNotCreateRoutine = false;
    12301234    while (!flowStack.empty())
    12311235    {
    12321236        FlowStackEntry3& entry = flowStack.back();
    1233         CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1237        CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    12341238       
    12351239        if (entry.nextIndex == 0)
     
    13521356                flowStack.pop_back();
    13531357               
    1354                 size_t curWayBIndex = flowStack.back().blockIndex;
     1358                size_t curWayBIndex = flowStack.back().blockIndex.index;
    13551359                if (lastCommonCacheWayPoint.first != SIZE_MAX)
    13561360                {
     
    13731377        {
    13741378            ARDOut << " ret: " << entry.blockIndex << "\n";
    1375             const size_t routineBlock = callStack.back().routineBlock;
     1379            if (!doNotCreateRoutine)
     1380            {
     1381            const size_t routineBlock = callStack.back().routineBlock.index;
    13761382            auto res = routineMap.insert({ routineBlock, { } });
    13771383           
    1378             if (res.second)
    1379             {
     1384            if (res.second || res.first->second.inSecondPass)
     1385            {
     1386                if (callStack.back().routineBlock.pass==1)
     1387                    res.first->second.inSecondPass = true;
     1388                else
     1389                    res.first->second.inSecondPass = false;
    13801390                auto varRes = vidxRoutineMap.insert({ routineBlock, VIdxSetEntry{} });
    13811391                createRoutineDataLv(codeBlocks, routineMap, recurseBlocks, vidxRoutineMap,
     
    13991409                }
    14001410            }
     1411            callBlocks.erase(routineBlock);
     1412            }
    14011413            callStack.pop_back(); // just return from call
    1402             callBlocks.erase(routineBlock);
    1403         }
     1414        }
     1415       
     1416        doNotCreateRoutine = false;
    14041417       
    14051418        if (entry.nextIndex < cblock.nexts.size())
    14061419        {
    14071420            //bool isCall = false;
    1408             size_t nextBlock = cblock.nexts[entry.nextIndex].block;
     1421            BlockIndex nextBlock = cblock.nexts[entry.nextIndex].block;
     1422            nextBlock.pass = entry.blockIndex.pass;
    14091423            if (cblock.nexts[entry.nextIndex].isCall)
    14101424            {
    1411                 callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
     1425                callStack.push_back({ entry.blockIndex,
     1426                            entry.nextIndex, nextBlock });
    14121427                //isCall = true;
    14131428                if (!callBlocks.insert(nextBlock).second)
    14141429                {
    14151430                    // just skip recursion (is good?)
    1416                     recurseBlocks.insert(nextBlock);
     1431                    if (recurseBlocks.insert(nextBlock.index).second)
     1432                    {
     1433                        ARDOut << "   -- recursion: " << nextBlock << "\n";
     1434                        nextBlock.pass = 1;
     1435                    }
     1436                    else if (entry.blockIndex.pass==1)
     1437                    {
     1438                        doNotCreateRoutine = true;
     1439                        entry.nextIndex++;
     1440                        continue;
     1441                    }
     1442                }
     1443                else if (entry.blockIndex.pass==1 &&
     1444                    recurseBlocks.find(nextBlock.index) != recurseBlocks.end())
     1445                {
     1446                    doNotCreateRoutine = true;
    14171447                    entry.nextIndex++;
    14181448                    continue;
     
    14201450            }
    14211451           
    1422             flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
     1452            flowStack.push_back({ nextBlock, 0 });
    14231453            entry.nextIndex++;
    14241454        }
     
    14361466                    if (next.isCall)
    14371467                    {
    1438                         const RoutineDataLv& rdata = routineMap.find(next.block)->second;
     1468                        /*size_t pass = 0;
     1469                        if (callBlocks.find(next.block) != callBlocks.end())
     1470                        {
     1471                            ARDOut << " is secpass: " << entry.blockIndex << " : " <<
     1472                                    next.block << "\n";
     1473                            pass = 1; // it ways second pass
     1474                        }*/
     1475                       
     1476                        auto rit = routineMap.find(next.block);
     1477                        if (rit == routineMap.end())
     1478                            continue;
     1479                        const RoutineDataLv& rdata = rit->second;
    14391480                        for (const auto& entry: rdata.lastAccessMap)
    14401481                            if (regSVRegs.insert(entry.first).second)
     
    14631504                if (next.isCall)
    14641505                {
    1465                     const RoutineDataLv& rdata = routineMap.find(next.block)->second;
     1506                    auto rit = routineMap.find(next.block);
     1507                    if (rit == routineMap.end())
     1508                        continue;
     1509                    const RoutineDataLv& rdata = rit->second;
    14661510                    for (const auto& entry: rdata.lastAccessMap)
    14671511                        if (revertedSVRegs.insert(entry.first).second)
     
    14731517           
    14741518            if (!flowStack.empty() && lastCommonCacheWayPoint.first != SIZE_MAX &&
    1475                     lastCommonCacheWayPoint.second >= flowStack.size())
     1519                    lastCommonCacheWayPoint.second >= flowStack.size() &&
     1520                    flowStack.back().blockIndex.pass == 0)
    14761521            {
    14771522                lastCommonCacheWayPoint =
    1478                         { flowStack.back().blockIndex, flowStack.size()-1 };
     1523                        { flowStack.back().blockIndex.index, flowStack.size()-1 };
    14791524                ARDOut << "POPlastCcwP: " << lastCommonCacheWayPoint.first << "\n";
    14801525            }
     
    14961541    {
    14971542        FlowStackEntry3& entry = flowStack.back();
    1498         CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1543        CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    14991544       
    15001545        if (entry.nextIndex == 0)
     
    15321577        {
    15331578            if (cblocksToCache.count(entry.blockIndex)==2 &&
    1534                 !joinSecondPointsCache.hasKey(entry.blockIndex))
     1579                !joinSecondPointsCache.hasKey(entry.blockIndex.index))
    15351580                // add to cache
    15361581                addJoinSecCacheEntry(routineMap, codeBlocks, joinSecondPointsCache,
    1537                             entry.blockIndex);
     1582                            entry.blockIndex.index);
    15381583            flowStack.pop_back();
    15391584        }
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4162 r4163  
    26422642        },
    26432643        true, ""
    2644     }
     2644    },
    26452645#if 0
    2646     ,
     2646    {   // 41 - some test
     2647        R"ffDXD(.regvar sa:s:8, va:v:8
     2648        s_mov_b32 sa[2], s4             # 0
     2649        s_mov_b32 sa[3], s4             # 4
     2650        s_mov_b32 sa[4], s5             # 8
     2651        s_mov_b32 sa[5], s6             # 12
     2652        s_mov_b32 sa[6], s7             # 16
     2653       
     2654        .cf_call routine
     2655        s_swappc_b64 s[0:1], s[2:3]     # 20
     2656       
     2657        s_add_u32 sa[2], sa[2], sa[0]   # 24
     2658        s_add_u32 sa[3], sa[3], sa[0]   # 28
     2659        s_add_u32 sa[4], sa[4], sa[1]   # 32
     2660        s_add_u32 sa[5], sa[5], sa[1]   # 36
     2661        s_add_u32 sa[6], sa[6], sa[1]   # 40
     2662        s_endpgm                        # 44
     2663       
     2664routine:
     2665        s_xor_b32 sa[2], sa[2], sa[0]   # 48
     2666        s_xor_b32 sa[3], sa[3], sa[1]   # 52
     2667        s_cbranch_vccnz b0              # 56
     2668       
     2669        .cf_call routine2
     2670        s_swappc_b64 s[0:1], s[2:3]     # 60
     2671       
     2672        s_xor_b32 sa[3], sa[3], sa[1]   # 64
     2673        s_xor_b32 sa[6], sa[6], sa[1]   # 68
     2674        s_xor_b32 sa[5], sa[5], sa[0]   # 72
     2675        .cf_ret
     2676        s_setpc_b64 s[0:1]              # 76
     2677       
     2678b0:     s_xor_b32 sa[3], sa[3], sa[0]   # 80
     2679        s_nop 7                         # 84
     2680        s_xor_b32 sa[6], sa[6], sa[0]   # 88
     2681        .cf_ret
     2682        s_setpc_b64 s[0:1]              # 92
     2683       
     2684routine2:
     2685        s_xor_b32 sa[2], sa[2], sa[0]   # 96
     2686        s_xor_b32 sa[3], sa[3], sa[1]   # 100
     2687        s_cbranch_vccnz b1              # 104
     2688       
     2689        s_xor_b32 sa[3], sa[3], sa[1]   # 108
     2690        s_xor_b32 sa[6], sa[6], sa[1]   # 112
     2691        s_xor_b32 sa[4], sa[4], sa[0]   # 116
     2692        .cf_ret
     2693        s_setpc_b64 s[0:1]              # 120
     2694       
     2695b1:     s_xor_b32 sa[3], sa[3], sa[0]   # 124
     2696        s_xor_b32 sa[2], sa[2], sa[0]   # 128
     2697        s_xor_b32 sa[6], sa[6], sa[0]   # 132
     2698        .cf_ret
     2699        s_setpc_b64 s[0:1]              # 136
     2700)ffDXD",
     2701        {   // liveness
     2702            {   // for SGPRs
     2703                { { 21, 24 }, { 48, 60 }, { 61, 77 },
     2704                    { 80, 93 }, { 96, 140 } }, // 0: S0
     2705                { { 21, 24 }, { 48, 60 }, { 61, 77 },
     2706                    { 80, 93 }, { 96, 140 } }, // 1: S1
     2707                { { 0, 24 }, { 48, 61 } }, // 2: S2
     2708                { { 0, 24 }, { 48, 61 } }, // 3: S3
     2709                { { 0, 5 } }, // 4: S4
     2710                { { 0, 9 } }, // 5: S5
     2711                { { 0, 13 } }, // 6: S6
     2712                { { 0, 17 } }, // 7: S7
     2713                { { 0, 29 }, { 48, 140 } }, // 8: sa[0]'0
     2714                { { 0, 41 }, { 48, 140 } }, // 9: sa[1]'0
     2715                { { 1, 24 }, { 48, 49 } }, // 10: sa[2]'0
     2716                { { 24, 25 }, { 49, 140 } }, // 11: sa[2]'1
     2717                { { 24, 25 }, { 64, 80 }, { 85, 96 }, { 97, 140 } }, // 12: sa[2]'2
     2718                { }, // 14: sa[3]'0
     2719                { }, // 15: sa[3]'1
     2720                { }, // 16: sa[3]'2
     2721                { }, // 17: sa[3]'3
     2722                { }, // 18: sa[3]'4
     2723                { }, // 19: sa[3]'5
     2724                { }, // 20: sa[4]'0
     2725                { }, // 21: sa[4]'1
     2726                { }, // 22: sa[5]'0
     2727                { }, // 23: sa[5]'1
     2728                { }, // 24: sa[6]'0
     2729                { }, // 25: sa[6]'1
     2730                { }, // 26: sa[6]'2
     2731                { }  // 27: sa[6]'3
     2732            }
     2733        },
     2734        { },
     2735        { },
     2736        { },
     2737        true, ""
     2738    },
     2739#endif
    26472740    {   // 41 - second recursion testcase
    26482741        R"ffDXD(.regvar sa:s:8, va:v:8
     
    27152808                { { 0, 29 }, { 48, 144 } }, // 8: sa[0]'0
    27162809                { { 0, 41 }, { 48, 144 } }, // 9: sa[1]'0
    2717                 { { 1, 25 }, { 48, 96 }, { 97, 112 }, { 128, 134 } }, // 10: sa[2]'0
    2718                 { }, // 11: sa[2]'1
    2719                 { }, // 12: sa[2]'2
    2720                 { }, // 13: sa[3]'0
    2721                 { }, // 14: sa[3]'1
    2722                 { }, // 15: sa[3]'2
    2723                 { }, // 16: sa[4]'0
    2724                 { }, // 17: sa[4]'1
    2725                 { }, // 18: sa[5]'0
    2726                 { }, // 19: sa[5]'1
    2727                 { }, // 20: sa[6]'0
    2728                 { }  // 21: sa[6]'1
    2729             },
    2730             { },
    2731             { },
    2732             { }
    2733         },
    2734         { },
    2735         { },
    2736         { },
     2810                //{ { 1, 25 }, { 48, 96 }, { 97, 144 } }, // 10: sa[2]'0
     2811                { { 1, 25 }, { 48, 49 }, { 64, 80 },
     2812                    { 85, 96 }, { 97, 144 } }, // 10: sa[2]'1
     2813                { { 49, 64 }, { 80, 85 }, { 96, 97 } }, // 11: sa[2]'2
     2814                { { 25, 26 } }, // 12: sa[2]'3
     2815                { { 5, 29 }, { 48, 53 }, { 65, 80 },
     2816                    { 81, 96 }, { 101, 113 }, { 128, 129 } }, // 13: sa[3]'0
     2817                { { 53, 65 }, { 80, 81 }, { 96, 101 },
     2818                    { 113, 128 }, { 129, 144 } }, // 14: sa[3]'1
     2819                { { 29, 30 } }, // 15: sa[3]'2
     2820                { { 9, 33 }, { 48, 144 } }, // 16: sa[4]'0
     2821                { { 33, 34 } }, // 17: sa[4]'1
     2822                { { 13, 37 }, { 48, 112 } }, // 18: sa[5]'0 // ???
     2823                { { 37, 38 } }, // 19: sa[5]'1
     2824                { { 17, 41 }, { 48, 144 } }, // 20: sa[6]'0
     2825                { { 41, 42 } }  // 21: sa[6]'1
     2826            },
     2827            { },
     2828            { },
     2829            { }
     2830        },
     2831        { }, // linearDepMaps
     2832        {   // vidxRoutineMap
     2833            { 2, { {
     2834                { 0, 1, 2, 3, 8, 9, 10, 11, 13, 14, 16, 18, 20 },
     2835                { }, { }, { } } } },
     2836            { 6, { {
     2837                { 0, 1, 2, 3, 8, 9, 10, 11, 13, 14, 16, 20 },
     2838                { }, { }, { } } } }
     2839        },
     2840        {   // vidxCallMap
     2841            { 3, { { { 18 }, { }, { }, { } } } },
     2842            { 7, { { { }, { }, { }, { } } } }
     2843        },
    27372844        true, ""
    27382845    }
    2739 #endif
    27402846};
    27412847
Note: See TracChangeset for help on using the changeset viewer.