Changeset efbf8f0 in rtems-tools


Ignore:
Timestamp:
May 8, 2018, 5:09:40 AM (13 months ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
cdfc56a
Parents:
fb987e8
git-author:
Chris Johns <chrisj@…> (05/08/18 05:09:40)
git-committer:
Chris Johns <chrisj@…> (06/15/18 05:54:25)
Message:

covoar: Refactor DesiredSymbols?.cc to C++11.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • tester/covoar/DesiredSymbols.cc

    rfb987e8 refbf8f0  
    122122  void DesiredSymbols::preprocess( void )
    123123  {
    124     ObjdumpProcessor::objdumpLines_t::iterator fitr;
    125     ObjdumpProcessor::objdumpLines_t::iterator n, p;
    126     DesiredSymbols::symbolSet_t::iterator      sitr;
    127     CoverageMapBase*                           theCoverageMap;
    128124
    129125    // Look at each symbol.
    130     for (sitr = SymbolsToAnalyze->set.begin();
    131          sitr != SymbolsToAnalyze->set.end();
    132          sitr++) {
    133 
     126    for (auto& s : SymbolsToAnalyze->set) {
    134127      // If the unified coverage map does not exist, the symbol was
    135128      // never referenced by any executable.  Just skip it.
    136       theCoverageMap = sitr->second.unifiedCoverageMap;
    137       if (!theCoverageMap)
    138         continue;
    139 
    140       // Mark any branch and NOP instructions.
    141       for (fitr = sitr->second.instructions.begin();
    142            fitr != sitr->second.instructions.end();
    143            fitr++) {
    144         if (fitr->isBranch) {
    145            theCoverageMap->setIsBranch(
    146              fitr->address - sitr->second.baseAddress
    147            );
    148         }
    149         if (fitr->isNop) {
    150            theCoverageMap->setIsNop(
    151              fitr->address - sitr->second.baseAddress
    152            );
    153         }
    154       }
    155 
     129      CoverageMapBase* theCoverageMap = s.second.unifiedCoverageMap;
     130      if (theCoverageMap)
     131      {
     132        // Mark any branch and NOP instructions.
     133        for (auto& f : s.second.instructions) {
     134          if (f.isBranch)
     135            theCoverageMap->setIsBranch( f.address - s.second.baseAddress );
     136          if (f.isNop)
     137            theCoverageMap->setIsNop( f.address - s.second.baseAddress );
     138        }
     139      }
    156140    }
    157141  }
     
    159143  void DesiredSymbols::calculateStatistics( void )
    160144  {
    161     uint32_t                              a;
    162     uint32_t                              endAddress;
    163     DesiredSymbols::symbolSet_t::iterator sitr;
    164     CoverageMapBase*                      theCoverageMap;
    165 
    166145    // Look at each symbol.
    167     for (sitr = SymbolsToAnalyze->set.begin();
    168          sitr != SymbolsToAnalyze->set.end();
    169          sitr++) {
    170 
     146    for (auto& s : SymbolsToAnalyze->set) {
    171147      // If the unified coverage map does not exist, the symbol was
    172148      // never referenced by any executable.  Just skip it.
    173       theCoverageMap = sitr->second.unifiedCoverageMap;
    174       if (!theCoverageMap)
    175         continue;
    176 
    177       // Increment the total sizeInBytes byt the bytes in the symbol
    178       stats.sizeInBytes += sitr->second.stats.sizeInBytes;
    179 
    180       // Now scan through the coverage map of this symbol.
    181       endAddress = sitr->second.stats.sizeInBytes - 1;
    182       a = 0;
    183       while (a <= endAddress) {
    184 
    185         // If we are at the start of instruction increment
    186         // instruction type counters as needed.
    187         if ( theCoverageMap->isStartOfInstruction( a ) ) {
    188 
    189           stats.sizeInInstructions++;
    190           sitr->second.stats.sizeInInstructions++;
    191 
    192           if (!theCoverageMap->wasExecuted( a ) ) {
    193             stats.uncoveredInstructions++;
    194             sitr->second.stats.uncoveredInstructions++;
    195 
    196             if ( theCoverageMap->isBranch( a )) {
    197               stats.branchesNotExecuted++;
    198               sitr->second.stats.branchesNotExecuted++;
    199              }
    200           } else if (theCoverageMap->isBranch( a )) {
    201             stats.branchesExecuted++;
    202             sitr->second.stats.branchesExecuted++;
     149      CoverageMapBase* theCoverageMap = s.second.unifiedCoverageMap;
     150      if (theCoverageMap)
     151      {
     152        // Increment the total sizeInBytes byt the bytes in the symbol
     153        stats.sizeInBytes += s.second.stats.sizeInBytes;
     154
     155        // Now scan through the coverage map of this symbol.
     156        uint32_t endAddress = s.second.stats.sizeInBytes - 1;
     157
     158        for (uint32_t a = 0; a <= endAddress; ++a) {
     159          // If we are at the start of instruction increment
     160          // instruction type counters as needed.
     161          if ( theCoverageMap->isStartOfInstruction( a ) ) {
     162
     163            stats.sizeInInstructions++;
     164            s.second.stats.sizeInInstructions++;
     165
     166            if (!theCoverageMap->wasExecuted( a ) ) {
     167              stats.uncoveredInstructions++;
     168              s.second.stats.uncoveredInstructions++;
     169
     170              if ( theCoverageMap->isBranch( a )) {
     171                stats.branchesNotExecuted++;
     172                s.second.stats.branchesNotExecuted++;
     173              }
     174            } else if (theCoverageMap->isBranch( a )) {
     175              stats.branchesExecuted++;
     176              s.second.stats.branchesExecuted++;
     177            }
    203178          }
    204179
    205         }
    206 
    207         if (!theCoverageMap->wasExecuted( a )) {
    208           stats.uncoveredBytes++;
    209           sitr->second.stats.uncoveredBytes++;
    210         }
    211         a++;
    212 
     180          if (!theCoverageMap->wasExecuted( a )) {
     181            stats.uncoveredBytes++;
     182            s.second.stats.uncoveredBytes++;
     183          }
     184        }
    213185      }
    214186    }
     
    218190  void DesiredSymbols::computeUncovered( void )
    219191  {
    220     uint32_t                              a, la, ha;
    221     uint32_t                              endAddress;
    222     uint32_t                              count;
    223     DesiredSymbols::symbolSet_t::iterator sitr;
    224     CoverageRanges*                       theBranches;
    225     CoverageMapBase*                      theCoverageMap;
    226     CoverageRanges*                       theRanges;
    227 
    228192    // Look at each symbol.
    229     for (sitr = SymbolsToAnalyze->set.begin();
    230          sitr != SymbolsToAnalyze->set.end();
    231          sitr++) {
    232 
     193    for (auto& s : SymbolsToAnalyze->set) {
    233194      // If the unified coverage map does not exist, the symbol was
    234195      // never referenced by any executable.  Just skip it.
    235       theCoverageMap = sitr->second.unifiedCoverageMap;
    236       if (!theCoverageMap)
    237         continue;
    238 
    239       // Create containers for the symbol's uncovered ranges and branches.
    240       theRanges = new CoverageRanges();
    241       sitr->second.uncoveredRanges = theRanges;
    242       theBranches = new CoverageRanges();
    243       sitr->second.uncoveredBranches = theBranches;
    244 
    245       // Mark NOPs as executed
    246       endAddress = sitr->second.stats.sizeInBytes - 1;
    247       a = 0;
    248       while (a < endAddress) {
    249         if (!theCoverageMap->wasExecuted( a )) {
    250           a++;
    251           continue;
    252         }
    253 
    254         for (ha=a+1;
    255              ha<=endAddress && !theCoverageMap->isStartOfInstruction( ha );
    256              ha++)
    257           ;
    258         if ( ha >= endAddress )
    259           break;
    260 
    261         if (theCoverageMap->isNop( ha ))
    262           do {
    263             theCoverageMap->setWasExecuted( ha );
    264             ha++;
    265             if ( ha >= endAddress )
    266               break;
    267           } while ( !theCoverageMap->isStartOfInstruction( ha ) );
    268         a = ha;
    269       }
    270 
    271       // Now scan through the coverage map of this symbol.
    272       endAddress = sitr->second.stats.sizeInBytes - 1;
    273       a = 0;
    274       while (a <= endAddress) {
    275 
    276         // If an address was NOT executed, find consecutive unexecuted
    277         // addresses and add them to the uncovered ranges.
    278         if (!theCoverageMap->wasExecuted( a )) {
    279 
    280           la = a;
    281           count = 1;
     196      CoverageMapBase* theCoverageMap = s.second.unifiedCoverageMap;
     197      if (theCoverageMap)
     198      {
     199        // Create containers for the symbol's uncovered ranges and branches.
     200        CoverageRanges* theRanges = new CoverageRanges();
     201        s.second.uncoveredRanges = theRanges;
     202        CoverageRanges* theBranches = new CoverageRanges();
     203        s.second.uncoveredBranches = theBranches;
     204
     205        uint32_t a;
     206        uint32_t la;
     207        uint32_t ha;
     208        uint32_t endAddress;
     209        uint32_t count;
     210
     211        // Mark NOPs as executed
     212        endAddress = s.second.stats.sizeInBytes - 1;
     213        a = 0;
     214        while (a < endAddress) {
     215          if (!theCoverageMap->wasExecuted( a )) {
     216            a++;
     217            continue;
     218          }
     219
    282220          for (ha=a+1;
    283                ha<=endAddress && !theCoverageMap->wasExecuted( ha );
    284                ha++)
    285           {
    286             if ( theCoverageMap->isStartOfInstruction( ha ) )
    287               count++;
    288           }
    289           ha--;
    290 
    291           stats.uncoveredRanges++;
    292           sitr->second.stats.uncoveredRanges++;
    293           theRanges->add(
    294             sitr->second.baseAddress + la,
    295             sitr->second.baseAddress + ha,
    296             CoverageRanges::UNCOVERED_REASON_NOT_EXECUTED,
    297             count
    298           );
    299           a = ha + 1;
    300         }
    301 
    302         // If an address is a branch instruction, add any uncovered branches
    303         // to the uncoverd branches.
    304         else if (theCoverageMap->isBranch( a )) {
    305           la = a;
    306           for (ha=a+1;
    307                ha<=endAddress && !theCoverageMap->isStartOfInstruction( ha );
     221               ha <= endAddress && !theCoverageMap->isStartOfInstruction( ha );
    308222               ha++)
    309223            ;
    310           ha--;
    311 
    312           if (theCoverageMap->wasAlwaysTaken( la )) {
    313             stats.branchesAlwaysTaken++;
    314             sitr->second.stats.branchesAlwaysTaken++;
    315             theBranches->add(
    316               sitr->second.baseAddress + la,
    317               sitr->second.baseAddress + ha,
    318               CoverageRanges::UNCOVERED_REASON_BRANCH_ALWAYS_TAKEN,
    319               1
     224          if ( ha >= endAddress )
     225            break;
     226
     227          if (theCoverageMap->isNop( ha ))
     228            do {
     229              theCoverageMap->setWasExecuted( ha );
     230              ha++;
     231              if ( ha >= endAddress )
     232                break;
     233            } while ( !theCoverageMap->isStartOfInstruction( ha ) );
     234          a = ha;
     235        }
     236
     237        // Now scan through the coverage map of this symbol.
     238        endAddress = s.second.stats.sizeInBytes - 1;
     239        a = 0;
     240        while (a <= endAddress) {
     241          // If an address was NOT executed, find consecutive unexecuted
     242          // addresses and add them to the uncovered ranges.
     243          if (!theCoverageMap->wasExecuted( a )) {
     244
     245            la = a;
     246            count = 1;
     247            for (ha = a + 1;
     248                 ha <= endAddress && !theCoverageMap->wasExecuted( ha );
     249                 ha++)
     250            {
     251              if ( theCoverageMap->isStartOfInstruction( ha ) )
     252                count++;
     253            }
     254            ha--;
     255
     256            stats.uncoveredRanges++;
     257            s.second.stats.uncoveredRanges++;
     258            theRanges->add(
     259              s.second.baseAddress + la,
     260              s.second.baseAddress + ha,
     261              CoverageRanges::UNCOVERED_REASON_NOT_EXECUTED,
     262              count
    320263            );
    321             if (Verbose)
    322               fprintf(
    323                 stderr,
    324                 "Branch always taken found in %s (0x%x - 0x%x)\n",
    325                 (sitr->first).c_str(),
    326                 sitr->second.baseAddress + la,
    327                 sitr->second.baseAddress + ha
     264            a = ha + 1;
     265          }
     266
     267          // If an address is a branch instruction, add any uncovered branches
     268          // to the uncoverd branches.
     269          else if (theCoverageMap->isBranch( a )) {
     270            la = a;
     271            for (ha = a + 1;
     272               ha <= endAddress && !theCoverageMap->isStartOfInstruction( ha );
     273                 ha++)
     274              ;
     275            ha--;
     276
     277            if (theCoverageMap->wasAlwaysTaken( la )) {
     278              stats.branchesAlwaysTaken++;
     279              s.second.stats.branchesAlwaysTaken++;
     280              theBranches->add(
     281                s.second.baseAddress + la,
     282                s.second.baseAddress + ha,
     283                CoverageRanges::UNCOVERED_REASON_BRANCH_ALWAYS_TAKEN,
     284                1
    328285              );
     286              if (Verbose)
     287                std::cerr << "Branch always taken found in" << s.first
     288                          << std::hex
     289                          << " (0x" << s.second.baseAddress + la
     290                          << " - 0x" << s.second.baseAddress + ha
     291                          << ")"
     292                          << std::dec
     293                          << std::endl;
     294            }
     295            else if (theCoverageMap->wasNeverTaken( la )) {
     296              stats.branchesNeverTaken++;
     297              s.second.stats.branchesNeverTaken++;
     298              theBranches->add(
     299                s.second.baseAddress + la,
     300                s.second.baseAddress + ha,
     301                CoverageRanges::UNCOVERED_REASON_BRANCH_NEVER_TAKEN,
     302                1
     303                );
     304              if (Verbose)
     305                std::cerr << "Branch never taken found in " << s.first
     306                          << " (0x" << s.second.baseAddress + la
     307                          << " - 0x" << s.second.baseAddress + ha
     308                          << ")"
     309                          << std::dec
     310                          << std::endl;
     311            }
     312            a = ha + 1;
    329313          }
    330 
    331           else if (theCoverageMap->wasNeverTaken( la )) {
    332             stats.branchesNeverTaken++;
    333             sitr->second.stats.branchesNeverTaken++;
    334             theBranches->add(
    335               sitr->second.baseAddress + la,
    336               sitr->second.baseAddress + ha,
    337               CoverageRanges::UNCOVERED_REASON_BRANCH_NEVER_TAKEN,
    338               1
    339             );
    340             if (Verbose)
    341               fprintf(
    342                 stderr,
    343                 "Branch never taken found in %s (0x%x - 0x%x)\n",
    344                 (sitr->first).c_str(),
    345                 sitr->second.baseAddress + la,
    346                 sitr->second.baseAddress + ha
    347               );
    348           }
    349           a = ha + 1;
    350         }
    351         else
    352           a++;
     314          else
     315            a++;
     316        }
    353317      }
    354318    }
     
    362326  )
    363327  {
    364     CoverageMapBase*      aCoverageMap;
    365     uint32_t              highAddress;
    366     symbolSet_t::iterator itr;
     328    CoverageMapBase* aCoverageMap;
     329    uint32_t         highAddress;
    367330
    368331    // Ensure that the symbol is a desired symbol.
    369     itr = set.find( symbolName );
     332    symbolSet_t::iterator itr = set.find( symbolName );
    370333
    371334    if (itr == set.end()) {
    372 
    373       fprintf(
    374         stderr,
    375         "ERROR: DesiredSymbols::createCoverageMap - Unable to create "
    376         "unified coverage map for %s because it is NOT a desired symbol\n",
    377         symbolName.c_str()
    378       );
     335      std::cerr << "ERROR: DesiredSymbols::createCoverageMap - Unable to create "
     336                << "unified coverage map for "
     337                << symbolName
     338                << " because it is NOT a desired symbol"
     339                << std::endl;
    379340      exit( -1 );
    380341    }
     
    391352        // Update value for longer byte size.
    392353        // 2015-07-22
    393         fprintf(
    394           stderr,
    395           "INFO: DesiredSymbols::createCoverageMap - Attempt to create "
    396           "unified coverage maps for %s with different sizes (%s/%d != %s/%d)\n",
    397 
    398           symbolName.c_str(),
    399           exefileName.c_str(),
    400           itr->second.stats.sizeInBytes,
    401           itr->second.sourceFile->getFileName().c_str(),
    402           size
    403         );
     354        std::cerr << "INFO: DesiredSymbols::createCoverageMap - Attempt to create "
     355                  << "unified coverage maps for "
     356                  << symbolName
     357                  << " with different sizes ("
     358                  << exefileName << '/' << itr->second.stats.sizeInBytes
     359                  << "!= "
     360                  << itr->second.sourceFile->getFileName() << '/' << size << ')'
     361                  << std::endl;
    404362
    405363        if ( itr->second.stats.sizeInBytes < size )
     
    466424  void DesiredSymbols::findSourceForUncovered( void )
    467425  {
    468     DesiredSymbols::symbolSet_t::iterator ditr;
    469     CoverageRanges*                       theBranches;
    470     CoverageRanges*                       theRanges;
    471 
    472426    // Process uncovered ranges and/or branches for each symbol.
    473     for (ditr = SymbolsToAnalyze->set.begin();
    474          ditr != SymbolsToAnalyze->set.end();
    475          ditr++) {
    476 
     427    for (auto& d : SymbolsToAnalyze->set) {
    477428      // First the unexecuted ranges, ...
    478       theRanges = ditr->second.uncoveredRanges;
    479       if (theRanges == NULL)
    480         continue;
    481 
    482       if (!theRanges->set.empty()) {
    483         if (Verbose)
    484           fprintf(
    485             stderr,
    486             "Looking up source lines for uncovered ranges in %s\n",
    487             (ditr->first).c_str()
    488           );
    489         determineSourceLines(
    490           theRanges,
    491           ditr->second.sourceFile
    492         );
    493       }
    494 
    495       // then the uncovered branches.
    496       theBranches = ditr->second.uncoveredBranches;
    497       if (theBranches == NULL)
    498         continue;
    499 
    500       if (!theBranches->set.empty()) {
    501         if (Verbose)
    502           fprintf(
    503             stderr,
    504             "Looking up source lines for uncovered branches in %s\n",
    505             (ditr->first).c_str()
    506           );
    507         determineSourceLines(
    508           theBranches,
    509           ditr->second.sourceFile
    510         );
     429      CoverageRanges* theRanges = d.second.uncoveredRanges;
     430      if (theRanges != nullptr) {
     431        if (!theRanges->set.empty()) {
     432          if (Verbose)
     433            std::cerr << "Looking up source lines for uncovered ranges in "
     434                      << d.first
     435                      << std::endl;
     436            determineSourceLines( theRanges, d.second.sourceFile );
     437        }
     438
     439        // then the uncovered branches.
     440        CoverageRanges* theBranches = d.second.uncoveredBranches;
     441        if (theBranches != nullptr) {
     442          if (!theBranches->set.empty()) {
     443            if (Verbose)
     444              std::cerr << "Looking up source lines for uncovered branches in "
     445                        << d.first
     446                        << std::endl;
     447            determineSourceLines( theBranches, d.second.sourceFile );
     448          }
     449        }
    511450      }
    512451    }
     
    535474    if (set.find( symbolName ) == set.end()) {
    536475      #if 0
    537         fprintf( stderr,
    538           "Warning: Unable to find symbol %s\n",
    539           symbolName.c_str()
    540         );
     476        std::cerr << "Warning: Unable to find symbol " << symbolName
     477                  << std::endl;
    541478      #endif
    542479      return false;
     
    550487  )
    551488  {
    552     uint32_t              dAddress;
    553     CoverageMapBase*      destinationCoverageMap;
    554     uint32_t              dMapSize;
    555     symbolSet_t::iterator itr;
    556     uint32_t              sAddress;
    557     uint32_t              sBaseAddress;
    558     uint32_t              sMapSize;
    559     uint32_t              executionCount;
    560 
    561489    // Ensure that the symbol is a desired symbol.
    562     itr = set.find( symbolName );
     490    symbolSet_t::iterator itr = set.find( symbolName );
    563491
    564492    if (itr == set.end()) {
    565 
    566       fprintf(
    567         stderr,
    568         "ERROR: DesiredSymbols::mergeCoverageMap - Unable to merge "
    569         "coverage map for %s because it is NOT a desired symbol\n",
    570         symbolName.c_str()
    571       );
     493      std::cerr << "ERROR: DesiredSymbols::mergeCoverageMap - Unable to merge "
     494                << "coverage map for %s because it is NOT a desired symbol"
     495                << symbolName
     496                << std::endl;
    572497      exit( -1 );
    573498    }
     
    577502    // Changed from ERROR msg to INFO, because size mismatch is not
    578503    // treated as error anymore. 2015-07-20
    579     dMapSize = itr->second.stats.sizeInBytes;
    580     sBaseAddress = sourceCoverageMap->getFirstLowAddress();
    581     sMapSize = sourceCoverageMap->getSize();
     504    uint32_t dMapSize = itr->second.stats.sizeInBytes;
     505    uint32_t sBaseAddress = sourceCoverageMap->getFirstLowAddress();
     506    uint32_t sMapSize = sourceCoverageMap->getSize();
    582507    if (dMapSize != sMapSize) {
    583 
    584       fprintf(
    585         stderr,
    586         "INFO: DesiredSymbols::mergeCoverageMap - Unable to merge "
    587         "coverage map for %s because the sizes are different\n",
    588         symbolName.c_str()
    589       );
     508      std::cerr << "INFO: DesiredSymbols::mergeCoverageMap - Unable to merge "
     509                << "coverage map for " << symbolName
     510                << " because the sizes are different"
     511                << std::endl;
    590512      return;
    591513    }
    592514
    593515    // Merge the data for each address.
    594     destinationCoverageMap = itr->second.unifiedCoverageMap;
    595 
    596     for (dAddress = 0; dAddress < dMapSize; dAddress++) {
    597 
    598       sAddress = dAddress + sBaseAddress;
     516    CoverageMapBase* destinationCoverageMap = itr->second.unifiedCoverageMap;
     517
     518    for (uint32_t dAddress = 0; dAddress < dMapSize; dAddress++) {
     519
     520      uint32_t sAddress = dAddress + sBaseAddress;
    599521
    600522      // Merge start of instruction indication.
     
    603525
    604526      // Merge the execution data.
    605       executionCount = sourceCoverageMap->getWasExecuted( sAddress );
     527      uint32_t executionCount = sourceCoverageMap->getWasExecuted( sAddress );
    606528      destinationCoverageMap->sumWasExecuted( dAddress, executionCount );
    607529
     
    614536    }
    615537  }
    616 
    617538}
Note: See TracChangeset for help on using the changeset viewer.