Changeset 3992 in CLRX


Ignore:
Timestamp:
Apr 13, 2018, 12:19:31 PM (6 days ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Some small changes in debugdump messages. Allow to enable/disable debugdump from source code.

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

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

    r3991 r3992  
    2222
    2323#include <CLRX/Config.h>
     24#include <iostream>
    2425#include <vector>
    2526#include <utility>
     
    3435using namespace CLRX;
    3536
     37#define ASMREGALLOC_DEBUGDUMP 0
     38
    3639namespace CLRX
    3740{
     
    207210typedef std::unordered_map<BlockIndex, RoutineData> RoutineMap;
    208211
    209 };
    210 
     212#if ASMREGALLOC_DEBUGDUMP
     213#define ARDOut std::cout
     214#else
     215struct NoOutput
     216{
     217    template<typename T>
     218    NoOutput& operator<<(const T& v)
     219    { return *this; }
     220};
     221
     222#define ARDOut NoOutput()
    211223#endif
     224
     225};
     226
     227#endif
  • CLRadeonExtender/trunk/amdasm/AsmRegAllocSSAData.cpp

    r3991 r3992  
    6666              size_t origId, size_t destId)
    6767{
     68    ARDOut << "  insertreplace: " << vreg.regVar << ":" << vreg.index  << ": " <<
     69                origId << ", " << destId << "\n";
    6870    auto res = rmap.insert({ vreg, {} });
    6971    res.first->second.insertValue({ origId, destId });
     
    110112                {
    111113                    if (ssaId > sinfo.ssaIdBefore)
    112                     {
    113                         std::cout << "  insertreplace: " << sentry.first.regVar << ":" <<
    114                             sentry.first.index  << ": " <<
    115                             ssaId << ", " << sinfo.ssaIdBefore << std::endl;
    116114                        insertReplace(*replacesMap, sentry.first, ssaId,
    117115                                    sinfo.ssaIdBefore);
    118                     }
    119116                    else if (ssaId < sinfo.ssaIdBefore)
    120                     {
    121                         std::cout << "  insertreplace2: " << sentry.first.regVar << ":" <<
    122                             sentry.first.index  << ": " <<
    123                             ssaId << ", " << sinfo.ssaIdBefore << std::endl;
    124117                        insertReplace(*replacesMap, sentry.first,
    125118                                        sinfo.ssaIdBefore, ssaId);
    126                     }
    127                     /*else
    128                         std::cout << "  noinsertreplace: " <<
    129                             ssaId << "," << sinfo.ssaIdBefore << std::endl;*/
    130119                }
    131120            }
     
    144133        RBWSSAIdMap* destCacheSecPoints)
    145134{
    146     std::cout << "use resSecPointCache for " << nextBlock <<
    147             ", alreadyRMapSize: " << alreadyReadMap.size() << std::endl;
     135    ARDOut << "use resSecPointCache for " << nextBlock <<
     136            ", alreadyRMapSize: " << alreadyReadMap.size() << "\n";
    148137    for (const auto& sentry: *resSecondPoints)
    149138    {
     
    169158                    {
    170159                        if (ssaId > secSSAId)
    171                         {
    172                             std::cout << "  insertreplace: " <<
    173                                 sentry.first.regVar << ":" <<
    174                                 sentry.first.index  << ": " <<
    175                                 ssaId << ", " << secSSAId << std::endl;
    176160                            insertReplace(*replacesMap, sentry.first, ssaId, secSSAId);
    177                         }
    178161                        else if (ssaId < secSSAId)
    179                         {
    180                             std::cout << "  insertreplace2: " <<
    181                                 sentry.first.regVar << ":" <<
    182                                 sentry.first.index  << ": " <<
    183                                 ssaId << ", " << secSSAId << std::endl;
    184162                            insertReplace(*replacesMap, sentry.first, secSSAId, ssaId);
    185                         }
    186                         /*else
    187                             std::cout << "  noinsertreplace: " <<
    188                                 ssaId << "," << sinfo.ssaIdBefore << std::endl;*/
    189163                    }
    190164                }
     
    200174                BlockIndex nextBlock)
    201175{
    202     std::cout << "addResSecCacheEntry: " << nextBlock << std::endl;
     176    ARDOut << "addResSecCacheEntry: " << nextBlock << "\n";
    203177    //std::stack<CallStackEntry> callStack = prevCallStack;
    204178    // traverse by graph from next block
     
    222196            {
    223197                visited[entry.blockIndex] = true;
    224                 std::cout << "  resolv (cache): " << entry.blockIndex << std::endl;
     198                ARDOut << "  resolv (cache): " << entry.blockIndex << "\n";
    225199               
    226200                const RBWSSAIdMap* resSecondPoints =
     
    242216            {
    243217                // back, already visited
    244                 std::cout << "resolv already (cache): " << entry.blockIndex << std::endl;
     218                ARDOut << "resolv already (cache): " << entry.blockIndex << "\n";
    245219                flowStack.pop_back();
    246220                continue;
     
    303277                    alreadyReadMap.erase(it);
    304278            }
    305             std::cout << "  popresolv (cache)" << std::endl;
     279            ARDOut << "  popresolv (cache)\n";
    306280            flowStack.pop_back();
    307281        }
     
    327301        if (next.isCall)
    328302        {
    329             std::cout << "  applycall: " << blockIndex << ": " <<
    330                     nextIndex << ": " << next.block << std::endl;
     303            ARDOut << "  applycall: " << blockIndex << ": " <<
     304                    nextIndex << ": " << next.block << "\n";
    331305            const LastSSAIdMap& regVarMap =
    332306                    routineMap.find(next.block)->second.lastSSAIdMap;
     
    351325    auto pfEnd = prevFlowStack.end();
    352326    --pfEnd;
    353     std::cout << "startResolv: " << (pfEnd-1)->blockIndex << "," << nextBlock << std::endl;
     327    ARDOut << "startResolv: " << (pfEnd-1)->blockIndex << "," << nextBlock << "\n";
    354328    LastSSAIdMap stackVarMap;
    355329   
     
    364338            if (cached!=nullptr)
    365339            {
    366                 std::cout << "use pfcached: " << it->second.first << ", " <<
    367                         it->second.second << std::endl;
     340                ARDOut << "use pfcached: " << it->second.first << ", " <<
     341                        it->second.second << "\n";
    368342                stackVarMap = *cached;
    369343                pfStartIndex = it->second.second+1;
     
    382356    {
    383357        const FlowStackEntry2& entry = *pfit;
    384         std::cout << "  apply: " << entry.blockIndex << std::endl;
     358        ARDOut << "  apply: " << entry.blockIndex << "\n";
    385359        const CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
    386360        for (const auto& sentry: cblock.ssaInfoMap)
     
    398372            !resFirstPointsCache.hasKey(pfit->blockIndex))
    399373        {
    400             std::cout << "put pfcache " << pfit->blockIndex << std::endl;
     374            ARDOut << "put pfcache " << pfit->blockIndex << "\n";
    401375            resFirstPointsCache.put(pfit->blockIndex, stackVarMap);
    402376        }
     
    428402            {
    429403                visited[entry.blockIndex] = true;
    430                 std::cout << "  resolv: " << entry.blockIndex << std::endl;
     404                ARDOut << "  resolv: " << entry.blockIndex << "\n";
    431405               
    432406                const RBWSSAIdMap* resSecondPoints =
     
    449423            {
    450424                cblocksToCache.increase(entry.blockIndex);
    451                 std::cout << "cblockToCache: " << entry.blockIndex << "=" <<
    452                             cblocksToCache.count(entry.blockIndex) << std::endl;
     425                ARDOut << "cblockToCache: " << entry.blockIndex << "=" <<
     426                            cblocksToCache.count(entry.blockIndex) << "\n";
    453427                // back, already visited
    454                 std::cout << "resolv already: " << entry.blockIndex << std::endl;
     428                ARDOut << "resolv already: " << entry.blockIndex << "\n";
    455429                flowStack.pop_back();
    456430                continue;
     
    513487                    alreadyReadMap.erase(it);
    514488            }
    515             std::cout << "  popresolv" << std::endl;
     489            ARDOut << "  popresolv\n";
    516490           
    517491            if (cblocksToCache.count(entry.blockIndex)==2 &&
     
    535509    for (const auto& entry: src)
    536510    {
    537         std::cout << "  entry2: " << entry.first.regVar << ":" <<
     511        ARDOut << "  joinRetSSAIdMap: " << entry.first.regVar << ":" <<
    538512                cxuint(entry.first.index) << ":";
    539513        for (size_t v: entry.second)
    540             std::cout << " " << v;
    541         std::cout << std::endl;
     514            ARDOut << " " << v;
     515        ARDOut << "\n";
    542516        // insert if not inserted
    543517        auto res = dest.insert({entry.first, { { routineBlock }, entry.second } });
     
    549523        for (size_t ssaId: entry.second)
    550524            destEntry.insertValue(ssaId);
    551         std::cout << "    :";
     525        ARDOut << "    :";
    552526        for (size_t v: destEntry)
    553             std::cout << " " << v;
    554         std::cout << std::endl;
     527            ARDOut << " " << v;
     528        ARDOut << "\n";
    555529    }
    556530}
     
    561535    for (const auto& entry: src)
    562536    {
    563         std::cout << "  entry: " << entry.first.regVar << ":" <<
     537        ARDOut << "  joinLastSSAIdMap: " << entry.first.regVar << ":" <<
    564538                cxuint(entry.first.index) << ":";
    565539        for (size_t v: entry.second)
    566             std::cout << " " << v;
    567         std::cout << std::endl;
     540            ARDOut << " " << v;
     541        ARDOut << "\n";
    568542        auto res = dest.insert(entry); // find
    569543        if (res.second)
     
    573547        for (size_t ssaId: entry.second)
    574548            destEntry.insertValue(ssaId);
    575         std::cout << "    :";
     549        ARDOut << "    :";
    576550        for (size_t v: destEntry)
    577             std::cout << " " << v;
    578         std::cout << std::endl;
     551            ARDOut << " " << v;
     552        ARDOut << "\n";
    579553    }
    580554}
     
    602576            }
    603577        }
    604         std::cout << "  entry: " << entry.first.regVar << ":" <<
     578        ARDOut << "  joinLastSSAIdMapInt: " << entry.first.regVar << ":" <<
    605579                cxuint(entry.first.index) << ":";
    606580        for (size_t v: entry.second)
    607             std::cout << " " << v;
    608         std::cout << std::endl;
     581            ARDOut << " " << v;
     582        ARDOut << "\n";
    609583        auto res = dest.insert(entry); // find
    610584        if (res.second)
     
    614588        for (size_t ssaId: entry.second)
    615589            destEntry.insertValue(ssaId);
    616         std::cout << "    :";
     590        ARDOut << "    :";
    617591        for (size_t v: destEntry)
    618             std::cout << " " << v;
    619         std::cout << std::endl;
     592            ARDOut << " " << v;
     593        ARDOut << "\n";
    620594    }
    621595    if (!loop) // do not if loop
     
    644618    for (const auto& entry: src.lastSSAIdMap)
    645619    {
    646         std::cout << "  entry3: " << entry.first.regVar << ":" <<
     620        ARDOut << "  joinRoutineData: " << entry.first.regVar << ":" <<
    647621                cxuint(entry.first.index) << ":";
    648622        for (size_t v: entry.second)
    649             std::cout << " " << v;
    650         std::cout << std::endl;
     623            ARDOut << " " << v;
     624        ARDOut << "\n";
    651625        auto res = dest.curSSAIdMap.insert(entry); // find
    652626        VectorSet<size_t>& destEntry = res.first->second;
     
    666640        }
    667641       
    668         std::cout << "    :";
     642        ARDOut << "    :";
    669643        for (size_t v: destEntry)
    670             std::cout << " " << v;
    671         std::cout << std::endl;
     644            ARDOut << " " << v;
     645        ARDOut << "\n";
    672646    }
    673647}
     
    725699                    insertReplace(ssaReplacesMap, rentry.first, *sit, minSSAId);
    726700               
    727                 std::cout << "calls retssa ssaid: " << rentry.first.regVar << ":" <<
    728                         rentry.first.index << std::endl;
     701                ARDOut << "calls retssa ssaid: " << rentry.first.regVar << ":" <<
     702                        rentry.first.index << "\n";
    729703            }
    730704           
     
    825799            ssaId = ssaIds.front()+1; // plus one
    826800       
    827         std::cout << "retssa ssaid: " << ssaEntry.first.regVar << ":" <<
    828                 ssaEntry.first.index << ": " << ssaId << std::endl;
     801        ARDOut << "retssa ssaid: " << ssaEntry.first.regVar << ":" <<
     802                ssaEntry.first.index << ": " << ssaId << "\n";
    829803        // replace smallest ssaId in routineMap lastSSAId entry
    830804        // reduce SSAIds replaces
     
    840814            if (rbwRetSSAId != SIZE_MAX)
    841815            {
    842                 std::cout << "  keep retSSAId rbw: " << rbwRetSSAId << std::endl;
     816                ARDOut << "  keep retSSAId rbw: " << rbwRetSSAId << "\n";
    843817                // add retSSAId without changes (in way without regvar changes)
    844818                rlsit->second.insertValue(rbwRetSSAId);
     
    871845    if (sinfo.readBeforeWrite)
    872846    {
    873         //std::cout << "PutCRBW: " << sinfo.ssaIdBefore << std::endl;
     847        //ARDOut << "PutCRBW: " << sinfo.ssaIdBefore << "\n";
    874848        if (!rdata.rbwSSAIdMap.insert({ ssaEntry.first, prevSSAId }).second)
    875849            // if already added
     
    882856    if (sinfo.ssaIdChange != 0)
    883857    {
    884         //std::cout << "PutC: " << sinfo.ssaIdLast << std::endl;
     858        //ARDOut << "PutC: " << sinfo.ssaIdLast << "\n";
    885859        auto res = rdata.curSSAIdMap.insert({ ssaEntry.first, { sinfo.ssaIdLast } });
    886860        // put last SSAId
     
    972946            }
    973947           
    974             std::cout << " popentry2 " << entry.blockIndex << ": " <<
     948            ARDOut << " revertSSAIdPopEntry" << entry.blockIndex << ": " <<
    975949                    v.first.regVar << ":" << v.first.index << ":";
    976950            for (size_t v: ssaIds)
    977                 std::cout << " " << v;
    978             std::cout << std::endl;
     951                ARDOut << " " << v;
     952            ARDOut << "\n";
    979953        }
    980954    }
     
    986960{
    987961    VectorSet<size_t>& ssaIds = rdata->curSSAIdMap[ssaEntry.first];
    988     std::cout << " pushentry " << entry.blockIndex << ": " <<
     962    ARDOut << " updateRoutineCurSSAIdMap " << entry.blockIndex << ": " <<
    989963                ssaEntry.first.regVar << ":" << ssaEntry.first.index << ":";
    990964    for (size_t v: ssaIds)
    991         std::cout << " " << v;
    992     std::cout << std::endl;
     965        ARDOut << " " << v;
     966    ARDOut << "\n";
    993967   
    994968    // if cblock with some children
     
    999973    ssaIds.insertValue(curSSAId-1);
    1000974   
    1001     std::cout << " popentry " << entry.blockIndex << ": " <<
     975    ARDOut << " updateRoutineCurSSAIdMap after " << entry.blockIndex << ": " <<
    1002976                ssaEntry.first.regVar << ":" << ssaEntry.first.index << ":";
    1003977    for (size_t v: ssaIds)
    1004         std::cout << " " << v;
    1005     std::cout << std::endl;
     978        ARDOut << " " << v;
     979    ARDOut << "\n";
    1006980}
    1007981
     
    1012986    {
    1013987        // handle loops
    1014         std::cout << "  join loop ssaids: " << entry.blockIndex << std::endl;
     988        ARDOut << "  join loop ssaids: " << entry.blockIndex << "\n";
    1015989        // add to routine data loopEnds
    1016990        auto loopsit2 = rdata.loopEnds.find(entry.blockIndex);
     
    10391013        const CBlockBitPool& prevFlowStackBlocks = {})
    10401014{
    1041     std::cout << "--------- createRoutineData ----------------\n";
     1015    ARDOut << "--------- createRoutineData ----------------\n";
    10421016    CBlockBitPool visited(codeBlocks.size(), false);
    10431017    CBlockBitPool haveReturnBlocks(codeBlocks.size(), false);
     
    10911065            if (loopBlocks.find(entry.blockIndex) != loopBlocks.end())
    10921066            {   // leave from loop point
    1093                 std::cout << "   loopfound " << entry.blockIndex << std::endl;
     1067                ARDOut << "   loopfound " << entry.blockIndex << "\n";
    10941068                if (loopsit2 != rdata.loopEnds.end())
    10951069                {
    10961070                    subrDataCopy = subrData;
    10971071                    subrDataForLoopMap.insert({ entry.blockIndex, subrDataCopy });
    1098                     std::cout << "   loopssaId2Map: " <<
    1099                             entry.blockIndex << std::endl;
     1072                    ARDOut << "   loopssaId2Map: " <<
     1073                            entry.blockIndex << "\n";
    11001074                    joinLastSSAIdMap(subrData.lastSSAIdMap,
    11011075                            loopsit2->second.ssaIdMap, subrData, true);
    1102                     std::cout << "   loopssaIdMap2End: " << std::endl;
     1076                    ARDOut << "   loopssaIdMap2End: \n";
    11031077                    if (applyToMainRoutine)
    11041078                        joinLastSSAIdMap(rdata.lastSSAIdMap, loopsit2->second.ssaIdMap,
     
    11111085            if (it != loopSubrsMap.end())
    11121086            {
    1113                 std::cout << "    found loopsubrsmap: " << entry.blockIndex << ":";
     1087                ARDOut << "    found loopsubrsmap: " << entry.blockIndex << ":";
    11141088                for (BlockIndex subr: it->second)
    11151089                {
    1116                     std::cout << " " << subr;
     1090                    ARDOut << " " << subr;
    11171091                    RoutineData* subrData2 = subroutinesCache.use(subr);
    11181092                    if (subrData2 == nullptr)
    11191093                        continue;
    11201094                    RoutineData subrData2Copy = *subrData2;
    1121                     std::cout << "*";
     1095                    ARDOut << "*";
    11221096                    joinLastSSAIdMap(subrData2Copy.lastSSAIdMap,
    11231097                            loopsit2->second.ssaIdMap, subrDataCopy, false);
     
    11261100                    subroutinesCache.put(subr, subrData2Copy);
    11271101                }
    1128                 std::cout << "\n";
     1102                ARDOut << "\n";
    11291103            }
    11301104            // apply loops to this subroutine
     
    11321106            if (it2 != subrLoopsMap.end())
    11331107            {
    1134                 std::cout << "    found subrloopsmap: " << entry.blockIndex << ":";
     1108                ARDOut << "    found subrloopsmap: " << entry.blockIndex << ":";
    11351109                for (auto lit2 = it2->second.rbegin(); lit2 != it2->second.rend(); ++lit2)
    11361110                {
     
    11401114                        activeLoops.hasValue(loop))
    11411115                        continue;
    1142                     std::cout << " " << loop;
     1116                    ARDOut << " " << loop;
    11431117                    auto  itx = subrDataForLoopMap.find(loop);
    11441118                    if (itx != subrDataForLoopMap.end())
     
    11461120                                loopsit3->second.ssaIdMap, itx->second, false);
    11471121                }
    1148                 std::cout << "\n";
     1122                ARDOut << "\n";
    11491123            }
    11501124           
     
    11831157                {
    11841158                    auto loopsit2 = rdata.loopEnds.find(entry.blockIndex);
    1185                     std::cout << "-- subrcache2 for " << entry.blockIndex << std::endl;
     1159                    ARDOut << "-- subrcache2 for " << entry.blockIndex << "\n";
    11861160                    addSubroutine(loopsit2, false);
    11871161                    cachedRdata = subroutinesCache.use(entry.blockIndex);
     
    11911165            if (cachedRdata != nullptr)
    11921166            {
    1193                 std::cout << "use cached subr " << entry.blockIndex << std::endl;
    1194                 std::cout << "procret2: " << entry.blockIndex << std::endl;
     1167                ARDOut << "use cached subr " << entry.blockIndex << "\n";
     1168                ARDOut << "procret2: " << entry.blockIndex << "\n";
    11951169                if (visited[entry.blockIndex] && !haveReturnBlocks[entry.blockIndex])
    11961170                {
    11971171                    // no joining. no returns
    1198                     std::cout << "procretend2 nojoin" << std::endl;
     1172                    ARDOut << "procretend2 nojoin\n";
    11991173                    flowStackBlocks[entry.blockIndex] = !flowStackBlocks[entry.blockIndex];
    12001174                    flowStack.pop_back();
     
    12281202                                cachedRdata->curSSAIdMap, loopEnd.second.ssaIdMap, true);
    12291203                }
    1230                 std::cout << "procretend2" << std::endl;
     1204                ARDOut << "procretend2\n";
    12311205                flowStackBlocks[entry.blockIndex] = !flowStackBlocks[entry.blockIndex];
    12321206                flowStack.pop_back();
     
    12521226                if (loopBlocks.find(entry.blockIndex) != loopBlocks.end())
    12531227                    activeLoops.insertValue(entry.blockIndex);
    1254                 std::cout << "proc: " << entry.blockIndex << std::endl;
     1228                ARDOut << "proc: " << entry.blockIndex << "\n";
    12551229                visited[entry.blockIndex] = true;
    12561230               
     
    13031277                        srcRdata.origRbwSSAIdMap : srcRdata.rbwSSAIdMap;
    13041278                    if (entry.blockIndex.pass == 0 && rblock.pass!=0)
    1305                         std::cout << "choose origRbwSSAIdMap: " << rblock << std::endl;
     1279                        ARDOut << "choose origRbwSSAIdMap: " << rblock << "\n";
    13061280                       
    13071281                    for (const auto& rbw: srcRbwSSAIdMap)
     
    13491323                    if (next.isCall)
    13501324                    {
    1351                         //std::cout << "joincall:"<< next.block << std::endl;
     1325                        //ARDOut << "joincall:"<< next.block << "\n";
    13521326                        BlockIndex rblock(next.block, entry.blockIndex.pass);
    13531327                        if (callBlocks.find(next.block) != callBlocks.end())
     
    13681342        else
    13691343        {
    1370             std::cout << "popstart: " << entry.blockIndex << std::endl;
     1344            ARDOut << "popstart: " << entry.blockIndex << "\n";
    13711345            if (cblock.haveReturn)
    13721346            {
    1373                 std::cout << "procret: " << entry.blockIndex << std::endl;
     1347                ARDOut << "procret: " << entry.blockIndex << "\n";
    13741348                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap);
    1375                 std::cout << "procretend" << std::endl;
     1349                ARDOut << "procretend\n";
    13761350                rdata.notFirstReturn = true;
    13771351                entry.haveReturn = true;
     
    13941368                curSSAIdMap[ssaEntry.first] = curSSAId;
    13951369               
    1396                 std::cout << "popcurnext: " << ssaEntry.first.regVar <<
     1370                ARDOut << "popcurnext: " << ssaEntry.first.regVar <<
    13971371                            ":" << ssaEntry.first.index << ": " <<
    1398                             nextSSAId << ", " << curSSAId << std::endl;
     1372                            nextSSAId << ", " << curSSAId << "\n";
    13991373               
    14001374                updateRoutineCurSSAIdMap(&rdata, ssaEntry, entry, curSSAId, nextSSAId);
     
    14081382                if (loopsit2 != rdata.loopEnds.end())
    14091383                {
    1410                     std::cout << "   mark loopblocks passed: " <<
    1411                                 entry.blockIndex << std::endl;
     1384                    ARDOut << "   mark loopblocks passed: " <<
     1385                                entry.blockIndex << "\n";
    14121386                    // mark that loop has passed fully
    14131387                    loopsit2->second.passed = true;
    14141388                }
    14151389                else
    1416                     std::cout << "   loopblocks nopassed: " <<
    1417                                 entry.blockIndex << std::endl;
     1390                    ARDOut << "   loopblocks nopassed: " <<
     1391                                entry.blockIndex << "\n";
    14181392            }
    14191393           
     
    14211395                subroutToCache.count(entry.blockIndex)!=0)
    14221396            { //put to cache
    1423                 std::cout << "-- subrcache for " << entry.blockIndex << std::endl;
     1397                ARDOut << "-- subrcache for " << entry.blockIndex << "\n";
    14241398                addSubroutine(loopsit2, true);
    14251399            }
    14261400           
    14271401            flowStackBlocks[entry.blockIndex] = false;
    1428             std::cout << "pop: " << entry.blockIndex << std::endl;
     1402            ARDOut << "pop: " << entry.blockIndex << "\n";
    14291403           
    14301404            flowStack.pop_back();
     
    14381412        }
    14391413    }
    1440     std::cout << "--------- createRoutineData end ------------\n";
     1414    ARDOut << "--------- createRoutineData end ------------\n";
    14411415}
    14421416
     
    15571531            if (!visited[entry.blockIndex])
    15581532            {
    1559                 std::cout << "proc: " << entry.blockIndex << std::endl;
     1533                ARDOut << "proc: " << entry.blockIndex << "\n";
    15601534                visited[entry.blockIndex] = true;
    15611535               
     
    16191593            {
    16201594                cblocksToCache.increase(entry.blockIndex);
    1621                 std::cout << "cblockToCache: " << entry.blockIndex << "=" <<
    1622                             cblocksToCache.count(entry.blockIndex) << std::endl;
     1595                ARDOut << "cblockToCache: " << entry.blockIndex << "=" <<
     1596                            cblocksToCache.count(entry.blockIndex) << "\n";
    16231597                // back, already visited
    16241598                flowStackBlocks[entry.blockIndex] = !flowStackBlocks[entry.blockIndex];
     
    16301604                    // mark point of way to cache (res first point)
    16311605                    waysToCache[lastCommonCacheWayPoint.first] = true;
    1632                     std::cout << "mark to pfcache " <<
     1606                    ARDOut << "mark to pfcache " <<
    16331607                            lastCommonCacheWayPoint.first << ", " <<
    1634                             curWayBIndex << std::endl;
     1608                            curWayBIndex << "\n";
    16351609                    prevWaysIndexMap[curWayBIndex] = lastCommonCacheWayPoint;
    16361610                }
    16371611                lastCommonCacheWayPoint = { curWayBIndex, flowStack.size()-1 };
    1638                 std::cout << "lastCcwP: " << curWayBIndex << std::endl;
     1612                ARDOut << "lastCcwP: " << curWayBIndex << "\n";
    16391613                continue;
    16401614            }
     
    16451619            entry.nextIndex-1 == callStack.back().callNextIndex)
    16461620        {
    1647             std::cout << " ret: " << entry.blockIndex << std::endl;
     1621            ARDOut << " ret: " << entry.blockIndex << "\n";
    16481622            const BlockIndex routineBlock = callStack.back().routineBlock;
    16491623            RoutineData& prevRdata = routineMap.find(routineBlock)->second;
     
    16591633                if (csimsmit != curSSAIdMapStateMap.end() && entry.blockIndex.pass==0)
    16601634                {
    1661                     std::cout << " get curSSAIdMap from back recur 2" << std::endl;
     1635                    ARDOut << " get curSSAIdMap from back recur 2\n";
    16621636                    curSSAIdMap = csimsmit->second;
    16631637                    curSSAIdMapStateMap.erase(csimsmit);
     
    16811655                    if (recurseBlocks.insert(nextBlock.index).second)
    16821656                    {
    1683                         std::cout << "   -- recursion: " << nextBlock << std::endl;
     1657                        ARDOut << "   -- recursion: " << nextBlock << "\n";
    16841658                        nextBlock.pass = 1;
    16851659                       
     
    16891663                    {
    16901664                        entry.nextIndex++;
    1691                         std::cout << " NO call (rec): " << entry.blockIndex << std::endl;
     1665                        ARDOut << " NO call (rec): " << entry.blockIndex << "\n";
    16921666                        continue;
    16931667                    }
     
    16971671                {
    16981672                    entry.nextIndex++;
    1699                     std::cout << " NO call (rec)2: " << entry.blockIndex << std::endl;
     1673                    ARDOut << " NO call (rec)2: " << entry.blockIndex << "\n";
    17001674                    continue;
    17011675                }
    17021676               
    1703                 std::cout << " call: " << entry.blockIndex << std::endl;
     1677                ARDOut << " call: " << entry.blockIndex << "\n";
    17041678               
    17051679                callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
     
    17321706                    if (next.isCall)
    17331707                    {
    1734                         //std::cout << "joincall:"<< next.block << std::endl;
     1708                        //ARDOut << "joincall:"<< next.block << "\n";
    17351709                        size_t pass = 0;
    17361710                        if (callBlocks.find(next.block) != callBlocks.end())
    17371711                        {
    1738                             std::cout << " is secpass: " << entry.blockIndex << " : " <<
    1739                                     next.block << std::endl;
     1712                            ARDOut << " is secpass: " << entry.blockIndex << " : " <<
     1713                                    next.block << "\n";
    17401714                            pass = 1; // it ways second pass
    17411715                        }
     
    17791753                curSSAId = ssaEntry.second.ssaIdBefore+1;
    17801754               
    1781                 std::cout << "popcurnext: " << ssaEntry.first.regVar <<
     1755                ARDOut << "popcurnext: " << ssaEntry.first.regVar <<
    17821756                            ":" << ssaEntry.first.index << ": " <<
    1783                             nextSSAId << ", " << curSSAId << std::endl;
    1784             }
    1785            
    1786             std::cout << "pop: " << entry.blockIndex << std::endl;
     1757                            nextSSAId << ", " << curSSAId << "\n";
     1758            }
     1759           
     1760            ARDOut << "pop: " << entry.blockIndex << "\n";
    17871761            flowStackBlocks[entry.blockIndex] = false;
    17881762           
     
    17921766                if (csimsmit != curSSAIdMapStateMap.end())
    17931767                {
    1794                     std::cout << " get curSSAIdMap from back recur" << std::endl;
     1768                    ARDOut << " get curSSAIdMap from back recur\n";
    17951769                    curSSAIdMap = csimsmit->second;
    17961770                }
     
    18041778                lastCommonCacheWayPoint =
    18051779                        { flowStack.back().blockIndex, flowStack.size()-1 };
    1806                 std::cout << "POPlastCcwP: " << lastCommonCacheWayPoint.first << std::endl;
     1780                ARDOut << "POPlastCcwP: " << lastCommonCacheWayPoint.first << "\n";
    18071781            }
    18081782        }
Note: See TracChangeset for help on using the changeset viewer.