Changeset 61410db in rtems-tools


Ignore:
Timestamp:
Nov 28, 2018, 9:03:29 PM (5 months ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
6d30de6
Parents:
09f4dbe
git-author:
Chris Johns <chrisj@…> (11/28/18 21:03:29)
git-committer:
Chris Johns <chrisj@…> (11/28/18 21:37:22)
Message:

tester/coverage: Remove warnings in covoar on Windows.

Location:
tester/covoar
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • tester/covoar/DesiredSymbols.cc

    r09f4dbe r61410db  
    416416                      << d.first
    417417                      << std::endl;
    418             determineSourceLines( theRanges, d.second.sourceFile );
     418          determineSourceLines( theRanges, d.second.sourceFile );
    419419        }
    420420
  • tester/covoar/GcovFunctionData.cc

    r09f4dbe r61410db  
    66 */
    77
    8 #include <stdio.h>
    9 #include <string.h>
    10 //#include <stdlib.h>
    11 //#include <sys/stat.h>
     8#include <cstdio>
     9#include <cstring>
     10#include <cinttypes>
    1211
    1312#include "app_common.h"
     
    5453    if ( strlen(fcnName) >= FUNCTION_NAME_LENGTH ) {
    5554      fprintf(
    56         stderr, 
    57         "ERROR: Function name is too long to be correctly stored: %u\n", 
     55        stderr,
     56        "ERROR: Function name is too long to be correctly stored: %u\n",
    5857        (unsigned int) strlen(fcnName)
    5958      );
     
    9089    if ( strlen(fileName) >= FILE_NAME_LENGTH ){
    9190      fprintf(
    92         stderr, 
    93         "ERROR: File name is too long to be correctly stored: %u\n", 
    94         (unsigned int) strlen(fileName) 
     91        stderr,
     92        "ERROR: File name is too long to be correctly stored: %u\n",
     93        (unsigned int) strlen(fileName)
    9594      );
    9695      return false;
     
    120119    uint64_t &countersSum,
    121120    uint64_t &countersMax
    122   ) 
     121  )
    123122  {
    124123    arcs_iterator_t     currentArc;
     
    187186
    188187  void GcovFunctionData::printFunctionInfo(
    189     FILE * textFile, 
     188    FILE * textFile,
    190189    uint32_t function_number
    191190  )
     
    231230
    232231  void GcovFunctionData::printCoverageInfo(
    233     FILE     *textFile, 
     232    FILE     *textFile,
    234233    uint32_t  function_number
    235234  )
     
    255254        textFile,
    256255        "\nInstructions (Base address: 0x%08x, Size: %4u): \n\n",
    257         baseAddress, 
    258         baseSize 
     256        baseAddress,
     257        baseSize
    259258      );
    260       for ( instruction = symbolInfo->instructions.begin(); 
    261             instruction != symbolInfo->instructions.end(); 
     259      for ( instruction = symbolInfo->instructions.begin();
     260            instruction != symbolInfo->instructions.end();
    262261            instruction++
    263262      )
     
    268267          fprintf( textFile, "| 0x%08x ",   currentAddress );
    269268          fprintf( textFile, "*");
    270           fprintf( textFile, 
    271                     "| exec: %4u ", 
    272                     coverageMap->getWasExecuted( currentAddress ) 
     269          fprintf( textFile,
     270                    "| exec: %4u ",
     271                    coverageMap->getWasExecuted( currentAddress )
    273272          );
    274273          fprintf( textFile, "| taken/not: %4u/%4u ",
    275                     coverageMap->getWasTaken( currentAddress ), 
    276                     coverageMap->getWasNotTaken( currentAddress ) 
     274                    coverageMap->getWasTaken( currentAddress ),
     275                    coverageMap->getWasNotTaken( currentAddress )
    277276          );
    278277
     
    330329  }
    331330
    332   void GcovFunctionData::printArcInfo( 
     331  void GcovFunctionData::printArcInfo(
    333332                FILE * textFile, arcs_iterator_t arc
    334333  )
     
    369368        break;
    370369    }
    371     fprintf( textFile, "\tTaken: %5llu\n", (unsigned long long) arc->counter );
    372   }
    373 
    374   void GcovFunctionData::printBlockInfo( 
    375     FILE * textFile, 
     370    fprintf( textFile, "\tTaken: %5" PRIu64 "\n", (uint64_t) arc->counter );
     371  }
     372
     373  void GcovFunctionData::printBlockInfo(
     374    FILE * textFile,
    376375    blocks_iterator_t block
    377376  )
     
    382381      textFile,
    383382      " > BLOCK %3u from %s\n"
    384       "    -counter: %5llu\n"
    385       "    -flags: 0x%x\n"
     383      "    -counter: %5" PRIu64 "\n"
     384      "    -flags: 0x%" PRIx32 "\n"
    386385      "    -lines: ",
    387386      block->id,
    388387      block->sourceFileName,
    389       (unsigned long long) block->counter,
     388      (uint64_t) block->counter,
    390389      block->flags
    391390    );
     
    408407    std::list<uint64_t>    notTaken;    // List of not taken counts for branches
    409408
    410     //fprintf( stderr, "DEBUG: Processing counters for file: %s\n", sourceFileName  ); 
     409    //fprintf( stderr, "DEBUG: Processing counters for file: %s\n", sourceFileName  );
    411410    if ( blocks.empty() || arcs.empty() || coverageMap == NULL || symbolInfo->instructions.empty())
    412411    {
    413       //fprintf( stderr, 
    414       //          "DEBUG: sanity check returned false for function: %s from file: %s\n", 
    415       //          functionName, 
    416       //          sourceFileName 
     412      //fprintf( stderr,
     413      //          "DEBUG: sanity check returned false for function: %s from file: %s\n",
     414      //          functionName,
     415      //          sourceFileName
    417416      //);
    418       return false; 
     417      return false;
    419418    }
    420419
     
    431430    if ( !processBranches( &taken , &notTaken ) )
    432431    {
    433       //fprintf( stderr, 
    434       //          "ERROR: Failed to process branches for function: %s from file: %s\n", 
    435       //          functionName, 
    436       //          sourceFileName 
     432      //fprintf( stderr,
     433      //          "ERROR: Failed to process branches for function: %s from file: %s\n",
     434      //          functionName,
     435      //          sourceFileName
    437436      //);
    438       return false; 
     437      return false;
    439438    };
    440439
     
    456455
    457456      // If this is a branch without FAKE arcs process it
    458       if ( 
    459         (arcIterator->sourceBlock == arcIterator2->sourceBlock ) && 
     457      if (
     458        (arcIterator->sourceBlock == arcIterator2->sourceBlock ) &&
    460459        !( arcIterator->flags & FAKE_ARC_FLAG ) &&
    461         !( arcIterator2->flags & FAKE_ARC_FLAG ) 
     460        !( arcIterator2->flags & FAKE_ARC_FLAG )
    462461      ) {
    463462        if ( taken.empty() || notTaken.empty() ) {
    464463          fprintf(
    465             stderr, 
    466             "ERROR: Branchess missing for function: %s from file: %s\n", 
    467             functionName, 
    468             sourceFileName 
     464            stderr,
     465            "ERROR: Branchess missing for function: %s from file: %s\n",
     466            functionName,
     467            sourceFileName
    469468          );
    470469          return false;
     
    480479          notTaken.pop_front();
    481480          arcIterator->counter = taken.front();
    482           taken.pop_front();                   
     481          taken.pop_front();
    483482        }
    484483
    485484        blockIterator2 = blocks.begin();
    486485        //TODO: ADD FAILSAFE
    487         while ( arcIterator->destinationBlock != blockIterator2->id)   
     486        while ( arcIterator->destinationBlock != blockIterator2->id)
    488487          blockIterator2++;
    489488        blockIterator2->counter += arcIterator->counter;
    490  
     489
    491490        blockIterator2 = blocks.begin();
    492491        //TODO: ADD FAILSAFE
     
    494493            blockIterator2++;
    495494          blockIterator2->counter += arcIterator2->counter;
    496       }     
     495      }
    497496      blockIterator++;
    498497    }
     
    520519      // If this is the last arc, propagate counter and exit
    521520      if ( arcIterator2 == arcs.end() ) {
    522         //fprintf( stderr, 
    523         //        "DEBUG: Found last arc %3u -> %3u\n", 
    524         //        arcIterator->sourceBlock, 
    525         //        arcIterator->destinationBlock 
     521        //fprintf( stderr,
     522        //        "DEBUG: Found last arc %3u -> %3u\n",
     523        //        arcIterator->sourceBlock,
     524        //        arcIterator->destinationBlock
    526525        //);
    527526        arcIterator->counter = blockIterator->counter;
     
    531530        blockIterator2->counter += arcIterator->counter;
    532531        return true;
    533       } 
     532      }
    534533
    535534      // If this is not a branch, propagate counter and continue
     
    538537        arcIterator->counter = blockIterator->counter;
    539538        blockIterator2 =  blocks.begin();;
    540         while ( arcIterator->destinationBlock != blockIterator2->id)    //TODO: ADD FAILSAFE 
     539        while ( arcIterator->destinationBlock != blockIterator2->id)    //TODO: ADD FAILSAFE
    541540          blockIterator2++;
    542541        blockIterator2->counter += arcIterator->counter;
    543542      }
    544            
     543
    545544      // If this is  a branch with FAKE arc
    546545      else if ( (arcIterator->sourceBlock == arcIterator2->sourceBlock ) && ( arcIterator2->flags & FAKE_ARC_FLAG ))
     
    554553      }
    555554
    556       // If this is a legitimate branch     
     555      // If this is a legitimate branch
    557556      blockIterator++;
    558557    }
     
    560559    return true;
    561560  }
    562    
    563   bool GcovFunctionData::processBranches( 
    564             std::list<uint64_t> * taken , 
    565             std::list<uint64_t> * notTaken 
     561
     562  bool GcovFunctionData::processBranches(
     563            std::list<uint64_t> * taken ,
     564            std::list<uint64_t> * notTaken
    566565  )
    567566  {
     
    588587          taken->push_back ( (uint64_t) coverageMap->getWasTaken( currentAddress  ) );
    589588          notTaken->push_back ( (uint64_t) coverageMap->getWasNotTaken( currentAddress ) );
    590           //fprintf( stderr, 
     589          //fprintf( stderr,
    591590          //          "Added branch to list taken/not: %4u/%4u\n",
    592           //          coverageMap->getWasTaken( currentAddress ), 
    593           //          coverageMap->getWasNotTaken( currentAddress ) 
     591          //          coverageMap->getWasTaken( currentAddress ),
     592          //          coverageMap->getWasNotTaken( currentAddress )
    594593          //);
    595594        }
     
    599598  }
    600599}
    601 
    602 
  • tester/covoar/ObjdumpProcessor.cc

    r09f4dbe r61410db  
    270270  {
    271271    std::string     currentSymbol = "";
    272     uint32_t        endAddress;
    273272    uint32_t        instructionOffset;
    274273    int             items;
     
    277276    uint32_t        offset;
    278277    bool            processSymbol = false;
    279     uint32_t        startAddress = 0;
    280278    char            symbol[ MAX_LINE_LENGTH ];
    281279    char            terminator1;
     
    349347      // If all items found, we are at the beginning of a symbol's objdump.
    350348      if ((items == 3) && (terminator1 == ':')) {
    351         endAddress = executableInformation->getLoadAddress() + offset - 1;
    352 
    353349        // If we are currently processing a symbol, finalize it.
    354350        if (processSymbol) {
     
    361357
    362358        // Start processing of a new symbol.
    363         startAddress = 0;
    364359        currentSymbol = "";
    365360        processSymbol = false;
     
    368363        // See if the new symbol is one that we care about.
    369364        if (SymbolsToAnalyze->isDesired( symbol )) {
    370           startAddress = executableInformation->getLoadAddress() + offset;
    371365          currentSymbol = symbol;
    372366          processSymbol = true;
     
    380374               && processSymbol )
    381375      {
    382         endAddress = executableInformation->getLoadAddress() + offset - 1;
    383 
    384376        // If we are currently processing a symbol, finalize it.
    385377        if ( processSymbol ) {
Note: See TracChangeset for help on using the changeset viewer.