Changeset df4d9e9 in rtems-testing


Ignore:
Timestamp:
May 2, 2014, 2:25:28 PM (5 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.11, 8895273c193787f84c4585a10f6d6aceb3b25dc4
Children:
db7c8e2
Parents:
85c521d
Message:

covoar: Fix issues spotted by clang on FreeBSD 10

Location:
covoar
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • covoar/CoverageReaderQEMU.cc

    r85c521d rdf4d9e9  
    1717#include "qemu-traces.h"
    1818
    19 /* hack so this can compile on the RH7 RTEMS 4.5 host */
    20 #if (__GNUC__ <= 2)
     19/* hack so this can compile on old Linux versions and FreeBSD */
     20#if (__GNUC__ <= 2) || defined(__FreeBSD__)
    2121#define OPEN fopen
    2222#else
  • covoar/GcovData.cc

    r85c521d rdf4d9e9  
    4545
    4646    if ( strlen(fileName) >= FILE_NAME_LENGTH ){
    47       fprintf( stderr, "ERROR: File name is to long to be correctly stored: %u\n", strlen(fileName) );
     47      fprintf(
     48        stderr,
     49        "ERROR: File name is too long to be correctly stored: %u\n",
     50        (unsigned int) strlen(fileName)
     51      );
    4852      return false;
    4953    }
  • covoar/GcovFunctionData.cc

    r85c521d rdf4d9e9  
    1515#include "ObjdumpProcessor.h"
    1616#include "CoverageMapBase.h"
    17 //#include "ExecutableInfo.h"
    18 //#include "CoverageMap.h"
    19 //#include "qemu-traces.h"
    2017
    2118
     
    5653
    5754    if ( strlen(fcnName) >= FUNCTION_NAME_LENGTH ) {
    58       fprintf( stderr,
    59               "ERROR: Function name is to long to be correctly stored: %u\n",
    60               strlen(fcnName)
    61               );
     55      fprintf(
     56        stderr,
     57        "ERROR: Function name is too long to be correctly stored: %u\n",
     58        (unsigned int) strlen(fcnName)
     59      );
    6260      return false;
    6361    }
     
    7068      coverageMap = symbolInfo->unifiedCoverageMap;
    7169
    72     //if ( coverageMap == NULL)
    73     //  fprintf( stderr, "ERROR: Could not find coverage map for: %s\n", symbolName.c_str() );
    74     //else
    75     //  fprintf( stderr, "SUCCESS: Hound coverage map for: %s\n", symbolName.c_str() );
     70#if 0
     71    if ( coverageMap == NULL) {
     72      fprintf(
     73        stderr,
     74        "ERROR: Could not find coverage map for: %s\n",
     75        symbolName.c_str()
     76      );
     77    } else {
     78      fprintf(
     79        stderr,
     80        "SUCCESS: Hound coverage map for: %s\n",
     81        symbolName.c_str()
     82      );
     83   }
     84#endif
    7685
    7786    return true;
     
    8089  bool GcovFunctionData::setFileName( const char* fileName ) {
    8190    if ( strlen(fileName) >= FILE_NAME_LENGTH ){
    82       fprintf( stderr,
    83               "ERROR: File name is to long to be correctly stored: %u\n",
    84               strlen(fileName)
     91      fprintf(
     92        stderr,
     93        "ERROR: File name is too long to be correctly stored: %u\n",
     94        (unsigned int) strlen(fileName)
    8595      );
    8696      return false;
     
    106116
    107117  void GcovFunctionData::getCounters(
    108                 uint64_t* counterValues,
    109                 uint32_t &countersFound,
    110                 uint64_t &countersSum,
    111                 uint64_t &countersMax
     118    uint64_t* counterValues,
     119    uint32_t &countersFound,
     120    uint64_t &countersSum,
     121    uint64_t &countersMax
    112122  )
    113123  {
    114     arcs_iterator_t             currentArc;
    115     int                                 i;
     124    arcs_iterator_t     currentArc;
     125    int                 i;
    116126
    117127    countersFound       = 0;
     
    127137    )
    128138    {
    129       if ( currentArc->flags == 0 || currentArc->flags == 2 || currentArc->flags == 4 ) {
     139      if ( currentArc->flags == 0 || currentArc->flags == 2 ||
     140           currentArc->flags == 4 ) {
    130141        countersFound++;
    131142        countersSum += currentArc->counter;
     
    144155
    145156  void GcovFunctionData::addArc(
    146                 uint32_t        source,
    147                 uint32_t        destination,
    148                 uint32_t        flags
     157    uint32_t  source,
     158    uint32_t  destination,
     159    uint32_t  flags
    149160  )
    150161  {
     
    167178    gcov_block_info block;
    168179    numberOfBlocks++;
    169     block.id             = id;
    170     block.flags                  = flags;
    171     block.numberOfLines  = 0;
    172     block.counter                = 0;
     180    block.id    = id;
     181    block.flags = flags;
     182    block.numberOfLines = 0;
     183    block.counter = 0;
    173184    strcpy (block.sourceFileName, sourceFileName);
    174185    blocks.push_back(block);
    175186  }
    176187
    177   void GcovFunctionData::printFunctionInfo( FILE * textFile,
    178                   uint32_t function_number
    179   )
    180   {
    181     blocks_iterator_t   currentBlock;
    182     arcs_iterator_t             currentArc;
     188  void GcovFunctionData::printFunctionInfo(
     189    FILE * textFile,
     190    uint32_t function_number
     191  )
     192  {
     193    blocks_iterator_t  currentBlock;
     194    arcs_iterator_t    currentArc;
    183195
    184196    fprintf(
    185           textFile,
    186           "\n\n=========================="
    187           "FUNCTION %3d "
    188           "==========================\n\n",
    189           function_number
     197      textFile,
     198      "\n\n=========================="
     199      "FUNCTION %3d "
     200      "==========================\n\n",
     201      function_number
    190202    );
    191203    fprintf(
    192           textFile,
    193           "Name:      %s\n"
    194           "File:      %s\n"
    195           "Line:      %u\n"
    196           "Id:        %u\n"
    197           "Checksum:  0x%x\n\n",
    198           functionName,
    199           sourceFileName,
    200           firstLineNumber,
    201           id,
    202           checksum
     204      textFile,
     205      "Name:      %s\n"
     206      "File:      %s\n"
     207      "Line:      %u\n"
     208      "Id:        %u\n"
     209      "Checksum:  0x%x\n\n",
     210      functionName,
     211      sourceFileName,
     212      firstLineNumber,
     213      id,
     214      checksum
    203215    );
    204216
    205217    // Print arcs info
    206     for (
    207         currentArc = arcs.begin();
    208         currentArc != arcs.end();
    209         currentArc++
    210     )
    211     {
    212         printArcInfo( textFile, currentArc );
     218    for ( currentArc = arcs.begin(); currentArc != arcs.end(); currentArc++ ) {
     219      printArcInfo( textFile, currentArc );
    213220    }
    214221    fprintf( textFile, "\n");
    215222
    216223    // Print blocks info
    217     for (
    218         currentBlock =  blocks.begin();
    219         currentBlock != blocks.end();
    220         currentBlock++
    221     )
    222     {
     224    for ( currentBlock = blocks.begin();
     225          currentBlock != blocks.end();
     226          currentBlock++
     227    ) {
    223228      printBlockInfo( textFile, currentBlock );
    224229    }
    225230  }
    226231
    227   void GcovFunctionData::printCoverageInfo( FILE * textFile,
    228                   uint32_t function_number
     232  void GcovFunctionData::printCoverageInfo(
     233    FILE     *textFile,
     234    uint32_t  function_number
    229235  )
    230236  {
     
    236242    if ( coverageMap != NULL ) {
    237243
    238       for (instruction = symbolInfo->instructions.begin(); instruction != symbolInfo->instructions.end(); instruction++)
     244      for (instruction = symbolInfo->instructions.begin();
     245           instruction != symbolInfo->instructions.end();
     246           instruction++) {
    239247        if( instruction->isInstruction ) {
    240248          baseAddress = instruction->address;
    241249          break;
    242250        }
     251      }
    243252      baseSize   = coverageMap->getSize();
    244253
    245       fprintf( textFile,
    246               "\nInstructions (Base address: 0x%08x, Size: %4u): \n\n",
    247               baseAddress,
    248               baseSize
     254      fprintf(
     255        textFile,
     256        "\nInstructions (Base address: 0x%08x, Size: %4u): \n\n",
     257        baseAddress,
     258        baseSize
    249259      );
    250       for (
    251             instruction = symbolInfo->instructions.begin();
     260      for ( instruction = symbolInfo->instructions.begin();
    252261            instruction != symbolInfo->instructions.end();
    253262            instruction++
     
    283292
    284293  void GcovFunctionData::setBlockFileName(
    285                 const blocks_iterator_t  block,
    286                 const char               *fileName
     294    const blocks_iterator_t  block,
     295    const char               *fileName
    287296  )
    288297  {
     
    291300
    292301  void GcovFunctionData::addBlockLine(
    293                 const blocks_iterator_t  block,
    294                 const uint32_t           line
     302    const blocks_iterator_t  block,
     303    const uint32_t           line
    295304  )
    296305  {
     
    300309
    301310  blocks_iterator_t GcovFunctionData::findBlockById(
    302                 const uint32_t    id
     311    const uint32_t    id
    303312  )
    304313  {
    305314    blocks_iterator_t blockIterator;
    306     if ( !blocks.empty() ){
     315
     316    if ( !blocks.empty() ) {
    307317      blockIterator = blocks.begin();
    308318      while (   blockIterator != blocks.end( ) ){
     
    311321        blockIterator++;
    312322      }
    313     }
    314     else
    315       fprintf( stderr,
    316               "ERROR: GcovFunctionData::findBlockById() failed,"
    317               "no blocks present\n"
     323    } else {
     324      fprintf(
     325        stderr,
     326        "ERROR: GcovFunctionData::findBlockById() failed, no blocks present\n"
    318327      );
     328    }
    319329    return blockIterator;
    320330  }
     
    324334  )
    325335  {
    326     fprintf( textFile,
    327             " > ARC %3u -> %3u ",
    328             arc->sourceBlock,
    329             arc->destinationBlock
     336    fprintf(
     337      textFile,
     338      " > ARC %3u -> %3u ",
     339      arc->sourceBlock,
     340      arc->destinationBlock
    330341    );
    331342
     
    358369        break;
    359370    }
    360     fprintf( textFile, "\tTaken: %5llu\n", arc->counter );
     371    fprintf( textFile, "\tTaken: %5llu\n", (unsigned long long) arc->counter );
    361372  }
    362373
    363374  void GcovFunctionData::printBlockInfo(
    364                 FILE * textFile,
    365                 blocks_iterator_t block )
     375    FILE * textFile,
     376    blocks_iterator_t block
     377  )
    366378  {
    367379    std::list<uint32_t>::iterator       line;
    368380
    369     fprintf( textFile,
    370             " > BLOCK %3u from %s\n"
    371             "    -counter: %5llu\n"
    372             "    -flags: 0x%x\n"
    373             "    -lines: ",
    374             block->id,
    375             block->sourceFileName,
    376             block->counter,
    377             block->flags
     381    fprintf(
     382      textFile,
     383      " > BLOCK %3u from %s\n"
     384      "    -counter: %5llu\n"
     385      "    -flags: 0x%x\n"
     386      "    -lines: ",
     387      block->id,
     388      block->sourceFileName,
     389      (unsigned long long) block->counter,
     390      block->flags
    378391    );
    379392    if ( !block->lines.empty( ) )
    380393      for ( line = block->lines.begin() ; line != block->lines.end(); line++ )
    381       fprintf ( textFile, "%u, ", *line);
     394        fprintf ( textFile, "%u, ", *line);
    382395    fprintf ( textFile, "\n");
    383396  }
     
    385398  bool GcovFunctionData::processFunctionCounters( void ) {
    386399
    387     uint32_t                                                    baseAddress = 0;
    388     uint32_t                                                    currentAddress = 0;
     400    uint32_t               baseAddress = 0;
     401    uint32_t               currentAddress = 0;
    389402    std::list<Coverage::ObjdumpProcessor::objdumpLine_t>::iterator  instruction;
    390     blocks_iterator_t                                           blockIterator;
    391     blocks_iterator_t                                           blockIterator2;
    392     arcs_iterator_t                                             arcIterator;
    393     arcs_iterator_t                                             arcIterator2;
    394     std::list<uint64_t>                 taken;       // List of taken counts for branches
    395     std::list<uint64_t>                 notTaken;    // List of not taken counts for branches
     403    blocks_iterator_t      blockIterator;
     404    blocks_iterator_t      blockIterator2;
     405    arcs_iterator_t        arcIterator;
     406    arcs_iterator_t        arcIterator2;
     407    std::list<uint64_t>    taken;       // List of taken counts for branches
     408    std::list<uint64_t>    notTaken;    // List of not taken counts for branches
    396409
    397410    //fprintf( stderr, "DEBUG: Processing counters for file: %s\n", sourceFileName  );
     
    447460        !( arcIterator->flags & FAKE_ARC_FLAG ) &&
    448461        !( arcIterator2->flags & FAKE_ARC_FLAG )
    449       )
    450       {
     462      ) {
    451463        if ( taken.empty() || notTaken.empty() ) {
    452           fprintf( stderr,
    453                     "ERROR: Branchess missing for function: %s from file: %s\n",
    454                     functionName,
    455                     sourceFileName
    456         );
    457         return false;
    458       }
    459       //fprintf( stderr, "DEBUG: Found true branching arc %3u -> %3u\n", arcIterator->sourceBlock, arcIterator->destinationBlock );
    460       if ( arcIterator->flags & FALLTHROUGH_ARC_FLAG ) {
    461         arcIterator->counter = notTaken.front();
    462         notTaken.pop_front();
    463         arcIterator2->counter = taken.front();
    464         taken.pop_front();
    465       }
    466       else {
    467         arcIterator2->counter = notTaken.front();
    468         notTaken.pop_front();
    469         arcIterator->counter = taken.front();
    470         taken.pop_front();                   
    471       }
    472 
    473       blockIterator2 = blocks.begin();
    474       //TODO: ADD FAILSAFE
    475       while ( arcIterator->destinationBlock != blockIterator2->id)     
    476         blockIterator2++;
    477       blockIterator2->counter += arcIterator->counter;
    478 
    479       blockIterator2 = blocks.begin();
    480       //TODO: ADD FAILSAFE
    481       while ( arcIterator2->destinationBlock != blockIterator2->id)
     464          fprintf(
     465            stderr,
     466            "ERROR: Branchess missing for function: %s from file: %s\n",
     467            functionName,
     468            sourceFileName
     469          );
     470          return false;
     471        }
     472        //fprintf( stderr, "DEBUG: Found true branching arc %3u -> %3u\n", arcIterator->sourceBlock, arcIterator->destinationBlock );
     473        if ( arcIterator->flags & FALLTHROUGH_ARC_FLAG ) {
     474          arcIterator->counter = notTaken.front();
     475          notTaken.pop_front();
     476          arcIterator2->counter = taken.front();
     477          taken.pop_front();
     478        } else {
     479          arcIterator2->counter = notTaken.front();
     480          notTaken.pop_front();
     481          arcIterator->counter = taken.front();
     482          taken.pop_front();                   
     483        }
     484
     485        blockIterator2 = blocks.begin();
     486        //TODO: ADD FAILSAFE
     487        while ( arcIterator->destinationBlock != blockIterator2->id)   
    482488          blockIterator2++;
    483         blockIterator2->counter += arcIterator2->counter;
    484     }       
    485     blockIterator++;
    486   }
    487 
     489        blockIterator2->counter += arcIterator->counter;
     490 
     491        blockIterator2 = blocks.begin();
     492        //TODO: ADD FAILSAFE
     493        while ( arcIterator2->destinationBlock != blockIterator2->id)
     494            blockIterator2++;
     495          blockIterator2->counter += arcIterator2->counter;
     496      }     
     497      blockIterator++;
     498    }
    488499
    489500    // Reset iterators and variables
  • covoar/ReportsHtml.cc

    r85c521d rdf4d9e9  
    470470    // new format.
    471471    if ( state != lastState_m ) {
    472       fprintf( aFile, stateText.c_str() );
     472      fprintf( aFile, "%s", stateText.c_str() );
    473473      lastState_m = state;
    474474    }
  • covoar/TargetBase.cc

    r85c521d rdf4d9e9  
    1111#include <algorithm>
    1212#include <stdio.h>
     13#include <stdlib.h>
    1314
    1415namespace Target {
  • covoar/TraceReaderLogQEMU.cc

    r85c521d rdf4d9e9  
    2323#include "qemu-traces.h"
    2424
    25 /* hack so this can compile on the RH7 RTEMS 4.5 host */
    26 #if (__GNUC__ <= 2)
     25/* hack so this can compile on old Linux versions and FreeBSD */
     26#if (__GNUC__ <= 2) || defined(__FreeBSD__)
    2727#define STAT stat
    2828#define OPEN fopen
  • covoar/TraceWriterQEMU.cc

    r85c521d rdf4d9e9  
    2020#include "qemu-traces.h"
    2121
    22 /* hack so this can compile on the RH7 RTEMS 4.5 host */
    23 #if (__GNUC__ <= 2)
     22/* hack so this can compile on old Linux versions and FreeBSD */
     23#if (__GNUC__ <= 2) || defined(__FreeBSD__)
    2424#define STAT stat
    2525#define OPEN fopen
  • covoar/app_common.cc

    r85c521d rdf4d9e9  
    1010#include "Explanations.h"
    1111
    12 /* hack so this can compile on the RH7 RTEMS 4.5 host */
    13 #if (__GNUC__ <= 2)
     12/* hack so this can compile on old Linux versions and FreeBSD */
     13#if (__GNUC__ <= 2) || defined(__FreeBSD__)
    1414#define STAT stat
    1515#define OPEN fopen
  • covoar/covoar.cc

    r85c521d rdf4d9e9  
    356356  if (Verbose)
    357357    fprintf(
    358       stderr, "Analyzing %u symbols\n", SymbolsToAnalyze->set.size()
     358      stderr,
     359      "Analyzing %u symbols\n",
     360      (unsigned int) SymbolsToAnalyze->set.size()
    359361    );
    360362
Note: See TracChangeset for help on using the changeset viewer.